# 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 msrest.serialization import Model
from msrest.exceptions import HttpOperationError


class AccessUri(Model):
    """A disk access SAS uri.

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

    :ivar access_sas: A SAS uri for accessing a disk.
    :vartype access_sas: str
    """

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

    _attribute_map = {
        'access_sas': {'key': 'accessSAS', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(AccessUri, self).__init__(**kwargs)
        self.access_sas = None


class ApiError(Model):
    """Api error.

    :param details: The Api error details
    :type details: list[~azure.mgmt.compute.v2020_06_30.models.ApiErrorBase]
    :param innererror: The Api inner error
    :type innererror: ~azure.mgmt.compute.v2020_06_30.models.InnerError
    :param code: The error code.
    :type code: str
    :param target: The target of the particular error.
    :type target: str
    :param message: The error message.
    :type message: str
    """

    _attribute_map = {
        'details': {'key': 'details', 'type': '[ApiErrorBase]'},
        'innererror': {'key': 'innererror', 'type': 'InnerError'},
        'code': {'key': 'code', 'type': 'str'},
        'target': {'key': 'target', 'type': 'str'},
        'message': {'key': 'message', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(ApiError, self).__init__(**kwargs)
        self.details = kwargs.get('details', None)
        self.innererror = kwargs.get('innererror', None)
        self.code = kwargs.get('code', None)
        self.target = kwargs.get('target', None)
        self.message = kwargs.get('message', None)


class ApiErrorBase(Model):
    """Api error base.

    :param code: The error code.
    :type code: str
    :param target: The target of the particular error.
    :type target: str
    :param message: The error message.
    :type message: str
    """

    _attribute_map = {
        'code': {'key': 'code', 'type': 'str'},
        'target': {'key': 'target', 'type': 'str'},
        'message': {'key': 'message', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(ApiErrorBase, self).__init__(**kwargs)
        self.code = kwargs.get('code', None)
        self.target = kwargs.get('target', None)
        self.message = kwargs.get('message', None)


class CloudError(Model):
    """An error response from the Compute service.

    :param error:
    :type error: ~azure.mgmt.compute.v2020_06_30.models.ApiError
    """

    _attribute_map = {
        'error': {'key': 'error', 'type': 'ApiError'},
    }

    def __init__(self, **kwargs):
        super(CloudError, self).__init__(**kwargs)
        self.error = kwargs.get('error', None)


class CloudErrorException(HttpOperationError):
    """Server responsed with exception of type: 'CloudError'.

    :param deserialize: A deserializer
    :param response: Server response to be deserialized.
    """

    def __init__(self, deserialize, response, *args):

        super(CloudErrorException, self).__init__(deserialize, response, 'CloudError', *args)


class CreationData(Model):
    """Data used when creating a disk.

    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 create_option: Required. This enumerates the possible sources of a
     disk's creation. Possible values include: 'Empty', 'Attach', 'FromImage',
     'Import', 'Copy', 'Restore', 'Upload'
    :type create_option: str or
     ~azure.mgmt.compute.v2020_06_30.models.DiskCreateOption
    :param storage_account_id: Required if createOption is Import. The Azure
     Resource Manager identifier of the storage account containing the blob to
     import as a disk.
    :type storage_account_id: str
    :param image_reference: Disk source information.
    :type image_reference:
     ~azure.mgmt.compute.v2020_06_30.models.ImageDiskReference
    :param gallery_image_reference: Required if creating from a Gallery Image.
     The id of the ImageDiskReference will be the ARM id of the shared galley
     image version from which to create a disk.
    :type gallery_image_reference:
     ~azure.mgmt.compute.v2020_06_30.models.ImageDiskReference
    :param source_uri: If createOption is Import, this is the URI of a blob to
     be imported into a managed disk.
    :type source_uri: str
    :param source_resource_id: If createOption is Copy, this is the ARM id of
     the source snapshot or disk.
    :type source_resource_id: str
    :ivar source_unique_id: If this field is set, this is the unique id
     identifying the source of this resource.
    :vartype source_unique_id: str
    :param upload_size_bytes: If createOption is Upload, this is the size of
     the contents of the upload including the VHD footer. This value should be
     between 20972032 (20 MiB + 512 bytes for the VHD footer) and
     35183298347520 bytes (32 TiB + 512 bytes for the VHD footer).
    :type upload_size_bytes: long
    :param logical_sector_size: Logical sector size in bytes for Ultra disks.
     Supported values are 512 ad 4096. 4096 is the default.
    :type logical_sector_size: int
    """

    _validation = {
        'create_option': {'required': True},
        'source_unique_id': {'readonly': True},
    }

    _attribute_map = {
        'create_option': {'key': 'createOption', 'type': 'str'},
        'storage_account_id': {'key': 'storageAccountId', 'type': 'str'},
        'image_reference': {'key': 'imageReference', 'type': 'ImageDiskReference'},
        'gallery_image_reference': {'key': 'galleryImageReference', 'type': 'ImageDiskReference'},
        'source_uri': {'key': 'sourceUri', 'type': 'str'},
        'source_resource_id': {'key': 'sourceResourceId', 'type': 'str'},
        'source_unique_id': {'key': 'sourceUniqueId', 'type': 'str'},
        'upload_size_bytes': {'key': 'uploadSizeBytes', 'type': 'long'},
        'logical_sector_size': {'key': 'logicalSectorSize', 'type': 'int'},
    }

    def __init__(self, **kwargs):
        super(CreationData, self).__init__(**kwargs)
        self.create_option = kwargs.get('create_option', None)
        self.storage_account_id = kwargs.get('storage_account_id', None)
        self.image_reference = kwargs.get('image_reference', None)
        self.gallery_image_reference = kwargs.get('gallery_image_reference', None)
        self.source_uri = kwargs.get('source_uri', None)
        self.source_resource_id = kwargs.get('source_resource_id', None)
        self.source_unique_id = None
        self.upload_size_bytes = kwargs.get('upload_size_bytes', None)
        self.logical_sector_size = kwargs.get('logical_sector_size', None)


class Resource(Model):
    """The Resource model definition.

    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
    :vartype id: str
    :ivar name: Resource name
    :vartype name: str
    :ivar type: Resource type
    :vartype type: str
    :param location: Required. Resource location
    :type location: str
    :param 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'},
        'location': {'key': 'location', 'type': 'str'},
        'tags': {'key': 'tags', 'type': '{str}'},
    }

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


class Disk(Resource):
    """Disk 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 id: Resource Id
    :vartype id: str
    :ivar name: Resource name
    :vartype name: str
    :ivar type: Resource type
    :vartype type: str
    :param location: Required. Resource location
    :type location: str
    :param tags: Resource tags
    :type tags: dict[str, str]
    :ivar managed_by: A relative URI containing the ID of the VM that has the
     disk attached.
    :vartype managed_by: str
    :ivar managed_by_extended: List of relative URIs containing the IDs of the
     VMs that have the disk attached. maxShares should be set to a value
     greater than one for disks to allow attaching them to multiple VMs.
    :vartype managed_by_extended: list[str]
    :param sku:
    :type sku: ~azure.mgmt.compute.v2020_06_30.models.DiskSku
    :param zones: The Logical zone list for Disk.
    :type zones: list[str]
    :ivar time_created: The time when the disk was created.
    :vartype time_created: datetime
    :param os_type: The Operating System type. Possible values include:
     'Windows', 'Linux'
    :type os_type: str or
     ~azure.mgmt.compute.v2020_06_30.models.OperatingSystemTypes
    :param hyper_vgeneration: The hypervisor generation of the Virtual
     Machine. Applicable to OS disks only. Possible values include: 'V1', 'V2'
    :type hyper_vgeneration: str or
     ~azure.mgmt.compute.v2020_06_30.models.HyperVGeneration
    :param creation_data: Required. Disk source information. CreationData
     information cannot be changed after the disk has been created.
    :type creation_data: ~azure.mgmt.compute.v2020_06_30.models.CreationData
    :param disk_size_gb: If creationData.createOption is Empty, this field is
     mandatory and it indicates the size of the disk to create. If this field
     is present for updates or creation with other options, it indicates a
     resize. Resizes are only allowed if the disk is not attached to a running
     VM, and can only increase the disk's size.
    :type disk_size_gb: int
    :ivar disk_size_bytes: The size of the disk in bytes. This field is read
     only.
    :vartype disk_size_bytes: long
    :ivar unique_id: Unique Guid identifying the resource.
    :vartype unique_id: str
    :param encryption_settings_collection: Encryption settings collection used
     for Azure Disk Encryption, can contain multiple encryption settings per
     disk or snapshot.
    :type encryption_settings_collection:
     ~azure.mgmt.compute.v2020_06_30.models.EncryptionSettingsCollection
    :ivar provisioning_state: The disk provisioning state.
    :vartype provisioning_state: str
    :param disk_iops_read_write: The number of IOPS allowed for this disk;
     only settable for UltraSSD disks. One operation can transfer between 4k
     and 256k bytes.
    :type disk_iops_read_write: long
    :param disk_mbps_read_write: The bandwidth allowed for this disk; only
     settable for UltraSSD disks. MBps means millions of bytes per second - MB
     here uses the ISO notation, of powers of 10.
    :type disk_mbps_read_write: long
    :param disk_iops_read_only: The total number of IOPS that will be allowed
     across all VMs mounting the shared disk as ReadOnly. One operation can
     transfer between 4k and 256k bytes.
    :type disk_iops_read_only: long
    :param disk_mbps_read_only: The total throughput (MBps) that will be
     allowed across all VMs mounting the shared disk as ReadOnly. MBps means
     millions of bytes per second - MB here uses the ISO notation, of powers of
     10.
    :type disk_mbps_read_only: long
    :param disk_state: The state of the disk. Possible values include:
     'Unattached', 'Attached', 'Reserved', 'ActiveSAS', 'ReadyToUpload',
     'ActiveUpload'
    :type disk_state: str or ~azure.mgmt.compute.v2020_06_30.models.DiskState
    :param encryption: Encryption property can be used to encrypt data at rest
     with customer managed keys or platform managed keys.
    :type encryption: ~azure.mgmt.compute.v2020_06_30.models.Encryption
    :param max_shares: The maximum number of VMs that can attach to the disk
     at the same time. Value greater than one indicates a disk that can be
     mounted on multiple VMs at the same time.
    :type max_shares: int
    :ivar share_info: Details of the list of all VMs that have the disk
     attached. maxShares should be set to a value greater than one for disks to
     allow attaching them to multiple VMs.
    :vartype share_info:
     list[~azure.mgmt.compute.v2020_06_30.models.ShareInfoElement]
    :param network_access_policy: Possible values include: 'AllowAll',
     'AllowPrivate', 'DenyAll'
    :type network_access_policy: str or
     ~azure.mgmt.compute.v2020_06_30.models.NetworkAccessPolicy
    :param disk_access_id: ARM id of the DiskAccess resource for using private
     endpoints on disks.
    :type disk_access_id: str
    :param tier: Performance tier of the disk (e.g, P4, S10) as described
     here: https://azure.microsoft.com/en-us/pricing/details/managed-disks/.
     Does not apply to Ultra disks.
    :type tier: str
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'location': {'required': True},
        'managed_by': {'readonly': True},
        'managed_by_extended': {'readonly': True},
        'time_created': {'readonly': True},
        'creation_data': {'required': True},
        'disk_size_bytes': {'readonly': True},
        'unique_id': {'readonly': True},
        'provisioning_state': {'readonly': True},
        'share_info': {'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}'},
        'managed_by': {'key': 'managedBy', 'type': 'str'},
        'managed_by_extended': {'key': 'managedByExtended', 'type': '[str]'},
        'sku': {'key': 'sku', 'type': 'DiskSku'},
        'zones': {'key': 'zones', 'type': '[str]'},
        'time_created': {'key': 'properties.timeCreated', 'type': 'iso-8601'},
        'os_type': {'key': 'properties.osType', 'type': 'OperatingSystemTypes'},
        'hyper_vgeneration': {'key': 'properties.hyperVGeneration', 'type': 'str'},
        'creation_data': {'key': 'properties.creationData', 'type': 'CreationData'},
        'disk_size_gb': {'key': 'properties.diskSizeGB', 'type': 'int'},
        'disk_size_bytes': {'key': 'properties.diskSizeBytes', 'type': 'long'},
        'unique_id': {'key': 'properties.uniqueId', 'type': 'str'},
        'encryption_settings_collection': {'key': 'properties.encryptionSettingsCollection', 'type': 'EncryptionSettingsCollection'},
        'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
        'disk_iops_read_write': {'key': 'properties.diskIOPSReadWrite', 'type': 'long'},
        'disk_mbps_read_write': {'key': 'properties.diskMBpsReadWrite', 'type': 'long'},
        'disk_iops_read_only': {'key': 'properties.diskIOPSReadOnly', 'type': 'long'},
        'disk_mbps_read_only': {'key': 'properties.diskMBpsReadOnly', 'type': 'long'},
        'disk_state': {'key': 'properties.diskState', 'type': 'str'},
        'encryption': {'key': 'properties.encryption', 'type': 'Encryption'},
        'max_shares': {'key': 'properties.maxShares', 'type': 'int'},
        'share_info': {'key': 'properties.shareInfo', 'type': '[ShareInfoElement]'},
        'network_access_policy': {'key': 'properties.networkAccessPolicy', 'type': 'str'},
        'disk_access_id': {'key': 'properties.diskAccessId', 'type': 'str'},
        'tier': {'key': 'properties.tier', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(Disk, self).__init__(**kwargs)
        self.managed_by = None
        self.managed_by_extended = None
        self.sku = kwargs.get('sku', None)
        self.zones = kwargs.get('zones', None)
        self.time_created = None
        self.os_type = kwargs.get('os_type', None)
        self.hyper_vgeneration = kwargs.get('hyper_vgeneration', None)
        self.creation_data = kwargs.get('creation_data', None)
        self.disk_size_gb = kwargs.get('disk_size_gb', None)
        self.disk_size_bytes = None
        self.unique_id = None
        self.encryption_settings_collection = kwargs.get('encryption_settings_collection', None)
        self.provisioning_state = None
        self.disk_iops_read_write = kwargs.get('disk_iops_read_write', None)
        self.disk_mbps_read_write = kwargs.get('disk_mbps_read_write', None)
        self.disk_iops_read_only = kwargs.get('disk_iops_read_only', None)
        self.disk_mbps_read_only = kwargs.get('disk_mbps_read_only', None)
        self.disk_state = kwargs.get('disk_state', None)
        self.encryption = kwargs.get('encryption', None)
        self.max_shares = kwargs.get('max_shares', None)
        self.share_info = None
        self.network_access_policy = kwargs.get('network_access_policy', None)
        self.disk_access_id = kwargs.get('disk_access_id', None)
        self.tier = kwargs.get('tier', None)


class DiskAccess(Resource):
    """disk access 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 id: Resource Id
    :vartype id: str
    :ivar name: Resource name
    :vartype name: str
    :ivar type: Resource type
    :vartype type: str
    :param location: Required. Resource location
    :type location: str
    :param tags: Resource tags
    :type tags: dict[str, str]
    :ivar private_endpoint_connections: A readonly collection of private
     endpoint connections created on the disk. Currently only one endpoint
     connection is supported.
    :vartype private_endpoint_connections:
     list[~azure.mgmt.compute.v2020_06_30.models.PrivateEndpointConnection]
    :ivar provisioning_state: The disk access resource provisioning state.
    :vartype provisioning_state: str
    :ivar time_created: The time when the disk access was created.
    :vartype time_created: datetime
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'location': {'required': True},
        'private_endpoint_connections': {'readonly': True},
        'provisioning_state': {'readonly': True},
        'time_created': {'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}'},
        'private_endpoint_connections': {'key': 'properties.privateEndpointConnections', 'type': '[PrivateEndpointConnection]'},
        'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
        'time_created': {'key': 'properties.timeCreated', 'type': 'iso-8601'},
    }

    def __init__(self, **kwargs):
        super(DiskAccess, self).__init__(**kwargs)
        self.private_endpoint_connections = None
        self.provisioning_state = None
        self.time_created = None


class DiskAccessUpdate(Model):
    """Used for updating a disk access resource.

    :param tags: Resource tags
    :type tags: dict[str, str]
    """

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

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


class DiskEncryptionSet(Resource):
    """disk encryption set 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 id: Resource Id
    :vartype id: str
    :ivar name: Resource name
    :vartype name: str
    :ivar type: Resource type
    :vartype type: str
    :param location: Required. Resource location
    :type location: str
    :param tags: Resource tags
    :type tags: dict[str, str]
    :param identity:
    :type identity:
     ~azure.mgmt.compute.v2020_06_30.models.EncryptionSetIdentity
    :param encryption_type: Possible values include:
     'EncryptionAtRestWithCustomerKey',
     'EncryptionAtRestWithPlatformAndCustomerKeys'
    :type encryption_type: str or
     ~azure.mgmt.compute.v2020_06_30.models.DiskEncryptionSetType
    :param active_key: The key vault key which is currently used by this disk
     encryption set.
    :type active_key:
     ~azure.mgmt.compute.v2020_06_30.models.KeyVaultAndKeyReference
    :ivar previous_keys: A readonly collection of key vault keys previously
     used by this disk encryption set while a key rotation is in progress. It
     will be empty if there is no ongoing key rotation.
    :vartype previous_keys:
     list[~azure.mgmt.compute.v2020_06_30.models.KeyVaultAndKeyReference]
    :ivar provisioning_state: The disk encryption set provisioning state.
    :vartype provisioning_state: str
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'location': {'required': True},
        'previous_keys': {'readonly': True},
        'provisioning_state': {'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}'},
        'identity': {'key': 'identity', 'type': 'EncryptionSetIdentity'},
        'encryption_type': {'key': 'properties.encryptionType', 'type': 'str'},
        'active_key': {'key': 'properties.activeKey', 'type': 'KeyVaultAndKeyReference'},
        'previous_keys': {'key': 'properties.previousKeys', 'type': '[KeyVaultAndKeyReference]'},
        'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(DiskEncryptionSet, self).__init__(**kwargs)
        self.identity = kwargs.get('identity', None)
        self.encryption_type = kwargs.get('encryption_type', None)
        self.active_key = kwargs.get('active_key', None)
        self.previous_keys = None
        self.provisioning_state = None


class DiskEncryptionSetUpdate(Model):
    """disk encryption set update resource.

    :param encryption_type: Possible values include:
     'EncryptionAtRestWithCustomerKey',
     'EncryptionAtRestWithPlatformAndCustomerKeys'
    :type encryption_type: str or
     ~azure.mgmt.compute.v2020_06_30.models.DiskEncryptionSetType
    :param active_key:
    :type active_key:
     ~azure.mgmt.compute.v2020_06_30.models.KeyVaultAndKeyReference
    :param tags: Resource tags
    :type tags: dict[str, str]
    """

    _attribute_map = {
        'encryption_type': {'key': 'properties.encryptionType', 'type': 'str'},
        'active_key': {'key': 'properties.activeKey', 'type': 'KeyVaultAndKeyReference'},
        'tags': {'key': 'tags', 'type': '{str}'},
    }

    def __init__(self, **kwargs):
        super(DiskEncryptionSetUpdate, self).__init__(**kwargs)
        self.encryption_type = kwargs.get('encryption_type', None)
        self.active_key = kwargs.get('active_key', None)
        self.tags = kwargs.get('tags', None)


class DiskSku(Model):
    """The disks sku name. Can be Standard_LRS, Premium_LRS, StandardSSD_LRS, or
    UltraSSD_LRS.

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

    :param name: The sku name. Possible values include: 'Standard_LRS',
     'Premium_LRS', 'StandardSSD_LRS', 'UltraSSD_LRS'
    :type name: str or
     ~azure.mgmt.compute.v2020_06_30.models.DiskStorageAccountTypes
    :ivar tier: The sku tier.
    :vartype tier: str
    """

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

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

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


class DiskUpdate(Model):
    """Disk update resource.

    :param os_type: the Operating System type. Possible values include:
     'Windows', 'Linux'
    :type os_type: str or
     ~azure.mgmt.compute.v2020_06_30.models.OperatingSystemTypes
    :param disk_size_gb: If creationData.createOption is Empty, this field is
     mandatory and it indicates the size of the disk to create. If this field
     is present for updates or creation with other options, it indicates a
     resize. Resizes are only allowed if the disk is not attached to a running
     VM, and can only increase the disk's size.
    :type disk_size_gb: int
    :param encryption_settings_collection: Encryption settings collection used
     be Azure Disk Encryption, can contain multiple encryption settings per
     disk or snapshot.
    :type encryption_settings_collection:
     ~azure.mgmt.compute.v2020_06_30.models.EncryptionSettingsCollection
    :param disk_iops_read_write: The number of IOPS allowed for this disk;
     only settable for UltraSSD disks. One operation can transfer between 4k
     and 256k bytes.
    :type disk_iops_read_write: long
    :param disk_mbps_read_write: The bandwidth allowed for this disk; only
     settable for UltraSSD disks. MBps means millions of bytes per second - MB
     here uses the ISO notation, of powers of 10.
    :type disk_mbps_read_write: long
    :param disk_iops_read_only: The total number of IOPS that will be allowed
     across all VMs mounting the shared disk as ReadOnly. One operation can
     transfer between 4k and 256k bytes.
    :type disk_iops_read_only: long
    :param disk_mbps_read_only: The total throughput (MBps) that will be
     allowed across all VMs mounting the shared disk as ReadOnly. MBps means
     millions of bytes per second - MB here uses the ISO notation, of powers of
     10.
    :type disk_mbps_read_only: long
    :param max_shares: The maximum number of VMs that can attach to the disk
     at the same time. Value greater than one indicates a disk that can be
     mounted on multiple VMs at the same time.
    :type max_shares: int
    :param encryption: Encryption property can be used to encrypt data at rest
     with customer managed keys or platform managed keys.
    :type encryption: ~azure.mgmt.compute.v2020_06_30.models.Encryption
    :param network_access_policy: Possible values include: 'AllowAll',
     'AllowPrivate', 'DenyAll'
    :type network_access_policy: str or
     ~azure.mgmt.compute.v2020_06_30.models.NetworkAccessPolicy
    :param disk_access_id: ARM id of the DiskAccess resource for using private
     endpoints on disks.
    :type disk_access_id: str
    :param tier: Performance tier of the disk (e.g, P4, S10) as described
     here: https://azure.microsoft.com/en-us/pricing/details/managed-disks/.
     Does not apply to Ultra disks.
    :type tier: str
    :param tags: Resource tags
    :type tags: dict[str, str]
    :param sku:
    :type sku: ~azure.mgmt.compute.v2020_06_30.models.DiskSku
    """

    _attribute_map = {
        'os_type': {'key': 'properties.osType', 'type': 'OperatingSystemTypes'},
        'disk_size_gb': {'key': 'properties.diskSizeGB', 'type': 'int'},
        'encryption_settings_collection': {'key': 'properties.encryptionSettingsCollection', 'type': 'EncryptionSettingsCollection'},
        'disk_iops_read_write': {'key': 'properties.diskIOPSReadWrite', 'type': 'long'},
        'disk_mbps_read_write': {'key': 'properties.diskMBpsReadWrite', 'type': 'long'},
        'disk_iops_read_only': {'key': 'properties.diskIOPSReadOnly', 'type': 'long'},
        'disk_mbps_read_only': {'key': 'properties.diskMBpsReadOnly', 'type': 'long'},
        'max_shares': {'key': 'properties.maxShares', 'type': 'int'},
        'encryption': {'key': 'properties.encryption', 'type': 'Encryption'},
        'network_access_policy': {'key': 'properties.networkAccessPolicy', 'type': 'str'},
        'disk_access_id': {'key': 'properties.diskAccessId', 'type': 'str'},
        'tier': {'key': 'properties.tier', 'type': 'str'},
        'tags': {'key': 'tags', 'type': '{str}'},
        'sku': {'key': 'sku', 'type': 'DiskSku'},
    }

    def __init__(self, **kwargs):
        super(DiskUpdate, self).__init__(**kwargs)
        self.os_type = kwargs.get('os_type', None)
        self.disk_size_gb = kwargs.get('disk_size_gb', None)
        self.encryption_settings_collection = kwargs.get('encryption_settings_collection', None)
        self.disk_iops_read_write = kwargs.get('disk_iops_read_write', None)
        self.disk_mbps_read_write = kwargs.get('disk_mbps_read_write', None)
        self.disk_iops_read_only = kwargs.get('disk_iops_read_only', None)
        self.disk_mbps_read_only = kwargs.get('disk_mbps_read_only', None)
        self.max_shares = kwargs.get('max_shares', None)
        self.encryption = kwargs.get('encryption', None)
        self.network_access_policy = kwargs.get('network_access_policy', None)
        self.disk_access_id = kwargs.get('disk_access_id', None)
        self.tier = kwargs.get('tier', None)
        self.tags = kwargs.get('tags', None)
        self.sku = kwargs.get('sku', None)


class Encryption(Model):
    """Encryption at rest settings for disk or snapshot.

    :param disk_encryption_set_id: ResourceId of the disk encryption set to
     use for enabling encryption at rest.
    :type disk_encryption_set_id: str
    :param type: Possible values include: 'EncryptionAtRestWithPlatformKey',
     'EncryptionAtRestWithCustomerKey',
     'EncryptionAtRestWithPlatformAndCustomerKeys'
    :type type: str or ~azure.mgmt.compute.v2020_06_30.models.EncryptionType
    """

    _attribute_map = {
        'disk_encryption_set_id': {'key': 'diskEncryptionSetId', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
    }

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


class EncryptionSetIdentity(Model):
    """The managed identity for the disk encryption set. It should be given
    permission on the key vault before it can be used to encrypt disks.

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

    :param type: The type of Managed Identity used by the DiskEncryptionSet.
     Only SystemAssigned is supported. Possible values include:
     'SystemAssigned'
    :type type: str or
     ~azure.mgmt.compute.v2020_06_30.models.DiskEncryptionSetIdentityType
    :ivar principal_id: The object id of the Managed Identity Resource. This
     will be sent to the RP from ARM via the x-ms-identity-principal-id header
     in the PUT request if the resource has a systemAssigned(implicit) identity
    :vartype principal_id: str
    :ivar tenant_id: The tenant id of the Managed Identity Resource. This will
     be sent to the RP from ARM via the x-ms-client-tenant-id header in the PUT
     request if the resource has a systemAssigned(implicit) identity
    :vartype tenant_id: str
    """

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

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

    def __init__(self, **kwargs):
        super(EncryptionSetIdentity, self).__init__(**kwargs)
        self.type = kwargs.get('type', None)
        self.principal_id = None
        self.tenant_id = None


class EncryptionSettingsCollection(Model):
    """Encryption settings for disk or snapshot.

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

    :param enabled: Required. Set this flag to true and provide
     DiskEncryptionKey and optional KeyEncryptionKey to enable encryption. Set
     this flag to false and remove DiskEncryptionKey and KeyEncryptionKey to
     disable encryption. If EncryptionSettings is null in the request object,
     the existing settings remain unchanged.
    :type enabled: bool
    :param encryption_settings: A collection of encryption settings, one for
     each disk volume.
    :type encryption_settings:
     list[~azure.mgmt.compute.v2020_06_30.models.EncryptionSettingsElement]
    :param encryption_settings_version: Describes what type of encryption is
     used for the disks. Once this field is set, it cannot be overwritten.
     '1.0' corresponds to Azure Disk Encryption with AAD app.'1.1' corresponds
     to Azure Disk Encryption.
    :type encryption_settings_version: str
    """

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

    _attribute_map = {
        'enabled': {'key': 'enabled', 'type': 'bool'},
        'encryption_settings': {'key': 'encryptionSettings', 'type': '[EncryptionSettingsElement]'},
        'encryption_settings_version': {'key': 'encryptionSettingsVersion', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(EncryptionSettingsCollection, self).__init__(**kwargs)
        self.enabled = kwargs.get('enabled', None)
        self.encryption_settings = kwargs.get('encryption_settings', None)
        self.encryption_settings_version = kwargs.get('encryption_settings_version', None)


class EncryptionSettingsElement(Model):
    """Encryption settings for one disk volume.

    :param disk_encryption_key: Key Vault Secret Url and vault id of the disk
     encryption key
    :type disk_encryption_key:
     ~azure.mgmt.compute.v2020_06_30.models.KeyVaultAndSecretReference
    :param key_encryption_key: Key Vault Key Url and vault id of the key
     encryption key. KeyEncryptionKey is optional and when provided is used to
     unwrap the disk encryption key.
    :type key_encryption_key:
     ~azure.mgmt.compute.v2020_06_30.models.KeyVaultAndKeyReference
    """

    _attribute_map = {
        'disk_encryption_key': {'key': 'diskEncryptionKey', 'type': 'KeyVaultAndSecretReference'},
        'key_encryption_key': {'key': 'keyEncryptionKey', 'type': 'KeyVaultAndKeyReference'},
    }

    def __init__(self, **kwargs):
        super(EncryptionSettingsElement, self).__init__(**kwargs)
        self.disk_encryption_key = kwargs.get('disk_encryption_key', None)
        self.key_encryption_key = kwargs.get('key_encryption_key', None)


class GrantAccessData(Model):
    """Data used for requesting a SAS.

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

    :param access: Required. Possible values include: 'None', 'Read', 'Write'
    :type access: str or ~azure.mgmt.compute.v2020_06_30.models.AccessLevel
    :param duration_in_seconds: Required. Time duration in seconds until the
     SAS access expires.
    :type duration_in_seconds: int
    """

    _validation = {
        'access': {'required': True},
        'duration_in_seconds': {'required': True},
    }

    _attribute_map = {
        'access': {'key': 'access', 'type': 'str'},
        'duration_in_seconds': {'key': 'durationInSeconds', 'type': 'int'},
    }

    def __init__(self, **kwargs):
        super(GrantAccessData, self).__init__(**kwargs)
        self.access = kwargs.get('access', None)
        self.duration_in_seconds = kwargs.get('duration_in_seconds', None)


class ImageDiskReference(Model):
    """The source image used for creating the disk.

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

    :param id: Required. A relative uri containing either a Platform Image
     Repository or user image reference.
    :type id: str
    :param lun: If the disk is created from an image's data disk, this is an
     index that indicates which of the data disks in the image to use. For OS
     disks, this field is null.
    :type lun: int
    """

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

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

    def __init__(self, **kwargs):
        super(ImageDiskReference, self).__init__(**kwargs)
        self.id = kwargs.get('id', None)
        self.lun = kwargs.get('lun', None)


class InnerError(Model):
    """Inner error details.

    :param exceptiontype: The exception type.
    :type exceptiontype: str
    :param errordetail: The internal error message or exception dump.
    :type errordetail: str
    """

    _attribute_map = {
        'exceptiontype': {'key': 'exceptiontype', 'type': 'str'},
        'errordetail': {'key': 'errordetail', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(InnerError, self).__init__(**kwargs)
        self.exceptiontype = kwargs.get('exceptiontype', None)
        self.errordetail = kwargs.get('errordetail', None)


class KeyVaultAndKeyReference(Model):
    """Key Vault Key Url and vault id of KeK, KeK is optional and when provided is
    used to unwrap the encryptionKey.

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

    :param source_vault: Required. Resource id of the KeyVault containing the
     key or secret
    :type source_vault: ~azure.mgmt.compute.v2020_06_30.models.SourceVault
    :param key_url: Required. Url pointing to a key or secret in KeyVault
    :type key_url: str
    """

    _validation = {
        'source_vault': {'required': True},
        'key_url': {'required': True},
    }

    _attribute_map = {
        'source_vault': {'key': 'sourceVault', 'type': 'SourceVault'},
        'key_url': {'key': 'keyUrl', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(KeyVaultAndKeyReference, self).__init__(**kwargs)
        self.source_vault = kwargs.get('source_vault', None)
        self.key_url = kwargs.get('key_url', None)


class KeyVaultAndSecretReference(Model):
    """Key Vault Secret Url and vault id of the encryption key .

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

    :param source_vault: Required. Resource id of the KeyVault containing the
     key or secret
    :type source_vault: ~azure.mgmt.compute.v2020_06_30.models.SourceVault
    :param secret_url: Required. Url pointing to a key or secret in KeyVault
    :type secret_url: str
    """

    _validation = {
        'source_vault': {'required': True},
        'secret_url': {'required': True},
    }

    _attribute_map = {
        'source_vault': {'key': 'sourceVault', 'type': 'SourceVault'},
        'secret_url': {'key': 'secretUrl', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(KeyVaultAndSecretReference, self).__init__(**kwargs)
        self.source_vault = kwargs.get('source_vault', None)
        self.secret_url = kwargs.get('secret_url', None)


class PrivateEndpoint(Model):
    """The Private Endpoint resource.

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

    :ivar id: The ARM identifier for Private Endpoint
    :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(Model):
    """The Private Endpoint Connection 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.

    :param private_endpoint: The resource of private end point.
    :type private_endpoint:
     ~azure.mgmt.compute.v2020_06_30.models.PrivateEndpoint
    :param private_link_service_connection_state: Required. A collection of
     information about the state of the connection between DiskAccess and
     Virtual Network.
    :type private_link_service_connection_state:
     ~azure.mgmt.compute.v2020_06_30.models.PrivateLinkServiceConnectionState
    :param provisioning_state: The provisioning state of the private endpoint
     connection resource. Possible values include: 'Succeeded', 'Creating',
     'Deleting', 'Failed'
    :type provisioning_state: str or
     ~azure.mgmt.compute.v2020_06_30.models.PrivateEndpointConnectionProvisioningState
    :ivar id: private endpoint connection Id
    :vartype id: str
    :ivar name: private endpoint connection name
    :vartype name: str
    :ivar type: private endpoint connection type
    :vartype type: str
    """

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

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

    def __init__(self, **kwargs):
        super(PrivateEndpointConnection, self).__init__(**kwargs)
        self.private_endpoint = kwargs.get('private_endpoint', None)
        self.private_link_service_connection_state = kwargs.get('private_link_service_connection_state', None)
        self.provisioning_state = kwargs.get('provisioning_state', None)
        self.id = None
        self.name = None
        self.type = None


class PrivateLinkResource(Model):
    """A private link resource.

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

    :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]
    :param required_zone_names: The private link resource DNS zone name.
    :type required_zone_names: list[str]
    :ivar id: private link resource Id
    :vartype id: str
    :ivar name: private link resource name
    :vartype name: str
    :ivar type: private link resource type
    :vartype type: str
    """

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

    _attribute_map = {
        'group_id': {'key': 'properties.groupId', 'type': 'str'},
        'required_members': {'key': 'properties.requiredMembers', 'type': '[str]'},
        'required_zone_names': {'key': 'properties.requiredZoneNames', 'type': '[str]'},
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(PrivateLinkResource, self).__init__(**kwargs)
        self.group_id = None
        self.required_members = None
        self.required_zone_names = kwargs.get('required_zone_names', None)
        self.id = None
        self.name = None
        self.type = None


class PrivateLinkResourceListResult(Model):
    """A list of private link resources.

    :param value: Array of private link resources
    :type value:
     list[~azure.mgmt.compute.v2020_06_30.models.PrivateLinkResource]
    """

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

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


class PrivateLinkServiceConnectionState(Model):
    """A collection of information about the state of the connection between
    service consumer and provider.

    :param status: Indicates whether the connection has been
     Approved/Rejected/Removed by the owner of the service. Possible values
     include: 'Pending', 'Approved', 'Rejected'
    :type status: str or
     ~azure.mgmt.compute.v2020_06_30.models.PrivateEndpointServiceConnectionStatus
    :param description: The reason for approval/rejection of the connection.
    :type description: str
    :param actions_required: A message indicating if changes on the service
     provider require any updates on the consumer.
    :type actions_required: str
    """

    _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 = kwargs.get('status', None)
        self.description = kwargs.get('description', None)
        self.actions_required = kwargs.get('actions_required', None)


class ShareInfoElement(Model):
    """ShareInfoElement.

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

    :ivar vm_uri: A relative URI containing the ID of the VM that has the disk
     attached.
    :vartype vm_uri: str
    """

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

    _attribute_map = {
        'vm_uri': {'key': 'vmUri', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(ShareInfoElement, self).__init__(**kwargs)
        self.vm_uri = None


class Snapshot(Resource):
    """Snapshot 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 id: Resource Id
    :vartype id: str
    :ivar name: Resource name
    :vartype name: str
    :ivar type: Resource type
    :vartype type: str
    :param location: Required. Resource location
    :type location: str
    :param tags: Resource tags
    :type tags: dict[str, str]
    :ivar managed_by: Unused. Always Null.
    :vartype managed_by: str
    :param sku:
    :type sku: ~azure.mgmt.compute.v2020_06_30.models.SnapshotSku
    :ivar time_created: The time when the snapshot was created.
    :vartype time_created: datetime
    :param os_type: The Operating System type. Possible values include:
     'Windows', 'Linux'
    :type os_type: str or
     ~azure.mgmt.compute.v2020_06_30.models.OperatingSystemTypes
    :param hyper_vgeneration: The hypervisor generation of the Virtual
     Machine. Applicable to OS disks only. Possible values include: 'V1', 'V2'
    :type hyper_vgeneration: str or
     ~azure.mgmt.compute.v2020_06_30.models.HyperVGeneration
    :param creation_data: Required. Disk source information. CreationData
     information cannot be changed after the disk has been created.
    :type creation_data: ~azure.mgmt.compute.v2020_06_30.models.CreationData
    :param disk_size_gb: If creationData.createOption is Empty, this field is
     mandatory and it indicates the size of the disk to create. If this field
     is present for updates or creation with other options, it indicates a
     resize. Resizes are only allowed if the disk is not attached to a running
     VM, and can only increase the disk's size.
    :type disk_size_gb: int
    :ivar disk_size_bytes: The size of the disk in bytes. This field is read
     only.
    :vartype disk_size_bytes: long
    :param disk_state: The state of the snapshot. Possible values include:
     'Unattached', 'Attached', 'Reserved', 'ActiveSAS', 'ReadyToUpload',
     'ActiveUpload'
    :type disk_state: str or ~azure.mgmt.compute.v2020_06_30.models.DiskState
    :ivar unique_id: Unique Guid identifying the resource.
    :vartype unique_id: str
    :param encryption_settings_collection: Encryption settings collection used
     be Azure Disk Encryption, can contain multiple encryption settings per
     disk or snapshot.
    :type encryption_settings_collection:
     ~azure.mgmt.compute.v2020_06_30.models.EncryptionSettingsCollection
    :ivar provisioning_state: The disk provisioning state.
    :vartype provisioning_state: str
    :param incremental: Whether a snapshot is incremental. Incremental
     snapshots on the same disk occupy less space than full snapshots and can
     be diffed.
    :type incremental: bool
    :param encryption: Encryption property can be used to encrypt data at rest
     with customer managed keys or platform managed keys.
    :type encryption: ~azure.mgmt.compute.v2020_06_30.models.Encryption
    :param network_access_policy: Possible values include: 'AllowAll',
     'AllowPrivate', 'DenyAll'
    :type network_access_policy: str or
     ~azure.mgmt.compute.v2020_06_30.models.NetworkAccessPolicy
    :param disk_access_id: ARM id of the DiskAccess resource for using private
     endpoints on disks.
    :type disk_access_id: str
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'location': {'required': True},
        'managed_by': {'readonly': True},
        'time_created': {'readonly': True},
        'creation_data': {'required': True},
        'disk_size_bytes': {'readonly': True},
        'unique_id': {'readonly': True},
        'provisioning_state': {'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}'},
        'managed_by': {'key': 'managedBy', 'type': 'str'},
        'sku': {'key': 'sku', 'type': 'SnapshotSku'},
        'time_created': {'key': 'properties.timeCreated', 'type': 'iso-8601'},
        'os_type': {'key': 'properties.osType', 'type': 'OperatingSystemTypes'},
        'hyper_vgeneration': {'key': 'properties.hyperVGeneration', 'type': 'str'},
        'creation_data': {'key': 'properties.creationData', 'type': 'CreationData'},
        'disk_size_gb': {'key': 'properties.diskSizeGB', 'type': 'int'},
        'disk_size_bytes': {'key': 'properties.diskSizeBytes', 'type': 'long'},
        'disk_state': {'key': 'properties.diskState', 'type': 'str'},
        'unique_id': {'key': 'properties.uniqueId', 'type': 'str'},
        'encryption_settings_collection': {'key': 'properties.encryptionSettingsCollection', 'type': 'EncryptionSettingsCollection'},
        'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
        'incremental': {'key': 'properties.incremental', 'type': 'bool'},
        'encryption': {'key': 'properties.encryption', 'type': 'Encryption'},
        'network_access_policy': {'key': 'properties.networkAccessPolicy', 'type': 'str'},
        'disk_access_id': {'key': 'properties.diskAccessId', 'type': 'str'},
    }

    def __init__(self, **kwargs):
        super(Snapshot, self).__init__(**kwargs)
        self.managed_by = None
        self.sku = kwargs.get('sku', None)
        self.time_created = None
        self.os_type = kwargs.get('os_type', None)
        self.hyper_vgeneration = kwargs.get('hyper_vgeneration', None)
        self.creation_data = kwargs.get('creation_data', None)
        self.disk_size_gb = kwargs.get('disk_size_gb', None)
        self.disk_size_bytes = None
        self.disk_state = kwargs.get('disk_state', None)
        self.unique_id = None
        self.encryption_settings_collection = kwargs.get('encryption_settings_collection', None)
        self.provisioning_state = None
        self.incremental = kwargs.get('incremental', None)
        self.encryption = kwargs.get('encryption', None)
        self.network_access_policy = kwargs.get('network_access_policy', None)
        self.disk_access_id = kwargs.get('disk_access_id', None)


class SnapshotSku(Model):
    """The snapshots sku name. Can be Standard_LRS, Premium_LRS, or Standard_ZRS.

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

    :param name: The sku name. Possible values include: 'Standard_LRS',
     'Premium_LRS', 'Standard_ZRS'
    :type name: str or
     ~azure.mgmt.compute.v2020_06_30.models.SnapshotStorageAccountTypes
    :ivar tier: The sku tier.
    :vartype tier: str
    """

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

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

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


class SnapshotUpdate(Model):
    """Snapshot update resource.

    :param os_type: the Operating System type. Possible values include:
     'Windows', 'Linux'
    :type os_type: str or
     ~azure.mgmt.compute.v2020_06_30.models.OperatingSystemTypes
    :param disk_size_gb: If creationData.createOption is Empty, this field is
     mandatory and it indicates the size of the disk to create. If this field
     is present for updates or creation with other options, it indicates a
     resize. Resizes are only allowed if the disk is not attached to a running
     VM, and can only increase the disk's size.
    :type disk_size_gb: int
    :param encryption_settings_collection: Encryption settings collection used
     be Azure Disk Encryption, can contain multiple encryption settings per
     disk or snapshot.
    :type encryption_settings_collection:
     ~azure.mgmt.compute.v2020_06_30.models.EncryptionSettingsCollection
    :param encryption: Encryption property can be used to encrypt data at rest
     with customer managed keys or platform managed keys.
    :type encryption: ~azure.mgmt.compute.v2020_06_30.models.Encryption
    :param network_access_policy: Possible values include: 'AllowAll',
     'AllowPrivate', 'DenyAll'
    :type network_access_policy: str or
     ~azure.mgmt.compute.v2020_06_30.models.NetworkAccessPolicy
    :param disk_access_id: ARM id of the DiskAccess resource for using private
     endpoints on disks.
    :type disk_access_id: str
    :param tags: Resource tags
    :type tags: dict[str, str]
    :param sku:
    :type sku: ~azure.mgmt.compute.v2020_06_30.models.SnapshotSku
    """

    _attribute_map = {
        'os_type': {'key': 'properties.osType', 'type': 'OperatingSystemTypes'},
        'disk_size_gb': {'key': 'properties.diskSizeGB', 'type': 'int'},
        'encryption_settings_collection': {'key': 'properties.encryptionSettingsCollection', 'type': 'EncryptionSettingsCollection'},
        'encryption': {'key': 'properties.encryption', 'type': 'Encryption'},
        'network_access_policy': {'key': 'properties.networkAccessPolicy', 'type': 'str'},
        'disk_access_id': {'key': 'properties.diskAccessId', 'type': 'str'},
        'tags': {'key': 'tags', 'type': '{str}'},
        'sku': {'key': 'sku', 'type': 'SnapshotSku'},
    }

    def __init__(self, **kwargs):
        super(SnapshotUpdate, self).__init__(**kwargs)
        self.os_type = kwargs.get('os_type', None)
        self.disk_size_gb = kwargs.get('disk_size_gb', None)
        self.encryption_settings_collection = kwargs.get('encryption_settings_collection', None)
        self.encryption = kwargs.get('encryption', None)
        self.network_access_policy = kwargs.get('network_access_policy', None)
        self.disk_access_id = kwargs.get('disk_access_id', None)
        self.tags = kwargs.get('tags', None)
        self.sku = kwargs.get('sku', None)


class SourceVault(Model):
    """The vault id is an Azure Resource Manager Resource id in the form
    /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}.

    :param id: Resource Id
    :type id: str
    """

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

    def __init__(self, **kwargs):
        super(SourceVault, self).__init__(**kwargs)
        self.id = kwargs.get('id', None)
