aquasec.Notification

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aquasec = Pulumiverse.Aquasec;

return await Deployment.RunAsync(() => 
{
    var teams = new Aquasec.Notification("teams", new()
    {
        Properties = 
        {
            { "url", "<TEAMS-URL>" },
        },
        Type = "teams",
    });

    var slack = new Aquasec.Notification("slack", new()
    {
        Properties = 
        {
            { "url", "<SLACK-URL>" },
        },
        Type = "slack",
    });

    var webhook = new Aquasec.Notification("webhook", new()
    {
        Properties = 
        {
            { "url", "<WEBHOOK-URL>" },
        },
        Type = "webhook",
    });

    var servicenow = new Aquasec.Notification("servicenow", new()
    {
        Properties = 
        {
            { "board_name", "" },
            { "instance_name", "" },
            { "password", "<PASSWORD>" },
            { "url", "<SERVICENOW-URL>" },
            { "user", "<USERNAME>" },
        },
        Type = "serviceNow",
    });

    var jiraWithToken = new Aquasec.Notification("jiraWithToken", new()
    {
        Properties = 
        {
            { "definition_of_done", "Done" },
            { "project_key", "<JIRA_PROJECT_KEY>" },
            { "summary", "SOME_TEXT" },
            { "token", "<JIRA-TOKEN>" },
            { "url", "<JIRA-URL>" },
        },
        Type = "jira",
    });

    var jiraWithCreds = new Aquasec.Notification("jiraWithCreds", new()
    {
        Properties = 
        {
            { "password", "<JIRA_PASSWORD>" },
            { "project_key", "<JIRA_PROJECT_KEY>" },
            { "summary", "SOME_TEXT" },
            { "url", "<JIRA-URL>" },
            { "user", "<JIRA_USERNAME>" },
        },
        Type = "jira",
    });

    var emailWithCreds = new Aquasec.Notification("emailWithCreds", new()
    {
        Properties = 
        {
            { "host", "<EMAIL_HOST>" },
            { "password", "<EMAIL_PASSWORD>" },
            { "port", "<EMAIL_PORT>" },
            { "recipients", "<RECIPIENTS>" },
            { "sender", "<SENDER_EMAIL_ADDRESS>" },
            { "user", "<EMAIL_USERNAME>" },
        },
        Type = "email",
    });

    var emailWithMx = new Aquasec.Notification("emailWithMx", new()
    {
        Properties = 
        {
            { "port", "<EMAIL_PORT>" },
            { "recipients", "<RECIPIENTS>" },
            { "sender", "<SENDER_EMAIL_ADDRESS>" },
            { "use_mx", "true" },
        },
        Type = "email",
    });

});

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-aquasec/sdk/go/aquasec"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := aquasec.NewNotification(ctx, "teams", &aquasec.NotificationArgs{
			Properties: pulumi.StringMap{
				"url": pulumi.String("<TEAMS-URL>"),
			},
			Type: pulumi.String("teams"),
		})
		if err != nil {
			return err
		}
		_, err = aquasec.NewNotification(ctx, "slack", &aquasec.NotificationArgs{
			Properties: pulumi.StringMap{
				"url": pulumi.String("<SLACK-URL>"),
			},
			Type: pulumi.String("slack"),
		})
		if err != nil {
			return err
		}
		_, err = aquasec.NewNotification(ctx, "webhook", &aquasec.NotificationArgs{
			Properties: pulumi.StringMap{
				"url": pulumi.String("<WEBHOOK-URL>"),
			},
			Type: pulumi.String("webhook"),
		})
		if err != nil {
			return err
		}
		_, err = aquasec.NewNotification(ctx, "servicenow", &aquasec.NotificationArgs{
			Properties: pulumi.StringMap{
				"board_name":    pulumi.String(""),
				"instance_name": pulumi.String(""),
				"password":      pulumi.String("<PASSWORD>"),
				"url":           pulumi.String("<SERVICENOW-URL>"),
				"user":          pulumi.String("<USERNAME>"),
			},
			Type: pulumi.String("serviceNow"),
		})
		if err != nil {
			return err
		}
		_, err = aquasec.NewNotification(ctx, "jiraWithToken", &aquasec.NotificationArgs{
			Properties: pulumi.StringMap{
				"definition_of_done": pulumi.String("Done"),
				"project_key":        pulumi.String("<JIRA_PROJECT_KEY>"),
				"summary":            pulumi.String("SOME_TEXT"),
				"token":              pulumi.String("<JIRA-TOKEN>"),
				"url":                pulumi.String("<JIRA-URL>"),
			},
			Type: pulumi.String("jira"),
		})
		if err != nil {
			return err
		}
		_, err = aquasec.NewNotification(ctx, "jiraWithCreds", &aquasec.NotificationArgs{
			Properties: pulumi.StringMap{
				"password":    pulumi.String("<JIRA_PASSWORD>"),
				"project_key": pulumi.String("<JIRA_PROJECT_KEY>"),
				"summary":     pulumi.String("SOME_TEXT"),
				"url":         pulumi.String("<JIRA-URL>"),
				"user":        pulumi.String("<JIRA_USERNAME>"),
			},
			Type: pulumi.String("jira"),
		})
		if err != nil {
			return err
		}
		_, err = aquasec.NewNotification(ctx, "emailWithCreds", &aquasec.NotificationArgs{
			Properties: pulumi.StringMap{
				"host":       pulumi.String("<EMAIL_HOST>"),
				"password":   pulumi.String("<EMAIL_PASSWORD>"),
				"port":       pulumi.String("<EMAIL_PORT>"),
				"recipients": pulumi.String("<RECIPIENTS>"),
				"sender":     pulumi.String("<SENDER_EMAIL_ADDRESS>"),
				"user":       pulumi.String("<EMAIL_USERNAME>"),
			},
			Type: pulumi.String("email"),
		})
		if err != nil {
			return err
		}
		_, err = aquasec.NewNotification(ctx, "emailWithMx", &aquasec.NotificationArgs{
			Properties: pulumi.StringMap{
				"port":       pulumi.String("<EMAIL_PORT>"),
				"recipients": pulumi.String("<RECIPIENTS>"),
				"sender":     pulumi.String("<SENDER_EMAIL_ADDRESS>"),
				"use_mx":     pulumi.String("true"),
			},
			Type: pulumi.String("email"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aquasec.Notification;
import com.pulumi.aquasec.NotificationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var teams = new Notification("teams", NotificationArgs.builder()        
            .properties(Map.of("url", "<TEAMS-URL>"))
            .type("teams")
            .build());

        var slack = new Notification("slack", NotificationArgs.builder()        
            .properties(Map.of("url", "<SLACK-URL>"))
            .type("slack")
            .build());

        var webhook = new Notification("webhook", NotificationArgs.builder()        
            .properties(Map.of("url", "<WEBHOOK-URL>"))
            .type("webhook")
            .build());

        var servicenow = new Notification("servicenow", NotificationArgs.builder()        
            .properties(Map.ofEntries(
                Map.entry("board_name", ""),
                Map.entry("instance_name", ""),
                Map.entry("password", "<PASSWORD>"),
                Map.entry("url", "<SERVICENOW-URL>"),
                Map.entry("user", "<USERNAME>")
            ))
            .type("serviceNow")
            .build());

        var jiraWithToken = new Notification("jiraWithToken", NotificationArgs.builder()        
            .properties(Map.ofEntries(
                Map.entry("definition_of_done", "Done"),
                Map.entry("project_key", "<JIRA_PROJECT_KEY>"),
                Map.entry("summary", "SOME_TEXT"),
                Map.entry("token", "<JIRA-TOKEN>"),
                Map.entry("url", "<JIRA-URL>")
            ))
            .type("jira")
            .build());

        var jiraWithCreds = new Notification("jiraWithCreds", NotificationArgs.builder()        
            .properties(Map.ofEntries(
                Map.entry("password", "<JIRA_PASSWORD>"),
                Map.entry("project_key", "<JIRA_PROJECT_KEY>"),
                Map.entry("summary", "SOME_TEXT"),
                Map.entry("url", "<JIRA-URL>"),
                Map.entry("user", "<JIRA_USERNAME>")
            ))
            .type("jira")
            .build());

        var emailWithCreds = new Notification("emailWithCreds", NotificationArgs.builder()        
            .properties(Map.ofEntries(
                Map.entry("host", "<EMAIL_HOST>"),
                Map.entry("password", "<EMAIL_PASSWORD>"),
                Map.entry("port", "<EMAIL_PORT>"),
                Map.entry("recipients", "<RECIPIENTS>"),
                Map.entry("sender", "<SENDER_EMAIL_ADDRESS>"),
                Map.entry("user", "<EMAIL_USERNAME>")
            ))
            .type("email")
            .build());

        var emailWithMx = new Notification("emailWithMx", NotificationArgs.builder()        
            .properties(Map.ofEntries(
                Map.entry("port", "<EMAIL_PORT>"),
                Map.entry("recipients", "<RECIPIENTS>"),
                Map.entry("sender", "<SENDER_EMAIL_ADDRESS>"),
                Map.entry("use_mx", true)
            ))
            .type("email")
            .build());

    }
}

import pulumi
import pulumiverse_aquasec as aquasec

teams = aquasec.Notification("teams",
    properties={
        "url": "<TEAMS-URL>",
    },
    type="teams")
slack = aquasec.Notification("slack",
    properties={
        "url": "<SLACK-URL>",
    },
    type="slack")
webhook = aquasec.Notification("webhook",
    properties={
        "url": "<WEBHOOK-URL>",
    },
    type="webhook")
servicenow = aquasec.Notification("servicenow",
    properties={
        "board_name": "",
        "instance_name": "",
        "password": "<PASSWORD>",
        "url": "<SERVICENOW-URL>",
        "user": "<USERNAME>",
    },
    type="serviceNow")
jira_with_token = aquasec.Notification("jiraWithToken",
    properties={
        "definition_of_done": "Done",
        "project_key": "<JIRA_PROJECT_KEY>",
        "summary": "SOME_TEXT",
        "token": "<JIRA-TOKEN>",
        "url": "<JIRA-URL>",
    },
    type="jira")
jira_with_creds = aquasec.Notification("jiraWithCreds",
    properties={
        "password": "<JIRA_PASSWORD>",
        "project_key": "<JIRA_PROJECT_KEY>",
        "summary": "SOME_TEXT",
        "url": "<JIRA-URL>",
        "user": "<JIRA_USERNAME>",
    },
    type="jira")
email_with_creds = aquasec.Notification("emailWithCreds",
    properties={
        "host": "<EMAIL_HOST>",
        "password": "<EMAIL_PASSWORD>",
        "port": "<EMAIL_PORT>",
        "recipients": "<RECIPIENTS>",
        "sender": "<SENDER_EMAIL_ADDRESS>",
        "user": "<EMAIL_USERNAME>",
    },
    type="email")
email_with_mx = aquasec.Notification("emailWithMx",
    properties={
        "port": "<EMAIL_PORT>",
        "recipients": "<RECIPIENTS>",
        "sender": "<SENDER_EMAIL_ADDRESS>",
        "use_mx": "true",
    },
    type="email")

import * as pulumi from "@pulumi/pulumi";
import * as aquasec from "@pulumiverse/aquasec";

const teams = new aquasec.Notification("teams", {
    properties: {
        url: "<TEAMS-URL>",
    },
    type: "teams",
});
const slack = new aquasec.Notification("slack", {
    properties: {
        url: "<SLACK-URL>",
    },
    type: "slack",
});
const webhook = new aquasec.Notification("webhook", {
    properties: {
        url: "<WEBHOOK-URL>",
    },
    type: "webhook",
});
const servicenow = new aquasec.Notification("servicenow", {
    properties: {
        board_name: "",
        instance_name: "",
        password: "<PASSWORD>",
        url: "<SERVICENOW-URL>",
        user: "<USERNAME>",
    },
    type: "serviceNow",
});
const jiraWithToken = new aquasec.Notification("jiraWithToken", {
    properties: {
        definition_of_done: "Done",
        project_key: "<JIRA_PROJECT_KEY>",
        summary: "SOME_TEXT",
        token: "<JIRA-TOKEN>",
        url: "<JIRA-URL>",
    },
    type: "jira",
});
const jiraWithCreds = new aquasec.Notification("jiraWithCreds", {
    properties: {
        password: "<JIRA_PASSWORD>",
        project_key: "<JIRA_PROJECT_KEY>",
        summary: "SOME_TEXT",
        url: "<JIRA-URL>",
        user: "<JIRA_USERNAME>",
    },
    type: "jira",
});
const emailWithCreds = new aquasec.Notification("emailWithCreds", {
    properties: {
        host: "<EMAIL_HOST>",
        password: "<EMAIL_PASSWORD>",
        port: "<EMAIL_PORT>",
        recipients: "<RECIPIENTS>",
        sender: "<SENDER_EMAIL_ADDRESS>",
        user: "<EMAIL_USERNAME>",
    },
    type: "email",
});
const emailWithMx = new aquasec.Notification("emailWithMx", {
    properties: {
        port: "<EMAIL_PORT>",
        recipients: "<RECIPIENTS>",
        sender: "<SENDER_EMAIL_ADDRESS>",
        use_mx: "true",
    },
    type: "email",
});

resources:
  teams:
    type: aquasec:Notification
    properties:
      properties:
        url: <TEAMS-URL>
      type: teams
  slack:
    type: aquasec:Notification
    properties:
      properties:
        url: <SLACK-URL>
      type: slack
  webhook:
    type: aquasec:Notification
    properties:
      properties:
        url: <WEBHOOK-URL>
      type: webhook
  servicenow:
    type: aquasec:Notification
    properties:
      properties:
        board_name:
        instance_name:
        password: <PASSWORD>
        url: <SERVICENOW-URL>
        user: <USERNAME>
      type: serviceNow
  jiraWithToken:
    type: aquasec:Notification
    properties:
      properties:
        definition_of_done: Done
        project_key: <JIRA_PROJECT_KEY>
        summary: SOME_TEXT
        token: <JIRA-TOKEN>
        url: <JIRA-URL>
      type: jira
  jiraWithCreds:
    type: aquasec:Notification
    properties:
      properties:
        password: <JIRA_PASSWORD>
        project_key: <JIRA_PROJECT_KEY>
        summary: SOME_TEXT
        url: <JIRA-URL>
        user: <JIRA_USERNAME>
      type: jira
  emailWithCreds:
    type: aquasec:Notification
    properties:
      properties:
        host: <EMAIL_HOST>
        password: <EMAIL_PASSWORD>
        port: <EMAIL_PORT>
        recipients: <RECIPIENTS>
        sender: <SENDER_EMAIL_ADDRESS>
        user: <EMAIL_USERNAME>
      type: email
  emailWithMx:
    type: aquasec:Notification
    properties:
      properties:
        port: <EMAIL_PORT>
        recipients: <RECIPIENTS>
        sender: <SENDER_EMAIL_ADDRESS>
        use_mx: true
      type: email