GremlinResourceGremlinGraphArgs

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var gremlinResourceGremlinGraph = new AzureNative.DocumentDB.GremlinResourceGremlinGraph("gremlinResourceGremlinGraph", new()
    {
        AccountName = "ddb1",
        DatabaseName = "databaseName",
        GraphName = "graphName",
        Location = "West US",
        Options = null,
        Resource = new AzureNative.DocumentDB.Inputs.GremlinGraphResourceArgs
        {
            ConflictResolutionPolicy = new AzureNative.DocumentDB.Inputs.ConflictResolutionPolicyArgs
            {
                ConflictResolutionPath = "/path",
                Mode = "LastWriterWins",
            },
            DefaultTtl = 100,
            Id = "graphName",
            IndexingPolicy = new AzureNative.DocumentDB.Inputs.IndexingPolicyArgs
            {
                Automatic = true,
                ExcludedPaths = new[] {},
                IncludedPaths = new[]
                {
                    new AzureNative.DocumentDB.Inputs.IncludedPathArgs
                    {
                        Indexes = new[]
                        {
                            new AzureNative.DocumentDB.Inputs.IndexesArgs
                            {
                                DataType = "String",
                                Kind = "Range",
                                Precision = -1,
                            },
                            new AzureNative.DocumentDB.Inputs.IndexesArgs
                            {
                                DataType = "Number",
                                Kind = "Range",
                                Precision = -1,
                            },
                        },
                        Path = "/*",
                    },
                },
                IndexingMode = "consistent",
            },
            PartitionKey = new AzureNative.DocumentDB.Inputs.ContainerPartitionKeyArgs
            {
                Kind = "Hash",
                Paths = new[]
                {
                    "/AccountNumber",
                },
            },
            UniqueKeyPolicy = new AzureNative.DocumentDB.Inputs.UniqueKeyPolicyArgs
            {
                UniqueKeys = new[]
                {
                    new AzureNative.DocumentDB.Inputs.UniqueKeyArgs
                    {
                        Paths = new[]
                        {
                            "/testPath",
                        },
                    },
                },
            },
        },
        ResourceGroupName = "rg1",
        Tags = null,
    });
});

package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/documentdb/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := documentdb.NewGremlinResourceGremlinGraph(ctx, "gremlinResourceGremlinGraph", &documentdb.GremlinResourceGremlinGraphArgs{
AccountName: pulumi.String("ddb1"),
DatabaseName: pulumi.String("databaseName"),
GraphName: pulumi.String("graphName"),
Location: pulumi.String("West US"),
Options: nil,
Resource: documentdb.GremlinGraphGetPropertiesResponseResource{
ConflictResolutionPolicy: &documentdb.ConflictResolutionPolicyArgs{
ConflictResolutionPath: pulumi.String("/path"),
Mode: pulumi.String("LastWriterWins"),
},
DefaultTtl: pulumi.Int(100),
Id: pulumi.String("graphName"),
IndexingPolicy: interface{}{
Automatic: pulumi.Bool(true),
ExcludedPaths: documentdb.ExcludedPathArray{
},
IncludedPaths: documentdb.IncludedPathArray{
interface{}{
Indexes: documentdb.IndexesArray{
&documentdb.IndexesArgs{
DataType: pulumi.String("String"),
Kind: pulumi.String("Range"),
Precision: -1,
},
&documentdb.IndexesArgs{
DataType: pulumi.String("Number"),
Kind: pulumi.String("Range"),
Precision: -1,
},
},
Path: pulumi.String("/*"),
},
},
IndexingMode: pulumi.String("consistent"),
},
PartitionKey: &documentdb.ContainerPartitionKeyArgs{
Kind: pulumi.String("Hash"),
Paths: pulumi.StringArray{
pulumi.String("/AccountNumber"),
},
},
UniqueKeyPolicy: interface{}{
UniqueKeys: documentdb.UniqueKeyArray{
&documentdb.UniqueKeyArgs{
Paths: pulumi.StringArray{
pulumi.String("/testPath"),
},
},
},
},
},
ResourceGroupName: pulumi.String("rg1"),
Tags: nil,
})
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.azurenative.documentdb.GremlinResourceGremlinGraph;
import com.pulumi.azurenative.documentdb.GremlinResourceGremlinGraphArgs;
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 gremlinResourceGremlinGraph = new GremlinResourceGremlinGraph("gremlinResourceGremlinGraph", GremlinResourceGremlinGraphArgs.builder()
            .accountName("ddb1")
            .databaseName("databaseName")
            .graphName("graphName")
            .location("West US")
            .options()
            .resource(Map.ofEntries(
                Map.entry("conflictResolutionPolicy", Map.ofEntries(
                    Map.entry("conflictResolutionPath", "/path"),
                    Map.entry("mode", "LastWriterWins")
                )),
                Map.entry("defaultTtl", 100),
                Map.entry("id", "graphName"),
                Map.entry("indexingPolicy", Map.ofEntries(
                    Map.entry("automatic", true),
                    Map.entry("excludedPaths", ),
                    Map.entry("includedPaths", Map.ofEntries(
                        Map.entry("indexes",
                            Map.ofEntries(
                                Map.entry("dataType", "String"),
                                Map.entry("kind", "Range"),
                                Map.entry("precision", "TODO: GenUnaryOpExpression")
                            ),
                            Map.ofEntries(
                                Map.entry("dataType", "Number"),
                                Map.entry("kind", "Range"),
                                Map.entry("precision", "TODO: GenUnaryOpExpression")
                            )),
                        Map.entry("path", "/*")
                    )),
                    Map.entry("indexingMode", "consistent")
                )),
                Map.entry("partitionKey", Map.ofEntries(
                    Map.entry("kind", "Hash"),
                    Map.entry("paths", "/AccountNumber")
                )),
                Map.entry("uniqueKeyPolicy", Map.of("uniqueKeys", Map.of("paths", "/testPath")))
            ))
            .resourceGroupName("rg1")
            .tags()
            .build());
    }
}

$ pulumi import azure-native:documentdb:GremlinResourceGremlinGraph graphName /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/gremlinDatabases/{databaseName}/graphs/{graphName}