recoveryservices/models/_models.py

# 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.
# --------------------------------------------------------------------------

import msrest.serialization


class CertificateRequest(msrest.serialization.Model):
    """Details of the certificate to be uploaded to the vault.

    :param properties: Raw certificate data.
    :type properties: ~azure.mgmt.recoveryservices.models.RawCertificateData
    """

    _attribute_map = {
        'properties': {'key': 'properties', 'type': 'RawCertificateData'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(CertificateRequest, self).__init__(**kwargs)
        self.properties = kwargs.get('properties', None)


class CheckNameAvailabilityParameters(msrest.serialization.Model):
    """Resource Name availability input parameters - Resource type and resource name.

    :param type: Describes the Resource type: Microsoft.RecoveryServices/Vaults.
    :type type: str
    :param name: Resource name for which availability needs to be checked.
    :type name: str
    """

    _attribute_map = {
        'type': {'key': 'type', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(CheckNameAvailabilityParameters, self).__init__(**kwargs)
        self.type = kwargs.get('type', None)
        self.name = kwargs.get('name', None)


class CheckNameAvailabilityResult(msrest.serialization.Model):
    """Response for check name availability API. Resource provider will set availability as true | false.

    :param name_available:
    :type name_available: bool
    :param reason:
    :type reason: str
    :param message:
    :type message: str
    """

    _attribute_map = {
        'name_available': {'key': 'nameAvailable', 'type': 'bool'},
        'reason': {'key': 'reason', 'type': 'str'},
        'message': {'key': 'message', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(CheckNameAvailabilityResult, self).__init__(**kwargs)
        self.name_available = kwargs.get('name_available', None)
        self.reason = kwargs.get('reason', None)
        self.message = kwargs.get('message', None)


class ClientDiscoveryDisplay(msrest.serialization.Model):
    """Localized display information of an operation.

    :param provider: Name of the provider for display purposes.
    :type provider: str
    :param resource: ResourceType for which this Operation can be performed.
    :type resource: str
    :param operation: Operations Name itself.
    :type operation: str
    :param description: Description of the operation having details of what operation is about.
    :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,
        **kwargs
    ):
        super(ClientDiscoveryDisplay, self).__init__(**kwargs)
        self.provider = kwargs.get('provider', None)
        self.resource = kwargs.get('resource', None)
        self.operation = kwargs.get('operation', None)
        self.description = kwargs.get('description', None)


class ClientDiscoveryForLogSpecification(msrest.serialization.Model):
    """Class to represent shoebox log specification in json client discovery.

    :param name: Name of the log.
    :type name: str
    :param display_name: Localized display name.
    :type display_name: str
    :param blob_duration: Blobs created in customer storage account per hour.
    :type blob_duration: str
    """

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'display_name': {'key': 'displayName', 'type': 'str'},
        'blob_duration': {'key': 'blobDuration', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ClientDiscoveryForLogSpecification, self).__init__(**kwargs)
        self.name = kwargs.get('name', None)
        self.display_name = kwargs.get('display_name', None)
        self.blob_duration = kwargs.get('blob_duration', None)


class ClientDiscoveryForProperties(msrest.serialization.Model):
    """Class to represent shoebox properties in json client discovery.

    :param service_specification: Operation properties.
    :type service_specification:
     ~azure.mgmt.recoveryservices.models.ClientDiscoveryForServiceSpecification
    """

    _attribute_map = {
        'service_specification': {'key': 'serviceSpecification', 'type': 'ClientDiscoveryForServiceSpecification'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ClientDiscoveryForProperties, self).__init__(**kwargs)
        self.service_specification = kwargs.get('service_specification', None)


class ClientDiscoveryForServiceSpecification(msrest.serialization.Model):
    """Class to represent shoebox service specification in json client discovery.

    :param log_specifications: List of log specifications of this operation.
    :type log_specifications:
     list[~azure.mgmt.recoveryservices.models.ClientDiscoveryForLogSpecification]
    """

    _attribute_map = {
        'log_specifications': {'key': 'logSpecifications', 'type': '[ClientDiscoveryForLogSpecification]'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ClientDiscoveryForServiceSpecification, self).__init__(**kwargs)
        self.log_specifications = kwargs.get('log_specifications', None)


class ClientDiscoveryResponse(msrest.serialization.Model):
    """Operations List response which contains list of available APIs.

    :param value: List of available operations.
    :type value: list[~azure.mgmt.recoveryservices.models.ClientDiscoveryValueForSingleApi]
    :param next_link: Link to the next chunk of the response.
    :type next_link: str
    """

    _attribute_map = {
        'value': {'key': 'value', 'type': '[ClientDiscoveryValueForSingleApi]'},
        'next_link': {'key': 'nextLink', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ClientDiscoveryResponse, self).__init__(**kwargs)
        self.value = kwargs.get('value', None)
        self.next_link = kwargs.get('next_link', None)


class ClientDiscoveryValueForSingleApi(msrest.serialization.Model):
    """Available operation details.

    :param name: Name of the Operation.
    :type name: str
    :param display: Contains the localized display information for this particular operation.
    :type display: ~azure.mgmt.recoveryservices.models.ClientDiscoveryDisplay
    :param origin: The intended executor of the operation;governs the display of the operation in
     the RBAC UX and the audit logs UX.
    :type origin: str
    :param properties: ShoeBox properties for the given operation.
    :type properties: ~azure.mgmt.recoveryservices.models.ClientDiscoveryForProperties
    """

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'display': {'key': 'display', 'type': 'ClientDiscoveryDisplay'},
        'origin': {'key': 'origin', 'type': 'str'},
        'properties': {'key': 'properties', 'type': 'ClientDiscoveryForProperties'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ClientDiscoveryValueForSingleApi, self).__init__(**kwargs)
        self.name = kwargs.get('name', None)
        self.display = kwargs.get('display', None)
        self.origin = kwargs.get('origin', None)
        self.properties = kwargs.get('properties', None)


class CmkKekIdentity(msrest.serialization.Model):
    """The details of the identity used for CMK.

    :param use_system_assigned_identity: Indicate that system assigned identity should be used.
     Mutually exclusive with 'userAssignedIdentity' field.
    :type use_system_assigned_identity: bool
    :param user_assigned_identity: The user assigned identity to be used to grant permissions in
     case the type of identity used is UserAssigned.
    :type user_assigned_identity: str
    """

    _attribute_map = {
        'use_system_assigned_identity': {'key': 'useSystemAssignedIdentity', 'type': 'bool'},
        'user_assigned_identity': {'key': 'userAssignedIdentity', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(CmkKekIdentity, self).__init__(**kwargs)
        self.use_system_assigned_identity = kwargs.get('use_system_assigned_identity', None)
        self.user_assigned_identity = kwargs.get('user_assigned_identity', None)


class CmkKeyVaultProperties(msrest.serialization.Model):
    """The properties of the Key Vault which hosts CMK.

    :param key_uri: The key uri of the Customer Managed Key.
    :type key_uri: str
    """

    _attribute_map = {
        'key_uri': {'key': 'keyUri', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(CmkKeyVaultProperties, self).__init__(**kwargs)
        self.key_uri = kwargs.get('key_uri', None)


class Error(msrest.serialization.Model):
    """The resource management error response.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar additional_info: The error additional info.
    :vartype additional_info: list[~azure.mgmt.recoveryservices.models.ErrorAdditionalInfo]
    :ivar code: The error code.
    :vartype code: str
    :ivar details: The error details.
    :vartype details: list[~azure.mgmt.recoveryservices.models.Error]
    :ivar message: The error message.
    :vartype message: str
    :ivar target: The error target.
    :vartype target: str
    """

    _validation = {
        'additional_info': {'readonly': True},
        'code': {'readonly': True},
        'details': {'readonly': True},
        'message': {'readonly': True},
        'target': {'readonly': True},
    }

    _attribute_map = {
        'additional_info': {'key': 'additionalInfo', 'type': '[ErrorAdditionalInfo]'},
        'code': {'key': 'code', 'type': 'str'},
        'details': {'key': 'details', 'type': '[Error]'},
        'message': {'key': 'message', 'type': 'str'},
        'target': {'key': 'target', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Error, self).__init__(**kwargs)
        self.additional_info = None
        self.code = None
        self.details = None
        self.message = None
        self.target = None


class ErrorAdditionalInfo(msrest.serialization.Model):
    """The resource management error additional info.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar info: The additional info.
    :vartype info: any
    :ivar type: The additional info type.
    :vartype type: str
    """

    _validation = {
        'info': {'readonly': True},
        'type': {'readonly': True},
    }

    _attribute_map = {
        'info': {'key': 'info', 'type': 'object'},
        'type': {'key': 'type', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ErrorAdditionalInfo, self).__init__(**kwargs)
        self.info = None
        self.type = None


class IdentityData(msrest.serialization.Model):
    """Identity for the resource.

    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 principal_id: The principal ID of resource identity.
    :vartype principal_id: str
    :ivar tenant_id: The tenant ID of resource.
    :vartype tenant_id: str
    :param type: Required. The type of managed identity used. The type 'SystemAssigned,
     UserAssigned' includes both an implicitly created identity and a set of user-assigned
     identities. The type 'None' will remove any identities. Possible values include:
     "SystemAssigned", "None", "UserAssigned", "SystemAssigned, UserAssigned".
    :type type: str or ~azure.mgmt.recoveryservices.models.ResourceIdentityType
    :param user_assigned_identities: The list of user-assigned identities associated with the
     resource. The user-assigned identity dictionary keys will be ARM resource ids in the form:
     '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
    :type user_assigned_identities: dict[str, ~azure.mgmt.recoveryservices.models.UserIdentity]
    """

    _validation = {
        'principal_id': {'readonly': True},
        'tenant_id': {'readonly': True},
        'type': {'required': True},
    }

    _attribute_map = {
        'principal_id': {'key': 'principalId', 'type': 'str'},
        'tenant_id': {'key': 'tenantId', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'user_assigned_identities': {'key': 'userAssignedIdentities', 'type': '{UserIdentity}'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(IdentityData, self).__init__(**kwargs)
        self.principal_id = None
        self.tenant_id = None
        self.type = kwargs['type']
        self.user_assigned_identities = kwargs.get('user_assigned_identities', None)


class JobsSummary(msrest.serialization.Model):
    """Summary of the replication job data for this vault.

    :param failed_jobs: Count of failed jobs.
    :type failed_jobs: int
    :param suspended_jobs: Count of suspended jobs.
    :type suspended_jobs: int
    :param in_progress_jobs: Count of in-progress jobs.
    :type in_progress_jobs: int
    """

    _attribute_map = {
        'failed_jobs': {'key': 'failedJobs', 'type': 'int'},
        'suspended_jobs': {'key': 'suspendedJobs', 'type': 'int'},
        'in_progress_jobs': {'key': 'inProgressJobs', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(JobsSummary, self).__init__(**kwargs)
        self.failed_jobs = kwargs.get('failed_jobs', None)
        self.suspended_jobs = kwargs.get('suspended_jobs', None)
        self.in_progress_jobs = kwargs.get('in_progress_jobs', None)


class MonitoringSummary(msrest.serialization.Model):
    """Summary of the replication monitoring data for this vault.

    :param un_healthy_vm_count: Count of unhealthy VMs.
    :type un_healthy_vm_count: int
    :param un_healthy_provider_count: Count of unhealthy replication providers.
    :type un_healthy_provider_count: int
    :param events_count: Count of all critical warnings.
    :type events_count: int
    :param deprecated_provider_count: Count of all deprecated recovery service providers.
    :type deprecated_provider_count: int
    :param supported_provider_count: Count of all the supported recovery service providers.
    :type supported_provider_count: int
    :param unsupported_provider_count: Count of all the unsupported recovery service providers.
    :type unsupported_provider_count: int
    """

    _attribute_map = {
        'un_healthy_vm_count': {'key': 'unHealthyVmCount', 'type': 'int'},
        'un_healthy_provider_count': {'key': 'unHealthyProviderCount', 'type': 'int'},
        'events_count': {'key': 'eventsCount', 'type': 'int'},
        'deprecated_provider_count': {'key': 'deprecatedProviderCount', 'type': 'int'},
        'supported_provider_count': {'key': 'supportedProviderCount', 'type': 'int'},
        'unsupported_provider_count': {'key': 'unsupportedProviderCount', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(MonitoringSummary, self).__init__(**kwargs)
        self.un_healthy_vm_count = kwargs.get('un_healthy_vm_count', None)
        self.un_healthy_provider_count = kwargs.get('un_healthy_provider_count', None)
        self.events_count = kwargs.get('events_count', None)
        self.deprecated_provider_count = kwargs.get('deprecated_provider_count', None)
        self.supported_provider_count = kwargs.get('supported_provider_count', None)
        self.unsupported_provider_count = kwargs.get('unsupported_provider_count', None)


class NameInfo(msrest.serialization.Model):
    """The name of usage.

    :param value: Value of usage.
    :type value: str
    :param localized_value: Localized value of usage.
    :type localized_value: str
    """

    _attribute_map = {
        'value': {'key': 'value', 'type': 'str'},
        'localized_value': {'key': 'localizedValue', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(NameInfo, self).__init__(**kwargs)
        self.value = kwargs.get('value', None)
        self.localized_value = kwargs.get('localized_value', None)


class OperationResource(msrest.serialization.Model):
    """Operation Resource.

    :param end_time: End time of the operation.
    :type end_time: ~datetime.datetime
    :param error: Required if status == failed or status == canceled. This is the OData v4 error
     format, used by the RPC and will go into the v2.2 Azure REST API guidelines.
    :type error: ~azure.mgmt.recoveryservices.models.Error
    :param id: It should match what is used to GET the operation result.
    :type id: str
    :param name: It must match the last segment of the "id" field, and will typically be a GUID /
     system generated value.
    :type name: str
    :param status: The status of the operation. (InProgress/Success/Failed/Cancelled).
    :type status: str
    :param start_time: Start time of the operation.
    :type start_time: ~datetime.datetime
    """

    _attribute_map = {
        'end_time': {'key': 'endTime', 'type': 'iso-8601'},
        'error': {'key': 'error', 'type': 'Error'},
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'status': {'key': 'status', 'type': 'str'},
        'start_time': {'key': 'startTime', 'type': 'iso-8601'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(OperationResource, self).__init__(**kwargs)
        self.end_time = kwargs.get('end_time', None)
        self.error = kwargs.get('error', None)
        self.id = kwargs.get('id', None)
        self.name = kwargs.get('name', None)
        self.status = kwargs.get('status', None)
        self.start_time = kwargs.get('start_time', None)


class Resource(msrest.serialization.Model):
    """ARM Resource.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar id: Resource Id represents the complete path to the resource.
    :vartype id: str
    :ivar name: Resource name associated with the resource.
    :vartype name: str
    :ivar type: Resource type represents the complete path of the form
     Namespace/ResourceType/ResourceType/...
    :vartype type: str
    :param etag: Optional ETag.
    :type etag: 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'},
        'etag': {'key': 'etag', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Resource, self).__init__(**kwargs)
        self.id = None
        self.name = None
        self.type = None
        self.etag = kwargs.get('etag', None)


class PatchTrackedResource(Resource):
    """Tracked resource with location.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar id: Resource Id represents the complete path to the resource.
    :vartype id: str
    :ivar name: Resource name associated with the resource.
    :vartype name: str
    :ivar type: Resource type represents the complete path of the form
     Namespace/ResourceType/ResourceType/...
    :vartype type: str
    :param etag: Optional ETag.
    :type etag: str
    :param location: Resource location.
    :type location: str
    :param tags: A set of tags. Resource tags.
    :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'},
        'etag': {'key': 'etag', 'type': 'str'},
        'location': {'key': 'location', 'type': 'str'},
        'tags': {'key': 'tags', 'type': '{str}'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(PatchTrackedResource, self).__init__(**kwargs)
        self.location = kwargs.get('location', None)
        self.tags = kwargs.get('tags', None)


class PatchVault(PatchTrackedResource):
    """Patch Resource information, as returned by the resource provider.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar id: Resource Id represents the complete path to the resource.
    :vartype id: str
    :ivar name: Resource name associated with the resource.
    :vartype name: str
    :ivar type: Resource type represents the complete path of the form
     Namespace/ResourceType/ResourceType/...
    :vartype type: str
    :param etag: Optional ETag.
    :type etag: str
    :param location: Resource location.
    :type location: str
    :param tags: A set of tags. Resource tags.
    :type tags: dict[str, str]
    :param properties: Properties of the vault.
    :type properties: ~azure.mgmt.recoveryservices.models.VaultProperties
    :param sku: Identifies the unique system identifier for each Azure resource.
    :type sku: ~azure.mgmt.recoveryservices.models.Sku
    :param identity: Identity for the resource.
    :type identity: ~azure.mgmt.recoveryservices.models.IdentityData
    """

    _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'},
        'etag': {'key': 'etag', 'type': 'str'},
        'location': {'key': 'location', 'type': 'str'},
        'tags': {'key': 'tags', 'type': '{str}'},
        'properties': {'key': 'properties', 'type': 'VaultProperties'},
        'sku': {'key': 'sku', 'type': 'Sku'},
        'identity': {'key': 'identity', 'type': 'IdentityData'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(PatchVault, self).__init__(**kwargs)
        self.properties = kwargs.get('properties', None)
        self.sku = kwargs.get('sku', None)
        self.identity = kwargs.get('identity', None)


class PrivateEndpoint(msrest.serialization.Model):
    """The Private Endpoint network resource that is linked to the Private Endpoint connection.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar id: Gets or sets id.
    :vartype id: str
    """

    _validation = {
        'id': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(PrivateEndpoint, self).__init__(**kwargs)
        self.id = None


class PrivateEndpointConnection(msrest.serialization.Model):
    """Private Endpoint Connection Response Properties.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar provisioning_state: Gets or sets provisioning state of the private endpoint connection.
     Possible values include: "Succeeded", "Deleting", "Failed", "Pending".
    :vartype provisioning_state: str or ~azure.mgmt.recoveryservices.models.ProvisioningState
    :ivar private_endpoint: The Private Endpoint network resource that is linked to the Private
     Endpoint connection.
    :vartype private_endpoint: ~azure.mgmt.recoveryservices.models.PrivateEndpoint
    :ivar private_link_service_connection_state: Gets or sets private link service connection
     state.
    :vartype private_link_service_connection_state:
     ~azure.mgmt.recoveryservices.models.PrivateLinkServiceConnectionState
    """

    _validation = {
        'provisioning_state': {'readonly': True},
        'private_endpoint': {'readonly': True},
        'private_link_service_connection_state': {'readonly': True},
    }

    _attribute_map = {
        'provisioning_state': {'key': 'provisioningState', 'type': 'str'},
        'private_endpoint': {'key': 'privateEndpoint', 'type': 'PrivateEndpoint'},
        'private_link_service_connection_state': {'key': 'privateLinkServiceConnectionState', 'type': 'PrivateLinkServiceConnectionState'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(PrivateEndpointConnection, self).__init__(**kwargs)
        self.provisioning_state = None
        self.private_endpoint = None
        self.private_link_service_connection_state = None


class PrivateEndpointConnectionVaultProperties(msrest.serialization.Model):
    """Information to be stored in Vault properties as an element of privateEndpointConnections List.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar id: Format of id
     subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.[Service]/{resource}/{resourceName}/privateEndpointConnections/{connectionName}.
    :vartype id: str
    :ivar properties: Private Endpoint Connection Response Properties.
    :vartype properties: ~azure.mgmt.recoveryservices.models.PrivateEndpointConnection
    """

    _validation = {
        'id': {'readonly': True},
        'properties': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'properties': {'key': 'properties', 'type': 'PrivateEndpointConnection'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(PrivateEndpointConnectionVaultProperties, self).__init__(**kwargs)
        self.id = None
        self.properties = None


class PrivateLinkResource(msrest.serialization.Model):
    """Information of the private link resource.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar id: Fully qualified identifier of the resource.
    :vartype id: str
    :ivar name: Name of the resource.
    :vartype name: str
    :ivar type: e.g. Microsoft.RecoveryServices/vaults/privateLinkResources.
    :vartype type: str
    :ivar group_id: e.g. f9ad6492-33d4-4690-9999-6bfd52a0d081 (Backup) or
     f9ad6492-33d4-4690-9999-6bfd52a0d082 (SiteRecovery).
    :vartype group_id: str
    :ivar required_members: [backup-ecs1, backup-prot1, backup-prot1b, backup-prot1c, backup-id1].
    :vartype required_members: list[str]
    :ivar required_zone_names: The private link resource Private link DNS zone name.
    :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.id = None
        self.name = None
        self.type = None
        self.group_id = None
        self.required_members = None
        self.required_zone_names = None


class PrivateLinkResources(msrest.serialization.Model):
    """Class which represent the stamps associated with the vault.

    :param value: A collection of private link resources.
    :type value: list[~azure.mgmt.recoveryservices.models.PrivateLinkResource]
    :param next_link: Link to the next chunk of the response.
    :type next_link: str
    """

    _attribute_map = {
        'value': {'key': 'value', 'type': '[PrivateLinkResource]'},
        'next_link': {'key': 'nextLink', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(PrivateLinkResources, self).__init__(**kwargs)
        self.value = kwargs.get('value', None)
        self.next_link = kwargs.get('next_link', None)


class PrivateLinkServiceConnectionState(msrest.serialization.Model):
    """Gets or sets private link service connection state.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar status: Gets or sets the status. Possible values include: "Pending", "Approved",
     "Rejected", "Disconnected".
    :vartype status: str or ~azure.mgmt.recoveryservices.models.PrivateEndpointConnectionStatus
    :ivar description: Gets or sets description.
    :vartype description: str
    :ivar actions_required: Gets or sets actions required.
    :vartype actions_required: str
    """

    _validation = {
        'status': {'readonly': True},
        'description': {'readonly': True},
        '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,
        **kwargs
    ):
        super(PrivateLinkServiceConnectionState, self).__init__(**kwargs)
        self.status = None
        self.description = None
        self.actions_required = None


class RawCertificateData(msrest.serialization.Model):
    """Raw certificate data.

    :param auth_type: Specifies the authentication type. Possible values include: "Invalid", "ACS",
     "AAD", "AccessControlService", "AzureActiveDirectory".
    :type auth_type: str or ~azure.mgmt.recoveryservices.models.AuthType
    :param certificate: The base64 encoded certificate raw data string.
    :type certificate: bytearray
    """

    _attribute_map = {
        'auth_type': {'key': 'authType', 'type': 'str'},
        'certificate': {'key': 'certificate', 'type': 'bytearray'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(RawCertificateData, self).__init__(**kwargs)
        self.auth_type = kwargs.get('auth_type', None)
        self.certificate = kwargs.get('certificate', None)


class ReplicationUsage(msrest.serialization.Model):
    """Replication usages of a vault.

    :param monitoring_summary: Summary of the replication monitoring data for this vault.
    :type monitoring_summary: ~azure.mgmt.recoveryservices.models.MonitoringSummary
    :param jobs_summary: Summary of the replication jobs data for this vault.
    :type jobs_summary: ~azure.mgmt.recoveryservices.models.JobsSummary
    :param protected_item_count: Number of replication protected items for this vault.
    :type protected_item_count: int
    :param recovery_plan_count: Number of replication recovery plans for this vault.
    :type recovery_plan_count: int
    :param registered_servers_count: Number of servers registered to this vault.
    :type registered_servers_count: int
    :param recovery_services_provider_auth_type: The authentication type of recovery service
     providers in the vault.
    :type recovery_services_provider_auth_type: int
    """

    _attribute_map = {
        'monitoring_summary': {'key': 'monitoringSummary', 'type': 'MonitoringSummary'},
        'jobs_summary': {'key': 'jobsSummary', 'type': 'JobsSummary'},
        'protected_item_count': {'key': 'protectedItemCount', 'type': 'int'},
        'recovery_plan_count': {'key': 'recoveryPlanCount', 'type': 'int'},
        'registered_servers_count': {'key': 'registeredServersCount', 'type': 'int'},
        'recovery_services_provider_auth_type': {'key': 'recoveryServicesProviderAuthType', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ReplicationUsage, self).__init__(**kwargs)
        self.monitoring_summary = kwargs.get('monitoring_summary', None)
        self.jobs_summary = kwargs.get('jobs_summary', None)
        self.protected_item_count = kwargs.get('protected_item_count', None)
        self.recovery_plan_count = kwargs.get('recovery_plan_count', None)
        self.registered_servers_count = kwargs.get('registered_servers_count', None)
        self.recovery_services_provider_auth_type = kwargs.get('recovery_services_provider_auth_type', None)


class ReplicationUsageList(msrest.serialization.Model):
    """Replication usages for vault.

    :param value: The list of replication usages for the given vault.
    :type value: list[~azure.mgmt.recoveryservices.models.ReplicationUsage]
    """

    _attribute_map = {
        'value': {'key': 'value', 'type': '[ReplicationUsage]'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ReplicationUsageList, self).__init__(**kwargs)
        self.value = kwargs.get('value', None)


class ResourceCertificateDetails(msrest.serialization.Model):
    """Certificate details representing the Vault credentials.

    You probably want to use the sub-classes and not this class directly. Known
    sub-classes are: ResourceCertificateAndAcsDetails, ResourceCertificateAndAadDetails.

    All required parameters must be populated in order to send to Azure.

    :param auth_type: Required. This property will be used as the discriminator for deciding the
     specific types in the polymorphic chain of types.Constant filled by server.
    :type auth_type: str
    :param certificate: The base64 encoded certificate raw data string.
    :type certificate: bytearray
    :param friendly_name: Certificate friendly name.
    :type friendly_name: str
    :param issuer: Certificate issuer.
    :type issuer: str
    :param resource_id: Resource ID of the vault.
    :type resource_id: long
    :param subject: Certificate Subject Name.
    :type subject: str
    :param thumbprint: Certificate thumbprint.
    :type thumbprint: str
    :param valid_from: Certificate Validity start Date time.
    :type valid_from: ~datetime.datetime
    :param valid_to: Certificate Validity End Date time.
    :type valid_to: ~datetime.datetime
    """

    _validation = {
        'auth_type': {'required': True},
    }

    _attribute_map = {
        'auth_type': {'key': 'authType', 'type': 'str'},
        'certificate': {'key': 'certificate', 'type': 'bytearray'},
        'friendly_name': {'key': 'friendlyName', 'type': 'str'},
        'issuer': {'key': 'issuer', 'type': 'str'},
        'resource_id': {'key': 'resourceId', 'type': 'long'},
        'subject': {'key': 'subject', 'type': 'str'},
        'thumbprint': {'key': 'thumbprint', 'type': 'str'},
        'valid_from': {'key': 'validFrom', 'type': 'iso-8601'},
        'valid_to': {'key': 'validTo', 'type': 'iso-8601'},
    }

    _subtype_map = {
        'auth_type': {'AccessControlService': 'ResourceCertificateAndAcsDetails', 'AzureActiveDirectory': 'ResourceCertificateAndAadDetails'}
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ResourceCertificateDetails, self).__init__(**kwargs)
        self.auth_type = None  # type: Optional[str]
        self.certificate = kwargs.get('certificate', None)
        self.friendly_name = kwargs.get('friendly_name', None)
        self.issuer = kwargs.get('issuer', None)
        self.resource_id = kwargs.get('resource_id', None)
        self.subject = kwargs.get('subject', None)
        self.thumbprint = kwargs.get('thumbprint', None)
        self.valid_from = kwargs.get('valid_from', None)
        self.valid_to = kwargs.get('valid_to', None)


class ResourceCertificateAndAadDetails(ResourceCertificateDetails):
    """Certificate details representing the Vault credentials for AAD.

    All required parameters must be populated in order to send to Azure.

    :param auth_type: Required. This property will be used as the discriminator for deciding the
     specific types in the polymorphic chain of types.Constant filled by server.
    :type auth_type: str
    :param certificate: The base64 encoded certificate raw data string.
    :type certificate: bytearray
    :param friendly_name: Certificate friendly name.
    :type friendly_name: str
    :param issuer: Certificate issuer.
    :type issuer: str
    :param resource_id: Resource ID of the vault.
    :type resource_id: long
    :param subject: Certificate Subject Name.
    :type subject: str
    :param thumbprint: Certificate thumbprint.
    :type thumbprint: str
    :param valid_from: Certificate Validity start Date time.
    :type valid_from: ~datetime.datetime
    :param valid_to: Certificate Validity End Date time.
    :type valid_to: ~datetime.datetime
    :param aad_authority: Required. AAD tenant authority.
    :type aad_authority: str
    :param aad_tenant_id: Required. AAD tenant Id.
    :type aad_tenant_id: str
    :param service_principal_client_id: Required. AAD service principal clientId.
    :type service_principal_client_id: str
    :param service_principal_object_id: Required. AAD service principal ObjectId.
    :type service_principal_object_id: str
    :param azure_management_endpoint_audience: Required. Azure Management Endpoint Audience.
    :type azure_management_endpoint_audience: str
    :param service_resource_id: Service Resource Id.
    :type service_resource_id: str
    """

    _validation = {
        'auth_type': {'required': True},
        'aad_authority': {'required': True},
        'aad_tenant_id': {'required': True},
        'service_principal_client_id': {'required': True},
        'service_principal_object_id': {'required': True},
        'azure_management_endpoint_audience': {'required': True},
    }

    _attribute_map = {
        'auth_type': {'key': 'authType', 'type': 'str'},
        'certificate': {'key': 'certificate', 'type': 'bytearray'},
        'friendly_name': {'key': 'friendlyName', 'type': 'str'},
        'issuer': {'key': 'issuer', 'type': 'str'},
        'resource_id': {'key': 'resourceId', 'type': 'long'},
        'subject': {'key': 'subject', 'type': 'str'},
        'thumbprint': {'key': 'thumbprint', 'type': 'str'},
        'valid_from': {'key': 'validFrom', 'type': 'iso-8601'},
        'valid_to': {'key': 'validTo', 'type': 'iso-8601'},
        'aad_authority': {'key': 'aadAuthority', 'type': 'str'},
        'aad_tenant_id': {'key': 'aadTenantId', 'type': 'str'},
        'service_principal_client_id': {'key': 'servicePrincipalClientId', 'type': 'str'},
        'service_principal_object_id': {'key': 'servicePrincipalObjectId', 'type': 'str'},
        'azure_management_endpoint_audience': {'key': 'azureManagementEndpointAudience', 'type': 'str'},
        'service_resource_id': {'key': 'serviceResourceId', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ResourceCertificateAndAadDetails, self).__init__(**kwargs)
        self.auth_type = 'AzureActiveDirectory'  # type: str
        self.aad_authority = kwargs['aad_authority']
        self.aad_tenant_id = kwargs['aad_tenant_id']
        self.service_principal_client_id = kwargs['service_principal_client_id']
        self.service_principal_object_id = kwargs['service_principal_object_id']
        self.azure_management_endpoint_audience = kwargs['azure_management_endpoint_audience']
        self.service_resource_id = kwargs.get('service_resource_id', None)


class ResourceCertificateAndAcsDetails(ResourceCertificateDetails):
    """Certificate details representing the Vault credentials for ACS.

    All required parameters must be populated in order to send to Azure.

    :param auth_type: Required. This property will be used as the discriminator for deciding the
     specific types in the polymorphic chain of types.Constant filled by server.
    :type auth_type: str
    :param certificate: The base64 encoded certificate raw data string.
    :type certificate: bytearray
    :param friendly_name: Certificate friendly name.
    :type friendly_name: str
    :param issuer: Certificate issuer.
    :type issuer: str
    :param resource_id: Resource ID of the vault.
    :type resource_id: long
    :param subject: Certificate Subject Name.
    :type subject: str
    :param thumbprint: Certificate thumbprint.
    :type thumbprint: str
    :param valid_from: Certificate Validity start Date time.
    :type valid_from: ~datetime.datetime
    :param valid_to: Certificate Validity End Date time.
    :type valid_to: ~datetime.datetime
    :param global_acs_namespace: Required. ACS namespace name - tenant for our service.
    :type global_acs_namespace: str
    :param global_acs_host_name: Required. Acs mgmt host name to connect to.
    :type global_acs_host_name: str
    :param global_acs_rp_realm: Required. Global ACS namespace RP realm.
    :type global_acs_rp_realm: str
    """

    _validation = {
        'auth_type': {'required': True},
        'global_acs_namespace': {'required': True},
        'global_acs_host_name': {'required': True},
        'global_acs_rp_realm': {'required': True},
    }

    _attribute_map = {
        'auth_type': {'key': 'authType', 'type': 'str'},
        'certificate': {'key': 'certificate', 'type': 'bytearray'},
        'friendly_name': {'key': 'friendlyName', 'type': 'str'},
        'issuer': {'key': 'issuer', 'type': 'str'},
        'resource_id': {'key': 'resourceId', 'type': 'long'},
        'subject': {'key': 'subject', 'type': 'str'},
        'thumbprint': {'key': 'thumbprint', 'type': 'str'},
        'valid_from': {'key': 'validFrom', 'type': 'iso-8601'},
        'valid_to': {'key': 'validTo', 'type': 'iso-8601'},
        'global_acs_namespace': {'key': 'globalAcsNamespace', 'type': 'str'},
        'global_acs_host_name': {'key': 'globalAcsHostName', 'type': 'str'},
        'global_acs_rp_realm': {'key': 'globalAcsRPRealm', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ResourceCertificateAndAcsDetails, self).__init__(**kwargs)
        self.auth_type = 'AccessControlService'  # type: str
        self.global_acs_namespace = kwargs['global_acs_namespace']
        self.global_acs_host_name = kwargs['global_acs_host_name']
        self.global_acs_rp_realm = kwargs['global_acs_rp_realm']


class Sku(msrest.serialization.Model):
    """Identifies the unique system identifier for each Azure resource.

    All required parameters must be populated in order to send to Azure.

    :param name: Required. The Sku name. Possible values include: "Standard", "RS0".
    :type name: str or ~azure.mgmt.recoveryservices.models.SkuName
    :param tier: The Sku tier.
    :type tier: str
    """

    _validation = {
        'name': {'required': True},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'tier': {'key': 'tier', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Sku, self).__init__(**kwargs)
        self.name = kwargs['name']
        self.tier = kwargs.get('tier', None)


class SystemData(msrest.serialization.Model):
    """Metadata pertaining to creation and last modification of the resource.

    :param created_by: The identity that created the resource.
    :type created_by: str
    :param created_by_type: The type of identity that created the resource. Possible values
     include: "User", "Application", "ManagedIdentity", "Key".
    :type created_by_type: str or ~azure.mgmt.recoveryservices.models.CreatedByType
    :param created_at: The timestamp of resource creation (UTC).
    :type created_at: ~datetime.datetime
    :param last_modified_by: The identity that last modified the resource.
    :type last_modified_by: str
    :param last_modified_by_type: The type of identity that last modified the resource. Possible
     values include: "User", "Application", "ManagedIdentity", "Key".
    :type last_modified_by_type: str or ~azure.mgmt.recoveryservices.models.CreatedByType
    :param last_modified_at: The type of identity that last modified the resource.
    :type last_modified_at: ~datetime.datetime
    """

    _attribute_map = {
        'created_by': {'key': 'createdBy', 'type': 'str'},
        'created_by_type': {'key': 'createdByType', 'type': 'str'},
        'created_at': {'key': 'createdAt', 'type': 'iso-8601'},
        'last_modified_by': {'key': 'lastModifiedBy', 'type': 'str'},
        'last_modified_by_type': {'key': 'lastModifiedByType', 'type': 'str'},
        'last_modified_at': {'key': 'lastModifiedAt', 'type': 'iso-8601'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(SystemData, self).__init__(**kwargs)
        self.created_by = kwargs.get('created_by', None)
        self.created_by_type = kwargs.get('created_by_type', None)
        self.created_at = kwargs.get('created_at', None)
        self.last_modified_by = kwargs.get('last_modified_by', None)
        self.last_modified_by_type = kwargs.get('last_modified_by_type', None)
        self.last_modified_at = kwargs.get('last_modified_at', None)


class TrackedResource(Resource):
    """Tracked resource with location.

    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: Resource Id represents the complete path to the resource.
    :vartype id: str
    :ivar name: Resource name associated with the resource.
    :vartype name: str
    :ivar type: Resource type represents the complete path of the form
     Namespace/ResourceType/ResourceType/...
    :vartype type: str
    :param etag: Optional ETag.
    :type etag: str
    :param location: Required. Resource location.
    :type location: str
    :param tags: A set of tags. Resource tags.
    :type tags: dict[str, str]
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'location': {'required': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'etag': {'key': 'etag', 'type': 'str'},
        'location': {'key': 'location', 'type': 'str'},
        'tags': {'key': 'tags', 'type': '{str}'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(TrackedResource, self).__init__(**kwargs)
        self.location = kwargs['location']
        self.tags = kwargs.get('tags', None)


class UpgradeDetails(msrest.serialization.Model):
    """Details for upgrading vault.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar operation_id: ID of the vault upgrade operation.
    :vartype operation_id: str
    :ivar start_time_utc: UTC time at which the upgrade operation has started.
    :vartype start_time_utc: ~datetime.datetime
    :ivar last_updated_time_utc: UTC time at which the upgrade operation status was last updated.
    :vartype last_updated_time_utc: ~datetime.datetime
    :ivar end_time_utc: UTC time at which the upgrade operation has ended.
    :vartype end_time_utc: ~datetime.datetime
    :ivar status: Status of the vault upgrade operation. Possible values include: "Unknown",
     "InProgress", "Upgraded", "Failed".
    :vartype status: str or ~azure.mgmt.recoveryservices.models.VaultUpgradeState
    :ivar message: Message to the user containing information about the upgrade operation.
    :vartype message: str
    :ivar trigger_type: The way the vault upgrade was triggered. Possible values include:
     "UserTriggered", "ForcedUpgrade".
    :vartype trigger_type: str or ~azure.mgmt.recoveryservices.models.TriggerType
    :ivar upgraded_resource_id: Resource ID of the upgraded vault.
    :vartype upgraded_resource_id: str
    :ivar previous_resource_id: Resource ID of the vault before the upgrade.
    :vartype previous_resource_id: str
    """

    _validation = {
        'operation_id': {'readonly': True},
        'start_time_utc': {'readonly': True},
        'last_updated_time_utc': {'readonly': True},
        'end_time_utc': {'readonly': True},
        'status': {'readonly': True},
        'message': {'readonly': True},
        'trigger_type': {'readonly': True},
        'upgraded_resource_id': {'readonly': True},
        'previous_resource_id': {'readonly': True},
    }

    _attribute_map = {
        'operation_id': {'key': 'operationId', 'type': 'str'},
        'start_time_utc': {'key': 'startTimeUtc', 'type': 'iso-8601'},
        'last_updated_time_utc': {'key': 'lastUpdatedTimeUtc', 'type': 'iso-8601'},
        'end_time_utc': {'key': 'endTimeUtc', 'type': 'iso-8601'},
        'status': {'key': 'status', 'type': 'str'},
        'message': {'key': 'message', 'type': 'str'},
        'trigger_type': {'key': 'triggerType', 'type': 'str'},
        'upgraded_resource_id': {'key': 'upgradedResourceId', 'type': 'str'},
        'previous_resource_id': {'key': 'previousResourceId', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(UpgradeDetails, self).__init__(**kwargs)
        self.operation_id = None
        self.start_time_utc = None
        self.last_updated_time_utc = None
        self.end_time_utc = None
        self.status = None
        self.message = None
        self.trigger_type = None
        self.upgraded_resource_id = None
        self.previous_resource_id = None


class UserIdentity(msrest.serialization.Model):
    """A resource identity that is managed by the user of the service.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar principal_id: The principal ID of the user-assigned identity.
    :vartype principal_id: str
    :ivar client_id: The client ID of the user-assigned identity.
    :vartype client_id: str
    """

    _validation = {
        'principal_id': {'readonly': True},
        'client_id': {'readonly': True},
    }

    _attribute_map = {
        'principal_id': {'key': 'principalId', 'type': 'str'},
        'client_id': {'key': 'clientId', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(UserIdentity, self).__init__(**kwargs)
        self.principal_id = None
        self.client_id = None


class Vault(TrackedResource):
    """Resource information, as returned by the resource provider.

    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: Resource Id represents the complete path to the resource.
    :vartype id: str
    :ivar name: Resource name associated with the resource.
    :vartype name: str
    :ivar type: Resource type represents the complete path of the form
     Namespace/ResourceType/ResourceType/...
    :vartype type: str
    :param etag: Optional ETag.
    :type etag: str
    :param location: Required. Resource location.
    :type location: str
    :param tags: A set of tags. Resource tags.
    :type tags: dict[str, str]
    :param identity: Identity for the resource.
    :type identity: ~azure.mgmt.recoveryservices.models.IdentityData
    :param properties: Properties of the vault.
    :type properties: ~azure.mgmt.recoveryservices.models.VaultProperties
    :param sku: Identifies the unique system identifier for each Azure resource.
    :type sku: ~azure.mgmt.recoveryservices.models.Sku
    :ivar system_data: Metadata pertaining to creation and last modification of the resource.
    :vartype system_data: ~azure.mgmt.recoveryservices.models.SystemData
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'location': {'required': True},
        'system_data': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'etag': {'key': 'etag', 'type': 'str'},
        'location': {'key': 'location', 'type': 'str'},
        'tags': {'key': 'tags', 'type': '{str}'},
        'identity': {'key': 'identity', 'type': 'IdentityData'},
        'properties': {'key': 'properties', 'type': 'VaultProperties'},
        'sku': {'key': 'sku', 'type': 'Sku'},
        'system_data': {'key': 'systemData', 'type': 'SystemData'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Vault, self).__init__(**kwargs)
        self.identity = kwargs.get('identity', None)
        self.properties = kwargs.get('properties', None)
        self.sku = kwargs.get('sku', None)
        self.system_data = None


class VaultCertificateResponse(msrest.serialization.Model):
    """Certificate corresponding to a vault that can be used by clients to register themselves with the vault.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar name: Resource name associated with the resource.
    :vartype name: str
    :ivar type: Resource type represents the complete path of the form
     Namespace/ResourceType/ResourceType/...
    :vartype type: str
    :ivar id: Resource Id represents the complete path to the resource.
    :vartype id: str
    :param properties: Certificate details representing the Vault credentials.
    :type properties: ~azure.mgmt.recoveryservices.models.ResourceCertificateDetails
    """

    _validation = {
        'name': {'readonly': True},
        'type': {'readonly': True},
        'id': {'readonly': True},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'id': {'key': 'id', 'type': 'str'},
        'properties': {'key': 'properties', 'type': 'ResourceCertificateDetails'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(VaultCertificateResponse, self).__init__(**kwargs)
        self.name = None
        self.type = None
        self.id = None
        self.properties = kwargs.get('properties', None)


class VaultExtendedInfoResource(Resource):
    """Vault extended information.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar id: Resource Id represents the complete path to the resource.
    :vartype id: str
    :ivar name: Resource name associated with the resource.
    :vartype name: str
    :ivar type: Resource type represents the complete path of the form
     Namespace/ResourceType/ResourceType/...
    :vartype type: str
    :param etag: Optional ETag.
    :type etag: str
    :param integrity_key: Integrity key.
    :type integrity_key: str
    :param encryption_key: Encryption key.
    :type encryption_key: str
    :param encryption_key_thumbprint: Encryption key thumbprint.
    :type encryption_key_thumbprint: str
    :param algorithm: Algorithm for Vault ExtendedInfo.
    :type algorithm: 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'},
        'etag': {'key': 'etag', 'type': 'str'},
        'integrity_key': {'key': 'properties.integrityKey', 'type': 'str'},
        'encryption_key': {'key': 'properties.encryptionKey', 'type': 'str'},
        'encryption_key_thumbprint': {'key': 'properties.encryptionKeyThumbprint', 'type': 'str'},
        'algorithm': {'key': 'properties.algorithm', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(VaultExtendedInfoResource, self).__init__(**kwargs)
        self.integrity_key = kwargs.get('integrity_key', None)
        self.encryption_key = kwargs.get('encryption_key', None)
        self.encryption_key_thumbprint = kwargs.get('encryption_key_thumbprint', None)
        self.algorithm = kwargs.get('algorithm', None)


class VaultList(msrest.serialization.Model):
    """The response model for a list of Vaults.

    Variables are only populated by the server, and will be ignored when sending a request.

    :param value:
    :type value: list[~azure.mgmt.recoveryservices.models.Vault]
    :ivar next_link:
    :vartype next_link: str
    """

    _validation = {
        'next_link': {'readonly': True},
    }

    _attribute_map = {
        'value': {'key': 'value', 'type': '[Vault]'},
        'next_link': {'key': 'nextLink', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(VaultList, self).__init__(**kwargs)
        self.value = kwargs.get('value', None)
        self.next_link = None


class VaultProperties(msrest.serialization.Model):
    """Properties of the vault.

    Variables are only populated by the server, and will be ignored when sending a request.

    :ivar provisioning_state: Provisioning State.
    :vartype provisioning_state: str
    :param upgrade_details: Details for upgrading vault.
    :type upgrade_details: ~azure.mgmt.recoveryservices.models.UpgradeDetails
    :ivar private_endpoint_connections: List of private endpoint connection.
    :vartype private_endpoint_connections:
     list[~azure.mgmt.recoveryservices.models.PrivateEndpointConnectionVaultProperties]
    :ivar private_endpoint_state_for_backup: Private endpoint state for backup. Possible values
     include: "None", "Enabled".
    :vartype private_endpoint_state_for_backup: str or
     ~azure.mgmt.recoveryservices.models.VaultPrivateEndpointState
    :ivar private_endpoint_state_for_site_recovery: Private endpoint state for site recovery.
     Possible values include: "None", "Enabled".
    :vartype private_endpoint_state_for_site_recovery: str or
     ~azure.mgmt.recoveryservices.models.VaultPrivateEndpointState
    :param encryption: Customer Managed Key details of the resource.
    :type encryption: ~azure.mgmt.recoveryservices.models.VaultPropertiesEncryption
    """

    _validation = {
        'provisioning_state': {'readonly': True},
        'private_endpoint_connections': {'readonly': True},
        'private_endpoint_state_for_backup': {'readonly': True},
        'private_endpoint_state_for_site_recovery': {'readonly': True},
    }

    _attribute_map = {
        'provisioning_state': {'key': 'provisioningState', 'type': 'str'},
        'upgrade_details': {'key': 'upgradeDetails', 'type': 'UpgradeDetails'},
        'private_endpoint_connections': {'key': 'privateEndpointConnections', 'type': '[PrivateEndpointConnectionVaultProperties]'},
        'private_endpoint_state_for_backup': {'key': 'privateEndpointStateForBackup', 'type': 'str'},
        'private_endpoint_state_for_site_recovery': {'key': 'privateEndpointStateForSiteRecovery', 'type': 'str'},
        'encryption': {'key': 'encryption', 'type': 'VaultPropertiesEncryption'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(VaultProperties, self).__init__(**kwargs)
        self.provisioning_state = None
        self.upgrade_details = kwargs.get('upgrade_details', None)
        self.private_endpoint_connections = None
        self.private_endpoint_state_for_backup = None
        self.private_endpoint_state_for_site_recovery = None
        self.encryption = kwargs.get('encryption', None)


class VaultPropertiesEncryption(msrest.serialization.Model):
    """Customer Managed Key details of the resource.

    :param key_vault_properties: The properties of the Key Vault which hosts CMK.
    :type key_vault_properties: ~azure.mgmt.recoveryservices.models.CmkKeyVaultProperties
    :param kek_identity: The details of the identity used for CMK.
    :type kek_identity: ~azure.mgmt.recoveryservices.models.CmkKekIdentity
    :param infrastructure_encryption: Enabling/Disabling the Double Encryption state. Possible
     values include: "Enabled", "Disabled".
    :type infrastructure_encryption: str or
     ~azure.mgmt.recoveryservices.models.InfrastructureEncryptionState
    """

    _attribute_map = {
        'key_vault_properties': {'key': 'keyVaultProperties', 'type': 'CmkKeyVaultProperties'},
        'kek_identity': {'key': 'kekIdentity', 'type': 'CmkKekIdentity'},
        'infrastructure_encryption': {'key': 'infrastructureEncryption', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(VaultPropertiesEncryption, self).__init__(**kwargs)
        self.key_vault_properties = kwargs.get('key_vault_properties', None)
        self.kek_identity = kwargs.get('kek_identity', None)
        self.infrastructure_encryption = kwargs.get('infrastructure_encryption', None)


class VaultUsage(msrest.serialization.Model):
    """Usages of a vault.

    :param unit: Unit of the usage. Possible values include: "Count", "Bytes", "Seconds",
     "Percent", "CountPerSecond", "BytesPerSecond".
    :type unit: str or ~azure.mgmt.recoveryservices.models.UsagesUnit
    :param quota_period: Quota period of usage.
    :type quota_period: str
    :param next_reset_time: Next reset time of usage.
    :type next_reset_time: ~datetime.datetime
    :param current_value: Current value of usage.
    :type current_value: long
    :param limit: Limit of usage.
    :type limit: long
    :param name: Name of usage.
    :type name: ~azure.mgmt.recoveryservices.models.NameInfo
    """

    _attribute_map = {
        'unit': {'key': 'unit', 'type': 'str'},
        'quota_period': {'key': 'quotaPeriod', 'type': 'str'},
        'next_reset_time': {'key': 'nextResetTime', 'type': 'iso-8601'},
        'current_value': {'key': 'currentValue', 'type': 'long'},
        'limit': {'key': 'limit', 'type': 'long'},
        'name': {'key': 'name', 'type': 'NameInfo'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(VaultUsage, self).__init__(**kwargs)
        self.unit = kwargs.get('unit', None)
        self.quota_period = kwargs.get('quota_period', None)
        self.next_reset_time = kwargs.get('next_reset_time', None)
        self.current_value = kwargs.get('current_value', None)
        self.limit = kwargs.get('limit', None)
        self.name = kwargs.get('name', None)


class VaultUsageList(msrest.serialization.Model):
    """Usage for vault.

    :param value: The list of usages for the given vault.
    :type value: list[~azure.mgmt.recoveryservices.models.VaultUsage]
    """

    _attribute_map = {
        'value': {'key': 'value', 'type': '[VaultUsage]'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(VaultUsageList, self).__init__(**kwargs)
        self.value = kwargs.get('value', None)