pulumi-azure-native 2.42.0a1715777949__py3-none-any.whl → 2.42.0a1716205654__py3-none-any.whl

pulumi_azure_native/documentdb/v20240515/_inputs.py

@@ -0,0 +1,3821 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from ... import _utilities
+from ._enums import *
+
+__all__ = [
+    'AnalyticalStorageConfigurationArgs',
+    'ApiPropertiesArgs',
+    'AuthenticationMethodLdapPropertiesArgs',
+    'AutoscaleSettingsArgs',
+    'BackupPolicyMigrationStateArgs',
+    'CapabilityArgs',
+    'CapacityArgs',
+    'CassandraErrorArgs',
+    'CassandraKeyspaceResourceArgs',
+    'CassandraPartitionKeyArgs',
+    'CassandraSchemaArgs',
+    'CassandraTableResourceArgs',
+    'CertificateArgs',
+    'ClientEncryptionIncludedPathArgs',
+    'ClientEncryptionPolicyArgs',
+    'ClusterKeyArgs',
+    'ClusterResourcePropertiesArgs',
+    'ColumnArgs',
+    'CompositePathArgs',
+    'ComputedPropertyArgs',
+    'ConflictResolutionPolicyArgs',
+    'ConsistencyPolicyArgs',
+    'ContainerPartitionKeyArgs',
+    'ContinuousModeBackupPolicyArgs',
+    'ContinuousModePropertiesArgs',
+    'CorsPolicyArgs',
+    'CreateUpdateOptionsArgs',
+    'DataCenterResourcePropertiesArgs',
+    'DatabaseRestoreResourceArgs',
+    'ExcludedPathArgs',
+    'GremlinDatabaseResourceArgs',
+    'GremlinDatabaseRestoreResourceArgs',
+    'GremlinGraphResourceArgs',
+    'IncludedPathArgs',
+    'IndexesArgs',
+    'IndexingPolicyArgs',
+    'IpAddressOrRangeArgs',
+    'LocationArgs',
+    'ManagedCassandraManagedServiceIdentityArgs',
+    'ManagedServiceIdentityArgs',
+    'MongoDBCollectionResourceArgs',
+    'MongoDBDatabaseResourceArgs',
+    'MongoIndexKeysArgs',
+    'MongoIndexOptionsArgs',
+    'MongoIndexArgs',
+    'PeriodicModeBackupPolicyArgs',
+    'PeriodicModePropertiesArgs',
+    'PermissionArgs',
+    'PrivateEndpointPropertyArgs',
+    'PrivateLinkServiceConnectionStatePropertyArgs',
+    'PrivilegeResourceArgs',
+    'PrivilegeArgs',
+    'ResourceRestoreParametersArgs',
+    'RestoreParametersArgs',
+    'RoleArgs',
+    'SeedNodeArgs',
+    'SpatialSpecArgs',
+    'SqlContainerResourceArgs',
+    'SqlDatabaseResourceArgs',
+    'SqlStoredProcedureResourceArgs',
+    'SqlTriggerResourceArgs',
+    'SqlUserDefinedFunctionResourceArgs',
+    'TableResourceArgs',
+    'UniqueKeyPolicyArgs',
+    'UniqueKeyArgs',
+    'VirtualNetworkRuleArgs',
+]
+
+@pulumi.input_type
+class AnalyticalStorageConfigurationArgs:
+    def __init__(__self__, *,
+                 schema_type: Optional[pulumi.Input[Union[str, 'AnalyticalStorageSchemaType']]] = None):
+        """
+        Analytical storage specific properties.
+        :param pulumi.Input[Union[str, 'AnalyticalStorageSchemaType']] schema_type: Describes the types of schema for analytical storage.
+        """
+        if schema_type is not None:
+            pulumi.set(__self__, "schema_type", schema_type)
+
+    @property
+    @pulumi.getter(name="schemaType")
+    def schema_type(self) -> Optional[pulumi.Input[Union[str, 'AnalyticalStorageSchemaType']]]:
+        """
+        Describes the types of schema for analytical storage.
+        """
+        return pulumi.get(self, "schema_type")
+
+    @schema_type.setter
+    def schema_type(self, value: Optional[pulumi.Input[Union[str, 'AnalyticalStorageSchemaType']]]):
+        pulumi.set(self, "schema_type", value)
+
+
+@pulumi.input_type
+class ApiPropertiesArgs:
+    def __init__(__self__, *,
+                 server_version: Optional[pulumi.Input[Union[str, 'ServerVersion']]] = None):
+        """
+        :param pulumi.Input[Union[str, 'ServerVersion']] server_version: Describes the ServerVersion of an a MongoDB account.
+        """
+        if server_version is not None:
+            pulumi.set(__self__, "server_version", server_version)
+
+    @property
+    @pulumi.getter(name="serverVersion")
+    def server_version(self) -> Optional[pulumi.Input[Union[str, 'ServerVersion']]]:
+        """
+        Describes the ServerVersion of an a MongoDB account.
+        """
+        return pulumi.get(self, "server_version")
+
+    @server_version.setter
+    def server_version(self, value: Optional[pulumi.Input[Union[str, 'ServerVersion']]]):
+        pulumi.set(self, "server_version", value)
+
+
+@pulumi.input_type
+class AuthenticationMethodLdapPropertiesArgs:
+    def __init__(__self__, *,
+                 connection_timeout_in_ms: Optional[pulumi.Input[int]] = None,
+                 search_base_distinguished_name: Optional[pulumi.Input[str]] = None,
+                 search_filter_template: Optional[pulumi.Input[str]] = None,
+                 server_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]] = None,
+                 server_hostname: Optional[pulumi.Input[str]] = None,
+                 server_port: Optional[pulumi.Input[int]] = None,
+                 service_user_distinguished_name: Optional[pulumi.Input[str]] = None,
+                 service_user_password: Optional[pulumi.Input[str]] = None):
+        """
+        Ldap authentication method properties. This feature is in preview.
+        :param pulumi.Input[int] connection_timeout_in_ms: Timeout for connecting to the LDAP server in miliseconds. The default is 5000 ms.
+        :param pulumi.Input[str] search_base_distinguished_name: Distinguished name of the object to start the recursive search of users from.
+        :param pulumi.Input[str] search_filter_template: Template to use for searching. Defaults to (cn=%s) where %s will be replaced by the username used to login.
+        :param pulumi.Input[str] server_hostname: Hostname of the LDAP server.
+        :param pulumi.Input[int] server_port: Port of the LDAP server.
+        :param pulumi.Input[str] service_user_distinguished_name: Distinguished name of the look up user account, who can look up user details on authentication.
+        :param pulumi.Input[str] service_user_password: Password of the look up user.
+        """
+        if connection_timeout_in_ms is not None:
+            pulumi.set(__self__, "connection_timeout_in_ms", connection_timeout_in_ms)
+        if search_base_distinguished_name is not None:
+            pulumi.set(__self__, "search_base_distinguished_name", search_base_distinguished_name)
+        if search_filter_template is not None:
+            pulumi.set(__self__, "search_filter_template", search_filter_template)
+        if server_certificates is not None:
+            pulumi.set(__self__, "server_certificates", server_certificates)
+        if server_hostname is not None:
+            pulumi.set(__self__, "server_hostname", server_hostname)
+        if server_port is not None:
+            pulumi.set(__self__, "server_port", server_port)
+        if service_user_distinguished_name is not None:
+            pulumi.set(__self__, "service_user_distinguished_name", service_user_distinguished_name)
+        if service_user_password is not None:
+            pulumi.set(__self__, "service_user_password", service_user_password)
+
+    @property
+    @pulumi.getter(name="connectionTimeoutInMs")
+    def connection_timeout_in_ms(self) -> Optional[pulumi.Input[int]]:
+        """
+        Timeout for connecting to the LDAP server in miliseconds. The default is 5000 ms.
+        """
+        return pulumi.get(self, "connection_timeout_in_ms")
+
+    @connection_timeout_in_ms.setter
+    def connection_timeout_in_ms(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "connection_timeout_in_ms", value)
+
+    @property
+    @pulumi.getter(name="searchBaseDistinguishedName")
+    def search_base_distinguished_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Distinguished name of the object to start the recursive search of users from.
+        """
+        return pulumi.get(self, "search_base_distinguished_name")
+
+    @search_base_distinguished_name.setter
+    def search_base_distinguished_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "search_base_distinguished_name", value)
+
+    @property
+    @pulumi.getter(name="searchFilterTemplate")
+    def search_filter_template(self) -> Optional[pulumi.Input[str]]:
+        """
+        Template to use for searching. Defaults to (cn=%s) where %s will be replaced by the username used to login.
+        """
+        return pulumi.get(self, "search_filter_template")
+
+    @search_filter_template.setter
+    def search_filter_template(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "search_filter_template", value)
+
+    @property
+    @pulumi.getter(name="serverCertificates")
+    def server_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]]:
+        return pulumi.get(self, "server_certificates")
+
+    @server_certificates.setter
+    def server_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]]):
+        pulumi.set(self, "server_certificates", value)
+
+    @property
+    @pulumi.getter(name="serverHostname")
+    def server_hostname(self) -> Optional[pulumi.Input[str]]:
+        """
+        Hostname of the LDAP server.
+        """
+        return pulumi.get(self, "server_hostname")
+
+    @server_hostname.setter
+    def server_hostname(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "server_hostname", value)
+
+    @property
+    @pulumi.getter(name="serverPort")
+    def server_port(self) -> Optional[pulumi.Input[int]]:
+        """
+        Port of the LDAP server.
+        """
+        return pulumi.get(self, "server_port")
+
+    @server_port.setter
+    def server_port(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "server_port", value)
+
+    @property
+    @pulumi.getter(name="serviceUserDistinguishedName")
+    def service_user_distinguished_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Distinguished name of the look up user account, who can look up user details on authentication.
+        """
+        return pulumi.get(self, "service_user_distinguished_name")
+
+    @service_user_distinguished_name.setter
+    def service_user_distinguished_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_user_distinguished_name", value)
+
+    @property
+    @pulumi.getter(name="serviceUserPassword")
+    def service_user_password(self) -> Optional[pulumi.Input[str]]:
+        """
+        Password of the look up user.
+        """
+        return pulumi.get(self, "service_user_password")
+
+    @service_user_password.setter
+    def service_user_password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_user_password", value)
+
+
+@pulumi.input_type
+class AutoscaleSettingsArgs:
+    def __init__(__self__, *,
+                 max_throughput: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] max_throughput: Represents maximum throughput, the resource can scale up to.
+        """
+        if max_throughput is not None:
+            pulumi.set(__self__, "max_throughput", max_throughput)
+
+    @property
+    @pulumi.getter(name="maxThroughput")
+    def max_throughput(self) -> Optional[pulumi.Input[int]]:
+        """
+        Represents maximum throughput, the resource can scale up to.
+        """
+        return pulumi.get(self, "max_throughput")
+
+    @max_throughput.setter
+    def max_throughput(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_throughput", value)
+
+
+@pulumi.input_type
+class BackupPolicyMigrationStateArgs:
+    def __init__(__self__, *,
+                 start_time: Optional[pulumi.Input[str]] = None,
+                 status: Optional[pulumi.Input[Union[str, 'BackupPolicyMigrationStatus']]] = None,
+                 target_type: Optional[pulumi.Input[Union[str, 'BackupPolicyType']]] = None):
+        """
+        The object representing the state of the migration between the backup policies.
+        :param pulumi.Input[str] start_time: Time at which the backup policy migration started (ISO-8601 format).
+        :param pulumi.Input[Union[str, 'BackupPolicyMigrationStatus']] status: Describes the status of migration between backup policy types.
+        :param pulumi.Input[Union[str, 'BackupPolicyType']] target_type: Describes the target backup policy type of the backup policy migration.
+        """
+        if start_time is not None:
+            pulumi.set(__self__, "start_time", start_time)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if target_type is not None:
+            pulumi.set(__self__, "target_type", target_type)
+
+    @property
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Time at which the backup policy migration started (ISO-8601 format).
+        """
+        return pulumi.get(self, "start_time")
+
+    @start_time.setter
+    def start_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "start_time", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[Union[str, 'BackupPolicyMigrationStatus']]]:
+        """
+        Describes the status of migration between backup policy types.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[Union[str, 'BackupPolicyMigrationStatus']]]):
+        pulumi.set(self, "status", value)
+
+    @property
+    @pulumi.getter(name="targetType")
+    def target_type(self) -> Optional[pulumi.Input[Union[str, 'BackupPolicyType']]]:
+        """
+        Describes the target backup policy type of the backup policy migration.
+        """
+        return pulumi.get(self, "target_type")
+
+    @target_type.setter
+    def target_type(self, value: Optional[pulumi.Input[Union[str, 'BackupPolicyType']]]):
+        pulumi.set(self, "target_type", value)
+
+
+@pulumi.input_type
+class CapabilityArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None):
+        """
+        Cosmos DB capability object
+        :param pulumi.Input[str] name: Name of the Cosmos DB capability. For example, "name": "EnableCassandra". Current values also include "EnableTable" and "EnableGremlin".
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the Cosmos DB capability. For example, "name": "EnableCassandra". Current values also include "EnableTable" and "EnableGremlin".
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+
+@pulumi.input_type
+class CapacityArgs:
+    def __init__(__self__, *,
+                 total_throughput_limit: Optional[pulumi.Input[int]] = None):
+        """
+        The object that represents all properties related to capacity enforcement on an account.
+        :param pulumi.Input[int] total_throughput_limit: The total throughput limit imposed on the account. A totalThroughputLimit of 2000 imposes a strict limit of max throughput that can be provisioned on that account to be 2000. A totalThroughputLimit of -1 indicates no limits on provisioning of throughput.
+        """
+        if total_throughput_limit is not None:
+            pulumi.set(__self__, "total_throughput_limit", total_throughput_limit)
+
+    @property
+    @pulumi.getter(name="totalThroughputLimit")
+    def total_throughput_limit(self) -> Optional[pulumi.Input[int]]:
+        """
+        The total throughput limit imposed on the account. A totalThroughputLimit of 2000 imposes a strict limit of max throughput that can be provisioned on that account to be 2000. A totalThroughputLimit of -1 indicates no limits on provisioning of throughput.
+        """
+        return pulumi.get(self, "total_throughput_limit")
+
+    @total_throughput_limit.setter
+    def total_throughput_limit(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "total_throughput_limit", value)
+
+
+@pulumi.input_type
+class CassandraErrorArgs:
+    def __init__(__self__, *,
+                 additional_error_info: Optional[pulumi.Input[str]] = None,
+                 code: Optional[pulumi.Input[str]] = None,
+                 message: Optional[pulumi.Input[str]] = None,
+                 target: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] additional_error_info: Additional information about the error.
+        :param pulumi.Input[str] code: The code of error that occurred.
+        :param pulumi.Input[str] message: The message of the error.
+        :param pulumi.Input[str] target: The target resource of the error.
+        """
+        if additional_error_info is not None:
+            pulumi.set(__self__, "additional_error_info", additional_error_info)
+        if code is not None:
+            pulumi.set(__self__, "code", code)
+        if message is not None:
+            pulumi.set(__self__, "message", message)
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+
+    @property
+    @pulumi.getter(name="additionalErrorInfo")
+    def additional_error_info(self) -> Optional[pulumi.Input[str]]:
+        """
+        Additional information about the error.
+        """
+        return pulumi.get(self, "additional_error_info")
+
+    @additional_error_info.setter
+    def additional_error_info(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "additional_error_info", value)
+
+    @property
+    @pulumi.getter
+    def code(self) -> Optional[pulumi.Input[str]]:
+        """
+        The code of error that occurred.
+        """
+        return pulumi.get(self, "code")
+
+    @code.setter
+    def code(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "code", value)
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[pulumi.Input[str]]:
+        """
+        The message of the error.
+        """
+        return pulumi.get(self, "message")
+
+    @message.setter
+    def message(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "message", value)
+
+    @property
+    @pulumi.getter
+    def target(self) -> Optional[pulumi.Input[str]]:
+        """
+        The target resource of the error.
+        """
+        return pulumi.get(self, "target")
+
+    @target.setter
+    def target(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "target", value)
+
+
+@pulumi.input_type
+class CassandraKeyspaceResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str]):
+        """
+        Cosmos DB Cassandra keyspace resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB Cassandra keyspace
+        """
+        pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB Cassandra keyspace
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+
+@pulumi.input_type
+class CassandraPartitionKeyArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None):
+        """
+        Cosmos DB Cassandra table partition key
+        :param pulumi.Input[str] name: Name of the Cosmos DB Cassandra table partition key
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the Cosmos DB Cassandra table partition key
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+
+@pulumi.input_type
+class CassandraSchemaArgs:
+    def __init__(__self__, *,
+                 cluster_keys: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterKeyArgs']]]] = None,
+                 columns: Optional[pulumi.Input[Sequence[pulumi.Input['ColumnArgs']]]] = None,
+                 partition_keys: Optional[pulumi.Input[Sequence[pulumi.Input['CassandraPartitionKeyArgs']]]] = None):
+        """
+        Cosmos DB Cassandra table schema
+        :param pulumi.Input[Sequence[pulumi.Input['ClusterKeyArgs']]] cluster_keys: List of cluster key.
+        :param pulumi.Input[Sequence[pulumi.Input['ColumnArgs']]] columns: List of Cassandra table columns.
+        :param pulumi.Input[Sequence[pulumi.Input['CassandraPartitionKeyArgs']]] partition_keys: List of partition key.
+        """
+        if cluster_keys is not None:
+            pulumi.set(__self__, "cluster_keys", cluster_keys)
+        if columns is not None:
+            pulumi.set(__self__, "columns", columns)
+        if partition_keys is not None:
+            pulumi.set(__self__, "partition_keys", partition_keys)
+
+    @property
+    @pulumi.getter(name="clusterKeys")
+    def cluster_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterKeyArgs']]]]:
+        """
+        List of cluster key.
+        """
+        return pulumi.get(self, "cluster_keys")
+
+    @cluster_keys.setter
+    def cluster_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterKeyArgs']]]]):
+        pulumi.set(self, "cluster_keys", value)
+
+    @property
+    @pulumi.getter
+    def columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ColumnArgs']]]]:
+        """
+        List of Cassandra table columns.
+        """
+        return pulumi.get(self, "columns")
+
+    @columns.setter
+    def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ColumnArgs']]]]):
+        pulumi.set(self, "columns", value)
+
+    @property
+    @pulumi.getter(name="partitionKeys")
+    def partition_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CassandraPartitionKeyArgs']]]]:
+        """
+        List of partition key.
+        """
+        return pulumi.get(self, "partition_keys")
+
+    @partition_keys.setter
+    def partition_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CassandraPartitionKeyArgs']]]]):
+        pulumi.set(self, "partition_keys", value)
+
+
+@pulumi.input_type
+class CassandraTableResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 analytical_storage_ttl: Optional[pulumi.Input[int]] = None,
+                 default_ttl: Optional[pulumi.Input[int]] = None,
+                 schema: Optional[pulumi.Input['CassandraSchemaArgs']] = None):
+        """
+        Cosmos DB Cassandra table resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB Cassandra table
+        :param pulumi.Input[int] analytical_storage_ttl: Analytical TTL.
+        :param pulumi.Input[int] default_ttl: Time to live of the Cosmos DB Cassandra table
+        :param pulumi.Input['CassandraSchemaArgs'] schema: Schema of the Cosmos DB Cassandra table
+        """
+        pulumi.set(__self__, "id", id)
+        if analytical_storage_ttl is not None:
+            pulumi.set(__self__, "analytical_storage_ttl", analytical_storage_ttl)
+        if default_ttl is not None:
+            pulumi.set(__self__, "default_ttl", default_ttl)
+        if schema is not None:
+            pulumi.set(__self__, "schema", schema)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB Cassandra table
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="analyticalStorageTtl")
+    def analytical_storage_ttl(self) -> Optional[pulumi.Input[int]]:
+        """
+        Analytical TTL.
+        """
+        return pulumi.get(self, "analytical_storage_ttl")
+
+    @analytical_storage_ttl.setter
+    def analytical_storage_ttl(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "analytical_storage_ttl", value)
+
+    @property
+    @pulumi.getter(name="defaultTtl")
+    def default_ttl(self) -> Optional[pulumi.Input[int]]:
+        """
+        Time to live of the Cosmos DB Cassandra table
+        """
+        return pulumi.get(self, "default_ttl")
+
+    @default_ttl.setter
+    def default_ttl(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "default_ttl", value)
+
+    @property
+    @pulumi.getter
+    def schema(self) -> Optional[pulumi.Input['CassandraSchemaArgs']]:
+        """
+        Schema of the Cosmos DB Cassandra table
+        """
+        return pulumi.get(self, "schema")
+
+    @schema.setter
+    def schema(self, value: Optional[pulumi.Input['CassandraSchemaArgs']]):
+        pulumi.set(self, "schema", value)
+
+
+@pulumi.input_type
+class CertificateArgs:
+    def __init__(__self__, *,
+                 pem: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] pem: PEM formatted public key.
+        """
+        if pem is not None:
+            pulumi.set(__self__, "pem", pem)
+
+    @property
+    @pulumi.getter
+    def pem(self) -> Optional[pulumi.Input[str]]:
+        """
+        PEM formatted public key.
+        """
+        return pulumi.get(self, "pem")
+
+    @pem.setter
+    def pem(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "pem", value)
+
+
+@pulumi.input_type
+class ClientEncryptionIncludedPathArgs:
+    def __init__(__self__, *,
+                 client_encryption_key_id: pulumi.Input[str],
+                 encryption_algorithm: pulumi.Input[str],
+                 encryption_type: pulumi.Input[str],
+                 path: pulumi.Input[str]):
+        """
+        .
+        :param pulumi.Input[str] client_encryption_key_id: The identifier of the Client Encryption Key to be used to encrypt the path.
+        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm which will be used. Eg - AEAD_AES_256_CBC_HMAC_SHA256.
+        :param pulumi.Input[str] encryption_type: The type of encryption to be performed. Eg - Deterministic, Randomized.
+        :param pulumi.Input[str] path: Path that needs to be encrypted.
+        """
+        pulumi.set(__self__, "client_encryption_key_id", client_encryption_key_id)
+        pulumi.set(__self__, "encryption_algorithm", encryption_algorithm)
+        pulumi.set(__self__, "encryption_type", encryption_type)
+        pulumi.set(__self__, "path", path)
+
+    @property
+    @pulumi.getter(name="clientEncryptionKeyId")
+    def client_encryption_key_id(self) -> pulumi.Input[str]:
+        """
+        The identifier of the Client Encryption Key to be used to encrypt the path.
+        """
+        return pulumi.get(self, "client_encryption_key_id")
+
+    @client_encryption_key_id.setter
+    def client_encryption_key_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "client_encryption_key_id", value)
+
+    @property
+    @pulumi.getter(name="encryptionAlgorithm")
+    def encryption_algorithm(self) -> pulumi.Input[str]:
+        """
+        The encryption algorithm which will be used. Eg - AEAD_AES_256_CBC_HMAC_SHA256.
+        """
+        return pulumi.get(self, "encryption_algorithm")
+
+    @encryption_algorithm.setter
+    def encryption_algorithm(self, value: pulumi.Input[str]):
+        pulumi.set(self, "encryption_algorithm", value)
+
+    @property
+    @pulumi.getter(name="encryptionType")
+    def encryption_type(self) -> pulumi.Input[str]:
+        """
+        The type of encryption to be performed. Eg - Deterministic, Randomized.
+        """
+        return pulumi.get(self, "encryption_type")
+
+    @encryption_type.setter
+    def encryption_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "encryption_type", value)
+
+    @property
+    @pulumi.getter
+    def path(self) -> pulumi.Input[str]:
+        """
+        Path that needs to be encrypted.
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: pulumi.Input[str]):
+        pulumi.set(self, "path", value)
+
+
+@pulumi.input_type
+class ClientEncryptionPolicyArgs:
+    def __init__(__self__, *,
+                 included_paths: pulumi.Input[Sequence[pulumi.Input['ClientEncryptionIncludedPathArgs']]],
+                 policy_format_version: pulumi.Input[int]):
+        """
+        Cosmos DB client encryption policy.
+        :param pulumi.Input[Sequence[pulumi.Input['ClientEncryptionIncludedPathArgs']]] included_paths: Paths of the item that need encryption along with path-specific settings.
+        :param pulumi.Input[int] policy_format_version: Version of the client encryption policy definition. Supported versions are 1 and 2. Version 2 supports id and partition key path encryption. 
+        """
+        pulumi.set(__self__, "included_paths", included_paths)
+        pulumi.set(__self__, "policy_format_version", policy_format_version)
+
+    @property
+    @pulumi.getter(name="includedPaths")
+    def included_paths(self) -> pulumi.Input[Sequence[pulumi.Input['ClientEncryptionIncludedPathArgs']]]:
+        """
+        Paths of the item that need encryption along with path-specific settings.
+        """
+        return pulumi.get(self, "included_paths")
+
+    @included_paths.setter
+    def included_paths(self, value: pulumi.Input[Sequence[pulumi.Input['ClientEncryptionIncludedPathArgs']]]):
+        pulumi.set(self, "included_paths", value)
+
+    @property
+    @pulumi.getter(name="policyFormatVersion")
+    def policy_format_version(self) -> pulumi.Input[int]:
+        """
+        Version of the client encryption policy definition. Supported versions are 1 and 2. Version 2 supports id and partition key path encryption. 
+        """
+        return pulumi.get(self, "policy_format_version")
+
+    @policy_format_version.setter
+    def policy_format_version(self, value: pulumi.Input[int]):
+        pulumi.set(self, "policy_format_version", value)
+
+
+@pulumi.input_type
+class ClusterKeyArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None,
+                 order_by: Optional[pulumi.Input[str]] = None):
+        """
+        Cosmos DB Cassandra table cluster key
+        :param pulumi.Input[str] name: Name of the Cosmos DB Cassandra table cluster key
+        :param pulumi.Input[str] order_by: Order of the Cosmos DB Cassandra table cluster key, only support "Asc" and "Desc"
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if order_by is not None:
+            pulumi.set(__self__, "order_by", order_by)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the Cosmos DB Cassandra table cluster key
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="orderBy")
+    def order_by(self) -> Optional[pulumi.Input[str]]:
+        """
+        Order of the Cosmos DB Cassandra table cluster key, only support "Asc" and "Desc"
+        """
+        return pulumi.get(self, "order_by")
+
+    @order_by.setter
+    def order_by(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "order_by", value)
+
+
+@pulumi.input_type
+class ClusterResourcePropertiesArgs:
+    def __init__(__self__, *,
+                 authentication_method: Optional[pulumi.Input[Union[str, 'AuthenticationMethod']]] = None,
+                 azure_connection_method: Optional[pulumi.Input[Union[str, 'AzureConnectionType']]] = None,
+                 cassandra_audit_logging_enabled: Optional[pulumi.Input[bool]] = None,
+                 cassandra_version: Optional[pulumi.Input[str]] = None,
+                 client_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]] = None,
+                 cluster_name_override: Optional[pulumi.Input[str]] = None,
+                 deallocated: Optional[pulumi.Input[bool]] = None,
+                 delegated_management_subnet_id: Optional[pulumi.Input[str]] = None,
+                 external_gossip_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]] = None,
+                 external_seed_nodes: Optional[pulumi.Input[Sequence[pulumi.Input['SeedNodeArgs']]]] = None,
+                 hours_between_backups: Optional[pulumi.Input[int]] = None,
+                 initial_cassandra_admin_password: Optional[pulumi.Input[str]] = None,
+                 prometheus_endpoint: Optional[pulumi.Input['SeedNodeArgs']] = None,
+                 provision_error: Optional[pulumi.Input['CassandraErrorArgs']] = None,
+                 provisioning_state: Optional[pulumi.Input[Union[str, 'ManagedCassandraProvisioningState']]] = None,
+                 repair_enabled: Optional[pulumi.Input[bool]] = None,
+                 restore_from_backup_id: Optional[pulumi.Input[str]] = None):
+        """
+        Properties of a managed Cassandra cluster.
+        :param pulumi.Input[Union[str, 'AuthenticationMethod']] authentication_method: Which authentication method Cassandra should use to authenticate clients. 'None' turns off authentication, so should not be used except in emergencies. 'Cassandra' is the default password based authentication. The default is 'Cassandra'.
+        :param pulumi.Input[Union[str, 'AzureConnectionType']] azure_connection_method: How to connect to the azure services needed for running the cluster
+        :param pulumi.Input[bool] cassandra_audit_logging_enabled: Whether Cassandra audit logging is enabled
+        :param pulumi.Input[str] cassandra_version: Which version of Cassandra should this cluster converge to running (e.g., 3.11). When updated, the cluster may take some time to migrate to the new version.
+        :param pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]] client_certificates: List of TLS certificates used to authorize clients connecting to the cluster. All connections are TLS encrypted whether clientCertificates is set or not, but if clientCertificates is set, the managed Cassandra cluster will reject all connections not bearing a TLS client certificate that can be validated from one or more of the public certificates in this property.
+        :param pulumi.Input[str] cluster_name_override: If you need to set the clusterName property in cassandra.yaml to something besides the resource name of the cluster, set the value to use on this property.
+        :param pulumi.Input[bool] deallocated: Whether the cluster and associated data centers has been deallocated.
+        :param pulumi.Input[str] delegated_management_subnet_id: Resource id of a subnet that this cluster's management service should have its network interface attached to. The subnet must be routable to all subnets that will be delegated to data centers. The resource id must be of the form '/subscriptions/<subscription id>/resourceGroups/<resource group>/providers/Microsoft.Network/virtualNetworks/<virtual network>/subnets/<subnet>'
+        :param pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]] external_gossip_certificates: List of TLS certificates used to authorize gossip from unmanaged data centers. The TLS certificates of all nodes in unmanaged data centers must be verifiable using one of the certificates provided in this property.
+        :param pulumi.Input[Sequence[pulumi.Input['SeedNodeArgs']]] external_seed_nodes: List of IP addresses of seed nodes in unmanaged data centers. These will be added to the seed node lists of all managed nodes.
+        :param pulumi.Input[int] hours_between_backups: (Deprecated) Number of hours to wait between taking a backup of the cluster.
+        :param pulumi.Input[str] initial_cassandra_admin_password: Initial password for clients connecting as admin to the cluster. Should be changed after cluster creation. Returns null on GET. This field only applies when the authenticationMethod field is 'Cassandra'.
+        :param pulumi.Input['SeedNodeArgs'] prometheus_endpoint: Hostname or IP address where the Prometheus endpoint containing data about the managed Cassandra nodes can be reached.
+        :param pulumi.Input['CassandraErrorArgs'] provision_error: Error related to resource provisioning.
+        :param pulumi.Input[Union[str, 'ManagedCassandraProvisioningState']] provisioning_state: The status of the resource at the time the operation was called.
+        :param pulumi.Input[bool] repair_enabled: Should automatic repairs run on this cluster? If omitted, this is true, and should stay true unless you are running a hybrid cluster where you are already doing your own repairs.
+        :param pulumi.Input[str] restore_from_backup_id: To create an empty cluster, omit this field or set it to null. To restore a backup into a new cluster, set this field to the resource id of the backup.
+        """
+        if authentication_method is not None:
+            pulumi.set(__self__, "authentication_method", authentication_method)
+        if azure_connection_method is not None:
+            pulumi.set(__self__, "azure_connection_method", azure_connection_method)
+        if cassandra_audit_logging_enabled is not None:
+            pulumi.set(__self__, "cassandra_audit_logging_enabled", cassandra_audit_logging_enabled)
+        if cassandra_version is not None:
+            pulumi.set(__self__, "cassandra_version", cassandra_version)
+        if client_certificates is not None:
+            pulumi.set(__self__, "client_certificates", client_certificates)
+        if cluster_name_override is not None:
+            pulumi.set(__self__, "cluster_name_override", cluster_name_override)
+        if deallocated is not None:
+            pulumi.set(__self__, "deallocated", deallocated)
+        if delegated_management_subnet_id is not None:
+            pulumi.set(__self__, "delegated_management_subnet_id", delegated_management_subnet_id)
+        if external_gossip_certificates is not None:
+            pulumi.set(__self__, "external_gossip_certificates", external_gossip_certificates)
+        if external_seed_nodes is not None:
+            pulumi.set(__self__, "external_seed_nodes", external_seed_nodes)
+        if hours_between_backups is not None:
+            pulumi.set(__self__, "hours_between_backups", hours_between_backups)
+        if initial_cassandra_admin_password is not None:
+            pulumi.set(__self__, "initial_cassandra_admin_password", initial_cassandra_admin_password)
+        if prometheus_endpoint is not None:
+            pulumi.set(__self__, "prometheus_endpoint", prometheus_endpoint)
+        if provision_error is not None:
+            pulumi.set(__self__, "provision_error", provision_error)
+        if provisioning_state is not None:
+            pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if repair_enabled is not None:
+            pulumi.set(__self__, "repair_enabled", repair_enabled)
+        if restore_from_backup_id is not None:
+            pulumi.set(__self__, "restore_from_backup_id", restore_from_backup_id)
+
+    @property
+    @pulumi.getter(name="authenticationMethod")
+    def authentication_method(self) -> Optional[pulumi.Input[Union[str, 'AuthenticationMethod']]]:
+        """
+        Which authentication method Cassandra should use to authenticate clients. 'None' turns off authentication, so should not be used except in emergencies. 'Cassandra' is the default password based authentication. The default is 'Cassandra'.
+        """
+        return pulumi.get(self, "authentication_method")
+
+    @authentication_method.setter
+    def authentication_method(self, value: Optional[pulumi.Input[Union[str, 'AuthenticationMethod']]]):
+        pulumi.set(self, "authentication_method", value)
+
+    @property
+    @pulumi.getter(name="azureConnectionMethod")
+    def azure_connection_method(self) -> Optional[pulumi.Input[Union[str, 'AzureConnectionType']]]:
+        """
+        How to connect to the azure services needed for running the cluster
+        """
+        return pulumi.get(self, "azure_connection_method")
+
+    @azure_connection_method.setter
+    def azure_connection_method(self, value: Optional[pulumi.Input[Union[str, 'AzureConnectionType']]]):
+        pulumi.set(self, "azure_connection_method", value)
+
+    @property
+    @pulumi.getter(name="cassandraAuditLoggingEnabled")
+    def cassandra_audit_logging_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether Cassandra audit logging is enabled
+        """
+        return pulumi.get(self, "cassandra_audit_logging_enabled")
+
+    @cassandra_audit_logging_enabled.setter
+    def cassandra_audit_logging_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "cassandra_audit_logging_enabled", value)
+
+    @property
+    @pulumi.getter(name="cassandraVersion")
+    def cassandra_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        Which version of Cassandra should this cluster converge to running (e.g., 3.11). When updated, the cluster may take some time to migrate to the new version.
+        """
+        return pulumi.get(self, "cassandra_version")
+
+    @cassandra_version.setter
+    def cassandra_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cassandra_version", value)
+
+    @property
+    @pulumi.getter(name="clientCertificates")
+    def client_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]]:
+        """
+        List of TLS certificates used to authorize clients connecting to the cluster. All connections are TLS encrypted whether clientCertificates is set or not, but if clientCertificates is set, the managed Cassandra cluster will reject all connections not bearing a TLS client certificate that can be validated from one or more of the public certificates in this property.
+        """
+        return pulumi.get(self, "client_certificates")
+
+    @client_certificates.setter
+    def client_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]]):
+        pulumi.set(self, "client_certificates", value)
+
+    @property
+    @pulumi.getter(name="clusterNameOverride")
+    def cluster_name_override(self) -> Optional[pulumi.Input[str]]:
+        """
+        If you need to set the clusterName property in cassandra.yaml to something besides the resource name of the cluster, set the value to use on this property.
+        """
+        return pulumi.get(self, "cluster_name_override")
+
+    @cluster_name_override.setter
+    def cluster_name_override(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cluster_name_override", value)
+
+    @property
+    @pulumi.getter
+    def deallocated(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether the cluster and associated data centers has been deallocated.
+        """
+        return pulumi.get(self, "deallocated")
+
+    @deallocated.setter
+    def deallocated(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "deallocated", value)
+
+    @property
+    @pulumi.getter(name="delegatedManagementSubnetId")
+    def delegated_management_subnet_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Resource id of a subnet that this cluster's management service should have its network interface attached to. The subnet must be routable to all subnets that will be delegated to data centers. The resource id must be of the form '/subscriptions/<subscription id>/resourceGroups/<resource group>/providers/Microsoft.Network/virtualNetworks/<virtual network>/subnets/<subnet>'
+        """
+        return pulumi.get(self, "delegated_management_subnet_id")
+
+    @delegated_management_subnet_id.setter
+    def delegated_management_subnet_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "delegated_management_subnet_id", value)
+
+    @property
+    @pulumi.getter(name="externalGossipCertificates")
+    def external_gossip_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]]:
+        """
+        List of TLS certificates used to authorize gossip from unmanaged data centers. The TLS certificates of all nodes in unmanaged data centers must be verifiable using one of the certificates provided in this property.
+        """
+        return pulumi.get(self, "external_gossip_certificates")
+
+    @external_gossip_certificates.setter
+    def external_gossip_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CertificateArgs']]]]):
+        pulumi.set(self, "external_gossip_certificates", value)
+
+    @property
+    @pulumi.getter(name="externalSeedNodes")
+    def external_seed_nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SeedNodeArgs']]]]:
+        """
+        List of IP addresses of seed nodes in unmanaged data centers. These will be added to the seed node lists of all managed nodes.
+        """
+        return pulumi.get(self, "external_seed_nodes")
+
+    @external_seed_nodes.setter
+    def external_seed_nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SeedNodeArgs']]]]):
+        pulumi.set(self, "external_seed_nodes", value)
+
+    @property
+    @pulumi.getter(name="hoursBetweenBackups")
+    def hours_between_backups(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Deprecated) Number of hours to wait between taking a backup of the cluster.
+        """
+        return pulumi.get(self, "hours_between_backups")
+
+    @hours_between_backups.setter
+    def hours_between_backups(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "hours_between_backups", value)
+
+    @property
+    @pulumi.getter(name="initialCassandraAdminPassword")
+    def initial_cassandra_admin_password(self) -> Optional[pulumi.Input[str]]:
+        """
+        Initial password for clients connecting as admin to the cluster. Should be changed after cluster creation. Returns null on GET. This field only applies when the authenticationMethod field is 'Cassandra'.
+        """
+        return pulumi.get(self, "initial_cassandra_admin_password")
+
+    @initial_cassandra_admin_password.setter
+    def initial_cassandra_admin_password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "initial_cassandra_admin_password", value)
+
+    @property
+    @pulumi.getter(name="prometheusEndpoint")
+    def prometheus_endpoint(self) -> Optional[pulumi.Input['SeedNodeArgs']]:
+        """
+        Hostname or IP address where the Prometheus endpoint containing data about the managed Cassandra nodes can be reached.
+        """
+        return pulumi.get(self, "prometheus_endpoint")
+
+    @prometheus_endpoint.setter
+    def prometheus_endpoint(self, value: Optional[pulumi.Input['SeedNodeArgs']]):
+        pulumi.set(self, "prometheus_endpoint", value)
+
+    @property
+    @pulumi.getter(name="provisionError")
+    def provision_error(self) -> Optional[pulumi.Input['CassandraErrorArgs']]:
+        """
+        Error related to resource provisioning.
+        """
+        return pulumi.get(self, "provision_error")
+
+    @provision_error.setter
+    def provision_error(self, value: Optional[pulumi.Input['CassandraErrorArgs']]):
+        pulumi.set(self, "provision_error", value)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> Optional[pulumi.Input[Union[str, 'ManagedCassandraProvisioningState']]]:
+        """
+        The status of the resource at the time the operation was called.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @provisioning_state.setter
+    def provisioning_state(self, value: Optional[pulumi.Input[Union[str, 'ManagedCassandraProvisioningState']]]):
+        pulumi.set(self, "provisioning_state", value)
+
+    @property
+    @pulumi.getter(name="repairEnabled")
+    def repair_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Should automatic repairs run on this cluster? If omitted, this is true, and should stay true unless you are running a hybrid cluster where you are already doing your own repairs.
+        """
+        return pulumi.get(self, "repair_enabled")
+
+    @repair_enabled.setter
+    def repair_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "repair_enabled", value)
+
+    @property
+    @pulumi.getter(name="restoreFromBackupId")
+    def restore_from_backup_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        To create an empty cluster, omit this field or set it to null. To restore a backup into a new cluster, set this field to the resource id of the backup.
+        """
+        return pulumi.get(self, "restore_from_backup_id")
+
+    @restore_from_backup_id.setter
+    def restore_from_backup_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "restore_from_backup_id", value)
+
+
+@pulumi.input_type
+class ColumnArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None,
+                 type: Optional[pulumi.Input[str]] = None):
+        """
+        Cosmos DB Cassandra table column
+        :param pulumi.Input[str] name: Name of the Cosmos DB Cassandra table column
+        :param pulumi.Input[str] type: Type of the Cosmos DB Cassandra table column
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the Cosmos DB Cassandra table column
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[pulumi.Input[str]]:
+        """
+        Type of the Cosmos DB Cassandra table column
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "type", value)
+
+
+@pulumi.input_type
+class CompositePathArgs:
+    def __init__(__self__, *,
+                 order: Optional[pulumi.Input[Union[str, 'CompositePathSortOrder']]] = None,
+                 path: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Union[str, 'CompositePathSortOrder']] order: Sort order for composite paths.
+        :param pulumi.Input[str] path: The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*)
+        """
+        if order is not None:
+            pulumi.set(__self__, "order", order)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+
+    @property
+    @pulumi.getter
+    def order(self) -> Optional[pulumi.Input[Union[str, 'CompositePathSortOrder']]]:
+        """
+        Sort order for composite paths.
+        """
+        return pulumi.get(self, "order")
+
+    @order.setter
+    def order(self, value: Optional[pulumi.Input[Union[str, 'CompositePathSortOrder']]]):
+        pulumi.set(self, "order", value)
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[str]]:
+        """
+        The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*)
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "path", value)
+
+
+@pulumi.input_type
+class ComputedPropertyArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None,
+                 query: Optional[pulumi.Input[str]] = None):
+        """
+        The definition of a computed property
+        :param pulumi.Input[str] name: The name of a computed property, for example - "cp_lowerName"
+        :param pulumi.Input[str] query: The query that evaluates the value for computed property, for example - "SELECT VALUE LOWER(c.name) FROM c"
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if query is not None:
+            pulumi.set(__self__, "query", query)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of a computed property, for example - "cp_lowerName"
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def query(self) -> Optional[pulumi.Input[str]]:
+        """
+        The query that evaluates the value for computed property, for example - "SELECT VALUE LOWER(c.name) FROM c"
+        """
+        return pulumi.get(self, "query")
+
+    @query.setter
+    def query(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "query", value)
+
+
+@pulumi.input_type
+class ConflictResolutionPolicyArgs:
+    def __init__(__self__, *,
+                 conflict_resolution_path: Optional[pulumi.Input[str]] = None,
+                 conflict_resolution_procedure: Optional[pulumi.Input[str]] = None,
+                 mode: Optional[pulumi.Input[Union[str, 'ConflictResolutionMode']]] = None):
+        """
+        The conflict resolution policy for the container.
+        :param pulumi.Input[str] conflict_resolution_path: The conflict resolution path in the case of LastWriterWins mode.
+        :param pulumi.Input[str] conflict_resolution_procedure: The procedure to resolve conflicts in the case of custom mode.
+        :param pulumi.Input[Union[str, 'ConflictResolutionMode']] mode: Indicates the conflict resolution mode.
+        """
+        if conflict_resolution_path is not None:
+            pulumi.set(__self__, "conflict_resolution_path", conflict_resolution_path)
+        if conflict_resolution_procedure is not None:
+            pulumi.set(__self__, "conflict_resolution_procedure", conflict_resolution_procedure)
+        if mode is None:
+            mode = 'LastWriterWins'
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
+
+    @property
+    @pulumi.getter(name="conflictResolutionPath")
+    def conflict_resolution_path(self) -> Optional[pulumi.Input[str]]:
+        """
+        The conflict resolution path in the case of LastWriterWins mode.
+        """
+        return pulumi.get(self, "conflict_resolution_path")
+
+    @conflict_resolution_path.setter
+    def conflict_resolution_path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "conflict_resolution_path", value)
+
+    @property
+    @pulumi.getter(name="conflictResolutionProcedure")
+    def conflict_resolution_procedure(self) -> Optional[pulumi.Input[str]]:
+        """
+        The procedure to resolve conflicts in the case of custom mode.
+        """
+        return pulumi.get(self, "conflict_resolution_procedure")
+
+    @conflict_resolution_procedure.setter
+    def conflict_resolution_procedure(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "conflict_resolution_procedure", value)
+
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[pulumi.Input[Union[str, 'ConflictResolutionMode']]]:
+        """
+        Indicates the conflict resolution mode.
+        """
+        return pulumi.get(self, "mode")
+
+    @mode.setter
+    def mode(self, value: Optional[pulumi.Input[Union[str, 'ConflictResolutionMode']]]):
+        pulumi.set(self, "mode", value)
+
+
+@pulumi.input_type
+class ConsistencyPolicyArgs:
+    def __init__(__self__, *,
+                 default_consistency_level: pulumi.Input['DefaultConsistencyLevel'],
+                 max_interval_in_seconds: Optional[pulumi.Input[int]] = None,
+                 max_staleness_prefix: Optional[pulumi.Input[float]] = None):
+        """
+        The consistency policy for the Cosmos DB database account.
+        :param pulumi.Input['DefaultConsistencyLevel'] default_consistency_level: The default consistency level and configuration settings of the Cosmos DB account.
+        :param pulumi.Input[int] max_interval_in_seconds: When used with the Bounded Staleness consistency level, this value represents the time amount of staleness (in seconds) tolerated. Accepted range for this value is 5 - 86400. Required when defaultConsistencyPolicy is set to 'BoundedStaleness'.
+        :param pulumi.Input[float] max_staleness_prefix: When used with the Bounded Staleness consistency level, this value represents the number of stale requests tolerated. Accepted range for this value is 1 – 2,147,483,647. Required when defaultConsistencyPolicy is set to 'BoundedStaleness'.
+        """
+        pulumi.set(__self__, "default_consistency_level", default_consistency_level)
+        if max_interval_in_seconds is not None:
+            pulumi.set(__self__, "max_interval_in_seconds", max_interval_in_seconds)
+        if max_staleness_prefix is not None:
+            pulumi.set(__self__, "max_staleness_prefix", max_staleness_prefix)
+
+    @property
+    @pulumi.getter(name="defaultConsistencyLevel")
+    def default_consistency_level(self) -> pulumi.Input['DefaultConsistencyLevel']:
+        """
+        The default consistency level and configuration settings of the Cosmos DB account.
+        """
+        return pulumi.get(self, "default_consistency_level")
+
+    @default_consistency_level.setter
+    def default_consistency_level(self, value: pulumi.Input['DefaultConsistencyLevel']):
+        pulumi.set(self, "default_consistency_level", value)
+
+    @property
+    @pulumi.getter(name="maxIntervalInSeconds")
+    def max_interval_in_seconds(self) -> Optional[pulumi.Input[int]]:
+        """
+        When used with the Bounded Staleness consistency level, this value represents the time amount of staleness (in seconds) tolerated. Accepted range for this value is 5 - 86400. Required when defaultConsistencyPolicy is set to 'BoundedStaleness'.
+        """
+        return pulumi.get(self, "max_interval_in_seconds")
+
+    @max_interval_in_seconds.setter
+    def max_interval_in_seconds(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_interval_in_seconds", value)
+
+    @property
+    @pulumi.getter(name="maxStalenessPrefix")
+    def max_staleness_prefix(self) -> Optional[pulumi.Input[float]]:
+        """
+        When used with the Bounded Staleness consistency level, this value represents the number of stale requests tolerated. Accepted range for this value is 1 – 2,147,483,647. Required when defaultConsistencyPolicy is set to 'BoundedStaleness'.
+        """
+        return pulumi.get(self, "max_staleness_prefix")
+
+    @max_staleness_prefix.setter
+    def max_staleness_prefix(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "max_staleness_prefix", value)
+
+
+@pulumi.input_type
+class ContainerPartitionKeyArgs:
+    def __init__(__self__, *,
+                 kind: Optional[pulumi.Input[Union[str, 'PartitionKind']]] = None,
+                 paths: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 version: Optional[pulumi.Input[int]] = None):
+        """
+        The configuration of the partition key to be used for partitioning data into multiple partitions
+        :param pulumi.Input[Union[str, 'PartitionKind']] kind: Indicates the kind of algorithm used for partitioning. For MultiHash, multiple partition keys (upto three maximum) are supported for container create
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] paths: List of paths using which data within the container can be partitioned
+        :param pulumi.Input[int] version: Indicates the version of the partition key definition
+        """
+        if kind is None:
+            kind = 'Hash'
+        if kind is not None:
+            pulumi.set(__self__, "kind", kind)
+        if paths is not None:
+            pulumi.set(__self__, "paths", paths)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[Union[str, 'PartitionKind']]]:
+        """
+        Indicates the kind of algorithm used for partitioning. For MultiHash, multiple partition keys (upto three maximum) are supported for container create
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[Union[str, 'PartitionKind']]]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def paths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        List of paths using which data within the container can be partitioned
+        """
+        return pulumi.get(self, "paths")
+
+    @paths.setter
+    def paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "paths", value)
+
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[pulumi.Input[int]]:
+        """
+        Indicates the version of the partition key definition
+        """
+        return pulumi.get(self, "version")
+
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "version", value)
+
+
+@pulumi.input_type
+class ContinuousModeBackupPolicyArgs:
+    def __init__(__self__, *,
+                 type: pulumi.Input[str],
+                 continuous_mode_properties: Optional[pulumi.Input['ContinuousModePropertiesArgs']] = None,
+                 migration_state: Optional[pulumi.Input['BackupPolicyMigrationStateArgs']] = None):
+        """
+        The object representing continuous mode backup policy.
+        :param pulumi.Input[str] type: Describes the mode of backups.
+               Expected value is 'Continuous'.
+        :param pulumi.Input['ContinuousModePropertiesArgs'] continuous_mode_properties: Configuration values for continuous mode backup
+        :param pulumi.Input['BackupPolicyMigrationStateArgs'] migration_state: The object representing the state of the migration between the backup policies.
+        """
+        pulumi.set(__self__, "type", 'Continuous')
+        if continuous_mode_properties is not None:
+            pulumi.set(__self__, "continuous_mode_properties", continuous_mode_properties)
+        if migration_state is not None:
+            pulumi.set(__self__, "migration_state", migration_state)
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Input[str]:
+        """
+        Describes the mode of backups.
+        Expected value is 'Continuous'.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter(name="continuousModeProperties")
+    def continuous_mode_properties(self) -> Optional[pulumi.Input['ContinuousModePropertiesArgs']]:
+        """
+        Configuration values for continuous mode backup
+        """
+        return pulumi.get(self, "continuous_mode_properties")
+
+    @continuous_mode_properties.setter
+    def continuous_mode_properties(self, value: Optional[pulumi.Input['ContinuousModePropertiesArgs']]):
+        pulumi.set(self, "continuous_mode_properties", value)
+
+    @property
+    @pulumi.getter(name="migrationState")
+    def migration_state(self) -> Optional[pulumi.Input['BackupPolicyMigrationStateArgs']]:
+        """
+        The object representing the state of the migration between the backup policies.
+        """
+        return pulumi.get(self, "migration_state")
+
+    @migration_state.setter
+    def migration_state(self, value: Optional[pulumi.Input['BackupPolicyMigrationStateArgs']]):
+        pulumi.set(self, "migration_state", value)
+
+
+@pulumi.input_type
+class ContinuousModePropertiesArgs:
+    def __init__(__self__, *,
+                 tier: Optional[pulumi.Input[Union[str, 'ContinuousTier']]] = None):
+        """
+        Configuration values for periodic mode backup
+        :param pulumi.Input[Union[str, 'ContinuousTier']] tier: Enum to indicate type of Continuous backup mode
+        """
+        if tier is not None:
+            pulumi.set(__self__, "tier", tier)
+
+    @property
+    @pulumi.getter
+    def tier(self) -> Optional[pulumi.Input[Union[str, 'ContinuousTier']]]:
+        """
+        Enum to indicate type of Continuous backup mode
+        """
+        return pulumi.get(self, "tier")
+
+    @tier.setter
+    def tier(self, value: Optional[pulumi.Input[Union[str, 'ContinuousTier']]]):
+        pulumi.set(self, "tier", value)
+
+
+@pulumi.input_type
+class CorsPolicyArgs:
+    def __init__(__self__, *,
+                 allowed_origins: pulumi.Input[str],
+                 allowed_headers: Optional[pulumi.Input[str]] = None,
+                 allowed_methods: Optional[pulumi.Input[str]] = None,
+                 exposed_headers: Optional[pulumi.Input[str]] = None,
+                 max_age_in_seconds: Optional[pulumi.Input[float]] = None):
+        """
+        The CORS policy for the Cosmos DB database account.
+        :param pulumi.Input[str] allowed_origins: The origin domains that are permitted to make a request against the service via CORS.
+        :param pulumi.Input[str] allowed_headers: The request headers that the origin domain may specify on the CORS request.
+        :param pulumi.Input[str] allowed_methods: The methods (HTTP request verbs) that the origin domain may use for a CORS request.
+        :param pulumi.Input[str] exposed_headers: The response headers that may be sent in the response to the CORS request and exposed by the browser to the request issuer.
+        :param pulumi.Input[float] max_age_in_seconds: The maximum amount time that a browser should cache the preflight OPTIONS request.
+        """
+        pulumi.set(__self__, "allowed_origins", allowed_origins)
+        if allowed_headers is not None:
+            pulumi.set(__self__, "allowed_headers", allowed_headers)
+        if allowed_methods is not None:
+            pulumi.set(__self__, "allowed_methods", allowed_methods)
+        if exposed_headers is not None:
+            pulumi.set(__self__, "exposed_headers", exposed_headers)
+        if max_age_in_seconds is not None:
+            pulumi.set(__self__, "max_age_in_seconds", max_age_in_seconds)
+
+    @property
+    @pulumi.getter(name="allowedOrigins")
+    def allowed_origins(self) -> pulumi.Input[str]:
+        """
+        The origin domains that are permitted to make a request against the service via CORS.
+        """
+        return pulumi.get(self, "allowed_origins")
+
+    @allowed_origins.setter
+    def allowed_origins(self, value: pulumi.Input[str]):
+        pulumi.set(self, "allowed_origins", value)
+
+    @property
+    @pulumi.getter(name="allowedHeaders")
+    def allowed_headers(self) -> Optional[pulumi.Input[str]]:
+        """
+        The request headers that the origin domain may specify on the CORS request.
+        """
+        return pulumi.get(self, "allowed_headers")
+
+    @allowed_headers.setter
+    def allowed_headers(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "allowed_headers", value)
+
+    @property
+    @pulumi.getter(name="allowedMethods")
+    def allowed_methods(self) -> Optional[pulumi.Input[str]]:
+        """
+        The methods (HTTP request verbs) that the origin domain may use for a CORS request.
+        """
+        return pulumi.get(self, "allowed_methods")
+
+    @allowed_methods.setter
+    def allowed_methods(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "allowed_methods", value)
+
+    @property
+    @pulumi.getter(name="exposedHeaders")
+    def exposed_headers(self) -> Optional[pulumi.Input[str]]:
+        """
+        The response headers that may be sent in the response to the CORS request and exposed by the browser to the request issuer.
+        """
+        return pulumi.get(self, "exposed_headers")
+
+    @exposed_headers.setter
+    def exposed_headers(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "exposed_headers", value)
+
+    @property
+    @pulumi.getter(name="maxAgeInSeconds")
+    def max_age_in_seconds(self) -> Optional[pulumi.Input[float]]:
+        """
+        The maximum amount time that a browser should cache the preflight OPTIONS request.
+        """
+        return pulumi.get(self, "max_age_in_seconds")
+
+    @max_age_in_seconds.setter
+    def max_age_in_seconds(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "max_age_in_seconds", value)
+
+
+@pulumi.input_type
+class CreateUpdateOptionsArgs:
+    def __init__(__self__, *,
+                 autoscale_settings: Optional[pulumi.Input['AutoscaleSettingsArgs']] = None,
+                 throughput: Optional[pulumi.Input[int]] = None):
+        """
+        CreateUpdateOptions are a list of key-value pairs that describe the resource. Supported keys are "If-Match", "If-None-Match", "Session-Token" and "Throughput"
+        :param pulumi.Input['AutoscaleSettingsArgs'] autoscale_settings: Specifies the Autoscale settings. Note: Either throughput or autoscaleSettings is required, but not both.
+        :param pulumi.Input[int] throughput: Request Units per second. For example, "throughput": 10000.
+        """
+        if autoscale_settings is not None:
+            pulumi.set(__self__, "autoscale_settings", autoscale_settings)
+        if throughput is not None:
+            pulumi.set(__self__, "throughput", throughput)
+
+    @property
+    @pulumi.getter(name="autoscaleSettings")
+    def autoscale_settings(self) -> Optional[pulumi.Input['AutoscaleSettingsArgs']]:
+        """
+        Specifies the Autoscale settings. Note: Either throughput or autoscaleSettings is required, but not both.
+        """
+        return pulumi.get(self, "autoscale_settings")
+
+    @autoscale_settings.setter
+    def autoscale_settings(self, value: Optional[pulumi.Input['AutoscaleSettingsArgs']]):
+        pulumi.set(self, "autoscale_settings", value)
+
+    @property
+    @pulumi.getter
+    def throughput(self) -> Optional[pulumi.Input[int]]:
+        """
+        Request Units per second. For example, "throughput": 10000.
+        """
+        return pulumi.get(self, "throughput")
+
+    @throughput.setter
+    def throughput(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "throughput", value)
+
+
+@pulumi.input_type
+class DataCenterResourcePropertiesArgs:
+    def __init__(__self__, *,
+                 authentication_method_ldap_properties: Optional[pulumi.Input['AuthenticationMethodLdapPropertiesArgs']] = None,
+                 availability_zone: Optional[pulumi.Input[bool]] = None,
+                 backup_storage_customer_key_uri: Optional[pulumi.Input[str]] = None,
+                 base64_encoded_cassandra_yaml_fragment: Optional[pulumi.Input[str]] = None,
+                 data_center_location: Optional[pulumi.Input[str]] = None,
+                 deallocated: Optional[pulumi.Input[bool]] = None,
+                 delegated_subnet_id: Optional[pulumi.Input[str]] = None,
+                 disk_capacity: Optional[pulumi.Input[int]] = None,
+                 disk_sku: Optional[pulumi.Input[str]] = None,
+                 managed_disk_customer_key_uri: Optional[pulumi.Input[str]] = None,
+                 node_count: Optional[pulumi.Input[int]] = None,
+                 private_endpoint_ip_address: Optional[pulumi.Input[str]] = None,
+                 provision_error: Optional[pulumi.Input['CassandraErrorArgs']] = None,
+                 provisioning_state: Optional[pulumi.Input[Union[str, 'ManagedCassandraProvisioningState']]] = None,
+                 sku: Optional[pulumi.Input[str]] = None):
+        """
+        Properties of a managed Cassandra data center.
+        :param pulumi.Input['AuthenticationMethodLdapPropertiesArgs'] authentication_method_ldap_properties: Ldap authentication method properties. This feature is in preview.
+        :param pulumi.Input[bool] availability_zone: If the data center has Availability Zone support, apply it to the Virtual Machine ScaleSet that host the cassandra data center virtual machines.
+        :param pulumi.Input[str] backup_storage_customer_key_uri: Indicates the Key Uri of the customer key to use for encryption of the backup storage account.
+        :param pulumi.Input[str] base64_encoded_cassandra_yaml_fragment: A fragment of a cassandra.yaml configuration file to be included in the cassandra.yaml for all nodes in this data center. The fragment should be Base64 encoded, and only a subset of keys are allowed.
+        :param pulumi.Input[str] data_center_location: The region this data center should be created in.
+        :param pulumi.Input[bool] deallocated: Whether the data center has been deallocated.
+        :param pulumi.Input[str] delegated_subnet_id: Resource id of a subnet the nodes in this data center should have their network interfaces connected to. The subnet must be in the same region specified in 'dataCenterLocation' and must be able to route to the subnet specified in the cluster's 'delegatedManagementSubnetId' property. This resource id will be of the form '/subscriptions/<subscription id>/resourceGroups/<resource group>/providers/Microsoft.Network/virtualNetworks/<virtual network>/subnets/<subnet>'.
+        :param pulumi.Input[int] disk_capacity: Number of disks attached to each node. Default is 4.
+        :param pulumi.Input[str] disk_sku: Disk SKU used for data centers. Default value is P30.
+        :param pulumi.Input[str] managed_disk_customer_key_uri: Key uri to use for encryption of managed disks. Ensure the system assigned identity of the cluster has been assigned appropriate permissions(key get/wrap/unwrap permissions) on the key.
+        :param pulumi.Input[int] node_count: The number of nodes the data center should have. This is the desired number. After it is set, it may take some time for the data center to be scaled to match. To monitor the number of nodes and their status, use the fetchNodeStatus method on the cluster.
+        :param pulumi.Input[str] private_endpoint_ip_address: Ip of the VPN Endpoint for this data center.
+        :param pulumi.Input['CassandraErrorArgs'] provision_error: Error related to resource provisioning.
+        :param pulumi.Input[Union[str, 'ManagedCassandraProvisioningState']] provisioning_state: The status of the resource at the time the operation was called.
+        :param pulumi.Input[str] sku: Virtual Machine SKU used for data centers. Default value is Standard_DS14_v2
+        """
+        if authentication_method_ldap_properties is not None:
+            pulumi.set(__self__, "authentication_method_ldap_properties", authentication_method_ldap_properties)
+        if availability_zone is not None:
+            pulumi.set(__self__, "availability_zone", availability_zone)
+        if backup_storage_customer_key_uri is not None:
+            pulumi.set(__self__, "backup_storage_customer_key_uri", backup_storage_customer_key_uri)
+        if base64_encoded_cassandra_yaml_fragment is not None:
+            pulumi.set(__self__, "base64_encoded_cassandra_yaml_fragment", base64_encoded_cassandra_yaml_fragment)
+        if data_center_location is not None:
+            pulumi.set(__self__, "data_center_location", data_center_location)
+        if deallocated is not None:
+            pulumi.set(__self__, "deallocated", deallocated)
+        if delegated_subnet_id is not None:
+            pulumi.set(__self__, "delegated_subnet_id", delegated_subnet_id)
+        if disk_capacity is not None:
+            pulumi.set(__self__, "disk_capacity", disk_capacity)
+        if disk_sku is not None:
+            pulumi.set(__self__, "disk_sku", disk_sku)
+        if managed_disk_customer_key_uri is not None:
+            pulumi.set(__self__, "managed_disk_customer_key_uri", managed_disk_customer_key_uri)
+        if node_count is not None:
+            pulumi.set(__self__, "node_count", node_count)
+        if private_endpoint_ip_address is not None:
+            pulumi.set(__self__, "private_endpoint_ip_address", private_endpoint_ip_address)
+        if provision_error is not None:
+            pulumi.set(__self__, "provision_error", provision_error)
+        if provisioning_state is not None:
+            pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if sku is not None:
+            pulumi.set(__self__, "sku", sku)
+
+    @property
+    @pulumi.getter(name="authenticationMethodLdapProperties")
+    def authentication_method_ldap_properties(self) -> Optional[pulumi.Input['AuthenticationMethodLdapPropertiesArgs']]:
+        """
+        Ldap authentication method properties. This feature is in preview.
+        """
+        return pulumi.get(self, "authentication_method_ldap_properties")
+
+    @authentication_method_ldap_properties.setter
+    def authentication_method_ldap_properties(self, value: Optional[pulumi.Input['AuthenticationMethodLdapPropertiesArgs']]):
+        pulumi.set(self, "authentication_method_ldap_properties", value)
+
+    @property
+    @pulumi.getter(name="availabilityZone")
+    def availability_zone(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If the data center has Availability Zone support, apply it to the Virtual Machine ScaleSet that host the cassandra data center virtual machines.
+        """
+        return pulumi.get(self, "availability_zone")
+
+    @availability_zone.setter
+    def availability_zone(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "availability_zone", value)
+
+    @property
+    @pulumi.getter(name="backupStorageCustomerKeyUri")
+    def backup_storage_customer_key_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        Indicates the Key Uri of the customer key to use for encryption of the backup storage account.
+        """
+        return pulumi.get(self, "backup_storage_customer_key_uri")
+
+    @backup_storage_customer_key_uri.setter
+    def backup_storage_customer_key_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "backup_storage_customer_key_uri", value)
+
+    @property
+    @pulumi.getter(name="base64EncodedCassandraYamlFragment")
+    def base64_encoded_cassandra_yaml_fragment(self) -> Optional[pulumi.Input[str]]:
+        """
+        A fragment of a cassandra.yaml configuration file to be included in the cassandra.yaml for all nodes in this data center. The fragment should be Base64 encoded, and only a subset of keys are allowed.
+        """
+        return pulumi.get(self, "base64_encoded_cassandra_yaml_fragment")
+
+    @base64_encoded_cassandra_yaml_fragment.setter
+    def base64_encoded_cassandra_yaml_fragment(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "base64_encoded_cassandra_yaml_fragment", value)
+
+    @property
+    @pulumi.getter(name="dataCenterLocation")
+    def data_center_location(self) -> Optional[pulumi.Input[str]]:
+        """
+        The region this data center should be created in.
+        """
+        return pulumi.get(self, "data_center_location")
+
+    @data_center_location.setter
+    def data_center_location(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "data_center_location", value)
+
+    @property
+    @pulumi.getter
+    def deallocated(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether the data center has been deallocated.
+        """
+        return pulumi.get(self, "deallocated")
+
+    @deallocated.setter
+    def deallocated(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "deallocated", value)
+
+    @property
+    @pulumi.getter(name="delegatedSubnetId")
+    def delegated_subnet_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Resource id of a subnet the nodes in this data center should have their network interfaces connected to. The subnet must be in the same region specified in 'dataCenterLocation' and must be able to route to the subnet specified in the cluster's 'delegatedManagementSubnetId' property. This resource id will be of the form '/subscriptions/<subscription id>/resourceGroups/<resource group>/providers/Microsoft.Network/virtualNetworks/<virtual network>/subnets/<subnet>'.
+        """
+        return pulumi.get(self, "delegated_subnet_id")
+
+    @delegated_subnet_id.setter
+    def delegated_subnet_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "delegated_subnet_id", value)
+
+    @property
+    @pulumi.getter(name="diskCapacity")
+    def disk_capacity(self) -> Optional[pulumi.Input[int]]:
+        """
+        Number of disks attached to each node. Default is 4.
+        """
+        return pulumi.get(self, "disk_capacity")
+
+    @disk_capacity.setter
+    def disk_capacity(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "disk_capacity", value)
+
+    @property
+    @pulumi.getter(name="diskSku")
+    def disk_sku(self) -> Optional[pulumi.Input[str]]:
+        """
+        Disk SKU used for data centers. Default value is P30.
+        """
+        return pulumi.get(self, "disk_sku")
+
+    @disk_sku.setter
+    def disk_sku(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "disk_sku", value)
+
+    @property
+    @pulumi.getter(name="managedDiskCustomerKeyUri")
+    def managed_disk_customer_key_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        Key uri to use for encryption of managed disks. Ensure the system assigned identity of the cluster has been assigned appropriate permissions(key get/wrap/unwrap permissions) on the key.
+        """
+        return pulumi.get(self, "managed_disk_customer_key_uri")
+
+    @managed_disk_customer_key_uri.setter
+    def managed_disk_customer_key_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "managed_disk_customer_key_uri", value)
+
+    @property
+    @pulumi.getter(name="nodeCount")
+    def node_count(self) -> Optional[pulumi.Input[int]]:
+        """
+        The number of nodes the data center should have. This is the desired number. After it is set, it may take some time for the data center to be scaled to match. To monitor the number of nodes and their status, use the fetchNodeStatus method on the cluster.
+        """
+        return pulumi.get(self, "node_count")
+
+    @node_count.setter
+    def node_count(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "node_count", value)
+
+    @property
+    @pulumi.getter(name="privateEndpointIpAddress")
+    def private_endpoint_ip_address(self) -> Optional[pulumi.Input[str]]:
+        """
+        Ip of the VPN Endpoint for this data center.
+        """
+        return pulumi.get(self, "private_endpoint_ip_address")
+
+    @private_endpoint_ip_address.setter
+    def private_endpoint_ip_address(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "private_endpoint_ip_address", value)
+
+    @property
+    @pulumi.getter(name="provisionError")
+    def provision_error(self) -> Optional[pulumi.Input['CassandraErrorArgs']]:
+        """
+        Error related to resource provisioning.
+        """
+        return pulumi.get(self, "provision_error")
+
+    @provision_error.setter
+    def provision_error(self, value: Optional[pulumi.Input['CassandraErrorArgs']]):
+        pulumi.set(self, "provision_error", value)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> Optional[pulumi.Input[Union[str, 'ManagedCassandraProvisioningState']]]:
+        """
+        The status of the resource at the time the operation was called.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @provisioning_state.setter
+    def provisioning_state(self, value: Optional[pulumi.Input[Union[str, 'ManagedCassandraProvisioningState']]]):
+        pulumi.set(self, "provisioning_state", value)
+
+    @property
+    @pulumi.getter
+    def sku(self) -> Optional[pulumi.Input[str]]:
+        """
+        Virtual Machine SKU used for data centers. Default value is Standard_DS14_v2
+        """
+        return pulumi.get(self, "sku")
+
+    @sku.setter
+    def sku(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "sku", value)
+
+
+@pulumi.input_type
+class DatabaseRestoreResourceArgs:
+    def __init__(__self__, *,
+                 collection_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 database_name: Optional[pulumi.Input[str]] = None):
+        """
+        Specific Databases to restore.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] collection_names: The names of the collections available for restore.
+        :param pulumi.Input[str] database_name: The name of the database available for restore.
+        """
+        if collection_names is not None:
+            pulumi.set(__self__, "collection_names", collection_names)
+        if database_name is not None:
+            pulumi.set(__self__, "database_name", database_name)
+
+    @property
+    @pulumi.getter(name="collectionNames")
+    def collection_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The names of the collections available for restore.
+        """
+        return pulumi.get(self, "collection_names")
+
+    @collection_names.setter
+    def collection_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "collection_names", value)
+
+    @property
+    @pulumi.getter(name="databaseName")
+    def database_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the database available for restore.
+        """
+        return pulumi.get(self, "database_name")
+
+    @database_name.setter
+    def database_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "database_name", value)
+
+
+@pulumi.input_type
+class ExcludedPathArgs:
+    def __init__(__self__, *,
+                 path: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] path: The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*)
+        """
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[str]]:
+        """
+        The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*)
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "path", value)
+
+
+@pulumi.input_type
+class GremlinDatabaseResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 create_mode: Optional[pulumi.Input[Union[str, 'CreateMode']]] = None,
+                 restore_parameters: Optional[pulumi.Input['ResourceRestoreParametersArgs']] = None):
+        """
+        Cosmos DB Gremlin database resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB Gremlin database
+        :param pulumi.Input[Union[str, 'CreateMode']] create_mode: Enum to indicate the mode of resource creation.
+        :param pulumi.Input['ResourceRestoreParametersArgs'] restore_parameters: Parameters to indicate the information about the restore
+        """
+        pulumi.set(__self__, "id", id)
+        if create_mode is not None:
+            pulumi.set(__self__, "create_mode", create_mode)
+        if restore_parameters is not None:
+            pulumi.set(__self__, "restore_parameters", restore_parameters)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB Gremlin database
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="createMode")
+    def create_mode(self) -> Optional[pulumi.Input[Union[str, 'CreateMode']]]:
+        """
+        Enum to indicate the mode of resource creation.
+        """
+        return pulumi.get(self, "create_mode")
+
+    @create_mode.setter
+    def create_mode(self, value: Optional[pulumi.Input[Union[str, 'CreateMode']]]):
+        pulumi.set(self, "create_mode", value)
+
+    @property
+    @pulumi.getter(name="restoreParameters")
+    def restore_parameters(self) -> Optional[pulumi.Input['ResourceRestoreParametersArgs']]:
+        """
+        Parameters to indicate the information about the restore
+        """
+        return pulumi.get(self, "restore_parameters")
+
+    @restore_parameters.setter
+    def restore_parameters(self, value: Optional[pulumi.Input['ResourceRestoreParametersArgs']]):
+        pulumi.set(self, "restore_parameters", value)
+
+
+@pulumi.input_type
+class GremlinDatabaseRestoreResourceArgs:
+    def __init__(__self__, *,
+                 database_name: Optional[pulumi.Input[str]] = None,
+                 graph_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Specific Gremlin Databases to restore.
+        :param pulumi.Input[str] database_name: The name of the gremlin database available for restore.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] graph_names: The names of the graphs available for restore.
+        """
+        if database_name is not None:
+            pulumi.set(__self__, "database_name", database_name)
+        if graph_names is not None:
+            pulumi.set(__self__, "graph_names", graph_names)
+
+    @property
+    @pulumi.getter(name="databaseName")
+    def database_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the gremlin database available for restore.
+        """
+        return pulumi.get(self, "database_name")
+
+    @database_name.setter
+    def database_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "database_name", value)
+
+    @property
+    @pulumi.getter(name="graphNames")
+    def graph_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The names of the graphs available for restore.
+        """
+        return pulumi.get(self, "graph_names")
+
+    @graph_names.setter
+    def graph_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "graph_names", value)
+
+
+@pulumi.input_type
+class GremlinGraphResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 analytical_storage_ttl: Optional[pulumi.Input[float]] = None,
+                 conflict_resolution_policy: Optional[pulumi.Input['ConflictResolutionPolicyArgs']] = None,
+                 create_mode: Optional[pulumi.Input[Union[str, 'CreateMode']]] = None,
+                 default_ttl: Optional[pulumi.Input[int]] = None,
+                 indexing_policy: Optional[pulumi.Input['IndexingPolicyArgs']] = None,
+                 partition_key: Optional[pulumi.Input['ContainerPartitionKeyArgs']] = None,
+                 restore_parameters: Optional[pulumi.Input['ResourceRestoreParametersArgs']] = None,
+                 unique_key_policy: Optional[pulumi.Input['UniqueKeyPolicyArgs']] = None):
+        """
+        Cosmos DB Gremlin graph resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB Gremlin graph
+        :param pulumi.Input[float] analytical_storage_ttl: Analytical TTL.
+        :param pulumi.Input['ConflictResolutionPolicyArgs'] conflict_resolution_policy: The conflict resolution policy for the graph.
+        :param pulumi.Input[Union[str, 'CreateMode']] create_mode: Enum to indicate the mode of resource creation.
+        :param pulumi.Input[int] default_ttl: Default time to live
+        :param pulumi.Input['IndexingPolicyArgs'] indexing_policy: The configuration of the indexing policy. By default, the indexing is automatic for all document paths within the graph
+        :param pulumi.Input['ContainerPartitionKeyArgs'] partition_key: The configuration of the partition key to be used for partitioning data into multiple partitions
+        :param pulumi.Input['ResourceRestoreParametersArgs'] restore_parameters: Parameters to indicate the information about the restore
+        :param pulumi.Input['UniqueKeyPolicyArgs'] unique_key_policy: The unique key policy configuration for specifying uniqueness constraints on documents in the collection in the Azure Cosmos DB service.
+        """
+        pulumi.set(__self__, "id", id)
+        if analytical_storage_ttl is not None:
+            pulumi.set(__self__, "analytical_storage_ttl", analytical_storage_ttl)
+        if conflict_resolution_policy is not None:
+            pulumi.set(__self__, "conflict_resolution_policy", conflict_resolution_policy)
+        if create_mode is not None:
+            pulumi.set(__self__, "create_mode", create_mode)
+        if default_ttl is not None:
+            pulumi.set(__self__, "default_ttl", default_ttl)
+        if indexing_policy is not None:
+            pulumi.set(__self__, "indexing_policy", indexing_policy)
+        if partition_key is not None:
+            pulumi.set(__self__, "partition_key", partition_key)
+        if restore_parameters is not None:
+            pulumi.set(__self__, "restore_parameters", restore_parameters)
+        if unique_key_policy is not None:
+            pulumi.set(__self__, "unique_key_policy", unique_key_policy)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB Gremlin graph
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="analyticalStorageTtl")
+    def analytical_storage_ttl(self) -> Optional[pulumi.Input[float]]:
+        """
+        Analytical TTL.
+        """
+        return pulumi.get(self, "analytical_storage_ttl")
+
+    @analytical_storage_ttl.setter
+    def analytical_storage_ttl(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "analytical_storage_ttl", value)
+
+    @property
+    @pulumi.getter(name="conflictResolutionPolicy")
+    def conflict_resolution_policy(self) -> Optional[pulumi.Input['ConflictResolutionPolicyArgs']]:
+        """
+        The conflict resolution policy for the graph.
+        """
+        return pulumi.get(self, "conflict_resolution_policy")
+
+    @conflict_resolution_policy.setter
+    def conflict_resolution_policy(self, value: Optional[pulumi.Input['ConflictResolutionPolicyArgs']]):
+        pulumi.set(self, "conflict_resolution_policy", value)
+
+    @property
+    @pulumi.getter(name="createMode")
+    def create_mode(self) -> Optional[pulumi.Input[Union[str, 'CreateMode']]]:
+        """
+        Enum to indicate the mode of resource creation.
+        """
+        return pulumi.get(self, "create_mode")
+
+    @create_mode.setter
+    def create_mode(self, value: Optional[pulumi.Input[Union[str, 'CreateMode']]]):
+        pulumi.set(self, "create_mode", value)
+
+    @property
+    @pulumi.getter(name="defaultTtl")
+    def default_ttl(self) -> Optional[pulumi.Input[int]]:
+        """
+        Default time to live
+        """
+        return pulumi.get(self, "default_ttl")
+
+    @default_ttl.setter
+    def default_ttl(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "default_ttl", value)
+
+    @property
+    @pulumi.getter(name="indexingPolicy")
+    def indexing_policy(self) -> Optional[pulumi.Input['IndexingPolicyArgs']]:
+        """
+        The configuration of the indexing policy. By default, the indexing is automatic for all document paths within the graph
+        """
+        return pulumi.get(self, "indexing_policy")
+
+    @indexing_policy.setter
+    def indexing_policy(self, value: Optional[pulumi.Input['IndexingPolicyArgs']]):
+        pulumi.set(self, "indexing_policy", value)
+
+    @property
+    @pulumi.getter(name="partitionKey")
+    def partition_key(self) -> Optional[pulumi.Input['ContainerPartitionKeyArgs']]:
+        """
+        The configuration of the partition key to be used for partitioning data into multiple partitions
+        """
+        return pulumi.get(self, "partition_key")
+
+    @partition_key.setter
+    def partition_key(self, value: Optional[pulumi.Input['ContainerPartitionKeyArgs']]):
+        pulumi.set(self, "partition_key", value)
+
+    @property
+    @pulumi.getter(name="restoreParameters")
+    def restore_parameters(self) -> Optional[pulumi.Input['ResourceRestoreParametersArgs']]:
+        """
+        Parameters to indicate the information about the restore
+        """
+        return pulumi.get(self, "restore_parameters")
+
+    @restore_parameters.setter
+    def restore_parameters(self, value: Optional[pulumi.Input['ResourceRestoreParametersArgs']]):
+        pulumi.set(self, "restore_parameters", value)
+
+    @property
+    @pulumi.getter(name="uniqueKeyPolicy")
+    def unique_key_policy(self) -> Optional[pulumi.Input['UniqueKeyPolicyArgs']]:
+        """
+        The unique key policy configuration for specifying uniqueness constraints on documents in the collection in the Azure Cosmos DB service.
+        """
+        return pulumi.get(self, "unique_key_policy")
+
+    @unique_key_policy.setter
+    def unique_key_policy(self, value: Optional[pulumi.Input['UniqueKeyPolicyArgs']]):
+        pulumi.set(self, "unique_key_policy", value)
+
+
+@pulumi.input_type
+class IncludedPathArgs:
+    def __init__(__self__, *,
+                 indexes: Optional[pulumi.Input[Sequence[pulumi.Input['IndexesArgs']]]] = None,
+                 path: Optional[pulumi.Input[str]] = None):
+        """
+        The paths that are included in indexing
+        :param pulumi.Input[Sequence[pulumi.Input['IndexesArgs']]] indexes: List of indexes for this path
+        :param pulumi.Input[str] path: The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*)
+        """
+        if indexes is not None:
+            pulumi.set(__self__, "indexes", indexes)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+
+    @property
+    @pulumi.getter
+    def indexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IndexesArgs']]]]:
+        """
+        List of indexes for this path
+        """
+        return pulumi.get(self, "indexes")
+
+    @indexes.setter
+    def indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IndexesArgs']]]]):
+        pulumi.set(self, "indexes", value)
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[str]]:
+        """
+        The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*)
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "path", value)
+
+
+@pulumi.input_type
+class IndexesArgs:
+    def __init__(__self__, *,
+                 data_type: Optional[pulumi.Input[Union[str, 'DataType']]] = None,
+                 kind: Optional[pulumi.Input[Union[str, 'IndexKind']]] = None,
+                 precision: Optional[pulumi.Input[int]] = None):
+        """
+        The indexes for the path.
+        :param pulumi.Input[Union[str, 'DataType']] data_type: The datatype for which the indexing behavior is applied to.
+        :param pulumi.Input[Union[str, 'IndexKind']] kind: Indicates the type of index.
+        :param pulumi.Input[int] precision: The precision of the index. -1 is maximum precision.
+        """
+        if data_type is None:
+            data_type = 'String'
+        if data_type is not None:
+            pulumi.set(__self__, "data_type", data_type)
+        if kind is None:
+            kind = 'Hash'
+        if kind is not None:
+            pulumi.set(__self__, "kind", kind)
+        if precision is not None:
+            pulumi.set(__self__, "precision", precision)
+
+    @property
+    @pulumi.getter(name="dataType")
+    def data_type(self) -> Optional[pulumi.Input[Union[str, 'DataType']]]:
+        """
+        The datatype for which the indexing behavior is applied to.
+        """
+        return pulumi.get(self, "data_type")
+
+    @data_type.setter
+    def data_type(self, value: Optional[pulumi.Input[Union[str, 'DataType']]]):
+        pulumi.set(self, "data_type", value)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[Union[str, 'IndexKind']]]:
+        """
+        Indicates the type of index.
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[Union[str, 'IndexKind']]]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def precision(self) -> Optional[pulumi.Input[int]]:
+        """
+        The precision of the index. -1 is maximum precision.
+        """
+        return pulumi.get(self, "precision")
+
+    @precision.setter
+    def precision(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "precision", value)
+
+
+@pulumi.input_type
+class IndexingPolicyArgs:
+    def __init__(__self__, *,
+                 automatic: Optional[pulumi.Input[bool]] = None,
+                 composite_indexes: Optional[pulumi.Input[Sequence[pulumi.Input[Sequence[pulumi.Input['CompositePathArgs']]]]]] = None,
+                 excluded_paths: Optional[pulumi.Input[Sequence[pulumi.Input['ExcludedPathArgs']]]] = None,
+                 included_paths: Optional[pulumi.Input[Sequence[pulumi.Input['IncludedPathArgs']]]] = None,
+                 indexing_mode: Optional[pulumi.Input[Union[str, 'IndexingMode']]] = None,
+                 spatial_indexes: Optional[pulumi.Input[Sequence[pulumi.Input['SpatialSpecArgs']]]] = None):
+        """
+        Cosmos DB indexing policy
+        :param pulumi.Input[bool] automatic: Indicates if the indexing policy is automatic
+        :param pulumi.Input[Sequence[pulumi.Input[Sequence[pulumi.Input['CompositePathArgs']]]]] composite_indexes: List of composite path list
+        :param pulumi.Input[Sequence[pulumi.Input['ExcludedPathArgs']]] excluded_paths: List of paths to exclude from indexing
+        :param pulumi.Input[Sequence[pulumi.Input['IncludedPathArgs']]] included_paths: List of paths to include in the indexing
+        :param pulumi.Input[Union[str, 'IndexingMode']] indexing_mode: Indicates the indexing mode.
+        :param pulumi.Input[Sequence[pulumi.Input['SpatialSpecArgs']]] spatial_indexes: List of spatial specifics
+        """
+        if automatic is not None:
+            pulumi.set(__self__, "automatic", automatic)
+        if composite_indexes is not None:
+            pulumi.set(__self__, "composite_indexes", composite_indexes)
+        if excluded_paths is not None:
+            pulumi.set(__self__, "excluded_paths", excluded_paths)
+        if included_paths is not None:
+            pulumi.set(__self__, "included_paths", included_paths)
+        if indexing_mode is None:
+            indexing_mode = 'consistent'
+        if indexing_mode is not None:
+            pulumi.set(__self__, "indexing_mode", indexing_mode)
+        if spatial_indexes is not None:
+            pulumi.set(__self__, "spatial_indexes", spatial_indexes)
+
+    @property
+    @pulumi.getter
+    def automatic(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Indicates if the indexing policy is automatic
+        """
+        return pulumi.get(self, "automatic")
+
+    @automatic.setter
+    def automatic(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "automatic", value)
+
+    @property
+    @pulumi.getter(name="compositeIndexes")
+    def composite_indexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Sequence[pulumi.Input['CompositePathArgs']]]]]]:
+        """
+        List of composite path list
+        """
+        return pulumi.get(self, "composite_indexes")
+
+    @composite_indexes.setter
+    def composite_indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Sequence[pulumi.Input['CompositePathArgs']]]]]]):
+        pulumi.set(self, "composite_indexes", value)
+
+    @property
+    @pulumi.getter(name="excludedPaths")
+    def excluded_paths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ExcludedPathArgs']]]]:
+        """
+        List of paths to exclude from indexing
+        """
+        return pulumi.get(self, "excluded_paths")
+
+    @excluded_paths.setter
+    def excluded_paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ExcludedPathArgs']]]]):
+        pulumi.set(self, "excluded_paths", value)
+
+    @property
+    @pulumi.getter(name="includedPaths")
+    def included_paths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IncludedPathArgs']]]]:
+        """
+        List of paths to include in the indexing
+        """
+        return pulumi.get(self, "included_paths")
+
+    @included_paths.setter
+    def included_paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IncludedPathArgs']]]]):
+        pulumi.set(self, "included_paths", value)
+
+    @property
+    @pulumi.getter(name="indexingMode")
+    def indexing_mode(self) -> Optional[pulumi.Input[Union[str, 'IndexingMode']]]:
+        """
+        Indicates the indexing mode.
+        """
+        return pulumi.get(self, "indexing_mode")
+
+    @indexing_mode.setter
+    def indexing_mode(self, value: Optional[pulumi.Input[Union[str, 'IndexingMode']]]):
+        pulumi.set(self, "indexing_mode", value)
+
+    @property
+    @pulumi.getter(name="spatialIndexes")
+    def spatial_indexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SpatialSpecArgs']]]]:
+        """
+        List of spatial specifics
+        """
+        return pulumi.get(self, "spatial_indexes")
+
+    @spatial_indexes.setter
+    def spatial_indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SpatialSpecArgs']]]]):
+        pulumi.set(self, "spatial_indexes", value)
+
+
+@pulumi.input_type
+class IpAddressOrRangeArgs:
+    def __init__(__self__, *,
+                 ip_address_or_range: Optional[pulumi.Input[str]] = None):
+        """
+        IpAddressOrRange object
+        :param pulumi.Input[str] ip_address_or_range: A single IPv4 address or a single IPv4 address range in CIDR format. Provided IPs must be well-formatted and cannot be contained in one of the following ranges: 10.0.0.0/8, 100.64.0.0/10, 172.16.0.0/12, 192.168.0.0/16, since these are not enforceable by the IP address filter. Example of valid inputs: “23.40.210.245” or “23.40.210.0/8”.
+        """
+        if ip_address_or_range is not None:
+            pulumi.set(__self__, "ip_address_or_range", ip_address_or_range)
+
+    @property
+    @pulumi.getter(name="ipAddressOrRange")
+    def ip_address_or_range(self) -> Optional[pulumi.Input[str]]:
+        """
+        A single IPv4 address or a single IPv4 address range in CIDR format. Provided IPs must be well-formatted and cannot be contained in one of the following ranges: 10.0.0.0/8, 100.64.0.0/10, 172.16.0.0/12, 192.168.0.0/16, since these are not enforceable by the IP address filter. Example of valid inputs: “23.40.210.245” or “23.40.210.0/8”.
+        """
+        return pulumi.get(self, "ip_address_or_range")
+
+    @ip_address_or_range.setter
+    def ip_address_or_range(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ip_address_or_range", value)
+
+
+@pulumi.input_type
+class LocationArgs:
+    def __init__(__self__, *,
+                 failover_priority: Optional[pulumi.Input[int]] = None,
+                 is_zone_redundant: Optional[pulumi.Input[bool]] = None,
+                 location_name: Optional[pulumi.Input[str]] = None):
+        """
+        A region in which the Azure Cosmos DB database account is deployed.
+        :param pulumi.Input[int] failover_priority: The failover priority of the region. A failover priority of 0 indicates a write region. The maximum value for a failover priority = (total number of regions - 1). Failover priority values must be unique for each of the regions in which the database account exists.
+        :param pulumi.Input[bool] is_zone_redundant: Flag to indicate whether or not this region is an AvailabilityZone region
+        :param pulumi.Input[str] location_name: The name of the region.
+        """
+        if failover_priority is not None:
+            pulumi.set(__self__, "failover_priority", failover_priority)
+        if is_zone_redundant is not None:
+            pulumi.set(__self__, "is_zone_redundant", is_zone_redundant)
+        if location_name is not None:
+            pulumi.set(__self__, "location_name", location_name)
+
+    @property
+    @pulumi.getter(name="failoverPriority")
+    def failover_priority(self) -> Optional[pulumi.Input[int]]:
+        """
+        The failover priority of the region. A failover priority of 0 indicates a write region. The maximum value for a failover priority = (total number of regions - 1). Failover priority values must be unique for each of the regions in which the database account exists.
+        """
+        return pulumi.get(self, "failover_priority")
+
+    @failover_priority.setter
+    def failover_priority(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "failover_priority", value)
+
+    @property
+    @pulumi.getter(name="isZoneRedundant")
+    def is_zone_redundant(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Flag to indicate whether or not this region is an AvailabilityZone region
+        """
+        return pulumi.get(self, "is_zone_redundant")
+
+    @is_zone_redundant.setter
+    def is_zone_redundant(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_zone_redundant", value)
+
+    @property
+    @pulumi.getter(name="locationName")
+    def location_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the region.
+        """
+        return pulumi.get(self, "location_name")
+
+    @location_name.setter
+    def location_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "location_name", value)
+
+
+@pulumi.input_type
+class ManagedCassandraManagedServiceIdentityArgs:
+    def __init__(__self__, *,
+                 type: Optional[pulumi.Input[Union[str, 'ManagedCassandraResourceIdentityType']]] = None):
+        """
+        Identity for the resource.
+        :param pulumi.Input[Union[str, 'ManagedCassandraResourceIdentityType']] type: The type of the resource.
+        """
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[pulumi.Input[Union[str, 'ManagedCassandraResourceIdentityType']]]:
+        """
+        The type of the resource.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: Optional[pulumi.Input[Union[str, 'ManagedCassandraResourceIdentityType']]]):
+        pulumi.set(self, "type", value)
+
+
+@pulumi.input_type
+class ManagedServiceIdentityArgs:
+    def __init__(__self__, *,
+                 type: Optional[pulumi.Input['ResourceIdentityType']] = None,
+                 user_assigned_identities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Identity for the resource.
+        :param pulumi.Input['ResourceIdentityType'] type: The type of identity used for the resource. The type 'SystemAssigned,UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the service.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] user_assigned_identities: The list of user identities associated with resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
+        """
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if user_assigned_identities is not None:
+            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[pulumi.Input['ResourceIdentityType']]:
+        """
+        The type of identity used for the resource. The type 'SystemAssigned,UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the service.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: Optional[pulumi.Input['ResourceIdentityType']]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of user identities associated with resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
+        """
+        return pulumi.get(self, "user_assigned_identities")
+
+    @user_assigned_identities.setter
+    def user_assigned_identities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "user_assigned_identities", value)
+
+
+@pulumi.input_type
+class MongoDBCollectionResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 analytical_storage_ttl: Optional[pulumi.Input[int]] = None,
+                 create_mode: Optional[pulumi.Input[Union[str, 'CreateMode']]] = None,
+                 indexes: Optional[pulumi.Input[Sequence[pulumi.Input['MongoIndexArgs']]]] = None,
+                 restore_parameters: Optional[pulumi.Input['ResourceRestoreParametersArgs']] = None,
+                 shard_key: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
+        """
+        Cosmos DB MongoDB collection resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB MongoDB collection
+        :param pulumi.Input[int] analytical_storage_ttl: Analytical TTL.
+        :param pulumi.Input[Union[str, 'CreateMode']] create_mode: Enum to indicate the mode of resource creation.
+        :param pulumi.Input[Sequence[pulumi.Input['MongoIndexArgs']]] indexes: List of index keys
+        :param pulumi.Input['ResourceRestoreParametersArgs'] restore_parameters: Parameters to indicate the information about the restore
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] shard_key: A key-value pair of shard keys to be applied for the request.
+        """
+        pulumi.set(__self__, "id", id)
+        if analytical_storage_ttl is not None:
+            pulumi.set(__self__, "analytical_storage_ttl", analytical_storage_ttl)
+        if create_mode is not None:
+            pulumi.set(__self__, "create_mode", create_mode)
+        if indexes is not None:
+            pulumi.set(__self__, "indexes", indexes)
+        if restore_parameters is not None:
+            pulumi.set(__self__, "restore_parameters", restore_parameters)
+        if shard_key is not None:
+            pulumi.set(__self__, "shard_key", shard_key)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB MongoDB collection
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="analyticalStorageTtl")
+    def analytical_storage_ttl(self) -> Optional[pulumi.Input[int]]:
+        """
+        Analytical TTL.
+        """
+        return pulumi.get(self, "analytical_storage_ttl")
+
+    @analytical_storage_ttl.setter
+    def analytical_storage_ttl(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "analytical_storage_ttl", value)
+
+    @property
+    @pulumi.getter(name="createMode")
+    def create_mode(self) -> Optional[pulumi.Input[Union[str, 'CreateMode']]]:
+        """
+        Enum to indicate the mode of resource creation.
+        """
+        return pulumi.get(self, "create_mode")
+
+    @create_mode.setter
+    def create_mode(self, value: Optional[pulumi.Input[Union[str, 'CreateMode']]]):
+        pulumi.set(self, "create_mode", value)
+
+    @property
+    @pulumi.getter
+    def indexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MongoIndexArgs']]]]:
+        """
+        List of index keys
+        """
+        return pulumi.get(self, "indexes")
+
+    @indexes.setter
+    def indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MongoIndexArgs']]]]):
+        pulumi.set(self, "indexes", value)
+
+    @property
+    @pulumi.getter(name="restoreParameters")
+    def restore_parameters(self) -> Optional[pulumi.Input['ResourceRestoreParametersArgs']]:
+        """
+        Parameters to indicate the information about the restore
+        """
+        return pulumi.get(self, "restore_parameters")
+
+    @restore_parameters.setter
+    def restore_parameters(self, value: Optional[pulumi.Input['ResourceRestoreParametersArgs']]):
+        pulumi.set(self, "restore_parameters", value)
+
+    @property
+    @pulumi.getter(name="shardKey")
+    def shard_key(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        """
+        A key-value pair of shard keys to be applied for the request.
+        """
+        return pulumi.get(self, "shard_key")
+
+    @shard_key.setter
+    def shard_key(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "shard_key", value)
+
+
+@pulumi.input_type
+class MongoDBDatabaseResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 create_mode: Optional[pulumi.Input[Union[str, 'CreateMode']]] = None,
+                 restore_parameters: Optional[pulumi.Input['ResourceRestoreParametersArgs']] = None):
+        """
+        Cosmos DB MongoDB database resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB MongoDB database
+        :param pulumi.Input[Union[str, 'CreateMode']] create_mode: Enum to indicate the mode of resource creation.
+        :param pulumi.Input['ResourceRestoreParametersArgs'] restore_parameters: Parameters to indicate the information about the restore
+        """
+        pulumi.set(__self__, "id", id)
+        if create_mode is not None:
+            pulumi.set(__self__, "create_mode", create_mode)
+        if restore_parameters is not None:
+            pulumi.set(__self__, "restore_parameters", restore_parameters)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB MongoDB database
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="createMode")
+    def create_mode(self) -> Optional[pulumi.Input[Union[str, 'CreateMode']]]:
+        """
+        Enum to indicate the mode of resource creation.
+        """
+        return pulumi.get(self, "create_mode")
+
+    @create_mode.setter
+    def create_mode(self, value: Optional[pulumi.Input[Union[str, 'CreateMode']]]):
+        pulumi.set(self, "create_mode", value)
+
+    @property
+    @pulumi.getter(name="restoreParameters")
+    def restore_parameters(self) -> Optional[pulumi.Input['ResourceRestoreParametersArgs']]:
+        """
+        Parameters to indicate the information about the restore
+        """
+        return pulumi.get(self, "restore_parameters")
+
+    @restore_parameters.setter
+    def restore_parameters(self, value: Optional[pulumi.Input['ResourceRestoreParametersArgs']]):
+        pulumi.set(self, "restore_parameters", value)
+
+
+@pulumi.input_type
+class MongoIndexKeysArgs:
+    def __init__(__self__, *,
+                 keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Cosmos DB MongoDB collection resource object
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] keys: List of keys for each MongoDB collection in the Azure Cosmos DB service
+        """
+        if keys is not None:
+            pulumi.set(__self__, "keys", keys)
+
+    @property
+    @pulumi.getter
+    def keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        List of keys for each MongoDB collection in the Azure Cosmos DB service
+        """
+        return pulumi.get(self, "keys")
+
+    @keys.setter
+    def keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "keys", value)
+
+
+@pulumi.input_type
+class MongoIndexOptionsArgs:
+    def __init__(__self__, *,
+                 expire_after_seconds: Optional[pulumi.Input[int]] = None,
+                 unique: Optional[pulumi.Input[bool]] = None):
+        """
+        Cosmos DB MongoDB collection index options
+        :param pulumi.Input[int] expire_after_seconds: Expire after seconds
+        :param pulumi.Input[bool] unique: Is unique or not
+        """
+        if expire_after_seconds is not None:
+            pulumi.set(__self__, "expire_after_seconds", expire_after_seconds)
+        if unique is not None:
+            pulumi.set(__self__, "unique", unique)
+
+    @property
+    @pulumi.getter(name="expireAfterSeconds")
+    def expire_after_seconds(self) -> Optional[pulumi.Input[int]]:
+        """
+        Expire after seconds
+        """
+        return pulumi.get(self, "expire_after_seconds")
+
+    @expire_after_seconds.setter
+    def expire_after_seconds(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "expire_after_seconds", value)
+
+    @property
+    @pulumi.getter
+    def unique(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Is unique or not
+        """
+        return pulumi.get(self, "unique")
+
+    @unique.setter
+    def unique(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "unique", value)
+
+
+@pulumi.input_type
+class MongoIndexArgs:
+    def __init__(__self__, *,
+                 key: Optional[pulumi.Input['MongoIndexKeysArgs']] = None,
+                 options: Optional[pulumi.Input['MongoIndexOptionsArgs']] = None):
+        """
+        Cosmos DB MongoDB collection index key
+        :param pulumi.Input['MongoIndexKeysArgs'] key: Cosmos DB MongoDB collection index keys
+        :param pulumi.Input['MongoIndexOptionsArgs'] options: Cosmos DB MongoDB collection index key options
+        """
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if options is not None:
+            pulumi.set(__self__, "options", options)
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[pulumi.Input['MongoIndexKeysArgs']]:
+        """
+        Cosmos DB MongoDB collection index keys
+        """
+        return pulumi.get(self, "key")
+
+    @key.setter
+    def key(self, value: Optional[pulumi.Input['MongoIndexKeysArgs']]):
+        pulumi.set(self, "key", value)
+
+    @property
+    @pulumi.getter
+    def options(self) -> Optional[pulumi.Input['MongoIndexOptionsArgs']]:
+        """
+        Cosmos DB MongoDB collection index key options
+        """
+        return pulumi.get(self, "options")
+
+    @options.setter
+    def options(self, value: Optional[pulumi.Input['MongoIndexOptionsArgs']]):
+        pulumi.set(self, "options", value)
+
+
+@pulumi.input_type
+class PeriodicModeBackupPolicyArgs:
+    def __init__(__self__, *,
+                 type: pulumi.Input[str],
+                 migration_state: Optional[pulumi.Input['BackupPolicyMigrationStateArgs']] = None,
+                 periodic_mode_properties: Optional[pulumi.Input['PeriodicModePropertiesArgs']] = None):
+        """
+        The object representing periodic mode backup policy.
+        :param pulumi.Input[str] type: Describes the mode of backups.
+               Expected value is 'Periodic'.
+        :param pulumi.Input['BackupPolicyMigrationStateArgs'] migration_state: The object representing the state of the migration between the backup policies.
+        :param pulumi.Input['PeriodicModePropertiesArgs'] periodic_mode_properties: Configuration values for periodic mode backup
+        """
+        pulumi.set(__self__, "type", 'Periodic')
+        if migration_state is not None:
+            pulumi.set(__self__, "migration_state", migration_state)
+        if periodic_mode_properties is not None:
+            pulumi.set(__self__, "periodic_mode_properties", periodic_mode_properties)
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Input[str]:
+        """
+        Describes the mode of backups.
+        Expected value is 'Periodic'.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter(name="migrationState")
+    def migration_state(self) -> Optional[pulumi.Input['BackupPolicyMigrationStateArgs']]:
+        """
+        The object representing the state of the migration between the backup policies.
+        """
+        return pulumi.get(self, "migration_state")
+
+    @migration_state.setter
+    def migration_state(self, value: Optional[pulumi.Input['BackupPolicyMigrationStateArgs']]):
+        pulumi.set(self, "migration_state", value)
+
+    @property
+    @pulumi.getter(name="periodicModeProperties")
+    def periodic_mode_properties(self) -> Optional[pulumi.Input['PeriodicModePropertiesArgs']]:
+        """
+        Configuration values for periodic mode backup
+        """
+        return pulumi.get(self, "periodic_mode_properties")
+
+    @periodic_mode_properties.setter
+    def periodic_mode_properties(self, value: Optional[pulumi.Input['PeriodicModePropertiesArgs']]):
+        pulumi.set(self, "periodic_mode_properties", value)
+
+
+@pulumi.input_type
+class PeriodicModePropertiesArgs:
+    def __init__(__self__, *,
+                 backup_interval_in_minutes: Optional[pulumi.Input[int]] = None,
+                 backup_retention_interval_in_hours: Optional[pulumi.Input[int]] = None,
+                 backup_storage_redundancy: Optional[pulumi.Input[Union[str, 'BackupStorageRedundancy']]] = None):
+        """
+        Configuration values for periodic mode backup
+        :param pulumi.Input[int] backup_interval_in_minutes: An integer representing the interval in minutes between two backups
+        :param pulumi.Input[int] backup_retention_interval_in_hours: An integer representing the time (in hours) that each backup is retained
+        :param pulumi.Input[Union[str, 'BackupStorageRedundancy']] backup_storage_redundancy: Enum to indicate type of backup residency
+        """
+        if backup_interval_in_minutes is not None:
+            pulumi.set(__self__, "backup_interval_in_minutes", backup_interval_in_minutes)
+        if backup_retention_interval_in_hours is not None:
+            pulumi.set(__self__, "backup_retention_interval_in_hours", backup_retention_interval_in_hours)
+        if backup_storage_redundancy is not None:
+            pulumi.set(__self__, "backup_storage_redundancy", backup_storage_redundancy)
+
+    @property
+    @pulumi.getter(name="backupIntervalInMinutes")
+    def backup_interval_in_minutes(self) -> Optional[pulumi.Input[int]]:
+        """
+        An integer representing the interval in minutes between two backups
+        """
+        return pulumi.get(self, "backup_interval_in_minutes")
+
+    @backup_interval_in_minutes.setter
+    def backup_interval_in_minutes(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "backup_interval_in_minutes", value)
+
+    @property
+    @pulumi.getter(name="backupRetentionIntervalInHours")
+    def backup_retention_interval_in_hours(self) -> Optional[pulumi.Input[int]]:
+        """
+        An integer representing the time (in hours) that each backup is retained
+        """
+        return pulumi.get(self, "backup_retention_interval_in_hours")
+
+    @backup_retention_interval_in_hours.setter
+    def backup_retention_interval_in_hours(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "backup_retention_interval_in_hours", value)
+
+    @property
+    @pulumi.getter(name="backupStorageRedundancy")
+    def backup_storage_redundancy(self) -> Optional[pulumi.Input[Union[str, 'BackupStorageRedundancy']]]:
+        """
+        Enum to indicate type of backup residency
+        """
+        return pulumi.get(self, "backup_storage_redundancy")
+
+    @backup_storage_redundancy.setter
+    def backup_storage_redundancy(self, value: Optional[pulumi.Input[Union[str, 'BackupStorageRedundancy']]]):
+        pulumi.set(self, "backup_storage_redundancy", value)
+
+
+@pulumi.input_type
+class PermissionArgs:
+    def __init__(__self__, *,
+                 data_actions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 not_data_actions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        The set of data plane operations permitted through this Role Definition.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_actions: An array of data actions that are allowed.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] not_data_actions: An array of data actions that are denied.
+        """
+        if data_actions is not None:
+            pulumi.set(__self__, "data_actions", data_actions)
+        if not_data_actions is not None:
+            pulumi.set(__self__, "not_data_actions", not_data_actions)
+
+    @property
+    @pulumi.getter(name="dataActions")
+    def data_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        An array of data actions that are allowed.
+        """
+        return pulumi.get(self, "data_actions")
+
+    @data_actions.setter
+    def data_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "data_actions", value)
+
+    @property
+    @pulumi.getter(name="notDataActions")
+    def not_data_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        An array of data actions that are denied.
+        """
+        return pulumi.get(self, "not_data_actions")
+
+    @not_data_actions.setter
+    def not_data_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "not_data_actions", value)
+
+
+@pulumi.input_type
+class PrivateEndpointPropertyArgs:
+    def __init__(__self__, *,
+                 id: Optional[pulumi.Input[str]] = None):
+        """
+        Private endpoint which the connection belongs to.
+        :param pulumi.Input[str] id: Resource id of the private endpoint.
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Resource id of the private endpoint.
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "id", value)
+
+
+@pulumi.input_type
+class PrivateLinkServiceConnectionStatePropertyArgs:
+    def __init__(__self__, *,
+                 description: Optional[pulumi.Input[str]] = None,
+                 status: Optional[pulumi.Input[str]] = None):
+        """
+        Connection State of the Private Endpoint Connection.
+        :param pulumi.Input[str] description: The private link service connection description.
+        :param pulumi.Input[str] status: The private link service connection status.
+        """
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        """
+        The private link service connection description.
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[str]]:
+        """
+        The private link service connection status.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "status", value)
+
+
+@pulumi.input_type
+class PrivilegeResourceArgs:
+    def __init__(__self__, *,
+                 collection: Optional[pulumi.Input[str]] = None,
+                 db: Optional[pulumi.Input[str]] = None):
+        """
+        An Azure Cosmos DB Mongo DB Resource.
+        :param pulumi.Input[str] collection: The collection name the role is applied.
+        :param pulumi.Input[str] db: The database name the role is applied.
+        """
+        if collection is not None:
+            pulumi.set(__self__, "collection", collection)
+        if db is not None:
+            pulumi.set(__self__, "db", db)
+
+    @property
+    @pulumi.getter
+    def collection(self) -> Optional[pulumi.Input[str]]:
+        """
+        The collection name the role is applied.
+        """
+        return pulumi.get(self, "collection")
+
+    @collection.setter
+    def collection(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "collection", value)
+
+    @property
+    @pulumi.getter
+    def db(self) -> Optional[pulumi.Input[str]]:
+        """
+        The database name the role is applied.
+        """
+        return pulumi.get(self, "db")
+
+    @db.setter
+    def db(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "db", value)
+
+
+@pulumi.input_type
+class PrivilegeArgs:
+    def __init__(__self__, *,
+                 actions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 resource: Optional[pulumi.Input['PrivilegeResourceArgs']] = None):
+        """
+        The set of data plane operations permitted through this Role Definition.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] actions: An array of actions that are allowed.
+        :param pulumi.Input['PrivilegeResourceArgs'] resource: An Azure Cosmos DB Mongo DB Resource.
+        """
+        if actions is not None:
+            pulumi.set(__self__, "actions", actions)
+        if resource is not None:
+            pulumi.set(__self__, "resource", resource)
+
+    @property
+    @pulumi.getter
+    def actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        An array of actions that are allowed.
+        """
+        return pulumi.get(self, "actions")
+
+    @actions.setter
+    def actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "actions", value)
+
+    @property
+    @pulumi.getter
+    def resource(self) -> Optional[pulumi.Input['PrivilegeResourceArgs']]:
+        """
+        An Azure Cosmos DB Mongo DB Resource.
+        """
+        return pulumi.get(self, "resource")
+
+    @resource.setter
+    def resource(self, value: Optional[pulumi.Input['PrivilegeResourceArgs']]):
+        pulumi.set(self, "resource", value)
+
+
+@pulumi.input_type
+class ResourceRestoreParametersArgs:
+    def __init__(__self__, *,
+                 restore_source: Optional[pulumi.Input[str]] = None,
+                 restore_timestamp_in_utc: Optional[pulumi.Input[str]] = None):
+        """
+        Parameters to indicate the information about the restore.
+        :param pulumi.Input[str] restore_source: The id of the restorable database account from which the restore has to be initiated. For example: /subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/locations/{location}/restorableDatabaseAccounts/{restorableDatabaseAccountName}
+        :param pulumi.Input[str] restore_timestamp_in_utc: Time to which the account has to be restored (ISO-8601 format).
+        """
+        if restore_source is not None:
+            pulumi.set(__self__, "restore_source", restore_source)
+        if restore_timestamp_in_utc is not None:
+            pulumi.set(__self__, "restore_timestamp_in_utc", restore_timestamp_in_utc)
+
+    @property
+    @pulumi.getter(name="restoreSource")
+    def restore_source(self) -> Optional[pulumi.Input[str]]:
+        """
+        The id of the restorable database account from which the restore has to be initiated. For example: /subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/locations/{location}/restorableDatabaseAccounts/{restorableDatabaseAccountName}
+        """
+        return pulumi.get(self, "restore_source")
+
+    @restore_source.setter
+    def restore_source(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "restore_source", value)
+
+    @property
+    @pulumi.getter(name="restoreTimestampInUtc")
+    def restore_timestamp_in_utc(self) -> Optional[pulumi.Input[str]]:
+        """
+        Time to which the account has to be restored (ISO-8601 format).
+        """
+        return pulumi.get(self, "restore_timestamp_in_utc")
+
+    @restore_timestamp_in_utc.setter
+    def restore_timestamp_in_utc(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "restore_timestamp_in_utc", value)
+
+
+@pulumi.input_type
+class RestoreParametersArgs:
+    def __init__(__self__, *,
+                 databases_to_restore: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseRestoreResourceArgs']]]] = None,
+                 gremlin_databases_to_restore: Optional[pulumi.Input[Sequence[pulumi.Input['GremlinDatabaseRestoreResourceArgs']]]] = None,
+                 restore_mode: Optional[pulumi.Input[Union[str, 'RestoreMode']]] = None,
+                 restore_source: Optional[pulumi.Input[str]] = None,
+                 restore_timestamp_in_utc: Optional[pulumi.Input[str]] = None,
+                 tables_to_restore: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Parameters to indicate the information about the restore.
+        :param pulumi.Input[Sequence[pulumi.Input['DatabaseRestoreResourceArgs']]] databases_to_restore: List of specific databases available for restore.
+        :param pulumi.Input[Sequence[pulumi.Input['GremlinDatabaseRestoreResourceArgs']]] gremlin_databases_to_restore: List of specific gremlin databases available for restore.
+        :param pulumi.Input[Union[str, 'RestoreMode']] restore_mode: Describes the mode of the restore.
+        :param pulumi.Input[str] restore_source: The id of the restorable database account from which the restore has to be initiated. For example: /subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/locations/{location}/restorableDatabaseAccounts/{restorableDatabaseAccountName}
+        :param pulumi.Input[str] restore_timestamp_in_utc: Time to which the account has to be restored (ISO-8601 format).
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] tables_to_restore: List of specific tables available for restore.
+        """
+        if databases_to_restore is not None:
+            pulumi.set(__self__, "databases_to_restore", databases_to_restore)
+        if gremlin_databases_to_restore is not None:
+            pulumi.set(__self__, "gremlin_databases_to_restore", gremlin_databases_to_restore)
+        if restore_mode is not None:
+            pulumi.set(__self__, "restore_mode", restore_mode)
+        if restore_source is not None:
+            pulumi.set(__self__, "restore_source", restore_source)
+        if restore_timestamp_in_utc is not None:
+            pulumi.set(__self__, "restore_timestamp_in_utc", restore_timestamp_in_utc)
+        if tables_to_restore is not None:
+            pulumi.set(__self__, "tables_to_restore", tables_to_restore)
+
+    @property
+    @pulumi.getter(name="databasesToRestore")
+    def databases_to_restore(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseRestoreResourceArgs']]]]:
+        """
+        List of specific databases available for restore.
+        """
+        return pulumi.get(self, "databases_to_restore")
+
+    @databases_to_restore.setter
+    def databases_to_restore(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseRestoreResourceArgs']]]]):
+        pulumi.set(self, "databases_to_restore", value)
+
+    @property
+    @pulumi.getter(name="gremlinDatabasesToRestore")
+    def gremlin_databases_to_restore(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GremlinDatabaseRestoreResourceArgs']]]]:
+        """
+        List of specific gremlin databases available for restore.
+        """
+        return pulumi.get(self, "gremlin_databases_to_restore")
+
+    @gremlin_databases_to_restore.setter
+    def gremlin_databases_to_restore(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GremlinDatabaseRestoreResourceArgs']]]]):
+        pulumi.set(self, "gremlin_databases_to_restore", value)
+
+    @property
+    @pulumi.getter(name="restoreMode")
+    def restore_mode(self) -> Optional[pulumi.Input[Union[str, 'RestoreMode']]]:
+        """
+        Describes the mode of the restore.
+        """
+        return pulumi.get(self, "restore_mode")
+
+    @restore_mode.setter
+    def restore_mode(self, value: Optional[pulumi.Input[Union[str, 'RestoreMode']]]):
+        pulumi.set(self, "restore_mode", value)
+
+    @property
+    @pulumi.getter(name="restoreSource")
+    def restore_source(self) -> Optional[pulumi.Input[str]]:
+        """
+        The id of the restorable database account from which the restore has to be initiated. For example: /subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/locations/{location}/restorableDatabaseAccounts/{restorableDatabaseAccountName}
+        """
+        return pulumi.get(self, "restore_source")
+
+    @restore_source.setter
+    def restore_source(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "restore_source", value)
+
+    @property
+    @pulumi.getter(name="restoreTimestampInUtc")
+    def restore_timestamp_in_utc(self) -> Optional[pulumi.Input[str]]:
+        """
+        Time to which the account has to be restored (ISO-8601 format).
+        """
+        return pulumi.get(self, "restore_timestamp_in_utc")
+
+    @restore_timestamp_in_utc.setter
+    def restore_timestamp_in_utc(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "restore_timestamp_in_utc", value)
+
+    @property
+    @pulumi.getter(name="tablesToRestore")
+    def tables_to_restore(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        List of specific tables available for restore.
+        """
+        return pulumi.get(self, "tables_to_restore")
+
+    @tables_to_restore.setter
+    def tables_to_restore(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "tables_to_restore", value)
+
+
+@pulumi.input_type
+class RoleArgs:
+    def __init__(__self__, *,
+                 db: Optional[pulumi.Input[str]] = None,
+                 role: Optional[pulumi.Input[str]] = None):
+        """
+        The set of roles permitted through this Role Definition.
+        :param pulumi.Input[str] db: The database name the role is applied.
+        :param pulumi.Input[str] role: The role name.
+        """
+        if db is not None:
+            pulumi.set(__self__, "db", db)
+        if role is not None:
+            pulumi.set(__self__, "role", role)
+
+    @property
+    @pulumi.getter
+    def db(self) -> Optional[pulumi.Input[str]]:
+        """
+        The database name the role is applied.
+        """
+        return pulumi.get(self, "db")
+
+    @db.setter
+    def db(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "db", value)
+
+    @property
+    @pulumi.getter
+    def role(self) -> Optional[pulumi.Input[str]]:
+        """
+        The role name.
+        """
+        return pulumi.get(self, "role")
+
+    @role.setter
+    def role(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "role", value)
+
+
+@pulumi.input_type
+class SeedNodeArgs:
+    def __init__(__self__, *,
+                 ip_address: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] ip_address: IP address of this seed node.
+        """
+        if ip_address is not None:
+            pulumi.set(__self__, "ip_address", ip_address)
+
+    @property
+    @pulumi.getter(name="ipAddress")
+    def ip_address(self) -> Optional[pulumi.Input[str]]:
+        """
+        IP address of this seed node.
+        """
+        return pulumi.get(self, "ip_address")
+
+    @ip_address.setter
+    def ip_address(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ip_address", value)
+
+
+@pulumi.input_type
+class SpatialSpecArgs:
+    def __init__(__self__, *,
+                 path: Optional[pulumi.Input[str]] = None,
+                 types: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'SpatialType']]]]] = None):
+        """
+        :param pulumi.Input[str] path: The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*)
+        :param pulumi.Input[Sequence[pulumi.Input[Union[str, 'SpatialType']]]] types: List of path's spatial type
+        """
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if types is not None:
+            pulumi.set(__self__, "types", types)
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[str]]:
+        """
+        The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*)
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "path", value)
+
+    @property
+    @pulumi.getter
+    def types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'SpatialType']]]]]:
+        """
+        List of path's spatial type
+        """
+        return pulumi.get(self, "types")
+
+    @types.setter
+    def types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'SpatialType']]]]]):
+        pulumi.set(self, "types", value)
+
+
+@pulumi.input_type
+class SqlContainerResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 analytical_storage_ttl: Optional[pulumi.Input[float]] = None,
+                 client_encryption_policy: Optional[pulumi.Input['ClientEncryptionPolicyArgs']] = None,
+                 computed_properties: Optional[pulumi.Input[Sequence[pulumi.Input['ComputedPropertyArgs']]]] = None,
+                 conflict_resolution_policy: Optional[pulumi.Input['ConflictResolutionPolicyArgs']] = None,
+                 create_mode: Optional[pulumi.Input[Union[str, 'CreateMode']]] = None,
+                 default_ttl: Optional[pulumi.Input[int]] = None,
+                 indexing_policy: Optional[pulumi.Input['IndexingPolicyArgs']] = None,
+                 partition_key: Optional[pulumi.Input['ContainerPartitionKeyArgs']] = None,
+                 restore_parameters: Optional[pulumi.Input['ResourceRestoreParametersArgs']] = None,
+                 unique_key_policy: Optional[pulumi.Input['UniqueKeyPolicyArgs']] = None):
+        """
+        Cosmos DB SQL container resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB SQL container
+        :param pulumi.Input[float] analytical_storage_ttl: Analytical TTL.
+        :param pulumi.Input['ClientEncryptionPolicyArgs'] client_encryption_policy: The client encryption policy for the container.
+        :param pulumi.Input[Sequence[pulumi.Input['ComputedPropertyArgs']]] computed_properties: List of computed properties
+        :param pulumi.Input['ConflictResolutionPolicyArgs'] conflict_resolution_policy: The conflict resolution policy for the container.
+        :param pulumi.Input[Union[str, 'CreateMode']] create_mode: Enum to indicate the mode of resource creation.
+        :param pulumi.Input[int] default_ttl: Default time to live
+        :param pulumi.Input['IndexingPolicyArgs'] indexing_policy: The configuration of the indexing policy. By default, the indexing is automatic for all document paths within the container
+        :param pulumi.Input['ContainerPartitionKeyArgs'] partition_key: The configuration of the partition key to be used for partitioning data into multiple partitions
+        :param pulumi.Input['ResourceRestoreParametersArgs'] restore_parameters: Parameters to indicate the information about the restore
+        :param pulumi.Input['UniqueKeyPolicyArgs'] unique_key_policy: The unique key policy configuration for specifying uniqueness constraints on documents in the collection in the Azure Cosmos DB service.
+        """
+        pulumi.set(__self__, "id", id)
+        if analytical_storage_ttl is not None:
+            pulumi.set(__self__, "analytical_storage_ttl", analytical_storage_ttl)
+        if client_encryption_policy is not None:
+            pulumi.set(__self__, "client_encryption_policy", client_encryption_policy)
+        if computed_properties is not None:
+            pulumi.set(__self__, "computed_properties", computed_properties)
+        if conflict_resolution_policy is not None:
+            pulumi.set(__self__, "conflict_resolution_policy", conflict_resolution_policy)
+        if create_mode is not None:
+            pulumi.set(__self__, "create_mode", create_mode)
+        if default_ttl is not None:
+            pulumi.set(__self__, "default_ttl", default_ttl)
+        if indexing_policy is not None:
+            pulumi.set(__self__, "indexing_policy", indexing_policy)
+        if partition_key is not None:
+            pulumi.set(__self__, "partition_key", partition_key)
+        if restore_parameters is not None:
+            pulumi.set(__self__, "restore_parameters", restore_parameters)
+        if unique_key_policy is not None:
+            pulumi.set(__self__, "unique_key_policy", unique_key_policy)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB SQL container
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="analyticalStorageTtl")
+    def analytical_storage_ttl(self) -> Optional[pulumi.Input[float]]:
+        """
+        Analytical TTL.
+        """
+        return pulumi.get(self, "analytical_storage_ttl")
+
+    @analytical_storage_ttl.setter
+    def analytical_storage_ttl(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "analytical_storage_ttl", value)
+
+    @property
+    @pulumi.getter(name="clientEncryptionPolicy")
+    def client_encryption_policy(self) -> Optional[pulumi.Input['ClientEncryptionPolicyArgs']]:
+        """
+        The client encryption policy for the container.
+        """
+        return pulumi.get(self, "client_encryption_policy")
+
+    @client_encryption_policy.setter
+    def client_encryption_policy(self, value: Optional[pulumi.Input['ClientEncryptionPolicyArgs']]):
+        pulumi.set(self, "client_encryption_policy", value)
+
+    @property
+    @pulumi.getter(name="computedProperties")
+    def computed_properties(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputedPropertyArgs']]]]:
+        """
+        List of computed properties
+        """
+        return pulumi.get(self, "computed_properties")
+
+    @computed_properties.setter
+    def computed_properties(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputedPropertyArgs']]]]):
+        pulumi.set(self, "computed_properties", value)
+
+    @property
+    @pulumi.getter(name="conflictResolutionPolicy")
+    def conflict_resolution_policy(self) -> Optional[pulumi.Input['ConflictResolutionPolicyArgs']]:
+        """
+        The conflict resolution policy for the container.
+        """
+        return pulumi.get(self, "conflict_resolution_policy")
+
+    @conflict_resolution_policy.setter
+    def conflict_resolution_policy(self, value: Optional[pulumi.Input['ConflictResolutionPolicyArgs']]):
+        pulumi.set(self, "conflict_resolution_policy", value)
+
+    @property
+    @pulumi.getter(name="createMode")
+    def create_mode(self) -> Optional[pulumi.Input[Union[str, 'CreateMode']]]:
+        """
+        Enum to indicate the mode of resource creation.
+        """
+        return pulumi.get(self, "create_mode")
+
+    @create_mode.setter
+    def create_mode(self, value: Optional[pulumi.Input[Union[str, 'CreateMode']]]):
+        pulumi.set(self, "create_mode", value)
+
+    @property
+    @pulumi.getter(name="defaultTtl")
+    def default_ttl(self) -> Optional[pulumi.Input[int]]:
+        """
+        Default time to live
+        """
+        return pulumi.get(self, "default_ttl")
+
+    @default_ttl.setter
+    def default_ttl(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "default_ttl", value)
+
+    @property
+    @pulumi.getter(name="indexingPolicy")
+    def indexing_policy(self) -> Optional[pulumi.Input['IndexingPolicyArgs']]:
+        """
+        The configuration of the indexing policy. By default, the indexing is automatic for all document paths within the container
+        """
+        return pulumi.get(self, "indexing_policy")
+
+    @indexing_policy.setter
+    def indexing_policy(self, value: Optional[pulumi.Input['IndexingPolicyArgs']]):
+        pulumi.set(self, "indexing_policy", value)
+
+    @property
+    @pulumi.getter(name="partitionKey")
+    def partition_key(self) -> Optional[pulumi.Input['ContainerPartitionKeyArgs']]:
+        """
+        The configuration of the partition key to be used for partitioning data into multiple partitions
+        """
+        return pulumi.get(self, "partition_key")
+
+    @partition_key.setter
+    def partition_key(self, value: Optional[pulumi.Input['ContainerPartitionKeyArgs']]):
+        pulumi.set(self, "partition_key", value)
+
+    @property
+    @pulumi.getter(name="restoreParameters")
+    def restore_parameters(self) -> Optional[pulumi.Input['ResourceRestoreParametersArgs']]:
+        """
+        Parameters to indicate the information about the restore
+        """
+        return pulumi.get(self, "restore_parameters")
+
+    @restore_parameters.setter
+    def restore_parameters(self, value: Optional[pulumi.Input['ResourceRestoreParametersArgs']]):
+        pulumi.set(self, "restore_parameters", value)
+
+    @property
+    @pulumi.getter(name="uniqueKeyPolicy")
+    def unique_key_policy(self) -> Optional[pulumi.Input['UniqueKeyPolicyArgs']]:
+        """
+        The unique key policy configuration for specifying uniqueness constraints on documents in the collection in the Azure Cosmos DB service.
+        """
+        return pulumi.get(self, "unique_key_policy")
+
+    @unique_key_policy.setter
+    def unique_key_policy(self, value: Optional[pulumi.Input['UniqueKeyPolicyArgs']]):
+        pulumi.set(self, "unique_key_policy", value)
+
+
+@pulumi.input_type
+class SqlDatabaseResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 create_mode: Optional[pulumi.Input[Union[str, 'CreateMode']]] = None,
+                 restore_parameters: Optional[pulumi.Input['ResourceRestoreParametersArgs']] = None):
+        """
+        Cosmos DB SQL database resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB SQL database
+        :param pulumi.Input[Union[str, 'CreateMode']] create_mode: Enum to indicate the mode of resource creation.
+        :param pulumi.Input['ResourceRestoreParametersArgs'] restore_parameters: Parameters to indicate the information about the restore
+        """
+        pulumi.set(__self__, "id", id)
+        if create_mode is not None:
+            pulumi.set(__self__, "create_mode", create_mode)
+        if restore_parameters is not None:
+            pulumi.set(__self__, "restore_parameters", restore_parameters)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB SQL database
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="createMode")
+    def create_mode(self) -> Optional[pulumi.Input[Union[str, 'CreateMode']]]:
+        """
+        Enum to indicate the mode of resource creation.
+        """
+        return pulumi.get(self, "create_mode")
+
+    @create_mode.setter
+    def create_mode(self, value: Optional[pulumi.Input[Union[str, 'CreateMode']]]):
+        pulumi.set(self, "create_mode", value)
+
+    @property
+    @pulumi.getter(name="restoreParameters")
+    def restore_parameters(self) -> Optional[pulumi.Input['ResourceRestoreParametersArgs']]:
+        """
+        Parameters to indicate the information about the restore
+        """
+        return pulumi.get(self, "restore_parameters")
+
+    @restore_parameters.setter
+    def restore_parameters(self, value: Optional[pulumi.Input['ResourceRestoreParametersArgs']]):
+        pulumi.set(self, "restore_parameters", value)
+
+
+@pulumi.input_type
+class SqlStoredProcedureResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 body: Optional[pulumi.Input[str]] = None):
+        """
+        Cosmos DB SQL storedProcedure resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB SQL storedProcedure
+        :param pulumi.Input[str] body: Body of the Stored Procedure
+        """
+        pulumi.set(__self__, "id", id)
+        if body is not None:
+            pulumi.set(__self__, "body", body)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB SQL storedProcedure
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter
+    def body(self) -> Optional[pulumi.Input[str]]:
+        """
+        Body of the Stored Procedure
+        """
+        return pulumi.get(self, "body")
+
+    @body.setter
+    def body(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "body", value)
+
+
+@pulumi.input_type
+class SqlTriggerResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 body: Optional[pulumi.Input[str]] = None,
+                 trigger_operation: Optional[pulumi.Input[Union[str, 'TriggerOperation']]] = None,
+                 trigger_type: Optional[pulumi.Input[Union[str, 'TriggerType']]] = None):
+        """
+        Cosmos DB SQL trigger resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB SQL trigger
+        :param pulumi.Input[str] body: Body of the Trigger
+        :param pulumi.Input[Union[str, 'TriggerOperation']] trigger_operation: The operation the trigger is associated with
+        :param pulumi.Input[Union[str, 'TriggerType']] trigger_type: Type of the Trigger
+        """
+        pulumi.set(__self__, "id", id)
+        if body is not None:
+            pulumi.set(__self__, "body", body)
+        if trigger_operation is not None:
+            pulumi.set(__self__, "trigger_operation", trigger_operation)
+        if trigger_type is not None:
+            pulumi.set(__self__, "trigger_type", trigger_type)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB SQL trigger
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter
+    def body(self) -> Optional[pulumi.Input[str]]:
+        """
+        Body of the Trigger
+        """
+        return pulumi.get(self, "body")
+
+    @body.setter
+    def body(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "body", value)
+
+    @property
+    @pulumi.getter(name="triggerOperation")
+    def trigger_operation(self) -> Optional[pulumi.Input[Union[str, 'TriggerOperation']]]:
+        """
+        The operation the trigger is associated with
+        """
+        return pulumi.get(self, "trigger_operation")
+
+    @trigger_operation.setter
+    def trigger_operation(self, value: Optional[pulumi.Input[Union[str, 'TriggerOperation']]]):
+        pulumi.set(self, "trigger_operation", value)
+
+    @property
+    @pulumi.getter(name="triggerType")
+    def trigger_type(self) -> Optional[pulumi.Input[Union[str, 'TriggerType']]]:
+        """
+        Type of the Trigger
+        """
+        return pulumi.get(self, "trigger_type")
+
+    @trigger_type.setter
+    def trigger_type(self, value: Optional[pulumi.Input[Union[str, 'TriggerType']]]):
+        pulumi.set(self, "trigger_type", value)
+
+
+@pulumi.input_type
+class SqlUserDefinedFunctionResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 body: Optional[pulumi.Input[str]] = None):
+        """
+        Cosmos DB SQL userDefinedFunction resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB SQL userDefinedFunction
+        :param pulumi.Input[str] body: Body of the User Defined Function
+        """
+        pulumi.set(__self__, "id", id)
+        if body is not None:
+            pulumi.set(__self__, "body", body)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB SQL userDefinedFunction
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter
+    def body(self) -> Optional[pulumi.Input[str]]:
+        """
+        Body of the User Defined Function
+        """
+        return pulumi.get(self, "body")
+
+    @body.setter
+    def body(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "body", value)
+
+
+@pulumi.input_type
+class TableResourceArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 create_mode: Optional[pulumi.Input[Union[str, 'CreateMode']]] = None,
+                 restore_parameters: Optional[pulumi.Input['ResourceRestoreParametersArgs']] = None):
+        """
+        Cosmos DB table resource object
+        :param pulumi.Input[str] id: Name of the Cosmos DB table
+        :param pulumi.Input[Union[str, 'CreateMode']] create_mode: Enum to indicate the mode of resource creation.
+        :param pulumi.Input['ResourceRestoreParametersArgs'] restore_parameters: Parameters to indicate the information about the restore
+        """
+        pulumi.set(__self__, "id", id)
+        if create_mode is not None:
+            pulumi.set(__self__, "create_mode", create_mode)
+        if restore_parameters is not None:
+            pulumi.set(__self__, "restore_parameters", restore_parameters)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Name of the Cosmos DB table
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="createMode")
+    def create_mode(self) -> Optional[pulumi.Input[Union[str, 'CreateMode']]]:
+        """
+        Enum to indicate the mode of resource creation.
+        """
+        return pulumi.get(self, "create_mode")
+
+    @create_mode.setter
+    def create_mode(self, value: Optional[pulumi.Input[Union[str, 'CreateMode']]]):
+        pulumi.set(self, "create_mode", value)
+
+    @property
+    @pulumi.getter(name="restoreParameters")
+    def restore_parameters(self) -> Optional[pulumi.Input['ResourceRestoreParametersArgs']]:
+        """
+        Parameters to indicate the information about the restore
+        """
+        return pulumi.get(self, "restore_parameters")
+
+    @restore_parameters.setter
+    def restore_parameters(self, value: Optional[pulumi.Input['ResourceRestoreParametersArgs']]):
+        pulumi.set(self, "restore_parameters", value)
+
+
+@pulumi.input_type
+class UniqueKeyPolicyArgs:
+    def __init__(__self__, *,
+                 unique_keys: Optional[pulumi.Input[Sequence[pulumi.Input['UniqueKeyArgs']]]] = None):
+        """
+        The unique key policy configuration for specifying uniqueness constraints on documents in the collection in the Azure Cosmos DB service.
+        :param pulumi.Input[Sequence[pulumi.Input['UniqueKeyArgs']]] unique_keys: List of unique keys on that enforces uniqueness constraint on documents in the collection in the Azure Cosmos DB service.
+        """
+        if unique_keys is not None:
+            pulumi.set(__self__, "unique_keys", unique_keys)
+
+    @property
+    @pulumi.getter(name="uniqueKeys")
+    def unique_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UniqueKeyArgs']]]]:
+        """
+        List of unique keys on that enforces uniqueness constraint on documents in the collection in the Azure Cosmos DB service.
+        """
+        return pulumi.get(self, "unique_keys")
+
+    @unique_keys.setter
+    def unique_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UniqueKeyArgs']]]]):
+        pulumi.set(self, "unique_keys", value)
+
+
+@pulumi.input_type
+class UniqueKeyArgs:
+    def __init__(__self__, *,
+                 paths: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        The unique key on that enforces uniqueness constraint on documents in the collection in the Azure Cosmos DB service.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] paths: List of paths must be unique for each document in the Azure Cosmos DB service
+        """
+        if paths is not None:
+            pulumi.set(__self__, "paths", paths)
+
+    @property
+    @pulumi.getter
+    def paths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        List of paths must be unique for each document in the Azure Cosmos DB service
+        """
+        return pulumi.get(self, "paths")
+
+    @paths.setter
+    def paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "paths", value)
+
+
+@pulumi.input_type
+class VirtualNetworkRuleArgs:
+    def __init__(__self__, *,
+                 id: Optional[pulumi.Input[str]] = None,
+                 ignore_missing_v_net_service_endpoint: Optional[pulumi.Input[bool]] = None):
+        """
+        Virtual Network ACL Rule object
+        :param pulumi.Input[str] id: Resource ID of a subnet, for example: /subscriptions/{subscriptionId}/resourceGroups/{groupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}.
+        :param pulumi.Input[bool] ignore_missing_v_net_service_endpoint: Create firewall rule before the virtual network has vnet service endpoint enabled.
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if ignore_missing_v_net_service_endpoint is not None:
+            pulumi.set(__self__, "ignore_missing_v_net_service_endpoint", ignore_missing_v_net_service_endpoint)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Resource ID of a subnet, for example: /subscriptions/{subscriptionId}/resourceGroups/{groupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}.
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="ignoreMissingVNetServiceEndpoint")
+    def ignore_missing_v_net_service_endpoint(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Create firewall rule before the virtual network has vnet service endpoint enabled.
+        """
+        return pulumi.get(self, "ignore_missing_v_net_service_endpoint")
+
+    @ignore_missing_v_net_service_endpoint.setter
+    def ignore_missing_v_net_service_endpoint(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "ignore_missing_v_net_service_endpoint", value)
+
+