# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
from typing import Dict, List, Optional, Union
from azure.core.exceptions import HttpResponseError
import msrest.serialization
from ._cosmos_db_management_client_enums import *
[docs]class ApiProperties(msrest.serialization.Model):
"""ApiProperties.
:param server_version: Describes the ServerVersion of an a MongoDB account. Possible values
include: "3.2", "3.6".
:type server_version: str or ~azure.mgmt.cosmosdb.models.ServerVersion
"""
_attribute_map = {
'server_version': {'key': 'serverVersion', 'type': 'str'},
}
def __init__(
self,
*,
server_version: Optional[Union[str, "ServerVersion"]] = None,
**kwargs
):
super(ApiProperties, self).__init__(**kwargs)
self.server_version = server_version
[docs]class ARMProxyResource(msrest.serialization.Model):
"""The resource model definition for a ARM proxy resource. It will have everything other than required location and tags.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the database account.
:vartype id: str
:ivar name: The name of the database account.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(ARMProxyResource, self).__init__(**kwargs)
self.id = None
self.name = None
self.type = None
[docs]class ARMResourceProperties(msrest.serialization.Model):
"""The core properties of ARM resources.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(ARMResourceProperties, self).__init__(**kwargs)
self.id = None
self.name = None
self.type = None
self.location = location
self.tags = tags
[docs]class AutoscaleSettings(msrest.serialization.Model):
"""AutoscaleSettings.
:param max_throughput: Represents maximum throughput, the resource can scale up to.
:type max_throughput: int
"""
_attribute_map = {
'max_throughput': {'key': 'maxThroughput', 'type': 'int'},
}
def __init__(
self,
*,
max_throughput: Optional[int] = None,
**kwargs
):
super(AutoscaleSettings, self).__init__(**kwargs)
self.max_throughput = max_throughput
[docs]class AutoscaleSettingsResource(msrest.serialization.Model):
"""Cosmos DB provisioned throughput settings object.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param max_throughput: Required. Represents maximum throughput container can scale up to.
:type max_throughput: int
:param auto_upgrade_policy: Cosmos DB resource auto-upgrade policy.
:type auto_upgrade_policy: ~azure.mgmt.cosmosdb.models.AutoUpgradePolicyResource
:ivar target_max_throughput: Represents target maximum throughput container can scale up to
once offer is no longer in pending state.
:vartype target_max_throughput: int
"""
_validation = {
'max_throughput': {'required': True},
'target_max_throughput': {'readonly': True},
}
_attribute_map = {
'max_throughput': {'key': 'maxThroughput', 'type': 'int'},
'auto_upgrade_policy': {'key': 'autoUpgradePolicy', 'type': 'AutoUpgradePolicyResource'},
'target_max_throughput': {'key': 'targetMaxThroughput', 'type': 'int'},
}
def __init__(
self,
*,
max_throughput: int,
auto_upgrade_policy: Optional["AutoUpgradePolicyResource"] = None,
**kwargs
):
super(AutoscaleSettingsResource, self).__init__(**kwargs)
self.max_throughput = max_throughput
self.auto_upgrade_policy = auto_upgrade_policy
self.target_max_throughput = None
[docs]class AutoUpgradePolicyResource(msrest.serialization.Model):
"""Cosmos DB resource auto-upgrade policy.
:param throughput_policy: Represents throughput policy which service must adhere to for auto-
upgrade.
:type throughput_policy: ~azure.mgmt.cosmosdb.models.ThroughputPolicyResource
"""
_attribute_map = {
'throughput_policy': {'key': 'throughputPolicy', 'type': 'ThroughputPolicyResource'},
}
def __init__(
self,
*,
throughput_policy: Optional["ThroughputPolicyResource"] = None,
**kwargs
):
super(AutoUpgradePolicyResource, self).__init__(**kwargs)
self.throughput_policy = throughput_policy
[docs]class Capability(msrest.serialization.Model):
"""Cosmos DB capability object.
:param name: Name of the Cosmos DB capability. For example, "name": "EnableCassandra". Current
values also include "EnableTable" and "EnableGremlin".
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(
self,
*,
name: Optional[str] = None,
**kwargs
):
super(Capability, self).__init__(**kwargs)
self.name = name
[docs]class CassandraKeyspaceCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB Cassandra keyspace.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a Cassandra keyspace.
:type resource: ~azure.mgmt.cosmosdb.models.CassandraKeyspaceResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'CassandraKeyspaceResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "CassandraKeyspaceResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(CassandraKeyspaceCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class OptionsResource(msrest.serialization.Model):
"""Cosmos DB options resource object.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(OptionsResource, self).__init__(**kwargs)
self.throughput = throughput
self.autoscale_settings = autoscale_settings
[docs]class CassandraKeyspaceGetPropertiesOptions(OptionsResource):
"""CassandraKeyspaceGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(CassandraKeyspaceGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class CassandraKeyspaceResource(msrest.serialization.Model):
"""Cosmos DB Cassandra keyspace resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB Cassandra keyspace.
:type id: str
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(CassandraKeyspaceResource, self).__init__(**kwargs)
self.id = id
[docs]class ExtendedResourceProperties(msrest.serialization.Model):
"""The system generated resource properties associated with SQL databases, SQL containers, Gremlin databases and Gremlin graphs.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(ExtendedResourceProperties, self).__init__(**kwargs)
self.rid = None
self.ts = None
self.etag = None
[docs]class CassandraKeyspaceGetPropertiesResource(ExtendedResourceProperties, CassandraKeyspaceResource):
"""CassandraKeyspaceGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB Cassandra keyspace.
:type id: str
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(CassandraKeyspaceGetPropertiesResource, self).__init__(id=id, **kwargs)
self.id = id
self.rid = None
self.ts = None
self.etag = None
[docs]class CassandraKeyspaceGetResults(ARMResourceProperties):
"""An Azure Cosmos DB Cassandra keyspace.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.CassandraKeyspaceGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'CassandraKeyspaceGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["CassandraKeyspaceGetPropertiesResource"] = None,
**kwargs
):
super(CassandraKeyspaceGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class CassandraKeyspaceListResult(msrest.serialization.Model):
"""The List operation response, that contains the Cassandra keyspaces and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of Cassandra keyspaces and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.CassandraKeyspaceGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[CassandraKeyspaceGetResults]'},
}
def __init__(
self,
**kwargs
):
super(CassandraKeyspaceListResult, self).__init__(**kwargs)
self.value = None
[docs]class CassandraPartitionKey(msrest.serialization.Model):
"""Cosmos DB Cassandra table partition key.
:param name: Name of the Cosmos DB Cassandra table partition key.
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(
self,
*,
name: Optional[str] = None,
**kwargs
):
super(CassandraPartitionKey, self).__init__(**kwargs)
self.name = name
[docs]class CassandraSchema(msrest.serialization.Model):
"""Cosmos DB Cassandra table schema.
:param columns: List of Cassandra table columns.
:type columns: list[~azure.mgmt.cosmosdb.models.Column]
:param partition_keys: List of partition key.
:type partition_keys: list[~azure.mgmt.cosmosdb.models.CassandraPartitionKey]
:param cluster_keys: List of cluster key.
:type cluster_keys: list[~azure.mgmt.cosmosdb.models.ClusterKey]
"""
_attribute_map = {
'columns': {'key': 'columns', 'type': '[Column]'},
'partition_keys': {'key': 'partitionKeys', 'type': '[CassandraPartitionKey]'},
'cluster_keys': {'key': 'clusterKeys', 'type': '[ClusterKey]'},
}
def __init__(
self,
*,
columns: Optional[List["Column"]] = None,
partition_keys: Optional[List["CassandraPartitionKey"]] = None,
cluster_keys: Optional[List["ClusterKey"]] = None,
**kwargs
):
super(CassandraSchema, self).__init__(**kwargs)
self.columns = columns
self.partition_keys = partition_keys
self.cluster_keys = cluster_keys
[docs]class CassandraTableCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB Cassandra table.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a Cassandra table.
:type resource: ~azure.mgmt.cosmosdb.models.CassandraTableResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'CassandraTableResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "CassandraTableResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(CassandraTableCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class CassandraTableGetPropertiesOptions(OptionsResource):
"""CassandraTableGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(CassandraTableGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class CassandraTableResource(msrest.serialization.Model):
"""Cosmos DB Cassandra table resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB Cassandra table.
:type id: str
:param default_ttl: Time to live of the Cosmos DB Cassandra table.
:type default_ttl: int
:param schema: Schema of the Cosmos DB Cassandra table.
:type schema: ~azure.mgmt.cosmosdb.models.CassandraSchema
:param analytical_storage_ttl: Analytical TTL.
:type analytical_storage_ttl: int
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'default_ttl': {'key': 'defaultTtl', 'type': 'int'},
'schema': {'key': 'schema', 'type': 'CassandraSchema'},
'analytical_storage_ttl': {'key': 'analyticalStorageTtl', 'type': 'int'},
}
def __init__(
self,
*,
id: str,
default_ttl: Optional[int] = None,
schema: Optional["CassandraSchema"] = None,
analytical_storage_ttl: Optional[int] = None,
**kwargs
):
super(CassandraTableResource, self).__init__(**kwargs)
self.id = id
self.default_ttl = default_ttl
self.schema = schema
self.analytical_storage_ttl = analytical_storage_ttl
[docs]class CassandraTableGetPropertiesResource(ExtendedResourceProperties, CassandraTableResource):
"""CassandraTableGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB Cassandra table.
:type id: str
:param default_ttl: Time to live of the Cosmos DB Cassandra table.
:type default_ttl: int
:param schema: Schema of the Cosmos DB Cassandra table.
:type schema: ~azure.mgmt.cosmosdb.models.CassandraSchema
:param analytical_storage_ttl: Analytical TTL.
:type analytical_storage_ttl: int
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'default_ttl': {'key': 'defaultTtl', 'type': 'int'},
'schema': {'key': 'schema', 'type': 'CassandraSchema'},
'analytical_storage_ttl': {'key': 'analyticalStorageTtl', 'type': 'int'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
default_ttl: Optional[int] = None,
schema: Optional["CassandraSchema"] = None,
analytical_storage_ttl: Optional[int] = None,
**kwargs
):
super(CassandraTableGetPropertiesResource, self).__init__(id=id, default_ttl=default_ttl, schema=schema, analytical_storage_ttl=analytical_storage_ttl, **kwargs)
self.id = id
self.default_ttl = default_ttl
self.schema = schema
self.analytical_storage_ttl = analytical_storage_ttl
self.rid = None
self.ts = None
self.etag = None
[docs]class CassandraTableGetResults(ARMResourceProperties):
"""An Azure Cosmos DB Cassandra table.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.CassandraTableGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'CassandraTableGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["CassandraTableGetPropertiesResource"] = None,
**kwargs
):
super(CassandraTableGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class CassandraTableListResult(msrest.serialization.Model):
"""The List operation response, that contains the Cassandra tables and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of Cassandra tables and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.CassandraTableGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[CassandraTableGetResults]'},
}
def __init__(
self,
**kwargs
):
super(CassandraTableListResult, self).__init__(**kwargs)
self.value = None
[docs]class ClusterKey(msrest.serialization.Model):
"""Cosmos DB Cassandra table cluster key.
:param name: Name of the Cosmos DB Cassandra table cluster key.
:type name: str
:param order_by: Order of the Cosmos DB Cassandra table cluster key, only support "Asc" and
"Desc".
:type order_by: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'order_by': {'key': 'orderBy', 'type': 'str'},
}
def __init__(
self,
*,
name: Optional[str] = None,
order_by: Optional[str] = None,
**kwargs
):
super(ClusterKey, self).__init__(**kwargs)
self.name = name
self.order_by = order_by
[docs]class Column(msrest.serialization.Model):
"""Cosmos DB Cassandra table column.
:param name: Name of the Cosmos DB Cassandra table column.
:type name: str
:param type: Type of the Cosmos DB Cassandra table column.
:type type: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
}
def __init__(
self,
*,
name: Optional[str] = None,
type: Optional[str] = None,
**kwargs
):
super(Column, self).__init__(**kwargs)
self.name = name
self.type = type
[docs]class CompositePath(msrest.serialization.Model):
"""CompositePath.
:param path: The path for which the indexing behavior applies to. Index paths typically start
with root and end with wildcard (/path/*).
:type path: str
:param order: Sort order for composite paths. Possible values include: "Ascending",
"Descending".
:type order: str or ~azure.mgmt.cosmosdb.models.CompositePathSortOrder
"""
_attribute_map = {
'path': {'key': 'path', 'type': 'str'},
'order': {'key': 'order', 'type': 'str'},
}
def __init__(
self,
*,
path: Optional[str] = None,
order: Optional[Union[str, "CompositePathSortOrder"]] = None,
**kwargs
):
super(CompositePath, self).__init__(**kwargs)
self.path = path
self.order = order
[docs]class ConflictResolutionPolicy(msrest.serialization.Model):
"""The conflict resolution policy for the container.
:param mode: Indicates the conflict resolution mode. Possible values include: "LastWriterWins",
"Custom". Default value: "LastWriterWins".
:type mode: str or ~azure.mgmt.cosmosdb.models.ConflictResolutionMode
:param conflict_resolution_path: The conflict resolution path in the case of LastWriterWins
mode.
:type conflict_resolution_path: str
:param conflict_resolution_procedure: The procedure to resolve conflicts in the case of custom
mode.
:type conflict_resolution_procedure: str
"""
_attribute_map = {
'mode': {'key': 'mode', 'type': 'str'},
'conflict_resolution_path': {'key': 'conflictResolutionPath', 'type': 'str'},
'conflict_resolution_procedure': {'key': 'conflictResolutionProcedure', 'type': 'str'},
}
def __init__(
self,
*,
mode: Optional[Union[str, "ConflictResolutionMode"]] = "LastWriterWins",
conflict_resolution_path: Optional[str] = None,
conflict_resolution_procedure: Optional[str] = None,
**kwargs
):
super(ConflictResolutionPolicy, self).__init__(**kwargs)
self.mode = mode
self.conflict_resolution_path = conflict_resolution_path
self.conflict_resolution_procedure = conflict_resolution_procedure
[docs]class ConsistencyPolicy(msrest.serialization.Model):
"""The consistency policy for the Cosmos DB database account.
All required parameters must be populated in order to send to Azure.
:param default_consistency_level: Required. The default consistency level and configuration
settings of the Cosmos DB account. Possible values include: "Eventual", "Session",
"BoundedStaleness", "Strong", "ConsistentPrefix".
:type default_consistency_level: str or ~azure.mgmt.cosmosdb.models.DefaultConsistencyLevel
:param 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'.
:type max_staleness_prefix: long
:param 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'.
:type max_interval_in_seconds: int
"""
_validation = {
'default_consistency_level': {'required': True},
'max_staleness_prefix': {'maximum': 2147483647, 'minimum': 1},
'max_interval_in_seconds': {'maximum': 86400, 'minimum': 5},
}
_attribute_map = {
'default_consistency_level': {'key': 'defaultConsistencyLevel', 'type': 'str'},
'max_staleness_prefix': {'key': 'maxStalenessPrefix', 'type': 'long'},
'max_interval_in_seconds': {'key': 'maxIntervalInSeconds', 'type': 'int'},
}
def __init__(
self,
*,
default_consistency_level: Union[str, "DefaultConsistencyLevel"],
max_staleness_prefix: Optional[int] = None,
max_interval_in_seconds: Optional[int] = None,
**kwargs
):
super(ConsistencyPolicy, self).__init__(**kwargs)
self.default_consistency_level = default_consistency_level
self.max_staleness_prefix = max_staleness_prefix
self.max_interval_in_seconds = max_interval_in_seconds
[docs]class ContainerPartitionKey(msrest.serialization.Model):
"""The configuration of the partition key to be used for partitioning data into multiple partitions.
:param paths: List of paths using which data within the container can be partitioned.
:type paths: list[str]
:param kind: Indicates the kind of algorithm used for partitioning. Possible values include:
"Hash", "Range". Default value: "Hash".
:type kind: str or ~azure.mgmt.cosmosdb.models.PartitionKind
:param version: Indicates the version of the partition key definition.
:type version: int
"""
_validation = {
'version': {'maximum': 2, 'minimum': 1},
}
_attribute_map = {
'paths': {'key': 'paths', 'type': '[str]'},
'kind': {'key': 'kind', 'type': 'str'},
'version': {'key': 'version', 'type': 'int'},
}
def __init__(
self,
*,
paths: Optional[List[str]] = None,
kind: Optional[Union[str, "PartitionKind"]] = "Hash",
version: Optional[int] = None,
**kwargs
):
super(ContainerPartitionKey, self).__init__(**kwargs)
self.paths = paths
self.kind = kind
self.version = version
[docs]class CorsPolicy(msrest.serialization.Model):
"""The CORS policy for the Cosmos DB database account.
All required parameters must be populated in order to send to Azure.
:param allowed_origins: Required. The origin domains that are permitted to make a request
against the service via CORS.
:type allowed_origins: str
:param allowed_methods: The methods (HTTP request verbs) that the origin domain may use for a
CORS request.
:type allowed_methods: str
:param allowed_headers: The request headers that the origin domain may specify on the CORS
request.
:type allowed_headers: str
:param 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.
:type exposed_headers: str
:param max_age_in_seconds: The maximum amount time that a browser should cache the preflight
OPTIONS request.
:type max_age_in_seconds: long
"""
_validation = {
'allowed_origins': {'required': True},
'max_age_in_seconds': {'maximum': 2147483647, 'minimum': 1},
}
_attribute_map = {
'allowed_origins': {'key': 'allowedOrigins', 'type': 'str'},
'allowed_methods': {'key': 'allowedMethods', 'type': 'str'},
'allowed_headers': {'key': 'allowedHeaders', 'type': 'str'},
'exposed_headers': {'key': 'exposedHeaders', 'type': 'str'},
'max_age_in_seconds': {'key': 'maxAgeInSeconds', 'type': 'long'},
}
def __init__(
self,
*,
allowed_origins: str,
allowed_methods: Optional[str] = None,
allowed_headers: Optional[str] = None,
exposed_headers: Optional[str] = None,
max_age_in_seconds: Optional[int] = None,
**kwargs
):
super(CorsPolicy, self).__init__(**kwargs)
self.allowed_origins = allowed_origins
self.allowed_methods = allowed_methods
self.allowed_headers = allowed_headers
self.exposed_headers = exposed_headers
self.max_age_in_seconds = max_age_in_seconds
[docs]class CreateUpdateOptions(msrest.serialization.Model):
"""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 throughput: Request Units per second. For example, "throughput": 10000.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(CreateUpdateOptions, self).__init__(**kwargs)
self.throughput = throughput
self.autoscale_settings = autoscale_settings
[docs]class DatabaseAccountConnectionString(msrest.serialization.Model):
"""Connection string for the Cosmos DB account.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar connection_string: Value of the connection string.
:vartype connection_string: str
:ivar description: Description of the connection string.
:vartype description: str
"""
_validation = {
'connection_string': {'readonly': True},
'description': {'readonly': True},
}
_attribute_map = {
'connection_string': {'key': 'connectionString', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(DatabaseAccountConnectionString, self).__init__(**kwargs)
self.connection_string = None
self.description = None
[docs]class DatabaseAccountCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB database accounts.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param kind: Indicates the type of database account. This can only be set at database account
creation. Possible values include: "GlobalDocumentDB", "MongoDB", "Parse".
:type kind: str or ~azure.mgmt.cosmosdb.models.DatabaseAccountKind
:param consistency_policy: The consistency policy for the Cosmos DB account.
:type consistency_policy: ~azure.mgmt.cosmosdb.models.ConsistencyPolicy
:param locations: Required. An array that contains the georeplication locations enabled for the
Cosmos DB account.
:type locations: list[~azure.mgmt.cosmosdb.models.Location]
:ivar database_account_offer_type: Required. The offer type for the database. Default value:
"Standard".
:vartype database_account_offer_type: str
:param ip_rules: List of IpRules.
:type ip_rules: list[~azure.mgmt.cosmosdb.models.IpAddressOrRange]
:param is_virtual_network_filter_enabled: Flag to indicate whether to enable/disable Virtual
Network ACL rules.
:type is_virtual_network_filter_enabled: bool
:param enable_automatic_failover: Enables automatic failover of the write region in the rare
event that the region is unavailable due to an outage. Automatic failover will result in a new
write region for the account and is chosen based on the failover priorities configured for the
account.
:type enable_automatic_failover: bool
:param capabilities: List of Cosmos DB capabilities for the account.
:type capabilities: list[~azure.mgmt.cosmosdb.models.Capability]
:param virtual_network_rules: List of Virtual Network ACL rules configured for the Cosmos DB
account.
:type virtual_network_rules: list[~azure.mgmt.cosmosdb.models.VirtualNetworkRule]
:param enable_multiple_write_locations: Enables the account to write in multiple locations.
:type enable_multiple_write_locations: bool
:param enable_cassandra_connector: Enables the cassandra connector on the Cosmos DB C* account.
:type enable_cassandra_connector: bool
:param connector_offer: The cassandra connector offer type for the Cosmos DB database C*
account. Possible values include: "Small".
:type connector_offer: str or ~azure.mgmt.cosmosdb.models.ConnectorOffer
:param disable_key_based_metadata_write_access: Disable write operations on metadata resources
(databases, containers, throughput) via account keys.
:type disable_key_based_metadata_write_access: bool
:param key_vault_key_uri: The URI of the key vault.
:type key_vault_key_uri: str
:ivar public_network_access: Whether requests from Public Network are allowed. Possible values
include: "Enabled", "Disabled".
:vartype public_network_access: str or ~azure.mgmt.cosmosdb.models.PublicNetworkAccess
:param enable_free_tier: Flag to indicate whether Free Tier is enabled.
:type enable_free_tier: bool
:param api_properties: API specific properties. Currently, supported only for MongoDB API.
:type api_properties: ~azure.mgmt.cosmosdb.models.ApiProperties
:param enable_analytical_storage: Flag to indicate whether to enable storage analytics.
:type enable_analytical_storage: bool
:param cors: The CORS policy for the Cosmos DB database account.
:type cors: list[~azure.mgmt.cosmosdb.models.CorsPolicy]
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'locations': {'required': True},
'database_account_offer_type': {'required': True, 'constant': True},
'public_network_access': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'kind': {'key': 'kind', 'type': 'str'},
'consistency_policy': {'key': 'properties.consistencyPolicy', 'type': 'ConsistencyPolicy'},
'locations': {'key': 'properties.locations', 'type': '[Location]'},
'database_account_offer_type': {'key': 'properties.databaseAccountOfferType', 'type': 'str'},
'ip_rules': {'key': 'properties.ipRules', 'type': '[IpAddressOrRange]'},
'is_virtual_network_filter_enabled': {'key': 'properties.isVirtualNetworkFilterEnabled', 'type': 'bool'},
'enable_automatic_failover': {'key': 'properties.enableAutomaticFailover', 'type': 'bool'},
'capabilities': {'key': 'properties.capabilities', 'type': '[Capability]'},
'virtual_network_rules': {'key': 'properties.virtualNetworkRules', 'type': '[VirtualNetworkRule]'},
'enable_multiple_write_locations': {'key': 'properties.enableMultipleWriteLocations', 'type': 'bool'},
'enable_cassandra_connector': {'key': 'properties.enableCassandraConnector', 'type': 'bool'},
'connector_offer': {'key': 'properties.connectorOffer', 'type': 'str'},
'disable_key_based_metadata_write_access': {'key': 'properties.disableKeyBasedMetadataWriteAccess', 'type': 'bool'},
'key_vault_key_uri': {'key': 'properties.keyVaultKeyUri', 'type': 'str'},
'public_network_access': {'key': 'properties.publicNetworkAccess', 'type': 'str'},
'enable_free_tier': {'key': 'properties.enableFreeTier', 'type': 'bool'},
'api_properties': {'key': 'properties.apiProperties', 'type': 'ApiProperties'},
'enable_analytical_storage': {'key': 'properties.enableAnalyticalStorage', 'type': 'bool'},
'cors': {'key': 'properties.cors', 'type': '[CorsPolicy]'},
}
database_account_offer_type = "Standard"
def __init__(
self,
*,
locations: List["Location"],
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
kind: Optional[Union[str, "DatabaseAccountKind"]] = None,
consistency_policy: Optional["ConsistencyPolicy"] = None,
ip_rules: Optional[List["IpAddressOrRange"]] = None,
is_virtual_network_filter_enabled: Optional[bool] = None,
enable_automatic_failover: Optional[bool] = None,
capabilities: Optional[List["Capability"]] = None,
virtual_network_rules: Optional[List["VirtualNetworkRule"]] = None,
enable_multiple_write_locations: Optional[bool] = None,
enable_cassandra_connector: Optional[bool] = None,
connector_offer: Optional[Union[str, "ConnectorOffer"]] = None,
disable_key_based_metadata_write_access: Optional[bool] = None,
key_vault_key_uri: Optional[str] = None,
enable_free_tier: Optional[bool] = None,
api_properties: Optional["ApiProperties"] = None,
enable_analytical_storage: Optional[bool] = None,
cors: Optional[List["CorsPolicy"]] = None,
**kwargs
):
super(DatabaseAccountCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.kind = kind
self.consistency_policy = consistency_policy
self.locations = locations
self.ip_rules = ip_rules
self.is_virtual_network_filter_enabled = is_virtual_network_filter_enabled
self.enable_automatic_failover = enable_automatic_failover
self.capabilities = capabilities
self.virtual_network_rules = virtual_network_rules
self.enable_multiple_write_locations = enable_multiple_write_locations
self.enable_cassandra_connector = enable_cassandra_connector
self.connector_offer = connector_offer
self.disable_key_based_metadata_write_access = disable_key_based_metadata_write_access
self.key_vault_key_uri = key_vault_key_uri
self.public_network_access = None
self.enable_free_tier = enable_free_tier
self.api_properties = api_properties
self.enable_analytical_storage = enable_analytical_storage
self.cors = cors
[docs]class DatabaseAccountGetResults(ARMResourceProperties):
"""An Azure Cosmos DB database account.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param kind: Indicates the type of database account. This can only be set at database account
creation. Possible values include: "GlobalDocumentDB", "MongoDB", "Parse".
:type kind: str or ~azure.mgmt.cosmosdb.models.DatabaseAccountKind
:ivar provisioning_state: The status of the Cosmos DB account at the time the operation was
called. The status can be one of following. 'Creating' – the Cosmos DB account is being
created. When an account is in Creating state, only properties that are specified as input for
the Create Cosmos DB account operation are returned. 'Succeeded' – the Cosmos DB account is
active for use. 'Updating' – the Cosmos DB account is being updated. 'Deleting' – the Cosmos DB
account is being deleted. 'Failed' – the Cosmos DB account failed creation. 'DeletionFailed' –
the Cosmos DB account deletion failed.
:vartype provisioning_state: str
:ivar document_endpoint: The connection endpoint for the Cosmos DB database account.
:vartype document_endpoint: str
:ivar database_account_offer_type: The offer type for the Cosmos DB database account. Default
value: Standard. Default value: "Standard".
:vartype database_account_offer_type: str
:param ip_rules: List of IpRules.
:type ip_rules: list[~azure.mgmt.cosmosdb.models.IpAddressOrRange]
:param is_virtual_network_filter_enabled: Flag to indicate whether to enable/disable Virtual
Network ACL rules.
:type is_virtual_network_filter_enabled: bool
:param enable_automatic_failover: Enables automatic failover of the write region in the rare
event that the region is unavailable due to an outage. Automatic failover will result in a new
write region for the account and is chosen based on the failover priorities configured for the
account.
:type enable_automatic_failover: bool
:param consistency_policy: The consistency policy for the Cosmos DB database account.
:type consistency_policy: ~azure.mgmt.cosmosdb.models.ConsistencyPolicy
:param capabilities: List of Cosmos DB capabilities for the account.
:type capabilities: list[~azure.mgmt.cosmosdb.models.Capability]
:ivar write_locations: An array that contains the write location for the Cosmos DB account.
:vartype write_locations: list[~azure.mgmt.cosmosdb.models.Location]
:ivar read_locations: An array that contains of the read locations enabled for the Cosmos DB
account.
:vartype read_locations: list[~azure.mgmt.cosmosdb.models.Location]
:ivar locations: An array that contains all of the locations enabled for the Cosmos DB account.
:vartype locations: list[~azure.mgmt.cosmosdb.models.Location]
:ivar failover_policies: An array that contains the regions ordered by their failover
priorities.
:vartype failover_policies: list[~azure.mgmt.cosmosdb.models.FailoverPolicy]
:param virtual_network_rules: List of Virtual Network ACL rules configured for the Cosmos DB
account.
:type virtual_network_rules: list[~azure.mgmt.cosmosdb.models.VirtualNetworkRule]
:ivar private_endpoint_connections: List of Private Endpoint Connections configured for the
Cosmos DB account.
:vartype private_endpoint_connections:
list[~azure.mgmt.cosmosdb.models.PrivateEndpointConnection]
:param enable_multiple_write_locations: Enables the account to write in multiple locations.
:type enable_multiple_write_locations: bool
:param enable_cassandra_connector: Enables the cassandra connector on the Cosmos DB C* account.
:type enable_cassandra_connector: bool
:param connector_offer: The cassandra connector offer type for the Cosmos DB database C*
account. Possible values include: "Small".
:type connector_offer: str or ~azure.mgmt.cosmosdb.models.ConnectorOffer
:param disable_key_based_metadata_write_access: Disable write operations on metadata resources
(databases, containers, throughput) via account keys.
:type disable_key_based_metadata_write_access: bool
:param key_vault_key_uri: The URI of the key vault.
:type key_vault_key_uri: str
:ivar public_network_access: Whether requests from Public Network are allowed. Possible values
include: "Enabled", "Disabled".
:vartype public_network_access: str or ~azure.mgmt.cosmosdb.models.PublicNetworkAccess
:param enable_free_tier: Flag to indicate whether Free Tier is enabled.
:type enable_free_tier: bool
:param api_properties: API specific properties.
:type api_properties: ~azure.mgmt.cosmosdb.models.ApiProperties
:param enable_analytical_storage: Flag to indicate whether to enable storage analytics.
:type enable_analytical_storage: bool
:param cors: The CORS policy for the Cosmos DB database account.
:type cors: list[~azure.mgmt.cosmosdb.models.CorsPolicy]
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'provisioning_state': {'readonly': True},
'document_endpoint': {'readonly': True},
'database_account_offer_type': {'readonly': True, 'constant': True},
'write_locations': {'readonly': True},
'read_locations': {'readonly': True},
'locations': {'readonly': True},
'failover_policies': {'readonly': True},
'private_endpoint_connections': {'readonly': True},
'public_network_access': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'kind': {'key': 'kind', 'type': 'str'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
'document_endpoint': {'key': 'properties.documentEndpoint', 'type': 'str'},
'database_account_offer_type': {'key': 'properties.databaseAccountOfferType', 'type': 'str'},
'ip_rules': {'key': 'properties.ipRules', 'type': '[IpAddressOrRange]'},
'is_virtual_network_filter_enabled': {'key': 'properties.isVirtualNetworkFilterEnabled', 'type': 'bool'},
'enable_automatic_failover': {'key': 'properties.enableAutomaticFailover', 'type': 'bool'},
'consistency_policy': {'key': 'properties.consistencyPolicy', 'type': 'ConsistencyPolicy'},
'capabilities': {'key': 'properties.capabilities', 'type': '[Capability]'},
'write_locations': {'key': 'properties.writeLocations', 'type': '[Location]'},
'read_locations': {'key': 'properties.readLocations', 'type': '[Location]'},
'locations': {'key': 'properties.locations', 'type': '[Location]'},
'failover_policies': {'key': 'properties.failoverPolicies', 'type': '[FailoverPolicy]'},
'virtual_network_rules': {'key': 'properties.virtualNetworkRules', 'type': '[VirtualNetworkRule]'},
'private_endpoint_connections': {'key': 'properties.privateEndpointConnections', 'type': '[PrivateEndpointConnection]'},
'enable_multiple_write_locations': {'key': 'properties.enableMultipleWriteLocations', 'type': 'bool'},
'enable_cassandra_connector': {'key': 'properties.enableCassandraConnector', 'type': 'bool'},
'connector_offer': {'key': 'properties.connectorOffer', 'type': 'str'},
'disable_key_based_metadata_write_access': {'key': 'properties.disableKeyBasedMetadataWriteAccess', 'type': 'bool'},
'key_vault_key_uri': {'key': 'properties.keyVaultKeyUri', 'type': 'str'},
'public_network_access': {'key': 'properties.publicNetworkAccess', 'type': 'str'},
'enable_free_tier': {'key': 'properties.enableFreeTier', 'type': 'bool'},
'api_properties': {'key': 'properties.apiProperties', 'type': 'ApiProperties'},
'enable_analytical_storage': {'key': 'properties.enableAnalyticalStorage', 'type': 'bool'},
'cors': {'key': 'properties.cors', 'type': '[CorsPolicy]'},
}
database_account_offer_type = "Standard"
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
kind: Optional[Union[str, "DatabaseAccountKind"]] = None,
ip_rules: Optional[List["IpAddressOrRange"]] = None,
is_virtual_network_filter_enabled: Optional[bool] = None,
enable_automatic_failover: Optional[bool] = None,
consistency_policy: Optional["ConsistencyPolicy"] = None,
capabilities: Optional[List["Capability"]] = None,
virtual_network_rules: Optional[List["VirtualNetworkRule"]] = None,
enable_multiple_write_locations: Optional[bool] = None,
enable_cassandra_connector: Optional[bool] = None,
connector_offer: Optional[Union[str, "ConnectorOffer"]] = None,
disable_key_based_metadata_write_access: Optional[bool] = None,
key_vault_key_uri: Optional[str] = None,
enable_free_tier: Optional[bool] = None,
api_properties: Optional["ApiProperties"] = None,
enable_analytical_storage: Optional[bool] = None,
cors: Optional[List["CorsPolicy"]] = None,
**kwargs
):
super(DatabaseAccountGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.kind = kind
self.provisioning_state = None
self.document_endpoint = None
self.database_account_offer_type = None
self.ip_rules = ip_rules
self.is_virtual_network_filter_enabled = is_virtual_network_filter_enabled
self.enable_automatic_failover = enable_automatic_failover
self.consistency_policy = consistency_policy
self.capabilities = capabilities
self.write_locations = None
self.read_locations = None
self.locations = None
self.failover_policies = None
self.virtual_network_rules = virtual_network_rules
self.private_endpoint_connections = None
self.enable_multiple_write_locations = enable_multiple_write_locations
self.enable_cassandra_connector = enable_cassandra_connector
self.connector_offer = connector_offer
self.disable_key_based_metadata_write_access = disable_key_based_metadata_write_access
self.key_vault_key_uri = key_vault_key_uri
self.public_network_access = None
self.enable_free_tier = enable_free_tier
self.api_properties = api_properties
self.enable_analytical_storage = enable_analytical_storage
self.cors = cors
[docs]class DatabaseAccountListConnectionStringsResult(msrest.serialization.Model):
"""The connection strings for the given database account.
:param connection_strings: An array that contains the connection strings for the Cosmos DB
account.
:type connection_strings: list[~azure.mgmt.cosmosdb.models.DatabaseAccountConnectionString]
"""
_attribute_map = {
'connection_strings': {'key': 'connectionStrings', 'type': '[DatabaseAccountConnectionString]'},
}
def __init__(
self,
*,
connection_strings: Optional[List["DatabaseAccountConnectionString"]] = None,
**kwargs
):
super(DatabaseAccountListConnectionStringsResult, self).__init__(**kwargs)
self.connection_strings = connection_strings
[docs]class DatabaseAccountListReadOnlyKeysResult(msrest.serialization.Model):
"""The read-only access keys for the given database account.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar primary_readonly_master_key: Base 64 encoded value of the primary read-only key.
:vartype primary_readonly_master_key: str
:ivar secondary_readonly_master_key: Base 64 encoded value of the secondary read-only key.
:vartype secondary_readonly_master_key: str
"""
_validation = {
'primary_readonly_master_key': {'readonly': True},
'secondary_readonly_master_key': {'readonly': True},
}
_attribute_map = {
'primary_readonly_master_key': {'key': 'primaryReadonlyMasterKey', 'type': 'str'},
'secondary_readonly_master_key': {'key': 'secondaryReadonlyMasterKey', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(DatabaseAccountListReadOnlyKeysResult, self).__init__(**kwargs)
self.primary_readonly_master_key = None
self.secondary_readonly_master_key = None
[docs]class DatabaseAccountListKeysResult(DatabaseAccountListReadOnlyKeysResult):
"""The access keys for the given database account.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar primary_readonly_master_key: Base 64 encoded value of the primary read-only key.
:vartype primary_readonly_master_key: str
:ivar secondary_readonly_master_key: Base 64 encoded value of the secondary read-only key.
:vartype secondary_readonly_master_key: str
:ivar primary_master_key: Base 64 encoded value of the primary read-write key.
:vartype primary_master_key: str
:ivar secondary_master_key: Base 64 encoded value of the secondary read-write key.
:vartype secondary_master_key: str
"""
_validation = {
'primary_readonly_master_key': {'readonly': True},
'secondary_readonly_master_key': {'readonly': True},
'primary_master_key': {'readonly': True},
'secondary_master_key': {'readonly': True},
}
_attribute_map = {
'primary_readonly_master_key': {'key': 'primaryReadonlyMasterKey', 'type': 'str'},
'secondary_readonly_master_key': {'key': 'secondaryReadonlyMasterKey', 'type': 'str'},
'primary_master_key': {'key': 'primaryMasterKey', 'type': 'str'},
'secondary_master_key': {'key': 'secondaryMasterKey', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(DatabaseAccountListKeysResult, self).__init__(**kwargs)
self.primary_master_key = None
self.secondary_master_key = None
[docs]class DatabaseAccountRegenerateKeyParameters(msrest.serialization.Model):
"""Parameters to regenerate the keys within the database account.
All required parameters must be populated in order to send to Azure.
:param key_kind: Required. The access key to regenerate. Possible values include: "primary",
"secondary", "primaryReadonly", "secondaryReadonly".
:type key_kind: str or ~azure.mgmt.cosmosdb.models.KeyKind
"""
_validation = {
'key_kind': {'required': True},
}
_attribute_map = {
'key_kind': {'key': 'keyKind', 'type': 'str'},
}
def __init__(
self,
*,
key_kind: Union[str, "KeyKind"],
**kwargs
):
super(DatabaseAccountRegenerateKeyParameters, self).__init__(**kwargs)
self.key_kind = key_kind
[docs]class DatabaseAccountsListResult(msrest.serialization.Model):
"""The List operation response, that contains the database accounts and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of database account and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.DatabaseAccountGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[DatabaseAccountGetResults]'},
}
def __init__(
self,
**kwargs
):
super(DatabaseAccountsListResult, self).__init__(**kwargs)
self.value = None
[docs]class DatabaseAccountUpdateParameters(msrest.serialization.Model):
"""Parameters for patching Azure Cosmos DB database account properties.
Variables are only populated by the server, and will be ignored when sending a request.
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param consistency_policy: The consistency policy for the Cosmos DB account.
:type consistency_policy: ~azure.mgmt.cosmosdb.models.ConsistencyPolicy
:param locations: An array that contains the georeplication locations enabled for the Cosmos DB
account.
:type locations: list[~azure.mgmt.cosmosdb.models.Location]
:param ip_rules: List of IpRules.
:type ip_rules: list[~azure.mgmt.cosmosdb.models.IpAddressOrRange]
:param is_virtual_network_filter_enabled: Flag to indicate whether to enable/disable Virtual
Network ACL rules.
:type is_virtual_network_filter_enabled: bool
:param enable_automatic_failover: Enables automatic failover of the write region in the rare
event that the region is unavailable due to an outage. Automatic failover will result in a new
write region for the account and is chosen based on the failover priorities configured for the
account.
:type enable_automatic_failover: bool
:param capabilities: List of Cosmos DB capabilities for the account.
:type capabilities: list[~azure.mgmt.cosmosdb.models.Capability]
:param virtual_network_rules: List of Virtual Network ACL rules configured for the Cosmos DB
account.
:type virtual_network_rules: list[~azure.mgmt.cosmosdb.models.VirtualNetworkRule]
:param enable_multiple_write_locations: Enables the account to write in multiple locations.
:type enable_multiple_write_locations: bool
:param enable_cassandra_connector: Enables the cassandra connector on the Cosmos DB C* account.
:type enable_cassandra_connector: bool
:param connector_offer: The cassandra connector offer type for the Cosmos DB database C*
account. Possible values include: "Small".
:type connector_offer: str or ~azure.mgmt.cosmosdb.models.ConnectorOffer
:param disable_key_based_metadata_write_access: Disable write operations on metadata resources
(databases, containers, throughput) via account keys.
:type disable_key_based_metadata_write_access: bool
:param key_vault_key_uri: The URI of the key vault.
:type key_vault_key_uri: str
:ivar public_network_access: Whether requests from Public Network are allowed. Possible values
include: "Enabled", "Disabled".
:vartype public_network_access: str or ~azure.mgmt.cosmosdb.models.PublicNetworkAccess
:param enable_free_tier: Flag to indicate whether Free Tier is enabled.
:type enable_free_tier: bool
:param api_properties: API specific properties. Currently, supported only for MongoDB API.
:type api_properties: ~azure.mgmt.cosmosdb.models.ApiProperties
:param enable_analytical_storage: Flag to indicate whether to enable storage analytics.
:type enable_analytical_storage: bool
:param cors: The CORS policy for the Cosmos DB database account.
:type cors: list[~azure.mgmt.cosmosdb.models.CorsPolicy]
"""
_validation = {
'public_network_access': {'readonly': True},
}
_attribute_map = {
'tags': {'key': 'tags', 'type': '{str}'},
'location': {'key': 'location', 'type': 'str'},
'consistency_policy': {'key': 'properties.consistencyPolicy', 'type': 'ConsistencyPolicy'},
'locations': {'key': 'properties.locations', 'type': '[Location]'},
'ip_rules': {'key': 'properties.ipRules', 'type': '[IpAddressOrRange]'},
'is_virtual_network_filter_enabled': {'key': 'properties.isVirtualNetworkFilterEnabled', 'type': 'bool'},
'enable_automatic_failover': {'key': 'properties.enableAutomaticFailover', 'type': 'bool'},
'capabilities': {'key': 'properties.capabilities', 'type': '[Capability]'},
'virtual_network_rules': {'key': 'properties.virtualNetworkRules', 'type': '[VirtualNetworkRule]'},
'enable_multiple_write_locations': {'key': 'properties.enableMultipleWriteLocations', 'type': 'bool'},
'enable_cassandra_connector': {'key': 'properties.enableCassandraConnector', 'type': 'bool'},
'connector_offer': {'key': 'properties.connectorOffer', 'type': 'str'},
'disable_key_based_metadata_write_access': {'key': 'properties.disableKeyBasedMetadataWriteAccess', 'type': 'bool'},
'key_vault_key_uri': {'key': 'properties.keyVaultKeyUri', 'type': 'str'},
'public_network_access': {'key': 'properties.publicNetworkAccess', 'type': 'str'},
'enable_free_tier': {'key': 'properties.enableFreeTier', 'type': 'bool'},
'api_properties': {'key': 'properties.apiProperties', 'type': 'ApiProperties'},
'enable_analytical_storage': {'key': 'properties.enableAnalyticalStorage', 'type': 'bool'},
'cors': {'key': 'properties.cors', 'type': '[CorsPolicy]'},
}
def __init__(
self,
*,
tags: Optional[Dict[str, str]] = None,
location: Optional[str] = None,
consistency_policy: Optional["ConsistencyPolicy"] = None,
locations: Optional[List["Location"]] = None,
ip_rules: Optional[List["IpAddressOrRange"]] = None,
is_virtual_network_filter_enabled: Optional[bool] = None,
enable_automatic_failover: Optional[bool] = None,
capabilities: Optional[List["Capability"]] = None,
virtual_network_rules: Optional[List["VirtualNetworkRule"]] = None,
enable_multiple_write_locations: Optional[bool] = None,
enable_cassandra_connector: Optional[bool] = None,
connector_offer: Optional[Union[str, "ConnectorOffer"]] = None,
disable_key_based_metadata_write_access: Optional[bool] = None,
key_vault_key_uri: Optional[str] = None,
enable_free_tier: Optional[bool] = None,
api_properties: Optional["ApiProperties"] = None,
enable_analytical_storage: Optional[bool] = None,
cors: Optional[List["CorsPolicy"]] = None,
**kwargs
):
super(DatabaseAccountUpdateParameters, self).__init__(**kwargs)
self.tags = tags
self.location = location
self.consistency_policy = consistency_policy
self.locations = locations
self.ip_rules = ip_rules
self.is_virtual_network_filter_enabled = is_virtual_network_filter_enabled
self.enable_automatic_failover = enable_automatic_failover
self.capabilities = capabilities
self.virtual_network_rules = virtual_network_rules
self.enable_multiple_write_locations = enable_multiple_write_locations
self.enable_cassandra_connector = enable_cassandra_connector
self.connector_offer = connector_offer
self.disable_key_based_metadata_write_access = disable_key_based_metadata_write_access
self.key_vault_key_uri = key_vault_key_uri
self.public_network_access = None
self.enable_free_tier = enable_free_tier
self.api_properties = api_properties
self.enable_analytical_storage = enable_analytical_storage
self.cors = cors
[docs]class ErrorResponse(msrest.serialization.Model):
"""Error Response.
:param code: Error code.
:type code: str
:param message: Error message indicating why the operation failed.
:type message: str
"""
_attribute_map = {
'code': {'key': 'code', 'type': 'str'},
'message': {'key': 'message', 'type': 'str'},
}
def __init__(
self,
*,
code: Optional[str] = None,
message: Optional[str] = None,
**kwargs
):
super(ErrorResponse, self).__init__(**kwargs)
self.code = code
self.message = message
[docs]class ExcludedPath(msrest.serialization.Model):
"""ExcludedPath.
:param path: The path for which the indexing behavior applies to. Index paths typically start
with root and end with wildcard (/path/*).
:type path: str
"""
_attribute_map = {
'path': {'key': 'path', 'type': 'str'},
}
def __init__(
self,
*,
path: Optional[str] = None,
**kwargs
):
super(ExcludedPath, self).__init__(**kwargs)
self.path = path
[docs]class FailoverPolicies(msrest.serialization.Model):
"""The list of new failover policies for the failover priority change.
All required parameters must be populated in order to send to Azure.
:param failover_policies: Required. List of failover policies.
:type failover_policies: list[~azure.mgmt.cosmosdb.models.FailoverPolicy]
"""
_validation = {
'failover_policies': {'required': True},
}
_attribute_map = {
'failover_policies': {'key': 'failoverPolicies', 'type': '[FailoverPolicy]'},
}
def __init__(
self,
*,
failover_policies: List["FailoverPolicy"],
**kwargs
):
super(FailoverPolicies, self).__init__(**kwargs)
self.failover_policies = failover_policies
[docs]class FailoverPolicy(msrest.serialization.Model):
"""The failover policy for a given region of a database account.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique identifier of the region in which the database account replicates to.
Example: <accountName>-<locationName>.
:vartype id: str
:param location_name: The name of the region in which the database account exists.
:type location_name: str
:param 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.
:type failover_priority: int
"""
_validation = {
'id': {'readonly': True},
'failover_priority': {'minimum': 0},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'location_name': {'key': 'locationName', 'type': 'str'},
'failover_priority': {'key': 'failoverPriority', 'type': 'int'},
}
def __init__(
self,
*,
location_name: Optional[str] = None,
failover_priority: Optional[int] = None,
**kwargs
):
super(FailoverPolicy, self).__init__(**kwargs)
self.id = None
self.location_name = location_name
self.failover_priority = failover_priority
[docs]class GremlinDatabaseCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB Gremlin database.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a Gremlin database.
:type resource: ~azure.mgmt.cosmosdb.models.GremlinDatabaseResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'GremlinDatabaseResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "GremlinDatabaseResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(GremlinDatabaseCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class GremlinDatabaseGetPropertiesOptions(OptionsResource):
"""GremlinDatabaseGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(GremlinDatabaseGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class GremlinDatabaseResource(msrest.serialization.Model):
"""Cosmos DB Gremlin database resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB Gremlin database.
:type id: str
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(GremlinDatabaseResource, self).__init__(**kwargs)
self.id = id
[docs]class GremlinDatabaseGetPropertiesResource(ExtendedResourceProperties, GremlinDatabaseResource):
"""GremlinDatabaseGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB Gremlin database.
:type id: str
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(GremlinDatabaseGetPropertiesResource, self).__init__(id=id, **kwargs)
self.id = id
self.rid = None
self.ts = None
self.etag = None
[docs]class GremlinDatabaseGetResults(ARMResourceProperties):
"""An Azure Cosmos DB Gremlin database.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.GremlinDatabaseGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'GremlinDatabaseGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["GremlinDatabaseGetPropertiesResource"] = None,
**kwargs
):
super(GremlinDatabaseGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class GremlinDatabaseListResult(msrest.serialization.Model):
"""The List operation response, that contains the Gremlin databases and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of Gremlin databases and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.GremlinDatabaseGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[GremlinDatabaseGetResults]'},
}
def __init__(
self,
**kwargs
):
super(GremlinDatabaseListResult, self).__init__(**kwargs)
self.value = None
[docs]class GremlinGraphCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB Gremlin graph.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a Gremlin graph.
:type resource: ~azure.mgmt.cosmosdb.models.GremlinGraphResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'GremlinGraphResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "GremlinGraphResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(GremlinGraphCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class GremlinGraphGetPropertiesOptions(OptionsResource):
"""GremlinGraphGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(GremlinGraphGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class GremlinGraphResource(msrest.serialization.Model):
"""Cosmos DB Gremlin graph resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB Gremlin graph.
:type id: str
:param indexing_policy: The configuration of the indexing policy. By default, the indexing is
automatic for all document paths within the graph.
:type indexing_policy: ~azure.mgmt.cosmosdb.models.IndexingPolicy
:param partition_key: The configuration of the partition key to be used for partitioning data
into multiple partitions.
:type partition_key: ~azure.mgmt.cosmosdb.models.ContainerPartitionKey
:param default_ttl: Default time to live.
:type default_ttl: int
:param unique_key_policy: The unique key policy configuration for specifying uniqueness
constraints on documents in the collection in the Azure Cosmos DB service.
:type unique_key_policy: ~azure.mgmt.cosmosdb.models.UniqueKeyPolicy
:param conflict_resolution_policy: The conflict resolution policy for the graph.
:type conflict_resolution_policy: ~azure.mgmt.cosmosdb.models.ConflictResolutionPolicy
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'indexing_policy': {'key': 'indexingPolicy', 'type': 'IndexingPolicy'},
'partition_key': {'key': 'partitionKey', 'type': 'ContainerPartitionKey'},
'default_ttl': {'key': 'defaultTtl', 'type': 'int'},
'unique_key_policy': {'key': 'uniqueKeyPolicy', 'type': 'UniqueKeyPolicy'},
'conflict_resolution_policy': {'key': 'conflictResolutionPolicy', 'type': 'ConflictResolutionPolicy'},
}
def __init__(
self,
*,
id: str,
indexing_policy: Optional["IndexingPolicy"] = None,
partition_key: Optional["ContainerPartitionKey"] = None,
default_ttl: Optional[int] = None,
unique_key_policy: Optional["UniqueKeyPolicy"] = None,
conflict_resolution_policy: Optional["ConflictResolutionPolicy"] = None,
**kwargs
):
super(GremlinGraphResource, self).__init__(**kwargs)
self.id = id
self.indexing_policy = indexing_policy
self.partition_key = partition_key
self.default_ttl = default_ttl
self.unique_key_policy = unique_key_policy
self.conflict_resolution_policy = conflict_resolution_policy
[docs]class GremlinGraphGetPropertiesResource(ExtendedResourceProperties, GremlinGraphResource):
"""GremlinGraphGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB Gremlin graph.
:type id: str
:param indexing_policy: The configuration of the indexing policy. By default, the indexing is
automatic for all document paths within the graph.
:type indexing_policy: ~azure.mgmt.cosmosdb.models.IndexingPolicy
:param partition_key: The configuration of the partition key to be used for partitioning data
into multiple partitions.
:type partition_key: ~azure.mgmt.cosmosdb.models.ContainerPartitionKey
:param default_ttl: Default time to live.
:type default_ttl: int
:param unique_key_policy: The unique key policy configuration for specifying uniqueness
constraints on documents in the collection in the Azure Cosmos DB service.
:type unique_key_policy: ~azure.mgmt.cosmosdb.models.UniqueKeyPolicy
:param conflict_resolution_policy: The conflict resolution policy for the graph.
:type conflict_resolution_policy: ~azure.mgmt.cosmosdb.models.ConflictResolutionPolicy
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'indexing_policy': {'key': 'indexingPolicy', 'type': 'IndexingPolicy'},
'partition_key': {'key': 'partitionKey', 'type': 'ContainerPartitionKey'},
'default_ttl': {'key': 'defaultTtl', 'type': 'int'},
'unique_key_policy': {'key': 'uniqueKeyPolicy', 'type': 'UniqueKeyPolicy'},
'conflict_resolution_policy': {'key': 'conflictResolutionPolicy', 'type': 'ConflictResolutionPolicy'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
indexing_policy: Optional["IndexingPolicy"] = None,
partition_key: Optional["ContainerPartitionKey"] = None,
default_ttl: Optional[int] = None,
unique_key_policy: Optional["UniqueKeyPolicy"] = None,
conflict_resolution_policy: Optional["ConflictResolutionPolicy"] = None,
**kwargs
):
super(GremlinGraphGetPropertiesResource, self).__init__(id=id, indexing_policy=indexing_policy, partition_key=partition_key, default_ttl=default_ttl, unique_key_policy=unique_key_policy, conflict_resolution_policy=conflict_resolution_policy, **kwargs)
self.id = id
self.indexing_policy = indexing_policy
self.partition_key = partition_key
self.default_ttl = default_ttl
self.unique_key_policy = unique_key_policy
self.conflict_resolution_policy = conflict_resolution_policy
self.rid = None
self.ts = None
self.etag = None
[docs]class GremlinGraphGetResults(ARMResourceProperties):
"""An Azure Cosmos DB Gremlin graph.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.GremlinGraphGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'GremlinGraphGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["GremlinGraphGetPropertiesResource"] = None,
**kwargs
):
super(GremlinGraphGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class GremlinGraphListResult(msrest.serialization.Model):
"""The List operation response, that contains the graphs and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of graphs and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.GremlinGraphGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[GremlinGraphGetResults]'},
}
def __init__(
self,
**kwargs
):
super(GremlinGraphListResult, self).__init__(**kwargs)
self.value = None
[docs]class IncludedPath(msrest.serialization.Model):
"""The paths that are included in indexing.
:param path: The path for which the indexing behavior applies to. Index paths typically start
with root and end with wildcard (/path/*).
:type path: str
:param indexes: List of indexes for this path.
:type indexes: list[~azure.mgmt.cosmosdb.models.Indexes]
"""
_attribute_map = {
'path': {'key': 'path', 'type': 'str'},
'indexes': {'key': 'indexes', 'type': '[Indexes]'},
}
def __init__(
self,
*,
path: Optional[str] = None,
indexes: Optional[List["Indexes"]] = None,
**kwargs
):
super(IncludedPath, self).__init__(**kwargs)
self.path = path
self.indexes = indexes
[docs]class Indexes(msrest.serialization.Model):
"""The indexes for the path.
:param data_type: The datatype for which the indexing behavior is applied to. Possible values
include: "String", "Number", "Point", "Polygon", "LineString", "MultiPolygon". Default value:
"String".
:type data_type: str or ~azure.mgmt.cosmosdb.models.DataType
:param precision: The precision of the index. -1 is maximum precision.
:type precision: int
:param kind: Indicates the type of index. Possible values include: "Hash", "Range", "Spatial".
Default value: "Hash".
:type kind: str or ~azure.mgmt.cosmosdb.models.IndexKind
"""
_attribute_map = {
'data_type': {'key': 'dataType', 'type': 'str'},
'precision': {'key': 'precision', 'type': 'int'},
'kind': {'key': 'kind', 'type': 'str'},
}
def __init__(
self,
*,
data_type: Optional[Union[str, "DataType"]] = "String",
precision: Optional[int] = None,
kind: Optional[Union[str, "IndexKind"]] = "Hash",
**kwargs
):
super(Indexes, self).__init__(**kwargs)
self.data_type = data_type
self.precision = precision
self.kind = kind
[docs]class IndexingPolicy(msrest.serialization.Model):
"""Cosmos DB indexing policy.
:param automatic: Indicates if the indexing policy is automatic.
:type automatic: bool
:param indexing_mode: Indicates the indexing mode. Possible values include: "Consistent",
"Lazy", "None". Default value: "Consistent".
:type indexing_mode: str or ~azure.mgmt.cosmosdb.models.IndexingMode
:param included_paths: List of paths to include in the indexing.
:type included_paths: list[~azure.mgmt.cosmosdb.models.IncludedPath]
:param excluded_paths: List of paths to exclude from indexing.
:type excluded_paths: list[~azure.mgmt.cosmosdb.models.ExcludedPath]
:param composite_indexes: List of composite path list.
:type composite_indexes: list[list[~azure.mgmt.cosmosdb.models.CompositePath]]
:param spatial_indexes: List of spatial specifics.
:type spatial_indexes: list[~azure.mgmt.cosmosdb.models.SpatialSpec]
"""
_attribute_map = {
'automatic': {'key': 'automatic', 'type': 'bool'},
'indexing_mode': {'key': 'indexingMode', 'type': 'str'},
'included_paths': {'key': 'includedPaths', 'type': '[IncludedPath]'},
'excluded_paths': {'key': 'excludedPaths', 'type': '[ExcludedPath]'},
'composite_indexes': {'key': 'compositeIndexes', 'type': '[[CompositePath]]'},
'spatial_indexes': {'key': 'spatialIndexes', 'type': '[SpatialSpec]'},
}
def __init__(
self,
*,
automatic: Optional[bool] = None,
indexing_mode: Optional[Union[str, "IndexingMode"]] = "Consistent",
included_paths: Optional[List["IncludedPath"]] = None,
excluded_paths: Optional[List["ExcludedPath"]] = None,
composite_indexes: Optional[List[List["CompositePath"]]] = None,
spatial_indexes: Optional[List["SpatialSpec"]] = None,
**kwargs
):
super(IndexingPolicy, self).__init__(**kwargs)
self.automatic = automatic
self.indexing_mode = indexing_mode
self.included_paths = included_paths
self.excluded_paths = excluded_paths
self.composite_indexes = composite_indexes
self.spatial_indexes = spatial_indexes
[docs]class IpAddressOrRange(msrest.serialization.Model):
"""IpAddressOrRange object.
:param 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”.
:type ip_address_or_range: str
"""
_attribute_map = {
'ip_address_or_range': {'key': 'ipAddressOrRange', 'type': 'str'},
}
def __init__(
self,
*,
ip_address_or_range: Optional[str] = None,
**kwargs
):
super(IpAddressOrRange, self).__init__(**kwargs)
self.ip_address_or_range = ip_address_or_range
[docs]class Location(msrest.serialization.Model):
"""A region in which the Azure Cosmos DB database account is deployed.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique identifier of the region within the database account. Example:
<accountName>-<locationName>.
:vartype id: str
:param location_name: The name of the region.
:type location_name: str
:ivar document_endpoint: The connection endpoint for the specific region. Example:
https://<accountName>-<locationName>.documents.azure.com:443/.
:vartype document_endpoint: str
:ivar provisioning_state: The status of the Cosmos DB account at the time the operation was
called. The status can be one of following. 'Creating' – the Cosmos DB account is being
created. When an account is in Creating state, only properties that are specified as input for
the Create Cosmos DB account operation are returned. 'Succeeded' – the Cosmos DB account is
active for use. 'Updating' – the Cosmos DB account is being updated. 'Deleting' – the Cosmos DB
account is being deleted. 'Failed' – the Cosmos DB account failed creation. 'DeletionFailed' –
the Cosmos DB account deletion failed.
:vartype provisioning_state: str
:param 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.
:type failover_priority: int
:param is_zone_redundant: Flag to indicate whether or not this region is an AvailabilityZone
region.
:type is_zone_redundant: bool
"""
_validation = {
'id': {'readonly': True},
'document_endpoint': {'readonly': True},
'provisioning_state': {'readonly': True},
'failover_priority': {'minimum': 0},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'location_name': {'key': 'locationName', 'type': 'str'},
'document_endpoint': {'key': 'documentEndpoint', 'type': 'str'},
'provisioning_state': {'key': 'provisioningState', 'type': 'str'},
'failover_priority': {'key': 'failoverPriority', 'type': 'int'},
'is_zone_redundant': {'key': 'isZoneRedundant', 'type': 'bool'},
}
def __init__(
self,
*,
location_name: Optional[str] = None,
failover_priority: Optional[int] = None,
is_zone_redundant: Optional[bool] = None,
**kwargs
):
super(Location, self).__init__(**kwargs)
self.id = None
self.location_name = location_name
self.document_endpoint = None
self.provisioning_state = None
self.failover_priority = failover_priority
self.is_zone_redundant = is_zone_redundant
[docs]class Metric(msrest.serialization.Model):
"""Metric data.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar start_time: The start time for the metric (ISO-8601 format).
:vartype start_time: ~datetime.datetime
:ivar end_time: The end time for the metric (ISO-8601 format).
:vartype end_time: ~datetime.datetime
:ivar time_grain: The time grain to be used to summarize the metric values.
:vartype time_grain: str
:ivar unit: The unit of the metric. Possible values include: "Count", "Bytes", "Seconds",
"Percent", "CountPerSecond", "BytesPerSecond", "Milliseconds".
:vartype unit: str or ~azure.mgmt.cosmosdb.models.UnitType
:ivar name: The name information for the metric.
:vartype name: ~azure.mgmt.cosmosdb.models.MetricName
:ivar metric_values: The metric values for the specified time window and timestep.
:vartype metric_values: list[~azure.mgmt.cosmosdb.models.MetricValue]
"""
_validation = {
'start_time': {'readonly': True},
'end_time': {'readonly': True},
'time_grain': {'readonly': True},
'unit': {'readonly': True},
'name': {'readonly': True},
'metric_values': {'readonly': True},
}
_attribute_map = {
'start_time': {'key': 'startTime', 'type': 'iso-8601'},
'end_time': {'key': 'endTime', 'type': 'iso-8601'},
'time_grain': {'key': 'timeGrain', 'type': 'str'},
'unit': {'key': 'unit', 'type': 'str'},
'name': {'key': 'name', 'type': 'MetricName'},
'metric_values': {'key': 'metricValues', 'type': '[MetricValue]'},
}
def __init__(
self,
**kwargs
):
super(Metric, self).__init__(**kwargs)
self.start_time = None
self.end_time = None
self.time_grain = None
self.unit = None
self.name = None
self.metric_values = None
[docs]class MetricAvailability(msrest.serialization.Model):
"""The availability of the metric.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar time_grain: The time grain to be used to summarize the metric values.
:vartype time_grain: str
:ivar retention: The retention for the metric values.
:vartype retention: str
"""
_validation = {
'time_grain': {'readonly': True},
'retention': {'readonly': True},
}
_attribute_map = {
'time_grain': {'key': 'timeGrain', 'type': 'str'},
'retention': {'key': 'retention', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(MetricAvailability, self).__init__(**kwargs)
self.time_grain = None
self.retention = None
[docs]class MetricDefinition(msrest.serialization.Model):
"""The definition of a metric.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar metric_availabilities: The list of metric availabilities for the account.
:vartype metric_availabilities: list[~azure.mgmt.cosmosdb.models.MetricAvailability]
:ivar primary_aggregation_type: The primary aggregation type of the metric. Possible values
include: "None", "Average", "Total", "Minimum", "Maximum", "Last".
:vartype primary_aggregation_type: str or ~azure.mgmt.cosmosdb.models.PrimaryAggregationType
:ivar unit: The unit of the metric. Possible values include: "Count", "Bytes", "Seconds",
"Percent", "CountPerSecond", "BytesPerSecond", "Milliseconds".
:vartype unit: str or ~azure.mgmt.cosmosdb.models.UnitType
:ivar resource_uri: The resource uri of the database.
:vartype resource_uri: str
:ivar name: The name information for the metric.
:vartype name: ~azure.mgmt.cosmosdb.models.MetricName
"""
_validation = {
'metric_availabilities': {'readonly': True},
'primary_aggregation_type': {'readonly': True},
'unit': {'readonly': True},
'resource_uri': {'readonly': True},
'name': {'readonly': True},
}
_attribute_map = {
'metric_availabilities': {'key': 'metricAvailabilities', 'type': '[MetricAvailability]'},
'primary_aggregation_type': {'key': 'primaryAggregationType', 'type': 'str'},
'unit': {'key': 'unit', 'type': 'str'},
'resource_uri': {'key': 'resourceUri', 'type': 'str'},
'name': {'key': 'name', 'type': 'MetricName'},
}
def __init__(
self,
**kwargs
):
super(MetricDefinition, self).__init__(**kwargs)
self.metric_availabilities = None
self.primary_aggregation_type = None
self.unit = None
self.resource_uri = None
self.name = None
[docs]class MetricDefinitionsListResult(msrest.serialization.Model):
"""The response to a list metric definitions request.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: The list of metric definitions for the account.
:vartype value: list[~azure.mgmt.cosmosdb.models.MetricDefinition]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[MetricDefinition]'},
}
def __init__(
self,
**kwargs
):
super(MetricDefinitionsListResult, self).__init__(**kwargs)
self.value = None
[docs]class MetricListResult(msrest.serialization.Model):
"""The response to a list metrics request.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: The list of metrics for the account.
:vartype value: list[~azure.mgmt.cosmosdb.models.Metric]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[Metric]'},
}
def __init__(
self,
**kwargs
):
super(MetricListResult, self).__init__(**kwargs)
self.value = None
[docs]class MetricName(msrest.serialization.Model):
"""A metric name.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: The name of the metric.
:vartype value: str
:ivar localized_value: The friendly name of the metric.
:vartype localized_value: str
"""
_validation = {
'value': {'readonly': True},
'localized_value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': 'str'},
'localized_value': {'key': 'localizedValue', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(MetricName, self).__init__(**kwargs)
self.value = None
self.localized_value = None
[docs]class MetricValue(msrest.serialization.Model):
"""Represents metrics values.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar count: The number of values for the metric.
:vartype count: int
:ivar average: The average value of the metric.
:vartype average: float
:ivar maximum: The max value of the metric.
:vartype maximum: float
:ivar minimum: The min value of the metric.
:vartype minimum: float
:ivar timestamp: The metric timestamp (ISO-8601 format).
:vartype timestamp: ~datetime.datetime
:ivar total: The total value of the metric.
:vartype total: float
"""
_validation = {
'count': {'readonly': True},
'average': {'readonly': True},
'maximum': {'readonly': True},
'minimum': {'readonly': True},
'timestamp': {'readonly': True},
'total': {'readonly': True},
}
_attribute_map = {
'count': {'key': '_count', 'type': 'int'},
'average': {'key': 'average', 'type': 'float'},
'maximum': {'key': 'maximum', 'type': 'float'},
'minimum': {'key': 'minimum', 'type': 'float'},
'timestamp': {'key': 'timestamp', 'type': 'iso-8601'},
'total': {'key': 'total', 'type': 'float'},
}
def __init__(
self,
**kwargs
):
super(MetricValue, self).__init__(**kwargs)
self.count = None
self.average = None
self.maximum = None
self.minimum = None
self.timestamp = None
self.total = None
[docs]class MongoDBCollectionCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB MongoDB collection.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a MongoDB collection.
:type resource: ~azure.mgmt.cosmosdb.models.MongoDBCollectionResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'MongoDBCollectionResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "MongoDBCollectionResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(MongoDBCollectionCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class MongoDBCollectionGetPropertiesOptions(OptionsResource):
"""MongoDBCollectionGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(MongoDBCollectionGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class MongoDBCollectionResource(msrest.serialization.Model):
"""Cosmos DB MongoDB collection resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB MongoDB collection.
:type id: str
:param shard_key: A key-value pair of shard keys to be applied for the request.
:type shard_key: dict[str, str]
:param indexes: List of index keys.
:type indexes: list[~azure.mgmt.cosmosdb.models.MongoIndex]
:param analytical_storage_ttl: Analytical TTL.
:type analytical_storage_ttl: int
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'shard_key': {'key': 'shardKey', 'type': '{str}'},
'indexes': {'key': 'indexes', 'type': '[MongoIndex]'},
'analytical_storage_ttl': {'key': 'analyticalStorageTtl', 'type': 'int'},
}
def __init__(
self,
*,
id: str,
shard_key: Optional[Dict[str, str]] = None,
indexes: Optional[List["MongoIndex"]] = None,
analytical_storage_ttl: Optional[int] = None,
**kwargs
):
super(MongoDBCollectionResource, self).__init__(**kwargs)
self.id = id
self.shard_key = shard_key
self.indexes = indexes
self.analytical_storage_ttl = analytical_storage_ttl
[docs]class MongoDBCollectionGetPropertiesResource(ExtendedResourceProperties, MongoDBCollectionResource):
"""MongoDBCollectionGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB MongoDB collection.
:type id: str
:param shard_key: A key-value pair of shard keys to be applied for the request.
:type shard_key: dict[str, str]
:param indexes: List of index keys.
:type indexes: list[~azure.mgmt.cosmosdb.models.MongoIndex]
:param analytical_storage_ttl: Analytical TTL.
:type analytical_storage_ttl: int
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'shard_key': {'key': 'shardKey', 'type': '{str}'},
'indexes': {'key': 'indexes', 'type': '[MongoIndex]'},
'analytical_storage_ttl': {'key': 'analyticalStorageTtl', 'type': 'int'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
shard_key: Optional[Dict[str, str]] = None,
indexes: Optional[List["MongoIndex"]] = None,
analytical_storage_ttl: Optional[int] = None,
**kwargs
):
super(MongoDBCollectionGetPropertiesResource, self).__init__(id=id, shard_key=shard_key, indexes=indexes, analytical_storage_ttl=analytical_storage_ttl, **kwargs)
self.id = id
self.shard_key = shard_key
self.indexes = indexes
self.analytical_storage_ttl = analytical_storage_ttl
self.rid = None
self.ts = None
self.etag = None
[docs]class MongoDBCollectionGetResults(ARMResourceProperties):
"""An Azure Cosmos DB MongoDB collection.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.MongoDBCollectionGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'MongoDBCollectionGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["MongoDBCollectionGetPropertiesResource"] = None,
**kwargs
):
super(MongoDBCollectionGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class MongoDBCollectionListResult(msrest.serialization.Model):
"""The List operation response, that contains the MongoDB collections and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of MongoDB collections and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.MongoDBCollectionGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[MongoDBCollectionGetResults]'},
}
def __init__(
self,
**kwargs
):
super(MongoDBCollectionListResult, self).__init__(**kwargs)
self.value = None
[docs]class MongoDBDatabaseCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB MongoDB database.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a MongoDB database.
:type resource: ~azure.mgmt.cosmosdb.models.MongoDBDatabaseResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'MongoDBDatabaseResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "MongoDBDatabaseResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(MongoDBDatabaseCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class MongoDBDatabaseGetPropertiesOptions(OptionsResource):
"""MongoDBDatabaseGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(MongoDBDatabaseGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class MongoDBDatabaseResource(msrest.serialization.Model):
"""Cosmos DB MongoDB database resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB MongoDB database.
:type id: str
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(MongoDBDatabaseResource, self).__init__(**kwargs)
self.id = id
[docs]class MongoDBDatabaseGetPropertiesResource(ExtendedResourceProperties, MongoDBDatabaseResource):
"""MongoDBDatabaseGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB MongoDB database.
:type id: str
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(MongoDBDatabaseGetPropertiesResource, self).__init__(id=id, **kwargs)
self.id = id
self.rid = None
self.ts = None
self.etag = None
[docs]class MongoDBDatabaseGetResults(ARMResourceProperties):
"""An Azure Cosmos DB MongoDB database.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.MongoDBDatabaseGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'MongoDBDatabaseGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["MongoDBDatabaseGetPropertiesResource"] = None,
**kwargs
):
super(MongoDBDatabaseGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class MongoDBDatabaseListResult(msrest.serialization.Model):
"""The List operation response, that contains the MongoDB databases and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of MongoDB databases and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.MongoDBDatabaseGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[MongoDBDatabaseGetResults]'},
}
def __init__(
self,
**kwargs
):
super(MongoDBDatabaseListResult, self).__init__(**kwargs)
self.value = None
[docs]class MongoIndex(msrest.serialization.Model):
"""Cosmos DB MongoDB collection index key.
:param key: Cosmos DB MongoDB collection index keys.
:type key: ~azure.mgmt.cosmosdb.models.MongoIndexKeys
:param options: Cosmos DB MongoDB collection index key options.
:type options: ~azure.mgmt.cosmosdb.models.MongoIndexOptions
"""
_attribute_map = {
'key': {'key': 'key', 'type': 'MongoIndexKeys'},
'options': {'key': 'options', 'type': 'MongoIndexOptions'},
}
def __init__(
self,
*,
key: Optional["MongoIndexKeys"] = None,
options: Optional["MongoIndexOptions"] = None,
**kwargs
):
super(MongoIndex, self).__init__(**kwargs)
self.key = key
self.options = options
[docs]class MongoIndexKeys(msrest.serialization.Model):
"""Cosmos DB MongoDB collection resource object.
:param keys: List of keys for each MongoDB collection in the Azure Cosmos DB service.
:type keys: list[str]
"""
_attribute_map = {
'keys': {'key': 'keys', 'type': '[str]'},
}
def __init__(
self,
*,
keys: Optional[List[str]] = None,
**kwargs
):
super(MongoIndexKeys, self).__init__(**kwargs)
self.keys = keys
[docs]class MongoIndexOptions(msrest.serialization.Model):
"""Cosmos DB MongoDB collection index options.
:param expire_after_seconds: Expire after seconds.
:type expire_after_seconds: int
:param unique: Is unique or not.
:type unique: bool
"""
_attribute_map = {
'expire_after_seconds': {'key': 'expireAfterSeconds', 'type': 'int'},
'unique': {'key': 'unique', 'type': 'bool'},
}
def __init__(
self,
*,
expire_after_seconds: Optional[int] = None,
unique: Optional[bool] = None,
**kwargs
):
super(MongoIndexOptions, self).__init__(**kwargs)
self.expire_after_seconds = expire_after_seconds
self.unique = unique
[docs]class NotebookWorkspace(ARMProxyResource):
"""A notebook workspace resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the database account.
:vartype id: str
:ivar name: The name of the database account.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:ivar notebook_server_endpoint: Specifies the endpoint of Notebook server.
:vartype notebook_server_endpoint: str
:ivar status: Status of the notebook workspace. Possible values are: Creating, Online,
Deleting, Failed, Updating.
:vartype status: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'notebook_server_endpoint': {'readonly': True},
'status': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'notebook_server_endpoint': {'key': 'properties.notebookServerEndpoint', 'type': 'str'},
'status': {'key': 'properties.status', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(NotebookWorkspace, self).__init__(**kwargs)
self.notebook_server_endpoint = None
self.status = None
[docs]class NotebookWorkspaceConnectionInfoResult(msrest.serialization.Model):
"""The connection info for the given notebook workspace.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar auth_token: Specifies auth token used for connecting to Notebook server (uses token-based
auth).
:vartype auth_token: str
:ivar notebook_server_endpoint: Specifies the endpoint of Notebook server.
:vartype notebook_server_endpoint: str
"""
_validation = {
'auth_token': {'readonly': True},
'notebook_server_endpoint': {'readonly': True},
}
_attribute_map = {
'auth_token': {'key': 'authToken', 'type': 'str'},
'notebook_server_endpoint': {'key': 'notebookServerEndpoint', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(NotebookWorkspaceConnectionInfoResult, self).__init__(**kwargs)
self.auth_token = None
self.notebook_server_endpoint = None
[docs]class NotebookWorkspaceCreateUpdateParameters(ARMProxyResource):
"""Parameters to create a notebook workspace resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the database account.
:vartype id: str
:ivar name: The name of the database account.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(NotebookWorkspaceCreateUpdateParameters, self).__init__(**kwargs)
[docs]class NotebookWorkspaceListResult(msrest.serialization.Model):
"""A list of notebook workspace resources.
:param value: Array of notebook workspace resources.
:type value: list[~azure.mgmt.cosmosdb.models.NotebookWorkspace]
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[NotebookWorkspace]'},
}
def __init__(
self,
*,
value: Optional[List["NotebookWorkspace"]] = None,
**kwargs
):
super(NotebookWorkspaceListResult, self).__init__(**kwargs)
self.value = value
[docs]class Operation(msrest.serialization.Model):
"""REST API operation.
:param name: Operation name: {provider}/{resource}/{operation}.
:type name: str
:param display: The object that represents the operation.
:type display: ~azure.mgmt.cosmosdb.models.OperationDisplay
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'display': {'key': 'display', 'type': 'OperationDisplay'},
}
def __init__(
self,
*,
name: Optional[str] = None,
display: Optional["OperationDisplay"] = None,
**kwargs
):
super(Operation, self).__init__(**kwargs)
self.name = name
self.display = display
[docs]class OperationDisplay(msrest.serialization.Model):
"""The object that represents the operation.
:param provider: Service provider: Microsoft.ResourceProvider.
:type provider: str
:param resource: Resource on which the operation is performed: Profile, endpoint, etc.
:type resource: str
:param operation: Operation type: Read, write, delete, etc.
:type operation: str
:param description: Description of operation.
:type description: str
"""
_attribute_map = {
'provider': {'key': 'Provider', 'type': 'str'},
'resource': {'key': 'Resource', 'type': 'str'},
'operation': {'key': 'Operation', 'type': 'str'},
'description': {'key': 'Description', 'type': 'str'},
}
def __init__(
self,
*,
provider: Optional[str] = None,
resource: Optional[str] = None,
operation: Optional[str] = None,
description: Optional[str] = None,
**kwargs
):
super(OperationDisplay, self).__init__(**kwargs)
self.provider = provider
self.resource = resource
self.operation = operation
self.description = description
[docs]class OperationListResult(msrest.serialization.Model):
"""Result of the request to list Resource Provider operations. It contains a list of operations and a URL link to get the next set of results.
:param value: List of operations supported by the Resource Provider.
:type value: list[~azure.mgmt.cosmosdb.models.Operation]
:param next_link: URL to get the next set of operation list results if there are any.
:type next_link: str
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[Operation]'},
'next_link': {'key': 'nextLink', 'type': 'str'},
}
def __init__(
self,
*,
value: Optional[List["Operation"]] = None,
next_link: Optional[str] = None,
**kwargs
):
super(OperationListResult, self).__init__(**kwargs)
self.value = value
self.next_link = next_link
[docs]class PartitionMetric(Metric):
"""The metric values for a single partition.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar start_time: The start time for the metric (ISO-8601 format).
:vartype start_time: ~datetime.datetime
:ivar end_time: The end time for the metric (ISO-8601 format).
:vartype end_time: ~datetime.datetime
:ivar time_grain: The time grain to be used to summarize the metric values.
:vartype time_grain: str
:ivar unit: The unit of the metric. Possible values include: "Count", "Bytes", "Seconds",
"Percent", "CountPerSecond", "BytesPerSecond", "Milliseconds".
:vartype unit: str or ~azure.mgmt.cosmosdb.models.UnitType
:ivar name: The name information for the metric.
:vartype name: ~azure.mgmt.cosmosdb.models.MetricName
:ivar metric_values: The metric values for the specified time window and timestep.
:vartype metric_values: list[~azure.mgmt.cosmosdb.models.MetricValue]
:ivar partition_id: The partition id (GUID identifier) of the metric values.
:vartype partition_id: str
:ivar partition_key_range_id: The partition key range id (integer identifier) of the metric
values.
:vartype partition_key_range_id: str
"""
_validation = {
'start_time': {'readonly': True},
'end_time': {'readonly': True},
'time_grain': {'readonly': True},
'unit': {'readonly': True},
'name': {'readonly': True},
'metric_values': {'readonly': True},
'partition_id': {'readonly': True},
'partition_key_range_id': {'readonly': True},
}
_attribute_map = {
'start_time': {'key': 'startTime', 'type': 'iso-8601'},
'end_time': {'key': 'endTime', 'type': 'iso-8601'},
'time_grain': {'key': 'timeGrain', 'type': 'str'},
'unit': {'key': 'unit', 'type': 'str'},
'name': {'key': 'name', 'type': 'MetricName'},
'metric_values': {'key': 'metricValues', 'type': '[MetricValue]'},
'partition_id': {'key': 'partitionId', 'type': 'str'},
'partition_key_range_id': {'key': 'partitionKeyRangeId', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(PartitionMetric, self).__init__(**kwargs)
self.partition_id = None
self.partition_key_range_id = None
[docs]class PartitionMetricListResult(msrest.serialization.Model):
"""The response to a list partition metrics request.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: The list of partition-level metrics for the account.
:vartype value: list[~azure.mgmt.cosmosdb.models.PartitionMetric]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[PartitionMetric]'},
}
def __init__(
self,
**kwargs
):
super(PartitionMetricListResult, self).__init__(**kwargs)
self.value = None
[docs]class Usage(msrest.serialization.Model):
"""The usage data for a usage request.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar unit: The unit of the metric. Possible values include: "Count", "Bytes", "Seconds",
"Percent", "CountPerSecond", "BytesPerSecond", "Milliseconds".
:vartype unit: str or ~azure.mgmt.cosmosdb.models.UnitType
:ivar name: The name information for the metric.
:vartype name: ~azure.mgmt.cosmosdb.models.MetricName
:ivar quota_period: The quota period used to summarize the usage values.
:vartype quota_period: str
:ivar limit: Maximum value for this metric.
:vartype limit: long
:ivar current_value: Current value for this metric.
:vartype current_value: long
"""
_validation = {
'unit': {'readonly': True},
'name': {'readonly': True},
'quota_period': {'readonly': True},
'limit': {'readonly': True},
'current_value': {'readonly': True},
}
_attribute_map = {
'unit': {'key': 'unit', 'type': 'str'},
'name': {'key': 'name', 'type': 'MetricName'},
'quota_period': {'key': 'quotaPeriod', 'type': 'str'},
'limit': {'key': 'limit', 'type': 'long'},
'current_value': {'key': 'currentValue', 'type': 'long'},
}
def __init__(
self,
**kwargs
):
super(Usage, self).__init__(**kwargs)
self.unit = None
self.name = None
self.quota_period = None
self.limit = None
self.current_value = None
[docs]class PartitionUsage(Usage):
"""The partition level usage data for a usage request.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar unit: The unit of the metric. Possible values include: "Count", "Bytes", "Seconds",
"Percent", "CountPerSecond", "BytesPerSecond", "Milliseconds".
:vartype unit: str or ~azure.mgmt.cosmosdb.models.UnitType
:ivar name: The name information for the metric.
:vartype name: ~azure.mgmt.cosmosdb.models.MetricName
:ivar quota_period: The quota period used to summarize the usage values.
:vartype quota_period: str
:ivar limit: Maximum value for this metric.
:vartype limit: long
:ivar current_value: Current value for this metric.
:vartype current_value: long
:ivar partition_id: The partition id (GUID identifier) of the usages.
:vartype partition_id: str
:ivar partition_key_range_id: The partition key range id (integer identifier) of the usages.
:vartype partition_key_range_id: str
"""
_validation = {
'unit': {'readonly': True},
'name': {'readonly': True},
'quota_period': {'readonly': True},
'limit': {'readonly': True},
'current_value': {'readonly': True},
'partition_id': {'readonly': True},
'partition_key_range_id': {'readonly': True},
}
_attribute_map = {
'unit': {'key': 'unit', 'type': 'str'},
'name': {'key': 'name', 'type': 'MetricName'},
'quota_period': {'key': 'quotaPeriod', 'type': 'str'},
'limit': {'key': 'limit', 'type': 'long'},
'current_value': {'key': 'currentValue', 'type': 'long'},
'partition_id': {'key': 'partitionId', 'type': 'str'},
'partition_key_range_id': {'key': 'partitionKeyRangeId', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(PartitionUsage, self).__init__(**kwargs)
self.partition_id = None
self.partition_key_range_id = None
[docs]class PartitionUsagesResult(msrest.serialization.Model):
"""The response to a list partition level usage request.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: The list of partition-level usages for the database. A usage is a point in time
metric.
:vartype value: list[~azure.mgmt.cosmosdb.models.PartitionUsage]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[PartitionUsage]'},
}
def __init__(
self,
**kwargs
):
super(PartitionUsagesResult, self).__init__(**kwargs)
self.value = None
[docs]class PercentileMetric(msrest.serialization.Model):
"""Percentile Metric data.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar start_time: The start time for the metric (ISO-8601 format).
:vartype start_time: ~datetime.datetime
:ivar end_time: The end time for the metric (ISO-8601 format).
:vartype end_time: ~datetime.datetime
:ivar time_grain: The time grain to be used to summarize the metric values.
:vartype time_grain: str
:ivar unit: The unit of the metric. Possible values include: "Count", "Bytes", "Seconds",
"Percent", "CountPerSecond", "BytesPerSecond", "Milliseconds".
:vartype unit: str or ~azure.mgmt.cosmosdb.models.UnitType
:ivar name: The name information for the metric.
:vartype name: ~azure.mgmt.cosmosdb.models.MetricName
:ivar metric_values: The percentile metric values for the specified time window and timestep.
:vartype metric_values: list[~azure.mgmt.cosmosdb.models.PercentileMetricValue]
"""
_validation = {
'start_time': {'readonly': True},
'end_time': {'readonly': True},
'time_grain': {'readonly': True},
'unit': {'readonly': True},
'name': {'readonly': True},
'metric_values': {'readonly': True},
}
_attribute_map = {
'start_time': {'key': 'startTime', 'type': 'iso-8601'},
'end_time': {'key': 'endTime', 'type': 'iso-8601'},
'time_grain': {'key': 'timeGrain', 'type': 'str'},
'unit': {'key': 'unit', 'type': 'str'},
'name': {'key': 'name', 'type': 'MetricName'},
'metric_values': {'key': 'metricValues', 'type': '[PercentileMetricValue]'},
}
def __init__(
self,
**kwargs
):
super(PercentileMetric, self).__init__(**kwargs)
self.start_time = None
self.end_time = None
self.time_grain = None
self.unit = None
self.name = None
self.metric_values = None
[docs]class PercentileMetricListResult(msrest.serialization.Model):
"""The response to a list percentile metrics request.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: The list of percentile metrics for the account.
:vartype value: list[~azure.mgmt.cosmosdb.models.PercentileMetric]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[PercentileMetric]'},
}
def __init__(
self,
**kwargs
):
super(PercentileMetricListResult, self).__init__(**kwargs)
self.value = None
[docs]class PercentileMetricValue(MetricValue):
"""Represents percentile metrics values.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar count: The number of values for the metric.
:vartype count: int
:ivar average: The average value of the metric.
:vartype average: float
:ivar maximum: The max value of the metric.
:vartype maximum: float
:ivar minimum: The min value of the metric.
:vartype minimum: float
:ivar timestamp: The metric timestamp (ISO-8601 format).
:vartype timestamp: ~datetime.datetime
:ivar total: The total value of the metric.
:vartype total: float
:ivar p10: The 10th percentile value for the metric.
:vartype p10: float
:ivar p25: The 25th percentile value for the metric.
:vartype p25: float
:ivar p50: The 50th percentile value for the metric.
:vartype p50: float
:ivar p75: The 75th percentile value for the metric.
:vartype p75: float
:ivar p90: The 90th percentile value for the metric.
:vartype p90: float
:ivar p95: The 95th percentile value for the metric.
:vartype p95: float
:ivar p99: The 99th percentile value for the metric.
:vartype p99: float
"""
_validation = {
'count': {'readonly': True},
'average': {'readonly': True},
'maximum': {'readonly': True},
'minimum': {'readonly': True},
'timestamp': {'readonly': True},
'total': {'readonly': True},
'p10': {'readonly': True},
'p25': {'readonly': True},
'p50': {'readonly': True},
'p75': {'readonly': True},
'p90': {'readonly': True},
'p95': {'readonly': True},
'p99': {'readonly': True},
}
_attribute_map = {
'count': {'key': '_count', 'type': 'int'},
'average': {'key': 'average', 'type': 'float'},
'maximum': {'key': 'maximum', 'type': 'float'},
'minimum': {'key': 'minimum', 'type': 'float'},
'timestamp': {'key': 'timestamp', 'type': 'iso-8601'},
'total': {'key': 'total', 'type': 'float'},
'p10': {'key': 'P10', 'type': 'float'},
'p25': {'key': 'P25', 'type': 'float'},
'p50': {'key': 'P50', 'type': 'float'},
'p75': {'key': 'P75', 'type': 'float'},
'p90': {'key': 'P90', 'type': 'float'},
'p95': {'key': 'P95', 'type': 'float'},
'p99': {'key': 'P99', 'type': 'float'},
}
def __init__(
self,
**kwargs
):
super(PercentileMetricValue, self).__init__(**kwargs)
self.p10 = None
self.p25 = None
self.p50 = None
self.p75 = None
self.p90 = None
self.p95 = None
self.p99 = None
[docs]class Resource(msrest.serialization.Model):
"""Resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource. Ex- Microsoft.Compute/virtualMachines or
Microsoft.Storage/storageAccounts.
:vartype type: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(Resource, self).__init__(**kwargs)
self.id = None
self.name = None
self.type = None
[docs]class PrivateEndpointConnection(Resource):
"""A private endpoint connection.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource. Ex- Microsoft.Compute/virtualMachines or
Microsoft.Storage/storageAccounts.
:vartype type: str
:param private_endpoint: Private endpoint which the connection belongs to.
:type private_endpoint: ~azure.mgmt.cosmosdb.models.PrivateEndpointProperty
:param private_link_service_connection_state: Connection State of the Private Endpoint
Connection.
:type private_link_service_connection_state:
~azure.mgmt.cosmosdb.models.PrivateLinkServiceConnectionStateProperty
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'private_endpoint': {'key': 'properties.privateEndpoint', 'type': 'PrivateEndpointProperty'},
'private_link_service_connection_state': {'key': 'properties.privateLinkServiceConnectionState', 'type': 'PrivateLinkServiceConnectionStateProperty'},
}
def __init__(
self,
*,
private_endpoint: Optional["PrivateEndpointProperty"] = None,
private_link_service_connection_state: Optional["PrivateLinkServiceConnectionStateProperty"] = None,
**kwargs
):
super(PrivateEndpointConnection, self).__init__(**kwargs)
self.private_endpoint = private_endpoint
self.private_link_service_connection_state = private_link_service_connection_state
[docs]class PrivateEndpointConnectionAutoGenerated(Resource):
"""A private endpoint connection.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource. Ex- Microsoft.Compute/virtualMachines or
Microsoft.Storage/storageAccounts.
:vartype type: str
:param private_endpoint: Private endpoint which the connection belongs to.
:type private_endpoint: ~azure.mgmt.cosmosdb.models.PrivateEndpointProperty
:param private_link_service_connection_state: Connection State of the Private Endpoint
Connection.
:type private_link_service_connection_state:
~azure.mgmt.cosmosdb.models.PrivateLinkServiceConnectionStatePropertyAutoGenerated
:param group_id: Group id of the private endpoint.
:type group_id: str
:param provisioning_state: Provisioning state of the private endpoint.
:type provisioning_state: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'private_endpoint': {'key': 'properties.privateEndpoint', 'type': 'PrivateEndpointProperty'},
'private_link_service_connection_state': {'key': 'properties.privateLinkServiceConnectionState', 'type': 'PrivateLinkServiceConnectionStatePropertyAutoGenerated'},
'group_id': {'key': 'properties.groupId', 'type': 'str'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
}
def __init__(
self,
*,
private_endpoint: Optional["PrivateEndpointProperty"] = None,
private_link_service_connection_state: Optional["PrivateLinkServiceConnectionStatePropertyAutoGenerated"] = None,
group_id: Optional[str] = None,
provisioning_state: Optional[str] = None,
**kwargs
):
super(PrivateEndpointConnectionAutoGenerated, self).__init__(**kwargs)
self.private_endpoint = private_endpoint
self.private_link_service_connection_state = private_link_service_connection_state
self.group_id = group_id
self.provisioning_state = provisioning_state
[docs]class PrivateEndpointConnectionListResult(msrest.serialization.Model):
"""A list of private endpoint connections.
:param value: Array of private endpoint connections.
:type value: list[~azure.mgmt.cosmosdb.models.PrivateEndpointConnectionAutoGenerated]
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[PrivateEndpointConnectionAutoGenerated]'},
}
def __init__(
self,
*,
value: Optional[List["PrivateEndpointConnectionAutoGenerated"]] = None,
**kwargs
):
super(PrivateEndpointConnectionListResult, self).__init__(**kwargs)
self.value = value
[docs]class PrivateEndpointProperty(msrest.serialization.Model):
"""Private endpoint which the connection belongs to.
:param id: Resource id of the private endpoint.
:type id: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
}
def __init__(
self,
*,
id: Optional[str] = None,
**kwargs
):
super(PrivateEndpointProperty, self).__init__(**kwargs)
self.id = id
[docs]class PrivateLinkResource(ARMProxyResource):
"""A private link resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the database account.
:vartype id: str
:ivar name: The name of the database account.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:ivar group_id: The private link resource group id.
:vartype group_id: str
:ivar required_members: The private link resource required member names.
:vartype required_members: list[str]
:ivar required_zone_names: The private link resource required zone names.
:vartype required_zone_names: list[str]
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'group_id': {'readonly': True},
'required_members': {'readonly': True},
'required_zone_names': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'group_id': {'key': 'properties.groupId', 'type': 'str'},
'required_members': {'key': 'properties.requiredMembers', 'type': '[str]'},
'required_zone_names': {'key': 'properties.requiredZoneNames', 'type': '[str]'},
}
def __init__(
self,
**kwargs
):
super(PrivateLinkResource, self).__init__(**kwargs)
self.group_id = None
self.required_members = None
self.required_zone_names = None
[docs]class PrivateLinkResourceListResult(msrest.serialization.Model):
"""A list of private link resources.
:param value: Array of private link resources.
:type value: list[~azure.mgmt.cosmosdb.models.PrivateLinkResource]
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[PrivateLinkResource]'},
}
def __init__(
self,
*,
value: Optional[List["PrivateLinkResource"]] = None,
**kwargs
):
super(PrivateLinkResourceListResult, self).__init__(**kwargs)
self.value = value
[docs]class PrivateLinkServiceConnectionStateProperty(msrest.serialization.Model):
"""Connection State of the Private Endpoint Connection.
Variables are only populated by the server, and will be ignored when sending a request.
:param status: The private link service connection status.
:type status: str
:ivar actions_required: Any action that is required beyond basic workflow (approve/ reject/
disconnect).
:vartype actions_required: str
"""
_validation = {
'actions_required': {'readonly': True},
}
_attribute_map = {
'status': {'key': 'status', 'type': 'str'},
'actions_required': {'key': 'actionsRequired', 'type': 'str'},
}
def __init__(
self,
*,
status: Optional[str] = None,
**kwargs
):
super(PrivateLinkServiceConnectionStateProperty, self).__init__(**kwargs)
self.status = status
self.actions_required = None
[docs]class PrivateLinkServiceConnectionStatePropertyAutoGenerated(msrest.serialization.Model):
"""Connection State of the Private Endpoint Connection.
Variables are only populated by the server, and will be ignored when sending a request.
:param status: The private link service connection status.
:type status: str
:param description: The private link service connection description.
:type description: str
:ivar actions_required: Any action that is required beyond basic workflow (approve/ reject/
disconnect).
:vartype actions_required: str
"""
_validation = {
'actions_required': {'readonly': True},
}
_attribute_map = {
'status': {'key': 'status', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
'actions_required': {'key': 'actionsRequired', 'type': 'str'},
}
def __init__(
self,
*,
status: Optional[str] = None,
description: Optional[str] = None,
**kwargs
):
super(PrivateLinkServiceConnectionStatePropertyAutoGenerated, self).__init__(**kwargs)
self.status = status
self.description = description
self.actions_required = None
[docs]class ProxyResource(Resource):
"""The resource model definition for a ARM proxy resource. It will have everything other than required location and tags.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource. Ex- Microsoft.Compute/virtualMachines or
Microsoft.Storage/storageAccounts.
:vartype type: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(ProxyResource, self).__init__(**kwargs)
[docs]class RegionForOnlineOffline(msrest.serialization.Model):
"""Cosmos DB region to online or offline.
All required parameters must be populated in order to send to Azure.
:param region: Required. Cosmos DB region, with spaces between words and each word capitalized.
:type region: str
"""
_validation = {
'region': {'required': True},
}
_attribute_map = {
'region': {'key': 'region', 'type': 'str'},
}
def __init__(
self,
*,
region: str,
**kwargs
):
super(RegionForOnlineOffline, self).__init__(**kwargs)
self.region = region
[docs]class SpatialSpec(msrest.serialization.Model):
"""SpatialSpec.
:param path: The path for which the indexing behavior applies to. Index paths typically start
with root and end with wildcard (/path/*).
:type path: str
:param types: List of path's spatial type.
:type types: list[str or ~azure.mgmt.cosmosdb.models.SpatialType]
"""
_attribute_map = {
'path': {'key': 'path', 'type': 'str'},
'types': {'key': 'types', 'type': '[str]'},
}
def __init__(
self,
*,
path: Optional[str] = None,
types: Optional[List[Union[str, "SpatialType"]]] = None,
**kwargs
):
super(SpatialSpec, self).__init__(**kwargs)
self.path = path
self.types = types
[docs]class SqlContainerCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB container.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a container.
:type resource: ~azure.mgmt.cosmosdb.models.SqlContainerResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlContainerResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "SqlContainerResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(SqlContainerCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class SqlContainerGetPropertiesOptions(OptionsResource):
"""SqlContainerGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(SqlContainerGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class SqlContainerResource(msrest.serialization.Model):
"""Cosmos DB SQL container resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL container.
:type id: str
:param indexing_policy: The configuration of the indexing policy. By default, the indexing is
automatic for all document paths within the container.
:type indexing_policy: ~azure.mgmt.cosmosdb.models.IndexingPolicy
:param partition_key: The configuration of the partition key to be used for partitioning data
into multiple partitions.
:type partition_key: ~azure.mgmt.cosmosdb.models.ContainerPartitionKey
:param default_ttl: Default time to live.
:type default_ttl: int
:param unique_key_policy: The unique key policy configuration for specifying uniqueness
constraints on documents in the collection in the Azure Cosmos DB service.
:type unique_key_policy: ~azure.mgmt.cosmosdb.models.UniqueKeyPolicy
:param conflict_resolution_policy: The conflict resolution policy for the container.
:type conflict_resolution_policy: ~azure.mgmt.cosmosdb.models.ConflictResolutionPolicy
:param analytical_storage_ttl: Analytical TTL.
:type analytical_storage_ttl: long
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'indexing_policy': {'key': 'indexingPolicy', 'type': 'IndexingPolicy'},
'partition_key': {'key': 'partitionKey', 'type': 'ContainerPartitionKey'},
'default_ttl': {'key': 'defaultTtl', 'type': 'int'},
'unique_key_policy': {'key': 'uniqueKeyPolicy', 'type': 'UniqueKeyPolicy'},
'conflict_resolution_policy': {'key': 'conflictResolutionPolicy', 'type': 'ConflictResolutionPolicy'},
'analytical_storage_ttl': {'key': 'analyticalStorageTtl', 'type': 'long'},
}
def __init__(
self,
*,
id: str,
indexing_policy: Optional["IndexingPolicy"] = None,
partition_key: Optional["ContainerPartitionKey"] = None,
default_ttl: Optional[int] = None,
unique_key_policy: Optional["UniqueKeyPolicy"] = None,
conflict_resolution_policy: Optional["ConflictResolutionPolicy"] = None,
analytical_storage_ttl: Optional[int] = None,
**kwargs
):
super(SqlContainerResource, self).__init__(**kwargs)
self.id = id
self.indexing_policy = indexing_policy
self.partition_key = partition_key
self.default_ttl = default_ttl
self.unique_key_policy = unique_key_policy
self.conflict_resolution_policy = conflict_resolution_policy
self.analytical_storage_ttl = analytical_storage_ttl
[docs]class SqlContainerGetPropertiesResource(ExtendedResourceProperties, SqlContainerResource):
"""SqlContainerGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL container.
:type id: str
:param indexing_policy: The configuration of the indexing policy. By default, the indexing is
automatic for all document paths within the container.
:type indexing_policy: ~azure.mgmt.cosmosdb.models.IndexingPolicy
:param partition_key: The configuration of the partition key to be used for partitioning data
into multiple partitions.
:type partition_key: ~azure.mgmt.cosmosdb.models.ContainerPartitionKey
:param default_ttl: Default time to live.
:type default_ttl: int
:param unique_key_policy: The unique key policy configuration for specifying uniqueness
constraints on documents in the collection in the Azure Cosmos DB service.
:type unique_key_policy: ~azure.mgmt.cosmosdb.models.UniqueKeyPolicy
:param conflict_resolution_policy: The conflict resolution policy for the container.
:type conflict_resolution_policy: ~azure.mgmt.cosmosdb.models.ConflictResolutionPolicy
:param analytical_storage_ttl: Analytical TTL.
:type analytical_storage_ttl: long
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'indexing_policy': {'key': 'indexingPolicy', 'type': 'IndexingPolicy'},
'partition_key': {'key': 'partitionKey', 'type': 'ContainerPartitionKey'},
'default_ttl': {'key': 'defaultTtl', 'type': 'int'},
'unique_key_policy': {'key': 'uniqueKeyPolicy', 'type': 'UniqueKeyPolicy'},
'conflict_resolution_policy': {'key': 'conflictResolutionPolicy', 'type': 'ConflictResolutionPolicy'},
'analytical_storage_ttl': {'key': 'analyticalStorageTtl', 'type': 'long'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
indexing_policy: Optional["IndexingPolicy"] = None,
partition_key: Optional["ContainerPartitionKey"] = None,
default_ttl: Optional[int] = None,
unique_key_policy: Optional["UniqueKeyPolicy"] = None,
conflict_resolution_policy: Optional["ConflictResolutionPolicy"] = None,
analytical_storage_ttl: Optional[int] = None,
**kwargs
):
super(SqlContainerGetPropertiesResource, self).__init__(id=id, indexing_policy=indexing_policy, partition_key=partition_key, default_ttl=default_ttl, unique_key_policy=unique_key_policy, conflict_resolution_policy=conflict_resolution_policy, analytical_storage_ttl=analytical_storage_ttl, **kwargs)
self.id = id
self.indexing_policy = indexing_policy
self.partition_key = partition_key
self.default_ttl = default_ttl
self.unique_key_policy = unique_key_policy
self.conflict_resolution_policy = conflict_resolution_policy
self.analytical_storage_ttl = analytical_storage_ttl
self.rid = None
self.ts = None
self.etag = None
[docs]class SqlContainerGetResults(ARMResourceProperties):
"""An Azure Cosmos DB container.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.SqlContainerGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlContainerGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["SqlContainerGetPropertiesResource"] = None,
**kwargs
):
super(SqlContainerGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class SqlContainerListResult(msrest.serialization.Model):
"""The List operation response, that contains the containers and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of containers and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.SqlContainerGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[SqlContainerGetResults]'},
}
def __init__(
self,
**kwargs
):
super(SqlContainerListResult, self).__init__(**kwargs)
self.value = None
[docs]class SqlDatabaseCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB SQL database.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a SQL database.
:type resource: ~azure.mgmt.cosmosdb.models.SqlDatabaseResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlDatabaseResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "SqlDatabaseResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(SqlDatabaseCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class SqlDatabaseGetPropertiesOptions(OptionsResource):
"""SqlDatabaseGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(SqlDatabaseGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class SqlDatabaseResource(msrest.serialization.Model):
"""Cosmos DB SQL database resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL database.
:type id: str
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(SqlDatabaseResource, self).__init__(**kwargs)
self.id = id
[docs]class SqlDatabaseGetPropertiesResource(SqlDatabaseResource, ExtendedResourceProperties):
"""SqlDatabaseGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
:param id: Required. Name of the Cosmos DB SQL database.
:type id: str
:param colls: A system generated property that specified the addressable path of the
collections resource.
:type colls: str
:param users: A system generated property that specifies the addressable path of the users
resource.
:type users: str
"""
_validation = {
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
'id': {'required': True},
}
_attribute_map = {
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
'id': {'key': 'id', 'type': 'str'},
'colls': {'key': '_colls', 'type': 'str'},
'users': {'key': '_users', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
colls: Optional[str] = None,
users: Optional[str] = None,
**kwargs
):
super(SqlDatabaseGetPropertiesResource, self).__init__(id=id, **kwargs)
self.rid = None
self.ts = None
self.etag = None
self.colls = colls
self.users = users
self.id = id
self.colls = colls
self.users = users
[docs]class SqlDatabaseGetResults(ARMResourceProperties):
"""An Azure Cosmos DB SQL database.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.SqlDatabaseGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlDatabaseGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["SqlDatabaseGetPropertiesResource"] = None,
**kwargs
):
super(SqlDatabaseGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class SqlDatabaseListResult(msrest.serialization.Model):
"""The List operation response, that contains the SQL databases and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of SQL databases and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.SqlDatabaseGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[SqlDatabaseGetResults]'},
}
def __init__(
self,
**kwargs
):
super(SqlDatabaseListResult, self).__init__(**kwargs)
self.value = None
[docs]class SqlStoredProcedureCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB storedProcedure.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a storedProcedure.
:type resource: ~azure.mgmt.cosmosdb.models.SqlStoredProcedureResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlStoredProcedureResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "SqlStoredProcedureResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(SqlStoredProcedureCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class SqlStoredProcedureResource(msrest.serialization.Model):
"""Cosmos DB SQL storedProcedure resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL storedProcedure.
:type id: str
:param body: Body of the Stored Procedure.
:type body: str
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'body': {'key': 'body', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
body: Optional[str] = None,
**kwargs
):
super(SqlStoredProcedureResource, self).__init__(**kwargs)
self.id = id
self.body = body
[docs]class SqlStoredProcedureGetPropertiesResource(ExtendedResourceProperties, SqlStoredProcedureResource):
"""SqlStoredProcedureGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL storedProcedure.
:type id: str
:param body: Body of the Stored Procedure.
:type body: str
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'body': {'key': 'body', 'type': 'str'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
body: Optional[str] = None,
**kwargs
):
super(SqlStoredProcedureGetPropertiesResource, self).__init__(id=id, body=body, **kwargs)
self.id = id
self.body = body
self.rid = None
self.ts = None
self.etag = None
[docs]class SqlStoredProcedureGetResults(ARMResourceProperties):
"""An Azure Cosmos DB storedProcedure.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.SqlStoredProcedureGetPropertiesResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlStoredProcedureGetPropertiesResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["SqlStoredProcedureGetPropertiesResource"] = None,
**kwargs
):
super(SqlStoredProcedureGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
[docs]class SqlStoredProcedureListResult(msrest.serialization.Model):
"""The List operation response, that contains the storedProcedures and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of storedProcedures and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.SqlStoredProcedureGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[SqlStoredProcedureGetResults]'},
}
def __init__(
self,
**kwargs
):
super(SqlStoredProcedureListResult, self).__init__(**kwargs)
self.value = None
[docs]class SqlTriggerCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB trigger.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a trigger.
:type resource: ~azure.mgmt.cosmosdb.models.SqlTriggerResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlTriggerResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "SqlTriggerResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(SqlTriggerCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class SqlTriggerResource(msrest.serialization.Model):
"""Cosmos DB SQL trigger resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL trigger.
:type id: str
:param body: Body of the Trigger.
:type body: str
:param trigger_type: Type of the Trigger. Possible values include: "Pre", "Post".
:type trigger_type: str or ~azure.mgmt.cosmosdb.models.TriggerType
:param trigger_operation: The operation the trigger is associated with. Possible values
include: "All", "Create", "Update", "Delete", "Replace".
:type trigger_operation: str or ~azure.mgmt.cosmosdb.models.TriggerOperation
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'body': {'key': 'body', 'type': 'str'},
'trigger_type': {'key': 'triggerType', 'type': 'str'},
'trigger_operation': {'key': 'triggerOperation', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
body: Optional[str] = None,
trigger_type: Optional[Union[str, "TriggerType"]] = None,
trigger_operation: Optional[Union[str, "TriggerOperation"]] = None,
**kwargs
):
super(SqlTriggerResource, self).__init__(**kwargs)
self.id = id
self.body = body
self.trigger_type = trigger_type
self.trigger_operation = trigger_operation
[docs]class SqlTriggerGetPropertiesResource(ExtendedResourceProperties, SqlTriggerResource):
"""SqlTriggerGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL trigger.
:type id: str
:param body: Body of the Trigger.
:type body: str
:param trigger_type: Type of the Trigger. Possible values include: "Pre", "Post".
:type trigger_type: str or ~azure.mgmt.cosmosdb.models.TriggerType
:param trigger_operation: The operation the trigger is associated with. Possible values
include: "All", "Create", "Update", "Delete", "Replace".
:type trigger_operation: str or ~azure.mgmt.cosmosdb.models.TriggerOperation
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'body': {'key': 'body', 'type': 'str'},
'trigger_type': {'key': 'triggerType', 'type': 'str'},
'trigger_operation': {'key': 'triggerOperation', 'type': 'str'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
body: Optional[str] = None,
trigger_type: Optional[Union[str, "TriggerType"]] = None,
trigger_operation: Optional[Union[str, "TriggerOperation"]] = None,
**kwargs
):
super(SqlTriggerGetPropertiesResource, self).__init__(id=id, body=body, trigger_type=trigger_type, trigger_operation=trigger_operation, **kwargs)
self.id = id
self.body = body
self.trigger_type = trigger_type
self.trigger_operation = trigger_operation
self.rid = None
self.ts = None
self.etag = None
[docs]class SqlTriggerGetResults(ARMResourceProperties):
"""An Azure Cosmos DB trigger.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.SqlTriggerGetPropertiesResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlTriggerGetPropertiesResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["SqlTriggerGetPropertiesResource"] = None,
**kwargs
):
super(SqlTriggerGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
[docs]class SqlTriggerListResult(msrest.serialization.Model):
"""The List operation response, that contains the triggers and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of triggers and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.SqlTriggerGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[SqlTriggerGetResults]'},
}
def __init__(
self,
**kwargs
):
super(SqlTriggerListResult, self).__init__(**kwargs)
self.value = None
[docs]class SqlUserDefinedFunctionCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB userDefinedFunction.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a userDefinedFunction.
:type resource: ~azure.mgmt.cosmosdb.models.SqlUserDefinedFunctionResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlUserDefinedFunctionResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "SqlUserDefinedFunctionResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(SqlUserDefinedFunctionCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class SqlUserDefinedFunctionResource(msrest.serialization.Model):
"""Cosmos DB SQL userDefinedFunction resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL userDefinedFunction.
:type id: str
:param body: Body of the User Defined Function.
:type body: str
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'body': {'key': 'body', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
body: Optional[str] = None,
**kwargs
):
super(SqlUserDefinedFunctionResource, self).__init__(**kwargs)
self.id = id
self.body = body
[docs]class SqlUserDefinedFunctionGetPropertiesResource(ExtendedResourceProperties, SqlUserDefinedFunctionResource):
"""SqlUserDefinedFunctionGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB SQL userDefinedFunction.
:type id: str
:param body: Body of the User Defined Function.
:type body: str
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'body': {'key': 'body', 'type': 'str'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
body: Optional[str] = None,
**kwargs
):
super(SqlUserDefinedFunctionGetPropertiesResource, self).__init__(id=id, body=body, **kwargs)
self.id = id
self.body = body
self.rid = None
self.ts = None
self.etag = None
[docs]class SqlUserDefinedFunctionGetResults(ARMResourceProperties):
"""An Azure Cosmos DB userDefinedFunction.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.SqlUserDefinedFunctionGetPropertiesResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'SqlUserDefinedFunctionGetPropertiesResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["SqlUserDefinedFunctionGetPropertiesResource"] = None,
**kwargs
):
super(SqlUserDefinedFunctionGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
[docs]class SqlUserDefinedFunctionListResult(msrest.serialization.Model):
"""The List operation response, that contains the userDefinedFunctions and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of userDefinedFunctions and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.SqlUserDefinedFunctionGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[SqlUserDefinedFunctionGetResults]'},
}
def __init__(
self,
**kwargs
):
super(SqlUserDefinedFunctionListResult, self).__init__(**kwargs)
self.value = None
[docs]class TableCreateUpdateParameters(ARMResourceProperties):
"""Parameters to create and update Cosmos DB Table.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a Table.
:type resource: ~azure.mgmt.cosmosdb.models.TableResource
:param options: Required. A key-value pair of options to be applied for the request. This
corresponds to the headers sent with the request.
:type options: ~azure.mgmt.cosmosdb.models.CreateUpdateOptions
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
'options': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'TableResource'},
'options': {'key': 'properties.options', 'type': 'CreateUpdateOptions'},
}
def __init__(
self,
*,
resource: "TableResource",
options: "CreateUpdateOptions",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(TableCreateUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = options
[docs]class TableGetPropertiesOptions(OptionsResource):
"""TableGetPropertiesOptions.
:param throughput: Value of the Cosmos DB resource throughput or autoscaleSettings. Use the
ThroughputSetting resource when retrieving offer details.
:type throughput: int
:param autoscale_settings: Specifies the Autoscale settings.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettings
"""
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettings'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettings"] = None,
**kwargs
):
super(TableGetPropertiesOptions, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
[docs]class TableResource(msrest.serialization.Model):
"""Cosmos DB table resource object.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB table.
:type id: str
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(TableResource, self).__init__(**kwargs)
self.id = id
[docs]class TableGetPropertiesResource(ExtendedResourceProperties, TableResource):
"""TableGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param id: Required. Name of the Cosmos DB table.
:type id: str
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'id': {'required': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
id: str,
**kwargs
):
super(TableGetPropertiesResource, self).__init__(id=id, **kwargs)
self.id = id
self.rid = None
self.ts = None
self.etag = None
[docs]class TableGetResults(ARMResourceProperties):
"""An Azure Cosmos DB Table.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.TableGetPropertiesResource
:ivar options: Cosmos DB options resource object.
:vartype options: ~azure.mgmt.cosmosdb.models.OptionsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'options': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'TableGetPropertiesResource'},
'options': {'key': 'properties.options', 'type': 'OptionsResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["TableGetPropertiesResource"] = None,
**kwargs
):
super(TableGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
self.options = None
[docs]class TableListResult(msrest.serialization.Model):
"""The List operation response, that contains the Table and their properties.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: List of Table and their properties.
:vartype value: list[~azure.mgmt.cosmosdb.models.TableGetResults]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[TableGetResults]'},
}
def __init__(
self,
**kwargs
):
super(TableListResult, self).__init__(**kwargs)
self.value = None
[docs]class ThroughputPolicyResource(msrest.serialization.Model):
"""Cosmos DB resource throughput policy.
:param is_enabled: Determines whether the ThroughputPolicy is active or not.
:type is_enabled: bool
:param increment_percent: Represents the percentage by which throughput can increase every time
throughput policy kicks in.
:type increment_percent: int
"""
_attribute_map = {
'is_enabled': {'key': 'isEnabled', 'type': 'bool'},
'increment_percent': {'key': 'incrementPercent', 'type': 'int'},
}
def __init__(
self,
*,
is_enabled: Optional[bool] = None,
increment_percent: Optional[int] = None,
**kwargs
):
super(ThroughputPolicyResource, self).__init__(**kwargs)
self.is_enabled = is_enabled
self.increment_percent = increment_percent
[docs]class ThroughputSettingsResource(msrest.serialization.Model):
"""Cosmos DB resource throughput object. Either throughput is required or autoscaleSettings is required, but not both.
Variables are only populated by the server, and will be ignored when sending a request.
:param throughput: Value of the Cosmos DB resource throughput. Either throughput is required or
autoscaleSettings is required, but not both.
:type throughput: int
:param autoscale_settings: Cosmos DB resource for autoscale settings. Either throughput is
required or autoscaleSettings is required, but not both.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettingsResource
:ivar minimum_throughput: The minimum throughput of the resource.
:vartype minimum_throughput: str
:ivar offer_replace_pending: The throughput replace is pending.
:vartype offer_replace_pending: str
"""
_validation = {
'minimum_throughput': {'readonly': True},
'offer_replace_pending': {'readonly': True},
}
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettingsResource'},
'minimum_throughput': {'key': 'minimumThroughput', 'type': 'str'},
'offer_replace_pending': {'key': 'offerReplacePending', 'type': 'str'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettingsResource"] = None,
**kwargs
):
super(ThroughputSettingsResource, self).__init__(**kwargs)
self.throughput = throughput
self.autoscale_settings = autoscale_settings
self.minimum_throughput = None
self.offer_replace_pending = None
[docs]class ThroughputSettingsGetPropertiesResource(ExtendedResourceProperties, ThroughputSettingsResource):
"""ThroughputSettingsGetPropertiesResource.
Variables are only populated by the server, and will be ignored when sending a request.
:param throughput: Value of the Cosmos DB resource throughput. Either throughput is required or
autoscaleSettings is required, but not both.
:type throughput: int
:param autoscale_settings: Cosmos DB resource for autoscale settings. Either throughput is
required or autoscaleSettings is required, but not both.
:type autoscale_settings: ~azure.mgmt.cosmosdb.models.AutoscaleSettingsResource
:ivar minimum_throughput: The minimum throughput of the resource.
:vartype minimum_throughput: str
:ivar offer_replace_pending: The throughput replace is pending.
:vartype offer_replace_pending: str
:ivar rid: A system generated property. A unique identifier.
:vartype rid: str
:ivar ts: A system generated property that denotes the last updated timestamp of the resource.
:vartype ts: object
:ivar etag: A system generated property representing the resource etag required for optimistic
concurrency control.
:vartype etag: str
"""
_validation = {
'minimum_throughput': {'readonly': True},
'offer_replace_pending': {'readonly': True},
'rid': {'readonly': True},
'ts': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'throughput': {'key': 'throughput', 'type': 'int'},
'autoscale_settings': {'key': 'autoscaleSettings', 'type': 'AutoscaleSettingsResource'},
'minimum_throughput': {'key': 'minimumThroughput', 'type': 'str'},
'offer_replace_pending': {'key': 'offerReplacePending', 'type': 'str'},
'rid': {'key': '_rid', 'type': 'str'},
'ts': {'key': '_ts', 'type': 'object'},
'etag': {'key': '_etag', 'type': 'str'},
}
def __init__(
self,
*,
throughput: Optional[int] = None,
autoscale_settings: Optional["AutoscaleSettingsResource"] = None,
**kwargs
):
super(ThroughputSettingsGetPropertiesResource, self).__init__(throughput=throughput, autoscale_settings=autoscale_settings, **kwargs)
self.throughput = throughput
self.autoscale_settings = autoscale_settings
self.minimum_throughput = None
self.offer_replace_pending = None
self.rid = None
self.ts = None
self.etag = None
[docs]class ThroughputSettingsGetResults(ARMResourceProperties):
"""An Azure Cosmos DB resource throughput.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource:
:type resource: ~azure.mgmt.cosmosdb.models.ThroughputSettingsGetPropertiesResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'ThroughputSettingsGetPropertiesResource'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
resource: Optional["ThroughputSettingsGetPropertiesResource"] = None,
**kwargs
):
super(ThroughputSettingsGetResults, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
[docs]class ThroughputSettingsUpdateParameters(ARMResourceProperties):
"""Parameters to update Cosmos DB resource throughput.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: The unique resource identifier of the ARM resource.
:vartype id: str
:ivar name: The name of the ARM resource.
:vartype name: str
:ivar type: The type of Azure resource.
:vartype type: str
:param location: The location of the resource group to which the resource belongs.
:type location: str
:param tags: A set of tags. Tags are a list of key-value pairs that describe the resource.
These tags can be used in viewing and grouping this resource (across resource groups). A
maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128
characters and value no greater than 256 characters. For example, the default experience for a
template type is set with "defaultExperience": "Cassandra". Current "defaultExperience" values
also include "Table", "Graph", "DocumentDB", and "MongoDB".
:type tags: dict[str, str]
:param resource: Required. The standard JSON format of a resource throughput.
:type resource: ~azure.mgmt.cosmosdb.models.ThroughputSettingsResource
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'resource': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'resource': {'key': 'properties.resource', 'type': 'ThroughputSettingsResource'},
}
def __init__(
self,
*,
resource: "ThroughputSettingsResource",
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(ThroughputSettingsUpdateParameters, self).__init__(location=location, tags=tags, **kwargs)
self.resource = resource
[docs]class UniqueKey(msrest.serialization.Model):
"""The unique key on that enforces uniqueness constraint on documents in the collection in the Azure Cosmos DB service.
:param paths: List of paths must be unique for each document in the Azure Cosmos DB service.
:type paths: list[str]
"""
_attribute_map = {
'paths': {'key': 'paths', 'type': '[str]'},
}
def __init__(
self,
*,
paths: Optional[List[str]] = None,
**kwargs
):
super(UniqueKey, self).__init__(**kwargs)
self.paths = paths
[docs]class UniqueKeyPolicy(msrest.serialization.Model):
"""The unique key policy configuration for specifying uniqueness constraints on documents in the collection in the Azure Cosmos DB service.
:param unique_keys: List of unique keys on that enforces uniqueness constraint on documents in
the collection in the Azure Cosmos DB service.
:type unique_keys: list[~azure.mgmt.cosmosdb.models.UniqueKey]
"""
_attribute_map = {
'unique_keys': {'key': 'uniqueKeys', 'type': '[UniqueKey]'},
}
def __init__(
self,
*,
unique_keys: Optional[List["UniqueKey"]] = None,
**kwargs
):
super(UniqueKeyPolicy, self).__init__(**kwargs)
self.unique_keys = unique_keys
[docs]class UsagesResult(msrest.serialization.Model):
"""The response to a list usage request.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar value: The list of usages for the database. A usage is a point in time metric.
:vartype value: list[~azure.mgmt.cosmosdb.models.Usage]
"""
_validation = {
'value': {'readonly': True},
}
_attribute_map = {
'value': {'key': 'value', 'type': '[Usage]'},
}
def __init__(
self,
**kwargs
):
super(UsagesResult, self).__init__(**kwargs)
self.value = None
[docs]class VirtualNetworkRule(msrest.serialization.Model):
"""Virtual Network ACL Rule object.
:param id: Resource ID of a subnet, for example:
/subscriptions/{subscriptionId}/resourceGroups/{groupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}.
:type id: str
:param ignore_missing_v_net_service_endpoint: Create firewall rule before the virtual network
has vnet service endpoint enabled.
:type ignore_missing_v_net_service_endpoint: bool
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'ignore_missing_v_net_service_endpoint': {'key': 'ignoreMissingVNetServiceEndpoint', 'type': 'bool'},
}
def __init__(
self,
*,
id: Optional[str] = None,
ignore_missing_v_net_service_endpoint: Optional[bool] = None,
**kwargs
):
super(VirtualNetworkRule, self).__init__(**kwargs)
self.id = id
self.ignore_missing_v_net_service_endpoint = ignore_missing_v_net_service_endpoint