coralogix.Connector

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

const genericHttpsExample = new coralogix.Connector("genericHttpsExample", {
    connectorId: "generic_https_example",
    type: "generic_https",
    description: "generic-https connector example",
    connectorConfig: {
        fields: [
            {
                fieldName: "url",
                value: "https://api.opsgenie.com/v2/alerts",
            },
            {
                fieldName: "method",
                value: "POST",
            },
            {
                fieldName: "additionalHeaders",
                value: JSON.stringify({
                    Authorization: "GenieKey <key>",
                    "Content-Type": "application/json",
                }),
            },
            {
                fieldName: "additionalBodyFields",
                value: JSON.stringify({
                    alias: "{{alert.groupingKey}}",
                }),
            },
        ],
    },
    configOverrides: [{
        entityType: "alerts",
        fields: [
            {
                fieldName: "url",
                template: `            {% if alert.status == 'Triggered' %}
            https://api.opsgenie.com/v2/alerts
            {% else %}
            https://api.opsgenie.com/v2/alerts/{{alert.groupingKey}}/close?identifierType=alias
            {% endif %}
`,
            },
            {
                fieldName: "additionalHeaders",
                template: `                {
                 "Authorization": "GenieKey some-key",
                 "Content-Type": "application/json"
              }
`,
            },
            {
                fieldName: "additionalBodyFields",
                template: `          {
            "alias": "{{alert.groupingKey}}"
          }
`,
            },
        ],
    }],
});
const slackExample = new coralogix.Connector("slackExample", {
    type: "slack",
    description: "slack connector example",
    connectorConfig: {
        fields: [
            {
                fieldName: "integrationId",
                value: "iac-internal",
            },
            {
                fieldName: "fallbackChannel",
                value: "iac-internal",
            },
            {
                fieldName: "channel",
                value: "iac-internal",
            },
        ],
    },
    configOverrides: [{
        entityType: "alerts",
        fields: [{
            fieldName: "channel",
            template: `            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
            sample-channel
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
            another-channel
            {% else %}
            generic-channel
            {% endif %}
`,
        }],
    }],
});
const pagerdutyExample = new coralogix.Connector("pagerdutyExample", {
    type: "pagerduty",
    description: "pagerduty connector example",
    connectorConfig: {
        fields: [{
            fieldName: "integrationKey",
            value: "integrationKey-example",
        }],
    },
    configOverrides: [{
        entityType: "alerts",
        fields: [{
            fieldName: "integrationKey",
            template: `            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
            sample-integration-key
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
            another-integrations-key
            {% else %}
            generic-integration-key
            {% endif %}
`,
        }],
    }],
});

import pulumi
import json
import pulumi_coralogix as coralogix

generic_https_example = coralogix.Connector("genericHttpsExample",
    connector_id="generic_https_example",
    type="generic_https",
    description="generic-https connector example",
    connector_config={
        "fields": [
            {
                "field_name": "url",
                "value": "https://api.opsgenie.com/v2/alerts",
            },
            {
                "field_name": "method",
                "value": "POST",
            },
            {
                "field_name": "additionalHeaders",
                "value": json.dumps({
                    "Authorization": "GenieKey <key>",
                    "Content-Type": "application/json",
                }),
            },
            {
                "field_name": "additionalBodyFields",
                "value": json.dumps({
                    "alias": "{{alert.groupingKey}}",
                }),
            },
        ],
    },
    config_overrides=[{
        "entity_type": "alerts",
        "fields": [
            {
                "field_name": "url",
                "template": """            {% if alert.status == 'Triggered' %}
            https://api.opsgenie.com/v2/alerts
            {% else %}
            https://api.opsgenie.com/v2/alerts/{{alert.groupingKey}}/close?identifierType=alias
            {% endif %}
""",
            },
            {
                "field_name": "additionalHeaders",
                "template": """                {
                 "Authorization": "GenieKey some-key",
                 "Content-Type": "application/json"
              }
""",
            },
            {
                "field_name": "additionalBodyFields",
                "template": """          {
            "alias": "{{alert.groupingKey}}"
          }
""",
            },
        ],
    }])
slack_example = coralogix.Connector("slackExample",
    type="slack",
    description="slack connector example",
    connector_config={
        "fields": [
            {
                "field_name": "integrationId",
                "value": "iac-internal",
            },
            {
                "field_name": "fallbackChannel",
                "value": "iac-internal",
            },
            {
                "field_name": "channel",
                "value": "iac-internal",
            },
        ],
    },
    config_overrides=[{
        "entity_type": "alerts",
        "fields": [{
            "field_name": "channel",
            "template": """            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
            sample-channel
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
            another-channel
            {% else %}
            generic-channel
            {% endif %}
""",
        }],
    }])
pagerduty_example = coralogix.Connector("pagerdutyExample",
    type="pagerduty",
    description="pagerduty connector example",
    connector_config={
        "fields": [{
            "field_name": "integrationKey",
            "value": "integrationKey-example",
        }],
    },
    config_overrides=[{
        "entity_type": "alerts",
        "fields": [{
            "field_name": "integrationKey",
            "template": """            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
            sample-integration-key
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
            another-integrations-key
            {% else %}
            generic-integration-key
            {% endif %}
""",
        }],
    }])

package main

import (
	"encoding/json"

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Authorization": "GenieKey <key>",
			"Content-Type":  "application/json",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"alias": "{{alert.groupingKey}}",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = coralogix.NewConnector(ctx, "genericHttpsExample", &coralogix.ConnectorArgs{
			ConnectorId: pulumi.String("generic_https_example"),
			Type:        pulumi.String("generic_https"),
			Description: pulumi.String("generic-https connector example"),
			ConnectorConfig: &coralogix.ConnectorConnectorConfigArgs{
				Fields: coralogix.ConnectorConnectorConfigFieldArray{
					&coralogix.ConnectorConnectorConfigFieldArgs{
						FieldName: pulumi.String("url"),
						Value:     pulumi.String("https://api.opsgenie.com/v2/alerts"),
					},
					&coralogix.ConnectorConnectorConfigFieldArgs{
						FieldName: pulumi.String("method"),
						Value:     pulumi.String("POST"),
					},
					&coralogix.ConnectorConnectorConfigFieldArgs{
						FieldName: pulumi.String("additionalHeaders"),
						Value:     pulumi.String(json0),
					},
					&coralogix.ConnectorConnectorConfigFieldArgs{
						FieldName: pulumi.String("additionalBodyFields"),
						Value:     pulumi.String(json1),
					},
				},
			},
			ConfigOverrides: coralogix.ConnectorConfigOverrideArray{
				&coralogix.ConnectorConfigOverrideArgs{
					EntityType: pulumi.String("alerts"),
					Fields: coralogix.ConnectorConfigOverrideFieldArray{
						&coralogix.ConnectorConfigOverrideFieldArgs{
							FieldName: pulumi.String("url"),
							Template: pulumi.String(`            {% if alert.status == 'Triggered' %}
            https://api.opsgenie.com/v2/alerts
            {% else %}
            https://api.opsgenie.com/v2/alerts/{{alert.groupingKey}}/close?identifierType=alias
            {% endif %}
`),
						},
						&coralogix.ConnectorConfigOverrideFieldArgs{
							FieldName: pulumi.String("additionalHeaders"),
							Template:  pulumi.String("                {\n                 \"Authorization\": \"GenieKey some-key\",\n                 \"Content-Type\": \"application/json\"\n              }\n"),
						},
						&coralogix.ConnectorConfigOverrideFieldArgs{
							FieldName: pulumi.String("additionalBodyFields"),
							Template:  pulumi.String("          {\n            \"alias\": \"{{alert.groupingKey}}\"\n          }\n"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = coralogix.NewConnector(ctx, "slackExample", &coralogix.ConnectorArgs{
			Type:        pulumi.String("slack"),
			Description: pulumi.String("slack connector example"),
			ConnectorConfig: &coralogix.ConnectorConnectorConfigArgs{
				Fields: coralogix.ConnectorConnectorConfigFieldArray{
					&coralogix.ConnectorConnectorConfigFieldArgs{
						FieldName: pulumi.String("integrationId"),
						Value:     pulumi.String("iac-internal"),
					},
					&coralogix.ConnectorConnectorConfigFieldArgs{
						FieldName: pulumi.String("fallbackChannel"),
						Value:     pulumi.String("iac-internal"),
					},
					&coralogix.ConnectorConnectorConfigFieldArgs{
						FieldName: pulumi.String("channel"),
						Value:     pulumi.String("iac-internal"),
					},
				},
			},
			ConfigOverrides: coralogix.ConnectorConfigOverrideArray{
				&coralogix.ConnectorConfigOverrideArgs{
					EntityType: pulumi.String("alerts"),
					Fields: coralogix.ConnectorConfigOverrideFieldArray{
						&coralogix.ConnectorConfigOverrideFieldArgs{
							FieldName: pulumi.String("channel"),
							Template: pulumi.String(`            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
            sample-channel
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
            another-channel
            {% else %}
            generic-channel
            {% endif %}
`),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = coralogix.NewConnector(ctx, "pagerdutyExample", &coralogix.ConnectorArgs{
			Type:        pulumi.String("pagerduty"),
			Description: pulumi.String("pagerduty connector example"),
			ConnectorConfig: &coralogix.ConnectorConnectorConfigArgs{
				Fields: coralogix.ConnectorConnectorConfigFieldArray{
					&coralogix.ConnectorConnectorConfigFieldArgs{
						FieldName: pulumi.String("integrationKey"),
						Value:     pulumi.String("integrationKey-example"),
					},
				},
			},
			ConfigOverrides: coralogix.ConnectorConfigOverrideArray{
				&coralogix.ConnectorConfigOverrideArgs{
					EntityType: pulumi.String("alerts"),
					Fields: coralogix.ConnectorConfigOverrideFieldArray{
						&coralogix.ConnectorConfigOverrideFieldArgs{
							FieldName: pulumi.String("integrationKey"),
							Template: pulumi.String(`            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
            sample-integration-key
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
            another-integrations-key
            {% else %}
            generic-integration-key
            {% endif %}
`),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var genericHttpsExample = new Coralogix.Connector("genericHttpsExample", new()
    {
        ConnectorId = "generic_https_example",
        Type = "generic_https",
        Description = "generic-https connector example",
        ConnectorConfig = new Coralogix.Inputs.ConnectorConnectorConfigArgs
        {
            Fields = new[]
            {
                new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
                {
                    FieldName = "url",
                    Value = "https://api.opsgenie.com/v2/alerts",
                },
                new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
                {
                    FieldName = "method",
                    Value = "POST",
                },
                new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
                {
                    FieldName = "additionalHeaders",
                    Value = JsonSerializer.Serialize(new Dictionary<string, object?>
                    {
                        ["Authorization"] = "GenieKey <key>",
                        ["Content-Type"] = "application/json",
                    }),
                },
                new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
                {
                    FieldName = "additionalBodyFields",
                    Value = JsonSerializer.Serialize(new Dictionary<string, object?>
                    {
                        ["alias"] = "{{alert.groupingKey}}",
                    }),
                },
            },
        },
        ConfigOverrides = new[]
        {
            new Coralogix.Inputs.ConnectorConfigOverrideArgs
            {
                EntityType = "alerts",
                Fields = new[]
                {
                    new Coralogix.Inputs.ConnectorConfigOverrideFieldArgs
                    {
                        FieldName = "url",
                        Template = @"            {% if alert.status == 'Triggered' %}
            https://api.opsgenie.com/v2/alerts
            {% else %}
            https://api.opsgenie.com/v2/alerts/{{alert.groupingKey}}/close?identifierType=alias
            {% endif %}
",
                    },
                    new Coralogix.Inputs.ConnectorConfigOverrideFieldArgs
                    {
                        FieldName = "additionalHeaders",
                        Template = @"                {
                 ""Authorization"": ""GenieKey some-key"",
                 ""Content-Type"": ""application/json""
              }
",
                    },
                    new Coralogix.Inputs.ConnectorConfigOverrideFieldArgs
                    {
                        FieldName = "additionalBodyFields",
                        Template = @"          {
            ""alias"": ""{{alert.groupingKey}}""
          }
",
                    },
                },
            },
        },
    });

    var slackExample = new Coralogix.Connector("slackExample", new()
    {
        Type = "slack",
        Description = "slack connector example",
        ConnectorConfig = new Coralogix.Inputs.ConnectorConnectorConfigArgs
        {
            Fields = new[]
            {
                new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
                {
                    FieldName = "integrationId",
                    Value = "iac-internal",
                },
                new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
                {
                    FieldName = "fallbackChannel",
                    Value = "iac-internal",
                },
                new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
                {
                    FieldName = "channel",
                    Value = "iac-internal",
                },
            },
        },
        ConfigOverrides = new[]
        {
            new Coralogix.Inputs.ConnectorConfigOverrideArgs
            {
                EntityType = "alerts",
                Fields = new[]
                {
                    new Coralogix.Inputs.ConnectorConfigOverrideFieldArgs
                    {
                        FieldName = "channel",
                        Template = @"            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == ""sample"" %}
            sample-channel
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == ""another"" %}
            another-channel
            {% else %}
            generic-channel
            {% endif %}
",
                    },
                },
            },
        },
    });

    var pagerdutyExample = new Coralogix.Connector("pagerdutyExample", new()
    {
        Type = "pagerduty",
        Description = "pagerduty connector example",
        ConnectorConfig = new Coralogix.Inputs.ConnectorConnectorConfigArgs
        {
            Fields = new[]
            {
                new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
                {
                    FieldName = "integrationKey",
                    Value = "integrationKey-example",
                },
            },
        },
        ConfigOverrides = new[]
        {
            new Coralogix.Inputs.ConnectorConfigOverrideArgs
            {
                EntityType = "alerts",
                Fields = new[]
                {
                    new Coralogix.Inputs.ConnectorConfigOverrideFieldArgs
                    {
                        FieldName = "integrationKey",
                        Template = @"            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == ""sample"" %}
            sample-integration-key
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == ""another"" %}
            another-integrations-key
            {% else %}
            generic-integration-key
            {% endif %}
",
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.coralogix.Connector;
import com.pulumi.coralogix.ConnectorArgs;
import com.pulumi.coralogix.inputs.ConnectorConnectorConfigArgs;
import com.pulumi.coralogix.inputs.ConnectorConfigOverrideArgs;
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 genericHttpsExample = new Connector("genericHttpsExample", ConnectorArgs.builder()
            .connectorId("generic_https_example")
            .type("generic_https")
            .description("generic-https connector example")
            .connectorConfig(ConnectorConnectorConfigArgs.builder()
                .fields(                
                    ConnectorConnectorConfigFieldArgs.builder()
                        .fieldName("url")
                        .value("https://api.opsgenie.com/v2/alerts")
                        .build(),
                    ConnectorConnectorConfigFieldArgs.builder()
                        .fieldName("method")
                        .value("POST")
                        .build(),
                    ConnectorConnectorConfigFieldArgs.builder()
                        .fieldName("additionalHeaders")
                        .value(serializeJson(
                            jsonObject(
                                jsonProperty("Authorization", "GenieKey <key>"),
                                jsonProperty("Content-Type", "application/json")
                            )))
                        .build(),
                    ConnectorConnectorConfigFieldArgs.builder()
                        .fieldName("additionalBodyFields")
                        .value(serializeJson(
                            jsonObject(
                                jsonProperty("alias", "{{alert.groupingKey}}")
                            )))
                        .build())
                .build())
            .configOverrides(ConnectorConfigOverrideArgs.builder()
                .entityType("alerts")
                .fields(                
                    ConnectorConfigOverrideFieldArgs.builder()
                        .fieldName("url")
                        .template("""
            {% if alert.status == 'Triggered' %}
            https://api.opsgenie.com/v2/alerts
            {% else %}
            https://api.opsgenie.com/v2/alerts/{{alert.groupingKey}}/close?identifierType=alias
            {% endif %}
                        """)
                        .build(),
                    ConnectorConfigOverrideFieldArgs.builder()
                        .fieldName("additionalHeaders")
                        .template("""
                {
                 "Authorization": "GenieKey some-key",
                 "Content-Type": "application/json"
              }
                        """)
                        .build(),
                    ConnectorConfigOverrideFieldArgs.builder()
                        .fieldName("additionalBodyFields")
                        .template("""
          {
            "alias": "{{alert.groupingKey}}"
          }
                        """)
                        .build())
                .build())
            .build());

        var slackExample = new Connector("slackExample", ConnectorArgs.builder()
            .type("slack")
            .description("slack connector example")
            .connectorConfig(ConnectorConnectorConfigArgs.builder()
                .fields(                
                    ConnectorConnectorConfigFieldArgs.builder()
                        .fieldName("integrationId")
                        .value("iac-internal")
                        .build(),
                    ConnectorConnectorConfigFieldArgs.builder()
                        .fieldName("fallbackChannel")
                        .value("iac-internal")
                        .build(),
                    ConnectorConnectorConfigFieldArgs.builder()
                        .fieldName("channel")
                        .value("iac-internal")
                        .build())
                .build())
            .configOverrides(ConnectorConfigOverrideArgs.builder()
                .entityType("alerts")
                .fields(ConnectorConfigOverrideFieldArgs.builder()
                    .fieldName("channel")
                    .template("""
            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
            sample-channel
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
            another-channel
            {% else %}
            generic-channel
            {% endif %}
                    """)
                    .build())
                .build())
            .build());

        var pagerdutyExample = new Connector("pagerdutyExample", ConnectorArgs.builder()
            .type("pagerduty")
            .description("pagerduty connector example")
            .connectorConfig(ConnectorConnectorConfigArgs.builder()
                .fields(ConnectorConnectorConfigFieldArgs.builder()
                    .fieldName("integrationKey")
                    .value("integrationKey-example")
                    .build())
                .build())
            .configOverrides(ConnectorConfigOverrideArgs.builder()
                .entityType("alerts")
                .fields(ConnectorConfigOverrideFieldArgs.builder()
                    .fieldName("integrationKey")
                    .template("""
            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
            sample-integration-key
            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
            another-integrations-key
            {% else %}
            generic-integration-key
            {% endif %}
                    """)
                    .build())
                .build())
            .build());

    }
}

resources:
  genericHttpsExample:
    type: coralogix:Connector
    properties:
      connectorId: generic_https_example
      # This field is optional, if not provided a random id will be generated
      type: generic_https
      description: generic-https connector example
      connectorConfig:
        fields:
          - fieldName: url
            value: https://api.opsgenie.com/v2/alerts
          - fieldName: method
            value: POST
          - fieldName: additionalHeaders
            value:
              fn::toJSON:
                Authorization: GenieKey <key>
                Content-Type: application/json
          - fieldName: additionalBodyFields
            value:
              fn::toJSON:
                alias: '{{alert.groupingKey}}'
      configOverrides:
        - entityType: alerts
          fields:
            - fieldName: url
              template: |2
                            {% if alert.status == 'Triggered' %}
                            https://api.opsgenie.com/v2/alerts
                            {% else %}
                            https://api.opsgenie.com/v2/alerts/{{alert.groupingKey}}/close?identifierType=alias
                            {% endif %}
            - fieldName: additionalHeaders
              template: |2
                                {
                                 "Authorization": "GenieKey some-key",
                                 "Content-Type": "application/json"
                              }
            - fieldName: additionalBodyFields
              template: |2
                          {
                            "alias": "{{alert.groupingKey}}"
                          }
  slackExample:
    type: coralogix:Connector
    properties:
      type: slack
      description: slack connector example
      connectorConfig:
        fields:
          - fieldName: integrationId
            value: iac-internal
          - fieldName: fallbackChannel
            value: iac-internal
          - fieldName: channel
            value: iac-internal
      configOverrides:
        - entityType: alerts
          fields:
            - fieldName: channel
              template: |2
                            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
                            sample-channel
                            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
                            another-channel
                            {% else %}
                            generic-channel
                            {% endif %}
  pagerdutyExample:
    type: coralogix:Connector
    properties:
      type: pagerduty
      description: pagerduty connector example
      connectorConfig:
        fields:
          - fieldName: integrationKey
            value: integrationKey-example
      configOverrides:
        - entityType: alerts
          fields:
            - fieldName: integrationKey
              template: |2
                            {% if alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "sample" %}
                            sample-integration-key
                            {% elif alert.groups[0].keyValues[alertDef.groupByKeys[1]]|lower == "another" %}
                            another-integrations-key
                            {% else %}
                            generic-integration-key
                            {% endif %}

var connectorResource = new Coralogix.Connector("connectorResource", new()
{
    Type = "string",
    ConfigOverrides = new[]
    {
        new Coralogix.Inputs.ConnectorConfigOverrideArgs
        {
            EntityType = "string",
            Fields = new[]
            {
                new Coralogix.Inputs.ConnectorConfigOverrideFieldArgs
                {
                    FieldName = "string",
                    Template = "string",
                },
            },
        },
    },
    ConnectorConfig = new Coralogix.Inputs.ConnectorConnectorConfigArgs
    {
        Fields = new[]
        {
            new Coralogix.Inputs.ConnectorConnectorConfigFieldArgs
            {
                FieldName = "string",
                Value = "string",
            },
        },
    },
    ConnectorId = "string",
    Description = "string",
    Name = "string",
});

example, err := coralogix.NewConnector(ctx, "connectorResource", &coralogix.ConnectorArgs{
	Type: pulumi.String("string"),
	ConfigOverrides: coralogix.ConnectorConfigOverrideArray{
		&coralogix.ConnectorConfigOverrideArgs{
			EntityType: pulumi.String("string"),
			Fields: coralogix.ConnectorConfigOverrideFieldArray{
				&coralogix.ConnectorConfigOverrideFieldArgs{
					FieldName: pulumi.String("string"),
					Template:  pulumi.String("string"),
				},
			},
		},
	},
	ConnectorConfig: &coralogix.ConnectorConnectorConfigArgs{
		Fields: coralogix.ConnectorConnectorConfigFieldArray{
			&coralogix.ConnectorConnectorConfigFieldArgs{
				FieldName: pulumi.String("string"),
				Value:     pulumi.String("string"),
			},
		},
	},
	ConnectorId: pulumi.String("string"),
	Description: pulumi.String("string"),
	Name:        pulumi.String("string"),
})

var connectorResource = new Connector("connectorResource", ConnectorArgs.builder()
    .type("string")
    .configOverrides(ConnectorConfigOverrideArgs.builder()
        .entityType("string")
        .fields(ConnectorConfigOverrideFieldArgs.builder()
            .fieldName("string")
            .template("string")
            .build())
        .build())
    .connectorConfig(ConnectorConnectorConfigArgs.builder()
        .fields(ConnectorConnectorConfigFieldArgs.builder()
            .fieldName("string")
            .value("string")
            .build())
        .build())
    .connectorId("string")
    .description("string")
    .name("string")
    .build());

connector_resource = coralogix.Connector("connectorResource",
    type="string",
    config_overrides=[{
        "entity_type": "string",
        "fields": [{
            "field_name": "string",
            "template": "string",
        }],
    }],
    connector_config={
        "fields": [{
            "field_name": "string",
            "value": "string",
        }],
    },
    connector_id="string",
    description="string",
    name="string")

const connectorResource = new coralogix.Connector("connectorResource", {
    type: "string",
    configOverrides: [{
        entityType: "string",
        fields: [{
            fieldName: "string",
            template: "string",
        }],
    }],
    connectorConfig: {
        fields: [{
            fieldName: "string",
            value: "string",
        }],
    },
    connectorId: "string",
    description: "string",
    name: "string",
});

type: coralogix:Connector
properties:
    configOverrides:
        - entityType: string
          fields:
            - fieldName: string
              template: string
    connectorConfig:
        fields:
            - fieldName: string
              value: string
    connectorId: string
    description: string
    name: string
    type: string