azure.kusto.CosmosdbDataConnection

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

const current = azure.core.getClientConfig({});
const exampleResourceGroup = new azure.core.ResourceGroup("example", {
    name: "exampleRG",
    location: "West Europe",
});
const builtin = azure.authorization.getRoleDefinition({
    roleDefinitionId: "fbdf93bf-df7d-467e-a4d2-9458aa1360c8",
});
const exampleCluster = new azure.kusto.Cluster("example", {
    name: "examplekc",
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    sku: {
        name: "Dev(No SLA)_Standard_D11_v2",
        capacity: 1,
    },
    identity: {
        type: "SystemAssigned",
    },
});
const exampleAssignment = new azure.authorization.Assignment("example", {
    scope: exampleResourceGroup.id,
    roleDefinitionName: builtin.then(builtin => builtin.name),
    principalId: exampleCluster.identity.apply(identity => identity?.principalId),
});
const exampleAccount = new azure.cosmosdb.Account("example", {
    name: "example-ca",
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    offerType: "Standard",
    kind: "GlobalDocumentDB",
    consistencyPolicy: {
        consistencyLevel: "Session",
        maxIntervalInSeconds: 5,
        maxStalenessPrefix: 100,
    },
    geoLocations: [{
        location: exampleResourceGroup.location,
        failoverPriority: 0,
    }],
});
const exampleSqlDatabase = new azure.cosmosdb.SqlDatabase("example", {
    name: "examplecosmosdbsqldb",
    resourceGroupName: exampleAccount.resourceGroupName,
    accountName: exampleAccount.name,
});
const exampleSqlContainer = new azure.cosmosdb.SqlContainer("example", {
    name: "examplecosmosdbsqlcon",
    resourceGroupName: exampleAccount.resourceGroupName,
    accountName: exampleAccount.name,
    databaseName: exampleSqlDatabase.name,
    partitionKeyPath: "/part",
    throughput: 400,
});
const example = azure.cosmosdb.getSqlRoleDefinitionOutput({
    roleDefinitionId: "00000000-0000-0000-0000-000000000001",
    resourceGroupName: exampleResourceGroup.name,
    accountName: exampleAccount.name,
});
const exampleSqlRoleAssignment = new azure.cosmosdb.SqlRoleAssignment("example", {
    resourceGroupName: exampleResourceGroup.name,
    accountName: exampleAccount.name,
    roleDefinitionId: example.apply(example => example.id),
    principalId: exampleCluster.identity.apply(identity => identity?.principalId),
    scope: exampleAccount.id,
});
const exampleDatabase = new azure.kusto.Database("example", {
    name: "examplekd",
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    clusterName: exampleCluster.name,
});
const exampleScript = new azure.kusto.Script("example", {
    name: "create-table-script",
    databaseId: exampleDatabase.id,
    scriptContent: `.create table TestTable(Id:string, Name:string, _ts:long, _timestamp:datetime)
.create table TestTable ingestion json mapping "TestMapping"
'['
'    {"column":"Id","path":".id"},'
'    {"column":"Name","path":".name"},'
'    {"column":"_ts","path":"._ts"},'
'    {"column":"_timestamp","path":"._ts", "transform":"DateTimeFromUnixSeconds"}'
']'
.alter table TestTable policy ingestionbatching "{'MaximumBatchingTimeSpan': '0:0:10', 'MaximumNumberOfItems': 10000}"
`,
});
const exampleCosmosdbDataConnection = new azure.kusto.CosmosdbDataConnection("example", {
    name: "examplekcdcd",
    location: exampleResourceGroup.location,
    cosmosdbContainerId: exampleSqlContainer.id,
    kustoDatabaseId: exampleDatabase.id,
    managedIdentityId: exampleCluster.id,
    tableName: "TestTable",
    mappingRuleName: "TestMapping",
    retrievalStartDate: "2023-06-26T12:00:00.6554616Z",
});

import pulumi
import pulumi_azure as azure

current = azure.core.get_client_config()
example_resource_group = azure.core.ResourceGroup("example",
    name="exampleRG",
    location="West Europe")
builtin = azure.authorization.get_role_definition(role_definition_id="fbdf93bf-df7d-467e-a4d2-9458aa1360c8")
example_cluster = azure.kusto.Cluster("example",
    name="examplekc",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    sku=azure.kusto.ClusterSkuArgs(
        name="Dev(No SLA)_Standard_D11_v2",
        capacity=1,
    ),
    identity=azure.kusto.ClusterIdentityArgs(
        type="SystemAssigned",
    ))
example_assignment = azure.authorization.Assignment("example",
    scope=example_resource_group.id,
    role_definition_name=builtin.name,
    principal_id=example_cluster.identity.principal_id)
example_account = azure.cosmosdb.Account("example",
    name="example-ca",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    offer_type="Standard",
    kind="GlobalDocumentDB",
    consistency_policy=azure.cosmosdb.AccountConsistencyPolicyArgs(
        consistency_level="Session",
        max_interval_in_seconds=5,
        max_staleness_prefix=100,
    ),
    geo_locations=[azure.cosmosdb.AccountGeoLocationArgs(
        location=example_resource_group.location,
        failover_priority=0,
    )])
example_sql_database = azure.cosmosdb.SqlDatabase("example",
    name="examplecosmosdbsqldb",
    resource_group_name=example_account.resource_group_name,
    account_name=example_account.name)
example_sql_container = azure.cosmosdb.SqlContainer("example",
    name="examplecosmosdbsqlcon",
    resource_group_name=example_account.resource_group_name,
    account_name=example_account.name,
    database_name=example_sql_database.name,
    partition_key_path="/part",
    throughput=400)
example = azure.cosmosdb.get_sql_role_definition_output(role_definition_id="00000000-0000-0000-0000-000000000001",
    resource_group_name=example_resource_group.name,
    account_name=example_account.name)
example_sql_role_assignment = azure.cosmosdb.SqlRoleAssignment("example",
    resource_group_name=example_resource_group.name,
    account_name=example_account.name,
    role_definition_id=example.id,
    principal_id=example_cluster.identity.principal_id,
    scope=example_account.id)
example_database = azure.kusto.Database("example",
    name="examplekd",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    cluster_name=example_cluster.name)
example_script = azure.kusto.Script("example",
    name="create-table-script",
    database_id=example_database.id,
    script_content=""".create table TestTable(Id:string, Name:string, _ts:long, _timestamp:datetime)
.create table TestTable ingestion json mapping "TestMapping"
'['
'    {"column":"Id","path":"$.id"},'
'    {"column":"Name","path":"$.name"},'
'    {"column":"_ts","path":"$._ts"},'
'    {"column":"_timestamp","path":"$._ts", "transform":"DateTimeFromUnixSeconds"}'
']'
.alter table TestTable policy ingestionbatching "{'MaximumBatchingTimeSpan': '0:0:10', 'MaximumNumberOfItems': 10000}"
""")
example_cosmosdb_data_connection = azure.kusto.CosmosdbDataConnection("example",
    name="examplekcdcd",
    location=example_resource_group.location,
    cosmosdb_container_id=example_sql_container.id,
    kusto_database_id=example_database.id,
    managed_identity_id=example_cluster.id,
    table_name="TestTable",
    mapping_rule_name="TestMapping",
    retrieval_start_date="2023-06-26T12:00:00.6554616Z")

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/cosmosdb"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/kusto"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := core.GetClientConfig(ctx, nil, nil)
		if err != nil {
			return err
		}
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("exampleRG"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		builtin, err := authorization.LookupRoleDefinition(ctx, &authorization.LookupRoleDefinitionArgs{
			RoleDefinitionId: pulumi.StringRef("fbdf93bf-df7d-467e-a4d2-9458aa1360c8"),
		}, nil)
		if err != nil {
			return err
		}
		exampleCluster, err := kusto.NewCluster(ctx, "example", &kusto.ClusterArgs{
			Name:              pulumi.String("examplekc"),
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku: &kusto.ClusterSkuArgs{
				Name:     pulumi.String("Dev(No SLA)_Standard_D11_v2"),
				Capacity: pulumi.Int(1),
			},
			Identity: &kusto.ClusterIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		_, err = authorization.NewAssignment(ctx, "example", &authorization.AssignmentArgs{
			Scope:              exampleResourceGroup.ID(),
			RoleDefinitionName: pulumi.String(builtin.Name),
			PrincipalId: exampleCluster.Identity.ApplyT(func(identity kusto.ClusterIdentity) (*string, error) {
				return &identity.PrincipalId, nil
			}).(pulumi.StringPtrOutput),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := cosmosdb.NewAccount(ctx, "example", &cosmosdb.AccountArgs{
			Name:              pulumi.String("example-ca"),
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			OfferType:         pulumi.String("Standard"),
			Kind:              pulumi.String("GlobalDocumentDB"),
			ConsistencyPolicy: &cosmosdb.AccountConsistencyPolicyArgs{
				ConsistencyLevel:     pulumi.String("Session"),
				MaxIntervalInSeconds: pulumi.Int(5),
				MaxStalenessPrefix:   pulumi.Int(100),
			},
			GeoLocations: cosmosdb.AccountGeoLocationArray{
				&cosmosdb.AccountGeoLocationArgs{
					Location:         exampleResourceGroup.Location,
					FailoverPriority: pulumi.Int(0),
				},
			},
		})
		if err != nil {
			return err
		}
		exampleSqlDatabase, err := cosmosdb.NewSqlDatabase(ctx, "example", &cosmosdb.SqlDatabaseArgs{
			Name:              pulumi.String("examplecosmosdbsqldb"),
			ResourceGroupName: exampleAccount.ResourceGroupName,
			AccountName:       exampleAccount.Name,
		})
		if err != nil {
			return err
		}
		exampleSqlContainer, err := cosmosdb.NewSqlContainer(ctx, "example", &cosmosdb.SqlContainerArgs{
			Name:              pulumi.String("examplecosmosdbsqlcon"),
			ResourceGroupName: exampleAccount.ResourceGroupName,
			AccountName:       exampleAccount.Name,
			DatabaseName:      exampleSqlDatabase.Name,
			PartitionKeyPath:  pulumi.String("/part"),
			Throughput:        pulumi.Int(400),
		})
		if err != nil {
			return err
		}
		example := cosmosdb.LookupSqlRoleDefinitionOutput(ctx, cosmosdb.GetSqlRoleDefinitionOutputArgs{
			RoleDefinitionId:  pulumi.String("00000000-0000-0000-0000-000000000001"),
			ResourceGroupName: exampleResourceGroup.Name,
			AccountName:       exampleAccount.Name,
		}, nil)
		_, err = cosmosdb.NewSqlRoleAssignment(ctx, "example", &cosmosdb.SqlRoleAssignmentArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			AccountName:       exampleAccount.Name,
			RoleDefinitionId: example.ApplyT(func(example cosmosdb.GetSqlRoleDefinitionResult) (*string, error) {
				return &example.Id, nil
			}).(pulumi.StringPtrOutput),
			PrincipalId: exampleCluster.Identity.ApplyT(func(identity kusto.ClusterIdentity) (*string, error) {
				return &identity.PrincipalId, nil
			}).(pulumi.StringPtrOutput),
			Scope: exampleAccount.ID(),
		})
		if err != nil {
			return err
		}
		exampleDatabase, err := kusto.NewDatabase(ctx, "example", &kusto.DatabaseArgs{
			Name:              pulumi.String("examplekd"),
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			ClusterName:       exampleCluster.Name,
		})
		if err != nil {
			return err
		}
		_, err = kusto.NewScript(ctx, "example", &kusto.ScriptArgs{
			Name:       pulumi.String("create-table-script"),
			DatabaseId: exampleDatabase.ID(),
			ScriptContent: pulumi.String(`.create table TestTable(Id:string, Name:string, _ts:long, _timestamp:datetime)
.create table TestTable ingestion json mapping "TestMapping"
'['
'    {"column":"Id","path":"$.id"},'
'    {"column":"Name","path":"$.name"},'
'    {"column":"_ts","path":"$._ts"},'
'    {"column":"_timestamp","path":"$._ts", "transform":"DateTimeFromUnixSeconds"}'
']'
.alter table TestTable policy ingestionbatching "{'MaximumBatchingTimeSpan': '0:0:10', 'MaximumNumberOfItems': 10000}"
`),
		})
		if err != nil {
			return err
		}
		_, err = kusto.NewCosmosdbDataConnection(ctx, "example", &kusto.CosmosdbDataConnectionArgs{
			Name:                pulumi.String("examplekcdcd"),
			Location:            exampleResourceGroup.Location,
			CosmosdbContainerId: exampleSqlContainer.ID(),
			KustoDatabaseId:     exampleDatabase.ID(),
			ManagedIdentityId:   exampleCluster.ID(),
			TableName:           pulumi.String("TestTable"),
			MappingRuleName:     pulumi.String("TestMapping"),
			RetrievalStartDate:  pulumi.String("2023-06-26T12:00:00.6554616Z"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var current = Azure.Core.GetClientConfig.Invoke();

    var exampleResourceGroup = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "exampleRG",
        Location = "West Europe",
    });

    var builtin = Azure.Authorization.GetRoleDefinition.Invoke(new()
    {
        RoleDefinitionId = "fbdf93bf-df7d-467e-a4d2-9458aa1360c8",
    });

    var exampleCluster = new Azure.Kusto.Cluster("example", new()
    {
        Name = "examplekc",
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        Sku = new Azure.Kusto.Inputs.ClusterSkuArgs
        {
            Name = "Dev(No SLA)_Standard_D11_v2",
            Capacity = 1,
        },
        Identity = new Azure.Kusto.Inputs.ClusterIdentityArgs
        {
            Type = "SystemAssigned",
        },
    });

    var exampleAssignment = new Azure.Authorization.Assignment("example", new()
    {
        Scope = exampleResourceGroup.Id,
        RoleDefinitionName = builtin.Apply(getRoleDefinitionResult => getRoleDefinitionResult.Name),
        PrincipalId = exampleCluster.Identity.Apply(identity => identity?.PrincipalId),
    });

    var exampleAccount = new Azure.CosmosDB.Account("example", new()
    {
        Name = "example-ca",
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        OfferType = "Standard",
        Kind = "GlobalDocumentDB",
        ConsistencyPolicy = new Azure.CosmosDB.Inputs.AccountConsistencyPolicyArgs
        {
            ConsistencyLevel = "Session",
            MaxIntervalInSeconds = 5,
            MaxStalenessPrefix = 100,
        },
        GeoLocations = new[]
        {
            new Azure.CosmosDB.Inputs.AccountGeoLocationArgs
            {
                Location = exampleResourceGroup.Location,
                FailoverPriority = 0,
            },
        },
    });

    var exampleSqlDatabase = new Azure.CosmosDB.SqlDatabase("example", new()
    {
        Name = "examplecosmosdbsqldb",
        ResourceGroupName = exampleAccount.ResourceGroupName,
        AccountName = exampleAccount.Name,
    });

    var exampleSqlContainer = new Azure.CosmosDB.SqlContainer("example", new()
    {
        Name = "examplecosmosdbsqlcon",
        ResourceGroupName = exampleAccount.ResourceGroupName,
        AccountName = exampleAccount.Name,
        DatabaseName = exampleSqlDatabase.Name,
        PartitionKeyPath = "/part",
        Throughput = 400,
    });

    var example = Azure.CosmosDB.GetSqlRoleDefinition.Invoke(new()
    {
        RoleDefinitionId = "00000000-0000-0000-0000-000000000001",
        ResourceGroupName = exampleResourceGroup.Name,
        AccountName = exampleAccount.Name,
    });

    var exampleSqlRoleAssignment = new Azure.CosmosDB.SqlRoleAssignment("example", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        AccountName = exampleAccount.Name,
        RoleDefinitionId = example.Apply(getSqlRoleDefinitionResult => getSqlRoleDefinitionResult.Id),
        PrincipalId = exampleCluster.Identity.Apply(identity => identity?.PrincipalId),
        Scope = exampleAccount.Id,
    });

    var exampleDatabase = new Azure.Kusto.Database("example", new()
    {
        Name = "examplekd",
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        ClusterName = exampleCluster.Name,
    });

    var exampleScript = new Azure.Kusto.Script("example", new()
    {
        Name = "create-table-script",
        DatabaseId = exampleDatabase.Id,
        ScriptContent = @".create table TestTable(Id:string, Name:string, _ts:long, _timestamp:datetime)
.create table TestTable ingestion json mapping ""TestMapping""
'['
'    {""column"":""Id"",""path"":""$.id""},'
'    {""column"":""Name"",""path"":""$.name""},'
'    {""column"":""_ts"",""path"":""$._ts""},'
'    {""column"":""_timestamp"",""path"":""$._ts"", ""transform"":""DateTimeFromUnixSeconds""}'
']'
.alter table TestTable policy ingestionbatching ""{'MaximumBatchingTimeSpan': '0:0:10', 'MaximumNumberOfItems': 10000}""
",
    });

    var exampleCosmosdbDataConnection = new Azure.Kusto.CosmosdbDataConnection("example", new()
    {
        Name = "examplekcdcd",
        Location = exampleResourceGroup.Location,
        CosmosdbContainerId = exampleSqlContainer.Id,
        KustoDatabaseId = exampleDatabase.Id,
        ManagedIdentityId = exampleCluster.Id,
        TableName = "TestTable",
        MappingRuleName = "TestMapping",
        RetrievalStartDate = "2023-06-26T12:00:00.6554616Z",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.CoreFunctions;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.authorization.AuthorizationFunctions;
import com.pulumi.azure.authorization.inputs.GetRoleDefinitionArgs;
import com.pulumi.azure.kusto.Cluster;
import com.pulumi.azure.kusto.ClusterArgs;
import com.pulumi.azure.kusto.inputs.ClusterSkuArgs;
import com.pulumi.azure.kusto.inputs.ClusterIdentityArgs;
import com.pulumi.azure.authorization.Assignment;
import com.pulumi.azure.authorization.AssignmentArgs;
import com.pulumi.azure.cosmosdb.Account;
import com.pulumi.azure.cosmosdb.AccountArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountConsistencyPolicyArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountGeoLocationArgs;
import com.pulumi.azure.cosmosdb.SqlDatabase;
import com.pulumi.azure.cosmosdb.SqlDatabaseArgs;
import com.pulumi.azure.cosmosdb.SqlContainer;
import com.pulumi.azure.cosmosdb.SqlContainerArgs;
import com.pulumi.azure.cosmosdb.CosmosdbFunctions;
import com.pulumi.azure.cosmosdb.inputs.GetSqlRoleDefinitionArgs;
import com.pulumi.azure.cosmosdb.SqlRoleAssignment;
import com.pulumi.azure.cosmosdb.SqlRoleAssignmentArgs;
import com.pulumi.azure.kusto.Database;
import com.pulumi.azure.kusto.DatabaseArgs;
import com.pulumi.azure.kusto.Script;
import com.pulumi.azure.kusto.ScriptArgs;
import com.pulumi.azure.kusto.CosmosdbDataConnection;
import com.pulumi.azure.kusto.CosmosdbDataConnectionArgs;
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) {
        final var current = CoreFunctions.getClientConfig();

        var exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()        
            .name("exampleRG")
            .location("West Europe")
            .build());

        final var builtin = AuthorizationFunctions.getRoleDefinition(GetRoleDefinitionArgs.builder()
            .roleDefinitionId("fbdf93bf-df7d-467e-a4d2-9458aa1360c8")
            .build());

        var exampleCluster = new Cluster("exampleCluster", ClusterArgs.builder()        
            .name("examplekc")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .sku(ClusterSkuArgs.builder()
                .name("Dev(No SLA)_Standard_D11_v2")
                .capacity(1)
                .build())
            .identity(ClusterIdentityArgs.builder()
                .type("SystemAssigned")
                .build())
            .build());

        var exampleAssignment = new Assignment("exampleAssignment", AssignmentArgs.builder()        
            .scope(exampleResourceGroup.id())
            .roleDefinitionName(builtin.applyValue(getRoleDefinitionResult -> getRoleDefinitionResult.name()))
            .principalId(exampleCluster.identity().applyValue(identity -> identity.principalId()))
            .build());

        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()        
            .name("example-ca")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .offerType("Standard")
            .kind("GlobalDocumentDB")
            .consistencyPolicy(AccountConsistencyPolicyArgs.builder()
                .consistencyLevel("Session")
                .maxIntervalInSeconds(5)
                .maxStalenessPrefix(100)
                .build())
            .geoLocations(AccountGeoLocationArgs.builder()
                .location(exampleResourceGroup.location())
                .failoverPriority(0)
                .build())
            .build());

        var exampleSqlDatabase = new SqlDatabase("exampleSqlDatabase", SqlDatabaseArgs.builder()        
            .name("examplecosmosdbsqldb")
            .resourceGroupName(exampleAccount.resourceGroupName())
            .accountName(exampleAccount.name())
            .build());

        var exampleSqlContainer = new SqlContainer("exampleSqlContainer", SqlContainerArgs.builder()        
            .name("examplecosmosdbsqlcon")
            .resourceGroupName(exampleAccount.resourceGroupName())
            .accountName(exampleAccount.name())
            .databaseName(exampleSqlDatabase.name())
            .partitionKeyPath("/part")
            .throughput(400)
            .build());

        final var example = CosmosdbFunctions.getSqlRoleDefinition(GetSqlRoleDefinitionArgs.builder()
            .roleDefinitionId("00000000-0000-0000-0000-000000000001")
            .resourceGroupName(exampleResourceGroup.name())
            .accountName(exampleAccount.name())
            .build());

        var exampleSqlRoleAssignment = new SqlRoleAssignment("exampleSqlRoleAssignment", SqlRoleAssignmentArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .accountName(exampleAccount.name())
            .roleDefinitionId(example.applyValue(getSqlRoleDefinitionResult -> getSqlRoleDefinitionResult).applyValue(example -> example.applyValue(getSqlRoleDefinitionResult -> getSqlRoleDefinitionResult.id())))
            .principalId(exampleCluster.identity().applyValue(identity -> identity.principalId()))
            .scope(exampleAccount.id())
            .build());

        var exampleDatabase = new Database("exampleDatabase", DatabaseArgs.builder()        
            .name("examplekd")
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .clusterName(exampleCluster.name())
            .build());

        var exampleScript = new Script("exampleScript", ScriptArgs.builder()        
            .name("create-table-script")
            .databaseId(exampleDatabase.id())
            .scriptContent("""
.create table TestTable(Id:string, Name:string, _ts:long, _timestamp:datetime)
.create table TestTable ingestion json mapping "TestMapping"
'['
'    {"column":"Id","path":"$.id"},'
'    {"column":"Name","path":"$.name"},'
'    {"column":"_ts","path":"$._ts"},'
'    {"column":"_timestamp","path":"$._ts", "transform":"DateTimeFromUnixSeconds"}'
']'
.alter table TestTable policy ingestionbatching "{'MaximumBatchingTimeSpan': '0:0:10', 'MaximumNumberOfItems': 10000}"
            """)
            .build());

        var exampleCosmosdbDataConnection = new CosmosdbDataConnection("exampleCosmosdbDataConnection", CosmosdbDataConnectionArgs.builder()        
            .name("examplekcdcd")
            .location(exampleResourceGroup.location())
            .cosmosdbContainerId(exampleSqlContainer.id())
            .kustoDatabaseId(exampleDatabase.id())
            .managedIdentityId(exampleCluster.id())
            .tableName("TestTable")
            .mappingRuleName("TestMapping")
            .retrievalStartDate("2023-06-26T12:00:00.6554616Z")
            .build());

    }
}

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    name: example
    properties:
      name: exampleRG
      location: West Europe
  exampleAssignment:
    type: azure:authorization:Assignment
    name: example
    properties:
      scope: ${exampleResourceGroup.id}
      roleDefinitionName: ${builtin.name}
      principalId: ${exampleCluster.identity.principalId}
  exampleAccount:
    type: azure:cosmosdb:Account
    name: example
    properties:
      name: example-ca
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      offerType: Standard
      kind: GlobalDocumentDB
      consistencyPolicy:
        consistencyLevel: Session
        maxIntervalInSeconds: 5
        maxStalenessPrefix: 100
      geoLocations:
        - location: ${exampleResourceGroup.location}
          failoverPriority: 0
  exampleSqlDatabase:
    type: azure:cosmosdb:SqlDatabase
    name: example
    properties:
      name: examplecosmosdbsqldb
      resourceGroupName: ${exampleAccount.resourceGroupName}
      accountName: ${exampleAccount.name}
  exampleSqlContainer:
    type: azure:cosmosdb:SqlContainer
    name: example
    properties:
      name: examplecosmosdbsqlcon
      resourceGroupName: ${exampleAccount.resourceGroupName}
      accountName: ${exampleAccount.name}
      databaseName: ${exampleSqlDatabase.name}
      partitionKeyPath: /part
      throughput: 400
  exampleSqlRoleAssignment:
    type: azure:cosmosdb:SqlRoleAssignment
    name: example
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      accountName: ${exampleAccount.name}
      roleDefinitionId: ${example.id}
      principalId: ${exampleCluster.identity.principalId}
      scope: ${exampleAccount.id}
  exampleCluster:
    type: azure:kusto:Cluster
    name: example
    properties:
      name: examplekc
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      sku:
        name: Dev(No SLA)_Standard_D11_v2
        capacity: 1
      identity:
        type: SystemAssigned
  exampleDatabase:
    type: azure:kusto:Database
    name: example
    properties:
      name: examplekd
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      clusterName: ${exampleCluster.name}
  exampleScript:
    type: azure:kusto:Script
    name: example
    properties:
      name: create-table-script
      databaseId: ${exampleDatabase.id}
      scriptContent: |
        .create table TestTable(Id:string, Name:string, _ts:long, _timestamp:datetime)
        .create table TestTable ingestion json mapping "TestMapping"
        '['
        '    {"column":"Id","path":"$.id"},'
        '    {"column":"Name","path":"$.name"},'
        '    {"column":"_ts","path":"$._ts"},'
        '    {"column":"_timestamp","path":"$._ts", "transform":"DateTimeFromUnixSeconds"}'
        ']'
        .alter table TestTable policy ingestionbatching "{'MaximumBatchingTimeSpan': '0:0:10', 'MaximumNumberOfItems': 10000}"        
  exampleCosmosdbDataConnection:
    type: azure:kusto:CosmosdbDataConnection
    name: example
    properties:
      name: examplekcdcd
      location: ${exampleResourceGroup.location}
      cosmosdbContainerId: ${exampleSqlContainer.id}
      kustoDatabaseId: ${exampleDatabase.id}
      managedIdentityId: ${exampleCluster.id}
      tableName: TestTable
      mappingRuleName: TestMapping
      retrievalStartDate: 2023-06-26T12:00:00.6554616Z
variables:
  current:
    fn::invoke:
      Function: azure:core:getClientConfig
      Arguments: {}
  builtin:
    fn::invoke:
      Function: azure:authorization:getRoleDefinition
      Arguments:
        roleDefinitionId: fbdf93bf-df7d-467e-a4d2-9458aa1360c8
  example:
    fn::invoke:
      Function: azure:cosmosdb:getSqlRoleDefinition
      Arguments:
        roleDefinitionId: 00000000-0000-0000-0000-000000000001
        resourceGroupName: ${exampleResourceGroup.name}
        accountName: ${exampleAccount.name}

var cosmosdbDataConnectionResource = new Azure.Kusto.CosmosdbDataConnection("cosmosdbDataConnectionResource", new()
{
    CosmosdbContainerId = "string",
    KustoDatabaseId = "string",
    ManagedIdentityId = "string",
    TableName = "string",
    Location = "string",
    MappingRuleName = "string",
    Name = "string",
    RetrievalStartDate = "string",
});

example, err := kusto.NewCosmosdbDataConnection(ctx, "cosmosdbDataConnectionResource", &kusto.CosmosdbDataConnectionArgs{
	CosmosdbContainerId: pulumi.String("string"),
	KustoDatabaseId:     pulumi.String("string"),
	ManagedIdentityId:   pulumi.String("string"),
	TableName:           pulumi.String("string"),
	Location:            pulumi.String("string"),
	MappingRuleName:     pulumi.String("string"),
	Name:                pulumi.String("string"),
	RetrievalStartDate:  pulumi.String("string"),
})

var cosmosdbDataConnectionResource = new CosmosdbDataConnection("cosmosdbDataConnectionResource", CosmosdbDataConnectionArgs.builder()        
    .cosmosdbContainerId("string")
    .kustoDatabaseId("string")
    .managedIdentityId("string")
    .tableName("string")
    .location("string")
    .mappingRuleName("string")
    .name("string")
    .retrievalStartDate("string")
    .build());

cosmosdb_data_connection_resource = azure.kusto.CosmosdbDataConnection("cosmosdbDataConnectionResource",
    cosmosdb_container_id="string",
    kusto_database_id="string",
    managed_identity_id="string",
    table_name="string",
    location="string",
    mapping_rule_name="string",
    name="string",
    retrieval_start_date="string")

const cosmosdbDataConnectionResource = new azure.kusto.CosmosdbDataConnection("cosmosdbDataConnectionResource", {
    cosmosdbContainerId: "string",
    kustoDatabaseId: "string",
    managedIdentityId: "string",
    tableName: "string",
    location: "string",
    mappingRuleName: "string",
    name: "string",
    retrievalStartDate: "string",
});

type: azure:kusto:CosmosdbDataConnection
properties:
    cosmosdbContainerId: string
    kustoDatabaseId: string
    location: string
    managedIdentityId: string
    mappingRuleName: string
    name: string
    retrievalStartDate: string
    tableName: string