import * as pulumi from "@pulumi/pulumi";
import * as dome9 from "@pulumi/dome9";

const exampleIntegration = new dome9.Integration("exampleIntegration", {
    type: "webhook",
    configuration: JSON.stringify({
        Url: "https://example.com/webhook",
        MethodType: "Post",
        AuthType: "BasicAuth",
        Username: "example-username",
        Password: "example-password",
        IgnoreCertificate: true,
    }),
});

import pulumi
import json
import pulumi_dome9 as dome9

example_integration = dome9.Integration("exampleIntegration",
    type="webhook",
    configuration=json.dumps({
        "Url": "https://example.com/webhook",
        "MethodType": "Post",
        "AuthType": "BasicAuth",
        "Username": "example-username",
        "Password": "example-password",
        "IgnoreCertificate": True,
    }))

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/dome9/dome9"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Url":               "https://example.com/webhook",
			"MethodType":        "Post",
			"AuthType":          "BasicAuth",
			"Username":          "example-username",
			"Password":          "example-password",
			"IgnoreCertificate": true,
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = dome9.NewIntegration(ctx, "exampleIntegration", &dome9.IntegrationArgs{
			Type:          pulumi.String("webhook"),
			Configuration: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Dome9 = Pulumi.Dome9;

return await Deployment.RunAsync(() => 
{
    var exampleIntegration = new Dome9.Integration("exampleIntegration", new()
    {
        Type = "webhook",
        Configuration = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Url"] = "https://example.com/webhook",
            ["MethodType"] = "Post",
            ["AuthType"] = "BasicAuth",
            ["Username"] = "example-username",
            ["Password"] = "example-password",
            ["IgnoreCertificate"] = true,
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dome9.Integration;
import com.pulumi.dome9.IntegrationArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
            .type("webhook")
            .configuration(serializeJson(
                jsonObject(
                    jsonProperty("Url", "https://example.com/webhook"),
                    jsonProperty("MethodType", "Post"),
                    jsonProperty("AuthType", "BasicAuth"),
                    jsonProperty("Username", "example-username"),
                    jsonProperty("Password", "example-password"),
                    jsonProperty("IgnoreCertificate", true)
                )))
            .build());

    }
}

resources:
  exampleIntegration:
    type: dome9:Integration
    properties:
      type: webhook
      configuration:
        fn::toJSON:
          Url: https://example.com/webhook
          MethodType: Post
          AuthType: BasicAuth
          Username: example-username
          Password: example-password
          IgnoreCertificate: true

var integrationResource = new Dome9.Integration("integrationResource", new()
{
    Configuration = "string",
    Type = "string",
    IntegrationId = "string",
    Name = "string",
});

example, err := dome9.NewIntegration(ctx, "integrationResource", &dome9.IntegrationArgs{
	Configuration: pulumi.String("string"),
	Type:          pulumi.String("string"),
	IntegrationId: pulumi.String("string"),
	Name:          pulumi.String("string"),
})

var integrationResource = new Integration("integrationResource", IntegrationArgs.builder()
    .configuration("string")
    .type("string")
    .integrationId("string")
    .name("string")
    .build());

integration_resource = dome9.Integration("integrationResource",
    configuration="string",
    type="string",
    integration_id="string",
    name="string")

const integrationResource = new dome9.Integration("integrationResource", {
    configuration: "string",
    type: "string",
    integrationId: "string",
    name: "string",
});

type: dome9:Integration
properties:
    configuration: string
    integrationId: string
    name: string
    type: string