port.Integration

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

const myCustomIntegration = new port.index.Port_integration("myCustomIntegration", {
    installationId: "my-custom-integration-id",
    title: "My Custom Integration",
    config: JSON.stringify({
        createMissingRelatedEntitiesboolean: true,
        deleteDependentEntities: true,
        resources: [{
            kind: "my-custom-kind",
            selector: {
                query: ".title",
            },
            port: {
                entity: {
                    mappings: [{
                        identifier: "'my-identifier'",
                        title: ".title",
                        blueprint: "'my-blueprint'",
                        properties: {
                            my_property: 123,
                        },
                        relations: {},
                    }],
                },
            },
        }],
    }),
});

import pulumi
import json
import pulumi_port as port

my_custom_integration = port.index.Port_integration("myCustomIntegration",
    installation_id=my-custom-integration-id,
    title=My Custom Integration,
    config=json.dumps({
        createMissingRelatedEntitiesboolean: True,
        deleteDependentEntities: True,
        resources: [{
            kind: my-custom-kind,
            selector: {
                query: .title,
            },
            port: {
                entity: {
                    mappings: [{
                        identifier: 'my-identifier',
                        title: .title,
                        blueprint: 'my-blueprint',
                        properties: {
                            my_property: 123,
                        },
                        relations: {},
                    }],
                },
            },
        }],
    }))

package main

import (
	"encoding/json"

	"github.com/port-labs/pulumi-port/sdk/v2/go/port"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := port.NewPort_integration(ctx, "myCustomIntegration", &port.Port_integrationArgs{
InstallationId: "my-custom-integration-id",
Title: "My Custom Integration",
Config: %!v(PANIC=Format method: fatal: An assertion has failed: unlowered function toJSON),
})
if err != nil {
return err
}
return nil
})
}

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

return await Deployment.RunAsync(() => 
{
    var myCustomIntegration = new Port.Index.Port_integration("myCustomIntegration", new()
    {
        InstallationId = "my-custom-integration-id",
        Title = "My Custom Integration",
        Config = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["createMissingRelatedEntitiesboolean"] = true,
            ["deleteDependentEntities"] = true,
            ["resources"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["kind"] = "my-custom-kind",
                    ["selector"] = new Dictionary<string, object?>
                    {
                        ["query"] = ".title",
                    },
                    ["port"] = new Dictionary<string, object?>
                    {
                        ["entity"] = new Dictionary<string, object?>
                        {
                            ["mappings"] = new[]
                            {
                                new Dictionary<string, object?>
                                {
                                    ["identifier"] = "'my-identifier'",
                                    ["title"] = ".title",
                                    ["blueprint"] = "'my-blueprint'",
                                    ["properties"] = new Dictionary<string, object?>
                                    {
                                        ["my_property"] = 123,
                                    },
                                    ["relations"] = new Dictionary<string, object?>
                                    {
                                    },
                                },
                            },
                        },
                    },
                },
            },
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.port.port_integration;
import com.pulumi.port.Port_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 myCustomIntegration = new Port_integration("myCustomIntegration", Port_integrationArgs.builder()
            .installationId("my-custom-integration-id")
            .title("My Custom Integration")
            .config(serializeJson(
                jsonObject(
                    jsonProperty("createMissingRelatedEntitiesboolean", true),
                    jsonProperty("deleteDependentEntities", true),
                    jsonProperty("resources", jsonArray(jsonObject(
                        jsonProperty("kind", "my-custom-kind"),
                        jsonProperty("selector", jsonObject(
                            jsonProperty("query", ".title")
                        )),
                        jsonProperty("port", jsonObject(
                            jsonProperty("entity", jsonObject(
                                jsonProperty("mappings", jsonArray(jsonObject(
                                    jsonProperty("identifier", "'my-identifier'"),
                                    jsonProperty("title", ".title"),
                                    jsonProperty("blueprint", "'my-blueprint'"),
                                    jsonProperty("properties", jsonObject(
                                        jsonProperty("my_property", 123)
                                    )),
                                    jsonProperty("relations", jsonObject(

                                    ))
                                )))
                            ))
                        ))
                    )))
                )))
            .build());

    }
}

resources:
  myCustomIntegration:
    type: port:port_integration
    properties:
      installationId: my-custom-integration-id
      title: My Custom Integration
      config:
        fn::toJSON:
          createMissingRelatedEntitiesboolean: true
          deleteDependentEntities: true
          resources:
            - kind: my-custom-kind
              selector:
                query: .title
              port:
                entity:
                  mappings:
                    - identifier: '''my-identifier'''
                      title: .title
                      blueprint: '''my-blueprint'''
                      properties:
                        my_property: 123
                      relations: {}

var integrationResource = new Port.Integration("integrationResource", new()
{
    InstallationId = "string",
    Config = "string",
    InstallationAppType = "string",
    KafkaChangelogDestination = null,
    Title = "string",
    Version = "string",
    WebhookChangelogDestination = new Port.Inputs.IntegrationWebhookChangelogDestinationArgs
    {
        Url = "string",
        Agent = false,
    },
});

example, err := port.NewIntegration(ctx, "integrationResource", &port.IntegrationArgs{
	InstallationId:            pulumi.String("string"),
	Config:                    pulumi.String("string"),
	InstallationAppType:       pulumi.String("string"),
	KafkaChangelogDestination: nil,
	Title:                     pulumi.String("string"),
	Version:                   pulumi.String("string"),
	WebhookChangelogDestination: &port.IntegrationWebhookChangelogDestinationArgs{
		Url:   pulumi.String("string"),
		Agent: pulumi.Bool(false),
	},
})

var integrationResource = new Integration("integrationResource", IntegrationArgs.builder()
    .installationId("string")
    .config("string")
    .installationAppType("string")
    .kafkaChangelogDestination()
    .title("string")
    .version("string")
    .webhookChangelogDestination(IntegrationWebhookChangelogDestinationArgs.builder()
        .url("string")
        .agent(false)
        .build())
    .build());

integration_resource = port.Integration("integrationResource",
    installation_id="string",
    config="string",
    installation_app_type="string",
    kafka_changelog_destination=port.IntegrationKafkaChangelogDestinationArgs(),
    title="string",
    version="string",
    webhook_changelog_destination=port.IntegrationWebhookChangelogDestinationArgs(
        url="string",
        agent=False,
    ))

const integrationResource = new port.Integration("integrationResource", {
    installationId: "string",
    config: "string",
    installationAppType: "string",
    kafkaChangelogDestination: {},
    title: "string",
    version: "string",
    webhookChangelogDestination: {
        url: "string",
        agent: false,
    },
});

type: port:Integration
properties:
    config: string
    installationAppType: string
    installationId: string
    kafkaChangelogDestination: {}
    title: string
    version: string
    webhookChangelogDestination:
        agent: false
        url: string