azure.cosmosdb.Account

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

const rg = new azure.core.ResourceGroup("rg", {
    name: "sample-rg",
    location: "westus",
});
const ri = new random.RandomInteger("ri", {
    min: 10000,
    max: 99999,
});
const db = new azure.cosmosdb.Account("db", {
    name: pulumi.interpolate`tfex-cosmos-db-${ri.result}`,
    location: example.location,
    resourceGroupName: example.name,
    offerType: "Standard",
    kind: "MongoDB",
    automaticFailoverEnabled: true,
    capabilities: [
        {
            name: "EnableAggregationPipeline",
        },
        {
            name: "mongoEnableDocLevelTTL",
        },
        {
            name: "MongoDBv3.4",
        },
        {
            name: "EnableMongo",
        },
    ],
    consistencyPolicy: {
        consistencyLevel: "BoundedStaleness",
        maxIntervalInSeconds: 300,
        maxStalenessPrefix: 100000,
    },
    geoLocations: [
        {
            location: "eastus",
            failoverPriority: 1,
        },
        {
            location: "westus",
            failoverPriority: 0,
        },
    ],
});

import pulumi
import pulumi_azure as azure
import pulumi_random as random

rg = azure.core.ResourceGroup("rg",
    name="sample-rg",
    location="westus")
ri = random.RandomInteger("ri",
    min=10000,
    max=99999)
db = azure.cosmosdb.Account("db",
    name=ri.result.apply(lambda result: f"tfex-cosmos-db-{result}"),
    location=example["location"],
    resource_group_name=example["name"],
    offer_type="Standard",
    kind="MongoDB",
    automatic_failover_enabled=True,
    capabilities=[
        {
            "name": "EnableAggregationPipeline",
        },
        {
            "name": "mongoEnableDocLevelTTL",
        },
        {
            "name": "MongoDBv3.4",
        },
        {
            "name": "EnableMongo",
        },
    ],
    consistency_policy={
        "consistency_level": "BoundedStaleness",
        "max_interval_in_seconds": 300,
        "max_staleness_prefix": 100000,
    },
    geo_locations=[
        {
            "location": "eastus",
            "failover_priority": 1,
        },
        {
            "location": "westus",
            "failover_priority": 0,
        },
    ])

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/cosmosdb"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := core.NewResourceGroup(ctx, "rg", &core.ResourceGroupArgs{
			Name:     pulumi.String("sample-rg"),
			Location: pulumi.String("westus"),
		})
		if err != nil {
			return err
		}
		ri, err := random.NewRandomInteger(ctx, "ri", &random.RandomIntegerArgs{
			Min: pulumi.Int(10000),
			Max: pulumi.Int(99999),
		})
		if err != nil {
			return err
		}
		_, err = cosmosdb.NewAccount(ctx, "db", &cosmosdb.AccountArgs{
			Name: ri.Result.ApplyT(func(result int) (string, error) {
				return fmt.Sprintf("tfex-cosmos-db-%v", result), nil
			}).(pulumi.StringOutput),
			Location:                 pulumi.Any(example.Location),
			ResourceGroupName:        pulumi.Any(example.Name),
			OfferType:                pulumi.String("Standard"),
			Kind:                     pulumi.String("MongoDB"),
			AutomaticFailoverEnabled: pulumi.Bool(true),
			Capabilities: cosmosdb.AccountCapabilityArray{
				&cosmosdb.AccountCapabilityArgs{
					Name: pulumi.String("EnableAggregationPipeline"),
				},
				&cosmosdb.AccountCapabilityArgs{
					Name: pulumi.String("mongoEnableDocLevelTTL"),
				},
				&cosmosdb.AccountCapabilityArgs{
					Name: pulumi.String("MongoDBv3.4"),
				},
				&cosmosdb.AccountCapabilityArgs{
					Name: pulumi.String("EnableMongo"),
				},
			},
			ConsistencyPolicy: &cosmosdb.AccountConsistencyPolicyArgs{
				ConsistencyLevel:     pulumi.String("BoundedStaleness"),
				MaxIntervalInSeconds: pulumi.Int(300),
				MaxStalenessPrefix:   pulumi.Int(100000),
			},
			GeoLocations: cosmosdb.AccountGeoLocationArray{
				&cosmosdb.AccountGeoLocationArgs{
					Location:         pulumi.String("eastus"),
					FailoverPriority: pulumi.Int(1),
				},
				&cosmosdb.AccountGeoLocationArgs{
					Location:         pulumi.String("westus"),
					FailoverPriority: pulumi.Int(0),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var rg = new Azure.Core.ResourceGroup("rg", new()
    {
        Name = "sample-rg",
        Location = "westus",
    });

    var ri = new Random.RandomInteger("ri", new()
    {
        Min = 10000,
        Max = 99999,
    });

    var db = new Azure.CosmosDB.Account("db", new()
    {
        Name = ri.Result.Apply(result => $"tfex-cosmos-db-{result}"),
        Location = example.Location,
        ResourceGroupName = example.Name,
        OfferType = "Standard",
        Kind = "MongoDB",
        AutomaticFailoverEnabled = true,
        Capabilities = new[]
        {
            new Azure.CosmosDB.Inputs.AccountCapabilityArgs
            {
                Name = "EnableAggregationPipeline",
            },
            new Azure.CosmosDB.Inputs.AccountCapabilityArgs
            {
                Name = "mongoEnableDocLevelTTL",
            },
            new Azure.CosmosDB.Inputs.AccountCapabilityArgs
            {
                Name = "MongoDBv3.4",
            },
            new Azure.CosmosDB.Inputs.AccountCapabilityArgs
            {
                Name = "EnableMongo",
            },
        },
        ConsistencyPolicy = new Azure.CosmosDB.Inputs.AccountConsistencyPolicyArgs
        {
            ConsistencyLevel = "BoundedStaleness",
            MaxIntervalInSeconds = 300,
            MaxStalenessPrefix = 100000,
        },
        GeoLocations = new[]
        {
            new Azure.CosmosDB.Inputs.AccountGeoLocationArgs
            {
                Location = "eastus",
                FailoverPriority = 1,
            },
            new Azure.CosmosDB.Inputs.AccountGeoLocationArgs
            {
                Location = "westus",
                FailoverPriority = 0,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.random.RandomInteger;
import com.pulumi.random.RandomIntegerArgs;
import com.pulumi.azure.cosmosdb.Account;
import com.pulumi.azure.cosmosdb.AccountArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountCapabilityArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountConsistencyPolicyArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountGeoLocationArgs;
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 rg = new ResourceGroup("rg", ResourceGroupArgs.builder()
            .name("sample-rg")
            .location("westus")
            .build());

        var ri = new RandomInteger("ri", RandomIntegerArgs.builder()
            .min(10000)
            .max(99999)
            .build());

        var db = new Account("db", AccountArgs.builder()
            .name(ri.result().applyValue(result -> String.format("tfex-cosmos-db-%s", result)))
            .location(example.location())
            .resourceGroupName(example.name())
            .offerType("Standard")
            .kind("MongoDB")
            .automaticFailoverEnabled(true)
            .capabilities(            
                AccountCapabilityArgs.builder()
                    .name("EnableAggregationPipeline")
                    .build(),
                AccountCapabilityArgs.builder()
                    .name("mongoEnableDocLevelTTL")
                    .build(),
                AccountCapabilityArgs.builder()
                    .name("MongoDBv3.4")
                    .build(),
                AccountCapabilityArgs.builder()
                    .name("EnableMongo")
                    .build())
            .consistencyPolicy(AccountConsistencyPolicyArgs.builder()
                .consistencyLevel("BoundedStaleness")
                .maxIntervalInSeconds(300)
                .maxStalenessPrefix(100000)
                .build())
            .geoLocations(            
                AccountGeoLocationArgs.builder()
                    .location("eastus")
                    .failoverPriority(1)
                    .build(),
                AccountGeoLocationArgs.builder()
                    .location("westus")
                    .failoverPriority(0)
                    .build())
            .build());

    }
}

resources:
  rg:
    type: azure:core:ResourceGroup
    properties:
      name: sample-rg
      location: westus
  ri:
    type: random:RandomInteger
    properties:
      min: 10000
      max: 99999
  db:
    type: azure:cosmosdb:Account
    properties:
      name: tfex-cosmos-db-${ri.result}
      location: ${example.location}
      resourceGroupName: ${example.name}
      offerType: Standard
      kind: MongoDB
      automaticFailoverEnabled: true
      capabilities:
        - name: EnableAggregationPipeline
        - name: mongoEnableDocLevelTTL
        - name: MongoDBv3.4
        - name: EnableMongo
      consistencyPolicy:
        consistencyLevel: BoundedStaleness
        maxIntervalInSeconds: 300
        maxStalenessPrefix: 100000
      geoLocations:
        - location: eastus
          failoverPriority: 1
        - location: westus
          failoverPriority: 0

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

const example = new azure.authorization.UserAssignedIdentity("example", {
    resourceGroupName: exampleAzurermResourceGroup.name,
    location: exampleAzurermResourceGroup.location,
    name: "example-resource",
});
const exampleAccount = new azure.cosmosdb.Account("example", {
    name: "example-resource",
    location: exampleAzurermResourceGroup.location,
    resourceGroupName: exampleAzurermResourceGroup.name,
    defaultIdentityType: std.joinOutput({
        separator: "=",
        input: [
            "UserAssignedIdentity",
            example.id,
        ],
    }).apply(invoke => invoke.result),
    offerType: "Standard",
    kind: "MongoDB",
    capabilities: [{
        name: "EnableMongo",
    }],
    consistencyPolicy: {
        consistencyLevel: "Strong",
    },
    geoLocations: [{
        location: "westus",
        failoverPriority: 0,
    }],
    identity: {
        type: "UserAssigned",
        identityIds: [example.id],
    },
});

import pulumi
import pulumi_azure as azure
import pulumi_std as std

example = azure.authorization.UserAssignedIdentity("example",
    resource_group_name=example_azurerm_resource_group["name"],
    location=example_azurerm_resource_group["location"],
    name="example-resource")
example_account = azure.cosmosdb.Account("example",
    name="example-resource",
    location=example_azurerm_resource_group["location"],
    resource_group_name=example_azurerm_resource_group["name"],
    default_identity_type=std.join_output(separator="=",
        input=[
            "UserAssignedIdentity",
            example.id,
        ]).apply(lambda invoke: invoke.result),
    offer_type="Standard",
    kind="MongoDB",
    capabilities=[{
        "name": "EnableMongo",
    }],
    consistency_policy={
        "consistency_level": "Strong",
    },
    geo_locations=[{
        "location": "westus",
        "failover_priority": 0,
    }],
    identity={
        "type": "UserAssigned",
        "identity_ids": [example.id],
    })

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/cosmosdb"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := authorization.NewUserAssignedIdentity(ctx, "example", &authorization.UserAssignedIdentityArgs{
			ResourceGroupName: pulumi.Any(exampleAzurermResourceGroup.Name),
			Location:          pulumi.Any(exampleAzurermResourceGroup.Location),
			Name:              pulumi.String("example-resource"),
		})
		if err != nil {
			return err
		}
		_, err = cosmosdb.NewAccount(ctx, "example", &cosmosdb.AccountArgs{
			Name:              pulumi.String("example-resource"),
			Location:          pulumi.Any(exampleAzurermResourceGroup.Location),
			ResourceGroupName: pulumi.Any(exampleAzurermResourceGroup.Name),
			DefaultIdentityType: pulumi.String(std.JoinOutput(ctx, std.JoinOutputArgs{
				Separator: pulumi.String("="),
				Input: pulumi.StringArray{
					pulumi.String("UserAssignedIdentity"),
					example.ID(),
				},
			}, nil).ApplyT(func(invoke std.JoinResult) (*string, error) {
				return invoke.Result, nil
			}).(pulumi.StringPtrOutput)),
			OfferType: pulumi.String("Standard"),
			Kind:      pulumi.String("MongoDB"),
			Capabilities: cosmosdb.AccountCapabilityArray{
				&cosmosdb.AccountCapabilityArgs{
					Name: pulumi.String("EnableMongo"),
				},
			},
			ConsistencyPolicy: &cosmosdb.AccountConsistencyPolicyArgs{
				ConsistencyLevel: pulumi.String("Strong"),
			},
			GeoLocations: cosmosdb.AccountGeoLocationArray{
				&cosmosdb.AccountGeoLocationArgs{
					Location:         pulumi.String("westus"),
					FailoverPriority: pulumi.Int(0),
				},
			},
			Identity: &cosmosdb.AccountIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				IdentityIds: pulumi.StringArray{
					example.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Azure.Authorization.UserAssignedIdentity("example", new()
    {
        ResourceGroupName = exampleAzurermResourceGroup.Name,
        Location = exampleAzurermResourceGroup.Location,
        Name = "example-resource",
    });

    var exampleAccount = new Azure.CosmosDB.Account("example", new()
    {
        Name = "example-resource",
        Location = exampleAzurermResourceGroup.Location,
        ResourceGroupName = exampleAzurermResourceGroup.Name,
        DefaultIdentityType = Std.Join.Invoke(new()
        {
            Separator = "=",
            Input = new[]
            {
                "UserAssignedIdentity",
                example.Id,
            },
        }).Apply(invoke => invoke.Result),
        OfferType = "Standard",
        Kind = "MongoDB",
        Capabilities = new[]
        {
            new Azure.CosmosDB.Inputs.AccountCapabilityArgs
            {
                Name = "EnableMongo",
            },
        },
        ConsistencyPolicy = new Azure.CosmosDB.Inputs.AccountConsistencyPolicyArgs
        {
            ConsistencyLevel = "Strong",
        },
        GeoLocations = new[]
        {
            new Azure.CosmosDB.Inputs.AccountGeoLocationArgs
            {
                Location = "westus",
                FailoverPriority = 0,
            },
        },
        Identity = new Azure.CosmosDB.Inputs.AccountIdentityArgs
        {
            Type = "UserAssigned",
            IdentityIds = new[]
            {
                example.Id,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.authorization.UserAssignedIdentity;
import com.pulumi.azure.authorization.UserAssignedIdentityArgs;
import com.pulumi.azure.cosmosdb.Account;
import com.pulumi.azure.cosmosdb.AccountArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountCapabilityArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountConsistencyPolicyArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountGeoLocationArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountIdentityArgs;
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 example = new UserAssignedIdentity("example", UserAssignedIdentityArgs.builder()
            .resourceGroupName(exampleAzurermResourceGroup.name())
            .location(exampleAzurermResourceGroup.location())
            .name("example-resource")
            .build());

        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
            .name("example-resource")
            .location(exampleAzurermResourceGroup.location())
            .resourceGroupName(exampleAzurermResourceGroup.name())
            .defaultIdentityType(StdFunctions.join().applyValue(invoke -> invoke.result()))
            .offerType("Standard")
            .kind("MongoDB")
            .capabilities(AccountCapabilityArgs.builder()
                .name("EnableMongo")
                .build())
            .consistencyPolicy(AccountConsistencyPolicyArgs.builder()
                .consistencyLevel("Strong")
                .build())
            .geoLocations(AccountGeoLocationArgs.builder()
                .location("westus")
                .failoverPriority(0)
                .build())
            .identity(AccountIdentityArgs.builder()
                .type("UserAssigned")
                .identityIds(example.id())
                .build())
            .build());

    }
}

resources:
  example:
    type: azure:authorization:UserAssignedIdentity
    properties:
      resourceGroupName: ${exampleAzurermResourceGroup.name}
      location: ${exampleAzurermResourceGroup.location}
      name: example-resource
  exampleAccount:
    type: azure:cosmosdb:Account
    name: example
    properties:
      name: example-resource
      location: ${exampleAzurermResourceGroup.location}
      resourceGroupName: ${exampleAzurermResourceGroup.name}
      defaultIdentityType:
        fn::invoke:
          Function: std:join
          Arguments:
            separator: =
            input:
              - UserAssignedIdentity
              - ${example.id}
          Return: result
      offerType: Standard
      kind: MongoDB
      capabilities:
        - name: EnableMongo
      consistencyPolicy:
        consistencyLevel: Strong
      geoLocations:
        - location: westus
          failoverPriority: 0
      identity:
        type: UserAssigned
        identityIds:
          - ${example.id}

var exampleaccountResourceResourceFromCosmosdbaccount = new Azure.CosmosDB.Account("exampleaccountResourceResourceFromCosmosdbaccount", new()
{
    ConsistencyPolicy = new Azure.CosmosDB.Inputs.AccountConsistencyPolicyArgs
    {
        ConsistencyLevel = "string",
        MaxIntervalInSeconds = 0,
        MaxStalenessPrefix = 0,
    },
    ResourceGroupName = "string",
    OfferType = "string",
    GeoLocations = new[]
    {
        new Azure.CosmosDB.Inputs.AccountGeoLocationArgs
        {
            FailoverPriority = 0,
            Location = "string",
            Id = "string",
            ZoneRedundant = false,
        },
    },
    IsVirtualNetworkFilterEnabled = false,
    LocalAuthenticationDisabled = false,
    Capabilities = new[]
    {
        new Azure.CosmosDB.Inputs.AccountCapabilityArgs
        {
            Name = "string",
        },
    },
    Capacity = new Azure.CosmosDB.Inputs.AccountCapacityArgs
    {
        TotalThroughputLimit = 0,
    },
    Backup = new Azure.CosmosDB.Inputs.AccountBackupArgs
    {
        Type = "string",
        IntervalInMinutes = 0,
        RetentionInHours = 0,
        StorageRedundancy = "string",
        Tier = "string",
    },
    CorsRule = new Azure.CosmosDB.Inputs.AccountCorsRuleArgs
    {
        AllowedHeaders = new[]
        {
            "string",
        },
        AllowedMethods = new[]
        {
            "string",
        },
        AllowedOrigins = new[]
        {
            "string",
        },
        ExposedHeaders = new[]
        {
            "string",
        },
        MaxAgeInSeconds = 0,
    },
    CreateMode = "string",
    DefaultIdentityType = "string",
    FreeTierEnabled = false,
    AutomaticFailoverEnabled = false,
    Identity = new Azure.CosmosDB.Inputs.AccountIdentityArgs
    {
        Type = "string",
        IdentityIds = new[]
        {
            "string",
        },
        PrincipalId = "string",
        TenantId = "string",
    },
    IpRangeFilters = new[]
    {
        "string",
    },
    AccessKeyMetadataWritesEnabled = false,
    KeyVaultKeyId = "string",
    Kind = "string",
    BurstCapacityEnabled = false,
    Location = "string",
    ManagedHsmKeyId = "string",
    MinimalTlsVersion = "string",
    MongoServerVersion = "string",
    MultipleWriteLocationsEnabled = false,
    Name = "string",
    NetworkAclBypassForAzureServices = false,
    NetworkAclBypassIds = new[]
    {
        "string",
    },
    AnalyticalStorageEnabled = false,
    PartitionMergeEnabled = false,
    PublicNetworkAccessEnabled = false,
    AnalyticalStorage = new Azure.CosmosDB.Inputs.AccountAnalyticalStorageArgs
    {
        SchemaType = "string",
    },
    Restore = new Azure.CosmosDB.Inputs.AccountRestoreArgs
    {
        RestoreTimestampInUtc = "string",
        SourceCosmosdbAccountId = "string",
        Databases = new[]
        {
            new Azure.CosmosDB.Inputs.AccountRestoreDatabaseArgs
            {
                Name = "string",
                CollectionNames = new[]
                {
                    "string",
                },
            },
        },
        GremlinDatabases = new[]
        {
            new Azure.CosmosDB.Inputs.AccountRestoreGremlinDatabaseArgs
            {
                Name = "string",
                GraphNames = new[]
                {
                    "string",
                },
            },
        },
        TablesToRestores = new[]
        {
            "string",
        },
    },
    Tags = 
    {
        { "string", "string" },
    },
    VirtualNetworkRules = new[]
    {
        new Azure.CosmosDB.Inputs.AccountVirtualNetworkRuleArgs
        {
            Id = "string",
            IgnoreMissingVnetServiceEndpoint = false,
        },
    },
});

example, err := cosmosdb.NewAccount(ctx, "exampleaccountResourceResourceFromCosmosdbaccount", &cosmosdb.AccountArgs{
	ConsistencyPolicy: &cosmosdb.AccountConsistencyPolicyArgs{
		ConsistencyLevel:     pulumi.String("string"),
		MaxIntervalInSeconds: pulumi.Int(0),
		MaxStalenessPrefix:   pulumi.Int(0),
	},
	ResourceGroupName: pulumi.String("string"),
	OfferType:         pulumi.String("string"),
	GeoLocations: cosmosdb.AccountGeoLocationArray{
		&cosmosdb.AccountGeoLocationArgs{
			FailoverPriority: pulumi.Int(0),
			Location:         pulumi.String("string"),
			Id:               pulumi.String("string"),
			ZoneRedundant:    pulumi.Bool(false),
		},
	},
	IsVirtualNetworkFilterEnabled: pulumi.Bool(false),
	LocalAuthenticationDisabled:   pulumi.Bool(false),
	Capabilities: cosmosdb.AccountCapabilityArray{
		&cosmosdb.AccountCapabilityArgs{
			Name: pulumi.String("string"),
		},
	},
	Capacity: &cosmosdb.AccountCapacityArgs{
		TotalThroughputLimit: pulumi.Int(0),
	},
	Backup: &cosmosdb.AccountBackupArgs{
		Type:              pulumi.String("string"),
		IntervalInMinutes: pulumi.Int(0),
		RetentionInHours:  pulumi.Int(0),
		StorageRedundancy: pulumi.String("string"),
		Tier:              pulumi.String("string"),
	},
	CorsRule: &cosmosdb.AccountCorsRuleArgs{
		AllowedHeaders: pulumi.StringArray{
			pulumi.String("string"),
		},
		AllowedMethods: pulumi.StringArray{
			pulumi.String("string"),
		},
		AllowedOrigins: pulumi.StringArray{
			pulumi.String("string"),
		},
		ExposedHeaders: pulumi.StringArray{
			pulumi.String("string"),
		},
		MaxAgeInSeconds: pulumi.Int(0),
	},
	CreateMode:               pulumi.String("string"),
	DefaultIdentityType:      pulumi.String("string"),
	FreeTierEnabled:          pulumi.Bool(false),
	AutomaticFailoverEnabled: pulumi.Bool(false),
	Identity: &cosmosdb.AccountIdentityArgs{
		Type: pulumi.String("string"),
		IdentityIds: pulumi.StringArray{
			pulumi.String("string"),
		},
		PrincipalId: pulumi.String("string"),
		TenantId:    pulumi.String("string"),
	},
	IpRangeFilters: pulumi.StringArray{
		pulumi.String("string"),
	},
	AccessKeyMetadataWritesEnabled:   pulumi.Bool(false),
	KeyVaultKeyId:                    pulumi.String("string"),
	Kind:                             pulumi.String("string"),
	BurstCapacityEnabled:             pulumi.Bool(false),
	Location:                         pulumi.String("string"),
	ManagedHsmKeyId:                  pulumi.String("string"),
	MinimalTlsVersion:                pulumi.String("string"),
	MongoServerVersion:               pulumi.String("string"),
	MultipleWriteLocationsEnabled:    pulumi.Bool(false),
	Name:                             pulumi.String("string"),
	NetworkAclBypassForAzureServices: pulumi.Bool(false),
	NetworkAclBypassIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	AnalyticalStorageEnabled:   pulumi.Bool(false),
	PartitionMergeEnabled:      pulumi.Bool(false),
	PublicNetworkAccessEnabled: pulumi.Bool(false),
	AnalyticalStorage: &cosmosdb.AccountAnalyticalStorageArgs{
		SchemaType: pulumi.String("string"),
	},
	Restore: &cosmosdb.AccountRestoreArgs{
		RestoreTimestampInUtc:   pulumi.String("string"),
		SourceCosmosdbAccountId: pulumi.String("string"),
		Databases: cosmosdb.AccountRestoreDatabaseArray{
			&cosmosdb.AccountRestoreDatabaseArgs{
				Name: pulumi.String("string"),
				CollectionNames: pulumi.StringArray{
					pulumi.String("string"),
				},
			},
		},
		GremlinDatabases: cosmosdb.AccountRestoreGremlinDatabaseArray{
			&cosmosdb.AccountRestoreGremlinDatabaseArgs{
				Name: pulumi.String("string"),
				GraphNames: pulumi.StringArray{
					pulumi.String("string"),
				},
			},
		},
		TablesToRestores: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	VirtualNetworkRules: cosmosdb.AccountVirtualNetworkRuleArray{
		&cosmosdb.AccountVirtualNetworkRuleArgs{
			Id:                               pulumi.String("string"),
			IgnoreMissingVnetServiceEndpoint: pulumi.Bool(false),
		},
	},
})

var exampleaccountResourceResourceFromCosmosdbaccount = new Account("exampleaccountResourceResourceFromCosmosdbaccount", AccountArgs.builder()
    .consistencyPolicy(AccountConsistencyPolicyArgs.builder()
        .consistencyLevel("string")
        .maxIntervalInSeconds(0)
        .maxStalenessPrefix(0)
        .build())
    .resourceGroupName("string")
    .offerType("string")
    .geoLocations(AccountGeoLocationArgs.builder()
        .failoverPriority(0)
        .location("string")
        .id("string")
        .zoneRedundant(false)
        .build())
    .isVirtualNetworkFilterEnabled(false)
    .localAuthenticationDisabled(false)
    .capabilities(AccountCapabilityArgs.builder()
        .name("string")
        .build())
    .capacity(AccountCapacityArgs.builder()
        .totalThroughputLimit(0)
        .build())
    .backup(AccountBackupArgs.builder()
        .type("string")
        .intervalInMinutes(0)
        .retentionInHours(0)
        .storageRedundancy("string")
        .tier("string")
        .build())
    .corsRule(AccountCorsRuleArgs.builder()
        .allowedHeaders("string")
        .allowedMethods("string")
        .allowedOrigins("string")
        .exposedHeaders("string")
        .maxAgeInSeconds(0)
        .build())
    .createMode("string")
    .defaultIdentityType("string")
    .freeTierEnabled(false)
    .automaticFailoverEnabled(false)
    .identity(AccountIdentityArgs.builder()
        .type("string")
        .identityIds("string")
        .principalId("string")
        .tenantId("string")
        .build())
    .ipRangeFilters("string")
    .accessKeyMetadataWritesEnabled(false)
    .keyVaultKeyId("string")
    .kind("string")
    .burstCapacityEnabled(false)
    .location("string")
    .managedHsmKeyId("string")
    .minimalTlsVersion("string")
    .mongoServerVersion("string")
    .multipleWriteLocationsEnabled(false)
    .name("string")
    .networkAclBypassForAzureServices(false)
    .networkAclBypassIds("string")
    .analyticalStorageEnabled(false)
    .partitionMergeEnabled(false)
    .publicNetworkAccessEnabled(false)
    .analyticalStorage(AccountAnalyticalStorageArgs.builder()
        .schemaType("string")
        .build())
    .restore(AccountRestoreArgs.builder()
        .restoreTimestampInUtc("string")
        .sourceCosmosdbAccountId("string")
        .databases(AccountRestoreDatabaseArgs.builder()
            .name("string")
            .collectionNames("string")
            .build())
        .gremlinDatabases(AccountRestoreGremlinDatabaseArgs.builder()
            .name("string")
            .graphNames("string")
            .build())
        .tablesToRestores("string")
        .build())
    .tags(Map.of("string", "string"))
    .virtualNetworkRules(AccountVirtualNetworkRuleArgs.builder()
        .id("string")
        .ignoreMissingVnetServiceEndpoint(false)
        .build())
    .build());

exampleaccount_resource_resource_from_cosmosdbaccount = azure.cosmosdb.Account("exampleaccountResourceResourceFromCosmosdbaccount",
    consistency_policy={
        "consistency_level": "string",
        "max_interval_in_seconds": 0,
        "max_staleness_prefix": 0,
    },
    resource_group_name="string",
    offer_type="string",
    geo_locations=[{
        "failover_priority": 0,
        "location": "string",
        "id": "string",
        "zone_redundant": False,
    }],
    is_virtual_network_filter_enabled=False,
    local_authentication_disabled=False,
    capabilities=[{
        "name": "string",
    }],
    capacity={
        "total_throughput_limit": 0,
    },
    backup={
        "type": "string",
        "interval_in_minutes": 0,
        "retention_in_hours": 0,
        "storage_redundancy": "string",
        "tier": "string",
    },
    cors_rule={
        "allowed_headers": ["string"],
        "allowed_methods": ["string"],
        "allowed_origins": ["string"],
        "exposed_headers": ["string"],
        "max_age_in_seconds": 0,
    },
    create_mode="string",
    default_identity_type="string",
    free_tier_enabled=False,
    automatic_failover_enabled=False,
    identity={
        "type": "string",
        "identity_ids": ["string"],
        "principal_id": "string",
        "tenant_id": "string",
    },
    ip_range_filters=["string"],
    access_key_metadata_writes_enabled=False,
    key_vault_key_id="string",
    kind="string",
    burst_capacity_enabled=False,
    location="string",
    managed_hsm_key_id="string",
    minimal_tls_version="string",
    mongo_server_version="string",
    multiple_write_locations_enabled=False,
    name="string",
    network_acl_bypass_for_azure_services=False,
    network_acl_bypass_ids=["string"],
    analytical_storage_enabled=False,
    partition_merge_enabled=False,
    public_network_access_enabled=False,
    analytical_storage={
        "schema_type": "string",
    },
    restore={
        "restore_timestamp_in_utc": "string",
        "source_cosmosdb_account_id": "string",
        "databases": [{
            "name": "string",
            "collection_names": ["string"],
        }],
        "gremlin_databases": [{
            "name": "string",
            "graph_names": ["string"],
        }],
        "tables_to_restores": ["string"],
    },
    tags={
        "string": "string",
    },
    virtual_network_rules=[{
        "id": "string",
        "ignore_missing_vnet_service_endpoint": False,
    }])

const exampleaccountResourceResourceFromCosmosdbaccount = new azure.cosmosdb.Account("exampleaccountResourceResourceFromCosmosdbaccount", {
    consistencyPolicy: {
        consistencyLevel: "string",
        maxIntervalInSeconds: 0,
        maxStalenessPrefix: 0,
    },
    resourceGroupName: "string",
    offerType: "string",
    geoLocations: [{
        failoverPriority: 0,
        location: "string",
        id: "string",
        zoneRedundant: false,
    }],
    isVirtualNetworkFilterEnabled: false,
    localAuthenticationDisabled: false,
    capabilities: [{
        name: "string",
    }],
    capacity: {
        totalThroughputLimit: 0,
    },
    backup: {
        type: "string",
        intervalInMinutes: 0,
        retentionInHours: 0,
        storageRedundancy: "string",
        tier: "string",
    },
    corsRule: {
        allowedHeaders: ["string"],
        allowedMethods: ["string"],
        allowedOrigins: ["string"],
        exposedHeaders: ["string"],
        maxAgeInSeconds: 0,
    },
    createMode: "string",
    defaultIdentityType: "string",
    freeTierEnabled: false,
    automaticFailoverEnabled: false,
    identity: {
        type: "string",
        identityIds: ["string"],
        principalId: "string",
        tenantId: "string",
    },
    ipRangeFilters: ["string"],
    accessKeyMetadataWritesEnabled: false,
    keyVaultKeyId: "string",
    kind: "string",
    burstCapacityEnabled: false,
    location: "string",
    managedHsmKeyId: "string",
    minimalTlsVersion: "string",
    mongoServerVersion: "string",
    multipleWriteLocationsEnabled: false,
    name: "string",
    networkAclBypassForAzureServices: false,
    networkAclBypassIds: ["string"],
    analyticalStorageEnabled: false,
    partitionMergeEnabled: false,
    publicNetworkAccessEnabled: false,
    analyticalStorage: {
        schemaType: "string",
    },
    restore: {
        restoreTimestampInUtc: "string",
        sourceCosmosdbAccountId: "string",
        databases: [{
            name: "string",
            collectionNames: ["string"],
        }],
        gremlinDatabases: [{
            name: "string",
            graphNames: ["string"],
        }],
        tablesToRestores: ["string"],
    },
    tags: {
        string: "string",
    },
    virtualNetworkRules: [{
        id: "string",
        ignoreMissingVnetServiceEndpoint: false,
    }],
});