xref: /dports/devel/py-azure-mgmt-databoxedge/azure-mgmt-databoxedge-1.0.0/azure/mgmt/databoxedge/v2020_05_01_preview/models/_models_py3.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 datetime
from typing import Dict, List, Optional, Union

import msrest.serialization

from ._data_box_edge_management_client_enums import *


class Address(msrest.serialization.Model):
    """The shipping address of the customer.

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

    :param address_line1: Required. The address line1.
    :type address_line1: str
    :param address_line2: The address line2.
    :type address_line2: str
    :param address_line3: The address line3.
    :type address_line3: str
    :param postal_code: Required. The postal code.
    :type postal_code: str
    :param city: Required. The city name.
    :type city: str
    :param state: Required. The state name.
    :type state: str
    :param country: Required. The country name.
    :type country: str
    """

    _validation = {
        'address_line1': {'required': True},
        'postal_code': {'required': True},
        'city': {'required': True},
        'state': {'required': True},
        'country': {'required': True},
    }

    _attribute_map = {
        'address_line1': {'key': 'addressLine1', 'type': 'str'},
        'address_line2': {'key': 'addressLine2', 'type': 'str'},
        'address_line3': {'key': 'addressLine3', 'type': 'str'},
        'postal_code': {'key': 'postalCode', 'type': 'str'},
        'city': {'key': 'city', 'type': 'str'},
        'state': {'key': 'state', 'type': 'str'},
        'country': {'key': 'country', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        address_line1: str,
        postal_code: str,
        city: str,
        state: str,
        country: str,
        address_line2: Optional[str] = None,
        address_line3: Optional[str] = None,
        **kwargs
    ):
        super(Address, self).__init__(**kwargs)
        self.address_line1 = address_line1
        self.address_line2 = address_line2
        self.address_line3 = address_line3
        self.postal_code = postal_code
        self.city = city
        self.state = state
        self.country = country


class ARMBaseModel(msrest.serialization.Model):
    """Represents the base class for all object models.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(ARMBaseModel, self).__init__(**kwargs)
        self.id = None
        self.name = None
        self.type = None


class Alert(ARMBaseModel):
    """Alert on the data box edge/gateway device.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :ivar title: Alert title.
    :vartype title: str
    :ivar alert_type: Alert type.
    :vartype alert_type: str
    :ivar appeared_at_date_time: UTC time when the alert appeared.
    :vartype appeared_at_date_time: ~datetime.datetime
    :ivar recommendation: Alert recommendation.
    :vartype recommendation: str
    :ivar severity: Severity of the alert. Possible values include: "Informational", "Warning",
     "Critical".
    :vartype severity: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AlertSeverity
    :ivar error_details: Error details of the alert.
    :vartype error_details: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AlertErrorDetails
    :ivar detailed_information: Alert details.
    :vartype detailed_information: dict[str, str]
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'title': {'readonly': True},
        'alert_type': {'readonly': True},
        'appeared_at_date_time': {'readonly': True},
        'recommendation': {'readonly': True},
        'severity': {'readonly': True},
        'error_details': {'readonly': True},
        'detailed_information': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'title': {'key': 'properties.title', 'type': 'str'},
        'alert_type': {'key': 'properties.alertType', 'type': 'str'},
        'appeared_at_date_time': {'key': 'properties.appearedAtDateTime', 'type': 'iso-8601'},
        'recommendation': {'key': 'properties.recommendation', 'type': 'str'},
        'severity': {'key': 'properties.severity', 'type': 'str'},
        'error_details': {'key': 'properties.errorDetails', 'type': 'AlertErrorDetails'},
        'detailed_information': {'key': 'properties.detailedInformation', 'type': '{str}'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Alert, self).__init__(**kwargs)
        self.title = None
        self.alert_type = None
        self.appeared_at_date_time = None
        self.recommendation = None
        self.severity = None
        self.error_details = None
        self.detailed_information = None


class AlertErrorDetails(msrest.serialization.Model):
    """Error details for the alert.

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

    :ivar error_code: Error code.
    :vartype error_code: str
    :ivar error_message: Error Message.
    :vartype error_message: str
    :ivar occurrences: Number of occurrences.
    :vartype occurrences: int
    """

    _validation = {
        'error_code': {'readonly': True},
        'error_message': {'readonly': True},
        'occurrences': {'readonly': True},
    }

    _attribute_map = {
        'error_code': {'key': 'errorCode', 'type': 'str'},
        'error_message': {'key': 'errorMessage', 'type': 'str'},
        'occurrences': {'key': 'occurrences', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(AlertErrorDetails, self).__init__(**kwargs)
        self.error_code = None
        self.error_message = None
        self.occurrences = None


class AlertList(msrest.serialization.Model):
    """Collection of alerts.

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

    :ivar value: The value.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.Alert]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(AlertList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class AsymmetricEncryptedSecret(msrest.serialization.Model):
    """Represent the secrets intended for encryption with asymmetric key pair.

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

    :param value: Required. The value of the secret.
    :type value: str
    :param encryption_cert_thumbprint: Thumbprint certificate used to encrypt \"Value\". If the
     value is unencrypted, it will be null.
    :type encryption_cert_thumbprint: str
    :param encryption_algorithm: Required. The algorithm used to encrypt "Value". Possible values
     include: "None", "AES256", "RSAES_PKCS1_v_1_5".
    :type encryption_algorithm: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.EncryptionAlgorithm
    """

    _validation = {
        'value': {'required': True},
        'encryption_algorithm': {'required': True},
    }

    _attribute_map = {
        'value': {'key': 'value', 'type': 'str'},
        'encryption_cert_thumbprint': {'key': 'encryptionCertThumbprint', 'type': 'str'},
        'encryption_algorithm': {'key': 'encryptionAlgorithm', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        value: str,
        encryption_algorithm: Union[str, "EncryptionAlgorithm"],
        encryption_cert_thumbprint: Optional[str] = None,
        **kwargs
    ):
        super(AsymmetricEncryptedSecret, self).__init__(**kwargs)
        self.value = value
        self.encryption_cert_thumbprint = encryption_cert_thumbprint
        self.encryption_algorithm = encryption_algorithm


class Authentication(msrest.serialization.Model):
    """Authentication mechanism for IoT devices.

    :param symmetric_key: Symmetric key for authentication.
    :type symmetric_key: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SymmetricKey
    """

    _attribute_map = {
        'symmetric_key': {'key': 'symmetricKey', 'type': 'SymmetricKey'},
    }

    def __init__(
        self,
        *,
        symmetric_key: Optional["SymmetricKey"] = None,
        **kwargs
    ):
        super(Authentication, self).__init__(**kwargs)
        self.symmetric_key = symmetric_key


class AzureContainerInfo(msrest.serialization.Model):
    """Azure container mapping of the endpoint.

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

    :param storage_account_credential_id: Required. ID of the storage account credential used to
     access storage.
    :type storage_account_credential_id: str
    :param container_name: Required. Container name (Based on the data format specified, this
     represents the name of Azure Files/Page blob/Block blob).
    :type container_name: str
    :param data_format: Required. Storage format used for the file represented by the share.
     Possible values include: "BlockBlob", "PageBlob", "AzureFile".
    :type data_format: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AzureContainerDataFormat
    """

    _validation = {
        'storage_account_credential_id': {'required': True},
        'container_name': {'required': True},
        'data_format': {'required': True},
    }

    _attribute_map = {
        'storage_account_credential_id': {'key': 'storageAccountCredentialId', 'type': 'str'},
        'container_name': {'key': 'containerName', 'type': 'str'},
        'data_format': {'key': 'dataFormat', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        storage_account_credential_id: str,
        container_name: str,
        data_format: Union[str, "AzureContainerDataFormat"],
        **kwargs
    ):
        super(AzureContainerInfo, self).__init__(**kwargs)
        self.storage_account_credential_id = storage_account_credential_id
        self.container_name = container_name
        self.data_format = data_format


class BandwidthSchedule(ARMBaseModel):
    """The bandwidth schedule details.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param start: Required. The start time of the schedule in UTC.
    :type start: str
    :param stop: Required. The stop time of the schedule in UTC.
    :type stop: str
    :param rate_in_mbps: Required. The bandwidth rate in Mbps.
    :type rate_in_mbps: int
    :param days: Required. The days of the week when this schedule is applicable.
    :type days: list[str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.DayOfWeek]
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'start': {'required': True},
        'stop': {'required': True},
        'rate_in_mbps': {'required': True},
        'days': {'required': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'start': {'key': 'properties.start', 'type': 'str'},
        'stop': {'key': 'properties.stop', 'type': 'str'},
        'rate_in_mbps': {'key': 'properties.rateInMbps', 'type': 'int'},
        'days': {'key': 'properties.days', 'type': '[str]'},
    }

    def __init__(
        self,
        *,
        start: str,
        stop: str,
        rate_in_mbps: int,
        days: List[Union[str, "DayOfWeek"]],
        **kwargs
    ):
        super(BandwidthSchedule, self).__init__(**kwargs)
        self.start = start
        self.stop = stop
        self.rate_in_mbps = rate_in_mbps
        self.days = days


class BandwidthSchedulesList(msrest.serialization.Model):
    """The collection of bandwidth schedules.

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

    :ivar value: The list of bandwidth schedules.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.BandwidthSchedule]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(BandwidthSchedulesList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class ClientAccessRight(msrest.serialization.Model):
    """The mapping between a particular client IP and the type of access client has on the NFS share.

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

    :param client: Required. IP of the client.
    :type client: str
    :param access_permission: Required. Type of access to be allowed for the client. Possible
     values include: "NoAccess", "ReadOnly", "ReadWrite".
    :type access_permission: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ClientPermissionType
    """

    _validation = {
        'client': {'required': True},
        'access_permission': {'required': True},
    }

    _attribute_map = {
        'client': {'key': 'client', 'type': 'str'},
        'access_permission': {'key': 'accessPermission', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        client: str,
        access_permission: Union[str, "ClientPermissionType"],
        **kwargs
    ):
        super(ClientAccessRight, self).__init__(**kwargs)
        self.client = client
        self.access_permission = access_permission


class CloudErrorBody(msrest.serialization.Model):
    """An error response from the service.

    :param code: An identifier for the error. Codes are invariant and are intended to be consumed
     programmatically.
    :type code: str
    :param message: A message describing the error, intended to be suitable for display in a user
     interface.
    :type message: str
    :param details: A list of additional details about the error.
    :type details: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.CloudErrorBody]
    """

    _attribute_map = {
        'code': {'key': 'code', 'type': 'str'},
        'message': {'key': 'message', 'type': 'str'},
        'details': {'key': 'details', 'type': '[CloudErrorBody]'},
    }

    def __init__(
        self,
        *,
        code: Optional[str] = None,
        message: Optional[str] = None,
        details: Optional[List["CloudErrorBody"]] = None,
        **kwargs
    ):
        super(CloudErrorBody, self).__init__(**kwargs)
        self.code = code
        self.message = message
        self.details = details


class ContactDetails(msrest.serialization.Model):
    """Contains all the contact details of the customer.

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

    :param contact_person: Required. The contact person name.
    :type contact_person: str
    :param company_name: Required. The name of the company.
    :type company_name: str
    :param phone: Required. The phone number.
    :type phone: str
    :param email_list: Required. The email list.
    :type email_list: list[str]
    """

    _validation = {
        'contact_person': {'required': True},
        'company_name': {'required': True},
        'phone': {'required': True},
        'email_list': {'required': True},
    }

    _attribute_map = {
        'contact_person': {'key': 'contactPerson', 'type': 'str'},
        'company_name': {'key': 'companyName', 'type': 'str'},
        'phone': {'key': 'phone', 'type': 'str'},
        'email_list': {'key': 'emailList', 'type': '[str]'},
    }

    def __init__(
        self,
        *,
        contact_person: str,
        company_name: str,
        phone: str,
        email_list: List[str],
        **kwargs
    ):
        super(ContactDetails, self).__init__(**kwargs)
        self.contact_person = contact_person
        self.company_name = company_name
        self.phone = phone
        self.email_list = email_list


class Container(ARMBaseModel):
    """Represents a container on the  Data Box Edge/Gateway device.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :ivar container_status: Current status of the container. Possible values include: "OK",
     "Offline", "Unknown", "Updating", "NeedsAttention".
    :vartype container_status: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ContainerStatus
    :param data_format: Required. DataFormat for Container. Possible values include: "BlockBlob",
     "PageBlob", "AzureFile".
    :type data_format: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AzureContainerDataFormat
    :ivar refresh_details: Details of the refresh job on this container.
    :vartype refresh_details: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RefreshDetails
    :ivar created_date_time: The UTC time when container got created.
    :vartype created_date_time: ~datetime.datetime
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'container_status': {'readonly': True},
        'data_format': {'required': True},
        'refresh_details': {'readonly': True},
        'created_date_time': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'container_status': {'key': 'properties.containerStatus', 'type': 'str'},
        'data_format': {'key': 'properties.dataFormat', 'type': 'str'},
        'refresh_details': {'key': 'properties.refreshDetails', 'type': 'RefreshDetails'},
        'created_date_time': {'key': 'properties.createdDateTime', 'type': 'iso-8601'},
    }

    def __init__(
        self,
        *,
        data_format: Union[str, "AzureContainerDataFormat"],
        **kwargs
    ):
        super(Container, self).__init__(**kwargs)
        self.container_status = None
        self.data_format = data_format
        self.refresh_details = None
        self.created_date_time = None


class ContainerList(msrest.serialization.Model):
    """Collection of all the containers on the Data Box Edge/Gateway device.

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

    :ivar value: The list of containers.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.Container]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(ContainerList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class DataBoxEdgeDevice(ARMBaseModel):
    """The Data Box Edge/Gateway device.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param location: Required. The location of the device. This is a supported and registered Azure
     geographical region (for example, West US, East US, or Southeast Asia). The geographical region
     of a device cannot be changed once it is created, but if an identical geographical region is
     specified on update, the request will succeed.
    :type location: str
    :param tags: A set of tags. The list of tags that describe the device. These tags can be used
     to view and group this device (across resource groups).
    :type tags: dict[str, str]
    :param sku: The SKU type.
    :type sku: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.Sku
    :param etag: The etag for the devices.
    :type etag: str
    :param data_box_edge_device_status: The status of the Data Box Edge/Gateway device. Possible
     values include: "ReadyToSetup", "Online", "Offline", "NeedsAttention", "Disconnected",
     "PartiallyDisconnected", "Maintenance".
    :type data_box_edge_device_status: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.DataBoxEdgeDeviceStatus
    :ivar serial_number: The Serial Number of Data Box Edge/Gateway device.
    :vartype serial_number: str
    :param description: The Description of the Data Box Edge/Gateway device.
    :type description: str
    :param model_description: The description of the Data Box Edge/Gateway device model.
    :type model_description: str
    :ivar device_type: The type of the Data Box Edge/Gateway device. Possible values include:
     "DataBoxEdgeDevice".
    :vartype device_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.DeviceType
    :param friendly_name: The Data Box Edge/Gateway device name.
    :type friendly_name: str
    :ivar culture: The Data Box Edge/Gateway device culture.
    :vartype culture: str
    :ivar device_model: The Data Box Edge/Gateway device model.
    :vartype device_model: str
    :ivar device_software_version: The Data Box Edge/Gateway device software version.
    :vartype device_software_version: str
    :ivar device_local_capacity: The Data Box Edge/Gateway device local capacity in MB.
    :vartype device_local_capacity: long
    :ivar time_zone: The Data Box Edge/Gateway device timezone.
    :vartype time_zone: str
    :ivar device_hcs_version: The device software version number of the device (eg: 1.2.18105.6).
    :vartype device_hcs_version: str
    :ivar configured_role_types: Type of compute roles configured.
    :vartype configured_role_types: list[str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RoleTypes]
    :ivar node_count: The number of nodes in the cluster.
    :vartype node_count: int
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'location': {'required': True},
        'serial_number': {'readonly': True},
        'device_type': {'readonly': True},
        'culture': {'readonly': True},
        'device_model': {'readonly': True},
        'device_software_version': {'readonly': True},
        'device_local_capacity': {'readonly': True},
        'time_zone': {'readonly': True},
        'device_hcs_version': {'readonly': True},
        'configured_role_types': {'readonly': True},
        'node_count': {'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}'},
        'sku': {'key': 'sku', 'type': 'Sku'},
        'etag': {'key': 'etag', 'type': 'str'},
        'data_box_edge_device_status': {'key': 'properties.dataBoxEdgeDeviceStatus', 'type': 'str'},
        'serial_number': {'key': 'properties.serialNumber', 'type': 'str'},
        'description': {'key': 'properties.description', 'type': 'str'},
        'model_description': {'key': 'properties.modelDescription', 'type': 'str'},
        'device_type': {'key': 'properties.deviceType', 'type': 'str'},
        'friendly_name': {'key': 'properties.friendlyName', 'type': 'str'},
        'culture': {'key': 'properties.culture', 'type': 'str'},
        'device_model': {'key': 'properties.deviceModel', 'type': 'str'},
        'device_software_version': {'key': 'properties.deviceSoftwareVersion', 'type': 'str'},
        'device_local_capacity': {'key': 'properties.deviceLocalCapacity', 'type': 'long'},
        'time_zone': {'key': 'properties.timeZone', 'type': 'str'},
        'device_hcs_version': {'key': 'properties.deviceHcsVersion', 'type': 'str'},
        'configured_role_types': {'key': 'properties.configuredRoleTypes', 'type': '[str]'},
        'node_count': {'key': 'properties.nodeCount', 'type': 'int'},
    }

    def __init__(
        self,
        *,
        location: str,
        tags: Optional[Dict[str, str]] = None,
        sku: Optional["Sku"] = None,
        etag: Optional[str] = None,
        data_box_edge_device_status: Optional[Union[str, "DataBoxEdgeDeviceStatus"]] = None,
        description: Optional[str] = None,
        model_description: Optional[str] = None,
        friendly_name: Optional[str] = None,
        **kwargs
    ):
        super(DataBoxEdgeDevice, self).__init__(**kwargs)
        self.location = location
        self.tags = tags
        self.sku = sku
        self.etag = etag
        self.data_box_edge_device_status = data_box_edge_device_status
        self.serial_number = None
        self.description = description
        self.model_description = model_description
        self.device_type = None
        self.friendly_name = friendly_name
        self.culture = None
        self.device_model = None
        self.device_software_version = None
        self.device_local_capacity = None
        self.time_zone = None
        self.device_hcs_version = None
        self.configured_role_types = None
        self.node_count = None


class DataBoxEdgeDeviceExtendedInfo(ARMBaseModel):
    """The extended Info of the Data Box Edge/Gateway device.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param encryption_key_thumbprint: The digital signature of encrypted certificate.
    :type encryption_key_thumbprint: str
    :param encryption_key: The public part of the encryption certificate. Client uses this to
     encrypt any secret.
    :type encryption_key: str
    :ivar resource_key: The Resource ID of the Resource.
    :vartype resource_key: str
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'encryption_key_thumbprint': {'key': 'properties.encryptionKeyThumbprint', 'type': 'str'},
        'encryption_key': {'key': 'properties.encryptionKey', 'type': 'str'},
        'resource_key': {'key': 'properties.resourceKey', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        encryption_key_thumbprint: Optional[str] = None,
        encryption_key: Optional[str] = None,
        **kwargs
    ):
        super(DataBoxEdgeDeviceExtendedInfo, self).__init__(**kwargs)
        self.encryption_key_thumbprint = encryption_key_thumbprint
        self.encryption_key = encryption_key
        self.resource_key = None


class DataBoxEdgeDeviceList(msrest.serialization.Model):
    """The collection of Data Box Edge/Gateway devices.

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

    :ivar value: The list of Data Box Edge/Gateway devices.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.DataBoxEdgeDevice]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(DataBoxEdgeDeviceList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class DataBoxEdgeDevicePatch(msrest.serialization.Model):
    """The Data Box Edge/Gateway device patch.

    :param tags: A set of tags. The tags attached to the Data Box Edge/Gateway resource.
    :type tags: dict[str, str]
    """

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

    def __init__(
        self,
        *,
        tags: Optional[Dict[str, str]] = None,
        **kwargs
    ):
        super(DataBoxEdgeDevicePatch, self).__init__(**kwargs)
        self.tags = tags


class DataBoxEdgeSku(msrest.serialization.Model):
    """The Sku information.

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

    :ivar resource_type: The type of the resource.
    :vartype resource_type: str
    :ivar name: The Sku name. Possible values include: "Gateway", "Edge", "TEA_1Node",
     "TEA_1Node_UPS", "TEA_1Node_Heater", "TEA_1Node_UPS_Heater", "TEA_4Node_Heater",
     "TEA_4Node_UPS_Heater", "TMA", "TDC", "TCA_Large", "TCA_Small", "GPU".
    :vartype name: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuName
    :ivar kind: The Sku kind.
    :vartype kind: str
    :ivar tier: The Sku tier. Possible values include: "Standard".
    :vartype tier: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuTier
    :ivar size: The Sku kind.
    :vartype size: str
    :ivar family: The Sku family.
    :vartype family: str
    :ivar locations: Availability of the Sku for the region.
    :vartype locations: list[str]
    :ivar api_versions: The API versions in which Sku is available.
    :vartype api_versions: list[str]
    :ivar location_info: Availability of the Sku for the location/zone/site.
    :vartype location_info:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuLocationInfo]
    :ivar costs: The pricing info of the Sku.
    :vartype costs: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuCost]
    :ivar restrictions: Restriction info of the SKU.
    :vartype restrictions: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuRestriction]
    :ivar signup_option: Can the SKU be signed up.. Possible values include: "None", "Available".
    :vartype signup_option: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuSignupOption
    :ivar version: Sku version. Possible values include: "Stable", "Preview".
    :vartype version: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuVersion
    :ivar availability: Is SKU available. Possible values include: "Available", "Unavailable".
    :vartype availability: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuAvailability
    """

    _validation = {
        'resource_type': {'readonly': True},
        'name': {'readonly': True},
        'kind': {'readonly': True},
        'tier': {'readonly': True},
        'size': {'readonly': True},
        'family': {'readonly': True},
        'locations': {'readonly': True},
        'api_versions': {'readonly': True},
        'location_info': {'readonly': True},
        'costs': {'readonly': True},
        'restrictions': {'readonly': True},
        'signup_option': {'readonly': True},
        'version': {'readonly': True},
        'availability': {'readonly': True},
    }

    _attribute_map = {
        'resource_type': {'key': 'resourceType', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'kind': {'key': 'kind', 'type': 'str'},
        'tier': {'key': 'tier', 'type': 'str'},
        'size': {'key': 'size', 'type': 'str'},
        'family': {'key': 'family', 'type': 'str'},
        'locations': {'key': 'locations', 'type': '[str]'},
        'api_versions': {'key': 'apiVersions', 'type': '[str]'},
        'location_info': {'key': 'locationInfo', 'type': '[SkuLocationInfo]'},
        'costs': {'key': 'costs', 'type': '[SkuCost]'},
        'restrictions': {'key': 'restrictions', 'type': '[SkuRestriction]'},
        'signup_option': {'key': 'signupOption', 'type': 'str'},
        'version': {'key': 'version', 'type': 'str'},
        'availability': {'key': 'availability', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(DataBoxEdgeSku, self).__init__(**kwargs)
        self.resource_type = None
        self.name = None
        self.kind = None
        self.tier = None
        self.size = None
        self.family = None
        self.locations = None
        self.api_versions = None
        self.location_info = None
        self.costs = None
        self.restrictions = None
        self.signup_option = None
        self.version = None
        self.availability = None


class DataBoxEdgeSkuList(msrest.serialization.Model):
    """List of SKU Information objects.

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

    :ivar value: List of ResourceType Sku.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.DataBoxEdgeSku]
    :ivar next_link: Links to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(DataBoxEdgeSkuList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class Trigger(ARMBaseModel):
    """Trigger details.

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

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param kind: Required. Trigger Kind.Constant filled by server.  Possible values include:
     "FileEvent", "PeriodicTimerEvent".
    :type kind: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.TriggerEventType
    """

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

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

    _subtype_map = {
        'kind': {'FileEvent': 'FileEventTrigger', 'PeriodicTimerEvent': 'PeriodicTimerEventTrigger'}
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Trigger, self).__init__(**kwargs)
        self.kind = 'Trigger'  # type: str


class FileEventTrigger(Trigger):
    """Trigger details.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param kind: Required. Trigger Kind.Constant filled by server.  Possible values include:
     "FileEvent", "PeriodicTimerEvent".
    :type kind: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.TriggerEventType
    :param source_info: Required. File event source details.
    :type source_info: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.FileSourceInfo
    :param sink_info: Required. Role sink info.
    :type sink_info: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RoleSinkInfo
    :param custom_context_tag: A custom context tag typically used to correlate the trigger against
     its usage. For example, if a periodic timer trigger is intended for certain specific IoT
     modules in the device, the tag can be the name or the image URL of the module.
    :type custom_context_tag: str
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'kind': {'required': True},
        'source_info': {'required': True},
        'sink_info': {'required': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'kind': {'key': 'kind', 'type': 'str'},
        'source_info': {'key': 'properties.sourceInfo', 'type': 'FileSourceInfo'},
        'sink_info': {'key': 'properties.sinkInfo', 'type': 'RoleSinkInfo'},
        'custom_context_tag': {'key': 'properties.customContextTag', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        source_info: "FileSourceInfo",
        sink_info: "RoleSinkInfo",
        custom_context_tag: Optional[str] = None,
        **kwargs
    ):
        super(FileEventTrigger, self).__init__(**kwargs)
        self.kind = 'FileEvent'  # type: str
        self.source_info = source_info
        self.sink_info = sink_info
        self.custom_context_tag = custom_context_tag


class FileSourceInfo(msrest.serialization.Model):
    """File source details.

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

    :param share_id: Required. File share ID.
    :type share_id: str
    """

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

    _attribute_map = {
        'share_id': {'key': 'shareId', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        share_id: str,
        **kwargs
    ):
        super(FileSourceInfo, self).__init__(**kwargs)
        self.share_id = share_id


class ImageRepositoryCredential(msrest.serialization.Model):
    """Image repository credential.

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

    :param image_repository_url: Required. Image repository url (e.g.: mcr.microsoft.com).
    :type image_repository_url: str
    :param user_name: Required. Repository user name.
    :type user_name: str
    :param password: Repository user password.
    :type password: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AsymmetricEncryptedSecret
    """

    _validation = {
        'image_repository_url': {'required': True},
        'user_name': {'required': True},
    }

    _attribute_map = {
        'image_repository_url': {'key': 'imageRepositoryUrl', 'type': 'str'},
        'user_name': {'key': 'userName', 'type': 'str'},
        'password': {'key': 'password', 'type': 'AsymmetricEncryptedSecret'},
    }

    def __init__(
        self,
        *,
        image_repository_url: str,
        user_name: str,
        password: Optional["AsymmetricEncryptedSecret"] = None,
        **kwargs
    ):
        super(ImageRepositoryCredential, self).__init__(**kwargs)
        self.image_repository_url = image_repository_url
        self.user_name = user_name
        self.password = password


class IoTDeviceInfo(msrest.serialization.Model):
    """Metadata of IoT device/IoT Edge device to be configured.

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

    :param device_id: Required. ID of the IoT device/edge device.
    :type device_id: str
    :param io_t_host_hub: Required. Host name for the IoT hub associated to the device.
    :type io_t_host_hub: str
    :param io_t_host_hub_id: Id for the IoT hub associated to the device.
    :type io_t_host_hub_id: str
    :param authentication: Encrypted IoT device/IoT edge device connection string.
    :type authentication: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.Authentication
    """

    _validation = {
        'device_id': {'required': True},
        'io_t_host_hub': {'required': True},
    }

    _attribute_map = {
        'device_id': {'key': 'deviceId', 'type': 'str'},
        'io_t_host_hub': {'key': 'ioTHostHub', 'type': 'str'},
        'io_t_host_hub_id': {'key': 'ioTHostHubId', 'type': 'str'},
        'authentication': {'key': 'authentication', 'type': 'Authentication'},
    }

    def __init__(
        self,
        *,
        device_id: str,
        io_t_host_hub: str,
        io_t_host_hub_id: Optional[str] = None,
        authentication: Optional["Authentication"] = None,
        **kwargs
    ):
        super(IoTDeviceInfo, self).__init__(**kwargs)
        self.device_id = device_id
        self.io_t_host_hub = io_t_host_hub
        self.io_t_host_hub_id = io_t_host_hub_id
        self.authentication = authentication


class IoTEdgeAgentInfo(msrest.serialization.Model):
    """IoT edge agent details is optional, this will be used for download system Agent module while bootstrapping IoT Role if specified.

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

    :param image_name: Required. Name of the IoT edge agent image.
    :type image_name: str
    :param tag: Required. Image Tag.
    :type tag: str
    :param image_repository: Image repository details.
    :type image_repository:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ImageRepositoryCredential
    """

    _validation = {
        'image_name': {'required': True},
        'tag': {'required': True},
    }

    _attribute_map = {
        'image_name': {'key': 'imageName', 'type': 'str'},
        'tag': {'key': 'tag', 'type': 'str'},
        'image_repository': {'key': 'imageRepository', 'type': 'ImageRepositoryCredential'},
    }

    def __init__(
        self,
        *,
        image_name: str,
        tag: str,
        image_repository: Optional["ImageRepositoryCredential"] = None,
        **kwargs
    ):
        super(IoTEdgeAgentInfo, self).__init__(**kwargs)
        self.image_name = image_name
        self.tag = tag
        self.image_repository = image_repository


class Role(ARMBaseModel):
    """Compute role.

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

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param kind: Required. Role type.Constant filled by server.  Possible values include: "IOT",
     "ASA", "Functions", "Cognitive".
    :type kind: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RoleTypes
    """

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

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

    _subtype_map = {
        'kind': {'IOT': 'IoTRole'}
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Role, self).__init__(**kwargs)
        self.kind = 'Role'  # type: str


class IoTRole(Role):
    """Compute role.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param kind: Required. Role type.Constant filled by server.  Possible values include: "IOT",
     "ASA", "Functions", "Cognitive".
    :type kind: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RoleTypes
    :param host_platform: Host OS supported by the IoT role. Possible values include: "Windows",
     "Linux".
    :type host_platform: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.PlatformType
    :param io_t_device_details: IoT device metadata to which data box edge device needs to be
     connected.
    :type io_t_device_details: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.IoTDeviceInfo
    :param io_t_edge_device_details: IoT edge device to which the IoT role needs to be configured.
    :type io_t_edge_device_details:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.IoTDeviceInfo
    :param share_mappings: Mount points of shares in role(s).
    :type share_mappings: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.MountPointMap]
    :param io_t_edge_agent_info: Iot edge agent details to download the agent and bootstrap iot
     runtime.
    :type io_t_edge_agent_info: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.IoTEdgeAgentInfo
    :ivar host_platform_type: Platform where the Iot runtime is hosted. Possible values include:
     "KubernetesCluster", "LinuxVM".
    :vartype host_platform_type: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.HostPlatformType
    :param role_status: Role status. Possible values include: "Enabled", "Disabled".
    :type role_status: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RoleStatus
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'kind': {'key': 'kind', 'type': 'str'},
        'host_platform': {'key': 'properties.hostPlatform', 'type': 'str'},
        'io_t_device_details': {'key': 'properties.ioTDeviceDetails', 'type': 'IoTDeviceInfo'},
        'io_t_edge_device_details': {'key': 'properties.ioTEdgeDeviceDetails', 'type': 'IoTDeviceInfo'},
        'share_mappings': {'key': 'properties.shareMappings', 'type': '[MountPointMap]'},
        'io_t_edge_agent_info': {'key': 'properties.ioTEdgeAgentInfo', 'type': 'IoTEdgeAgentInfo'},
        'host_platform_type': {'key': 'properties.hostPlatformType', 'type': 'str'},
        'role_status': {'key': 'properties.roleStatus', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        host_platform: Optional[Union[str, "PlatformType"]] = None,
        io_t_device_details: Optional["IoTDeviceInfo"] = None,
        io_t_edge_device_details: Optional["IoTDeviceInfo"] = None,
        share_mappings: Optional[List["MountPointMap"]] = None,
        io_t_edge_agent_info: Optional["IoTEdgeAgentInfo"] = None,
        role_status: Optional[Union[str, "RoleStatus"]] = None,
        **kwargs
    ):
        super(IoTRole, self).__init__(**kwargs)
        self.kind = 'IOT'  # type: str
        self.host_platform = host_platform
        self.io_t_device_details = io_t_device_details
        self.io_t_edge_device_details = io_t_edge_device_details
        self.share_mappings = share_mappings
        self.io_t_edge_agent_info = io_t_edge_agent_info
        self.host_platform_type = None
        self.role_status = role_status


class Ipv4Config(msrest.serialization.Model):
    """Details related to the IPv4 address configuration.

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

    :ivar ip_address: The IPv4 address of the network adapter.
    :vartype ip_address: str
    :ivar subnet: The IPv4 subnet of the network adapter.
    :vartype subnet: str
    :ivar gateway: The IPv4 gateway of the network adapter.
    :vartype gateway: str
    """

    _validation = {
        'ip_address': {'readonly': True},
        'subnet': {'readonly': True},
        'gateway': {'readonly': True},
    }

    _attribute_map = {
        'ip_address': {'key': 'ipAddress', 'type': 'str'},
        'subnet': {'key': 'subnet', 'type': 'str'},
        'gateway': {'key': 'gateway', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Ipv4Config, self).__init__(**kwargs)
        self.ip_address = None
        self.subnet = None
        self.gateway = None


class Ipv6Config(msrest.serialization.Model):
    """Details related to the IPv6 address configuration.

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

    :ivar ip_address: The IPv6 address of the network adapter.
    :vartype ip_address: str
    :ivar prefix_length: The IPv6 prefix of the network adapter.
    :vartype prefix_length: int
    :ivar gateway: The IPv6 gateway of the network adapter.
    :vartype gateway: str
    """

    _validation = {
        'ip_address': {'readonly': True},
        'prefix_length': {'readonly': True},
        'gateway': {'readonly': True},
    }

    _attribute_map = {
        'ip_address': {'key': 'ipAddress', 'type': 'str'},
        'prefix_length': {'key': 'prefixLength', 'type': 'int'},
        'gateway': {'key': 'gateway', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Ipv6Config, self).__init__(**kwargs)
        self.ip_address = None
        self.prefix_length = None
        self.gateway = None


class Job(msrest.serialization.Model):
    """A device job.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The name of the object.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :ivar status: The current status of the job. Possible values include: "Invalid", "Running",
     "Succeeded", "Failed", "Canceled", "Paused", "Scheduled".
    :vartype status: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.JobStatus
    :ivar start_time: The UTC date and time at which the job started.
    :vartype start_time: ~datetime.datetime
    :ivar end_time: The UTC date and time at which the job completed.
    :vartype end_time: ~datetime.datetime
    :ivar percent_complete: The percentage of the job that is complete.
    :vartype percent_complete: int
    :ivar error: The error details.
    :vartype error: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.JobErrorDetails
    :ivar job_type: The type of the job. Possible values include: "Invalid", "ScanForUpdates",
     "DownloadUpdates", "InstallUpdates", "RefreshShare", "RefreshContainer".
    :vartype job_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.JobType
    :ivar current_stage: Current stage of the update operation. Possible values include: "Unknown",
     "Initial", "ScanStarted", "ScanComplete", "ScanFailed", "DownloadStarted", "DownloadComplete",
     "DownloadFailed", "InstallStarted", "InstallComplete", "InstallFailed", "RebootInitiated",
     "Success", "Failure", "RescanStarted", "RescanComplete", "RescanFailed".
    :vartype current_stage: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.UpdateOperationStage
    :ivar download_progress: The download progress.
    :vartype download_progress:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.UpdateDownloadProgress
    :ivar install_progress: The install progress.
    :vartype install_progress:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.UpdateInstallProgress
    :ivar total_refresh_errors: Total number of errors encountered during the refresh process.
    :vartype total_refresh_errors: int
    :ivar error_manifest_file: Local share/remote container relative path to the error manifest
     file of the refresh.
    :vartype error_manifest_file: str
    :ivar refreshed_entity_id: ARM ID of the entity that was refreshed.
    :vartype refreshed_entity_id: str
    :param folder: If only subfolders need to be refreshed, then the subfolder path inside the
     share or container. (The path is empty if there are no subfolders.).
    :type folder: str
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'status': {'readonly': True},
        'start_time': {'readonly': True},
        'end_time': {'readonly': True},
        'percent_complete': {'readonly': True},
        'error': {'readonly': True},
        'job_type': {'readonly': True},
        'current_stage': {'readonly': True},
        'download_progress': {'readonly': True},
        'install_progress': {'readonly': True},
        'total_refresh_errors': {'readonly': True},
        'error_manifest_file': {'readonly': True},
        'refreshed_entity_id': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'status': {'key': 'status', 'type': 'str'},
        'start_time': {'key': 'startTime', 'type': 'iso-8601'},
        'end_time': {'key': 'endTime', 'type': 'iso-8601'},
        'percent_complete': {'key': 'percentComplete', 'type': 'int'},
        'error': {'key': 'error', 'type': 'JobErrorDetails'},
        'job_type': {'key': 'properties.jobType', 'type': 'str'},
        'current_stage': {'key': 'properties.currentStage', 'type': 'str'},
        'download_progress': {'key': 'properties.downloadProgress', 'type': 'UpdateDownloadProgress'},
        'install_progress': {'key': 'properties.installProgress', 'type': 'UpdateInstallProgress'},
        'total_refresh_errors': {'key': 'properties.totalRefreshErrors', 'type': 'int'},
        'error_manifest_file': {'key': 'properties.errorManifestFile', 'type': 'str'},
        'refreshed_entity_id': {'key': 'properties.refreshedEntityId', 'type': 'str'},
        'folder': {'key': 'properties.folder', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        folder: Optional[str] = None,
        **kwargs
    ):
        super(Job, self).__init__(**kwargs)
        self.id = None
        self.name = None
        self.type = None
        self.status = None
        self.start_time = None
        self.end_time = None
        self.percent_complete = None
        self.error = None
        self.job_type = None
        self.current_stage = None
        self.download_progress = None
        self.install_progress = None
        self.total_refresh_errors = None
        self.error_manifest_file = None
        self.refreshed_entity_id = None
        self.folder = folder


class JobErrorDetails(msrest.serialization.Model):
    """The job error information containing the list of job errors.

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

    :ivar error_details: The error details.
    :vartype error_details: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.JobErrorItem]
    :ivar code: The code intended for programmatic access.
    :vartype code: str
    :ivar message: The message that describes the error in detail.
    :vartype message: str
    """

    _validation = {
        'error_details': {'readonly': True},
        'code': {'readonly': True},
        'message': {'readonly': True},
    }

    _attribute_map = {
        'error_details': {'key': 'errorDetails', 'type': '[JobErrorItem]'},
        'code': {'key': 'code', 'type': 'str'},
        'message': {'key': 'message', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(JobErrorDetails, self).__init__(**kwargs)
        self.error_details = None
        self.code = None
        self.message = None


class JobErrorItem(msrest.serialization.Model):
    """The job error items.

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

    :ivar recommendations: The recommended actions.
    :vartype recommendations: list[str]
    :ivar code: The code intended for programmatic access.
    :vartype code: str
    :ivar message: The message that describes the error in detail.
    :vartype message: str
    """

    _validation = {
        'recommendations': {'readonly': True},
        'code': {'readonly': True},
        'message': {'readonly': True},
    }

    _attribute_map = {
        'recommendations': {'key': 'recommendations', 'type': '[str]'},
        'code': {'key': 'code', 'type': 'str'},
        'message': {'key': 'message', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(JobErrorItem, self).__init__(**kwargs)
        self.recommendations = None
        self.code = None
        self.message = None


class MetricDimensionV1(msrest.serialization.Model):
    """Metric Dimension v1.

    :param name: Name of the metrics dimension.
    :type name: str
    :param display_name: Display name of the metrics dimension.
    :type display_name: str
    :param to_be_exported_for_shoebox: To be exported to shoe box.
    :type to_be_exported_for_shoebox: bool
    """

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'display_name': {'key': 'displayName', 'type': 'str'},
        'to_be_exported_for_shoebox': {'key': 'toBeExportedForShoebox', 'type': 'bool'},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        display_name: Optional[str] = None,
        to_be_exported_for_shoebox: Optional[bool] = None,
        **kwargs
    ):
        super(MetricDimensionV1, self).__init__(**kwargs)
        self.name = name
        self.display_name = display_name
        self.to_be_exported_for_shoebox = to_be_exported_for_shoebox


class MetricSpecificationV1(msrest.serialization.Model):
    """Metric specification version 1.

    :param name: Name of the metric.
    :type name: str
    :param display_name: Display name of the metric.
    :type display_name: str
    :param display_description: Description of the metric to be displayed.
    :type display_description: str
    :param unit: Metric units. Possible values include: "NotSpecified", "Percent", "Count",
     "Seconds", "Milliseconds", "Bytes", "BytesPerSecond", "CountPerSecond".
    :type unit: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.MetricUnit
    :param aggregation_type: Metric aggregation type. Possible values include: "NotSpecified",
     "None", "Average", "Minimum", "Maximum", "Total", "Count".
    :type aggregation_type: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.MetricAggregationType
    :param dimensions: Metric dimensions, other than default dimension which is resource.
    :type dimensions: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.MetricDimensionV1]
    :param fill_gap_with_zero: Set true to fill the gaps with zero.
    :type fill_gap_with_zero: bool
    :param category: Metric category. Possible values include: "Capacity", "Transaction".
    :type category: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.MetricCategory
    :param resource_id_dimension_name_override: Resource name override.
    :type resource_id_dimension_name_override: str
    :param supported_time_grain_types: Support granularity of metrics.
    :type supported_time_grain_types: list[str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.TimeGrain]
    :param supported_aggregation_types: Support metric aggregation type.
    :type supported_aggregation_types: list[str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.MetricAggregationType]
    """

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'display_name': {'key': 'displayName', 'type': 'str'},
        'display_description': {'key': 'displayDescription', 'type': 'str'},
        'unit': {'key': 'unit', 'type': 'str'},
        'aggregation_type': {'key': 'aggregationType', 'type': 'str'},
        'dimensions': {'key': 'dimensions', 'type': '[MetricDimensionV1]'},
        'fill_gap_with_zero': {'key': 'fillGapWithZero', 'type': 'bool'},
        'category': {'key': 'category', 'type': 'str'},
        'resource_id_dimension_name_override': {'key': 'resourceIdDimensionNameOverride', 'type': 'str'},
        'supported_time_grain_types': {'key': 'supportedTimeGrainTypes', 'type': '[str]'},
        'supported_aggregation_types': {'key': 'supportedAggregationTypes', 'type': '[str]'},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        display_name: Optional[str] = None,
        display_description: Optional[str] = None,
        unit: Optional[Union[str, "MetricUnit"]] = None,
        aggregation_type: Optional[Union[str, "MetricAggregationType"]] = None,
        dimensions: Optional[List["MetricDimensionV1"]] = None,
        fill_gap_with_zero: Optional[bool] = None,
        category: Optional[Union[str, "MetricCategory"]] = None,
        resource_id_dimension_name_override: Optional[str] = None,
        supported_time_grain_types: Optional[List[Union[str, "TimeGrain"]]] = None,
        supported_aggregation_types: Optional[List[Union[str, "MetricAggregationType"]]] = None,
        **kwargs
    ):
        super(MetricSpecificationV1, self).__init__(**kwargs)
        self.name = name
        self.display_name = display_name
        self.display_description = display_description
        self.unit = unit
        self.aggregation_type = aggregation_type
        self.dimensions = dimensions
        self.fill_gap_with_zero = fill_gap_with_zero
        self.category = category
        self.resource_id_dimension_name_override = resource_id_dimension_name_override
        self.supported_time_grain_types = supported_time_grain_types
        self.supported_aggregation_types = supported_aggregation_types


class MountPointMap(msrest.serialization.Model):
    """The share mount point.

    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 share_id: Required. ID of the share mounted to the role VM.
    :type share_id: str
    :ivar role_id: ID of the role to which share is mounted.
    :vartype role_id: str
    :ivar mount_point: Mount point for the share.
    :vartype mount_point: str
    :ivar mount_type: Mounting type. Possible values include: "Volume", "HostPath".
    :vartype mount_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.MountType
    :ivar role_type: Role type. Possible values include: "IOT", "ASA", "Functions", "Cognitive".
    :vartype role_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RoleTypes
    """

    _validation = {
        'share_id': {'required': True},
        'role_id': {'readonly': True},
        'mount_point': {'readonly': True},
        'mount_type': {'readonly': True},
        'role_type': {'readonly': True},
    }

    _attribute_map = {
        'share_id': {'key': 'shareId', 'type': 'str'},
        'role_id': {'key': 'roleId', 'type': 'str'},
        'mount_point': {'key': 'mountPoint', 'type': 'str'},
        'mount_type': {'key': 'mountType', 'type': 'str'},
        'role_type': {'key': 'roleType', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        share_id: str,
        **kwargs
    ):
        super(MountPointMap, self).__init__(**kwargs)
        self.share_id = share_id
        self.role_id = None
        self.mount_point = None
        self.mount_type = None
        self.role_type = None


class NetworkAdapter(msrest.serialization.Model):
    """Represents the networkAdapter on a device.

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

    :ivar adapter_id: Instance ID of network adapter.
    :vartype adapter_id: str
    :ivar adapter_position: Hardware position of network adapter.
    :vartype adapter_position:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.NetworkAdapterPosition
    :ivar index: Logical index of the adapter.
    :vartype index: int
    :ivar node_id: Node ID of the network adapter.
    :vartype node_id: str
    :ivar network_adapter_name: Network adapter name.
    :vartype network_adapter_name: str
    :ivar label: Hardware label for the adapter.
    :vartype label: str
    :ivar mac_address: MAC address.
    :vartype mac_address: str
    :ivar link_speed: Link speed.
    :vartype link_speed: long
    :ivar status: Value indicating whether this adapter is valid. Possible values include:
     "Inactive", "Active".
    :vartype status: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.NetworkAdapterStatus
    :param rdma_status: Value indicating whether this adapter is RDMA capable. Possible values
     include: "Incapable", "Capable".
    :type rdma_status: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.NetworkAdapterRDMAStatus
    :param dhcp_status: Value indicating whether this adapter has DHCP enabled. Possible values
     include: "Disabled", "Enabled".
    :type dhcp_status: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.NetworkAdapterDHCPStatus
    :ivar ipv4_configuration: The IPv4 configuration of the network adapter.
    :vartype ipv4_configuration: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.Ipv4Config
    :ivar ipv6_configuration: The IPv6 configuration of the network adapter.
    :vartype ipv6_configuration: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.Ipv6Config
    :ivar ipv6_link_local_address: The IPv6 local address.
    :vartype ipv6_link_local_address: str
    :ivar dns_servers: The list of DNS Servers of the device.
    :vartype dns_servers: list[str]
    """

    _validation = {
        'adapter_id': {'readonly': True},
        'adapter_position': {'readonly': True},
        'index': {'readonly': True},
        'node_id': {'readonly': True},
        'network_adapter_name': {'readonly': True},
        'label': {'readonly': True},
        'mac_address': {'readonly': True},
        'link_speed': {'readonly': True},
        'status': {'readonly': True},
        'ipv4_configuration': {'readonly': True},
        'ipv6_configuration': {'readonly': True},
        'ipv6_link_local_address': {'readonly': True},
        'dns_servers': {'readonly': True},
    }

    _attribute_map = {
        'adapter_id': {'key': 'adapterId', 'type': 'str'},
        'adapter_position': {'key': 'adapterPosition', 'type': 'NetworkAdapterPosition'},
        'index': {'key': 'index', 'type': 'int'},
        'node_id': {'key': 'nodeId', 'type': 'str'},
        'network_adapter_name': {'key': 'networkAdapterName', 'type': 'str'},
        'label': {'key': 'label', 'type': 'str'},
        'mac_address': {'key': 'macAddress', 'type': 'str'},
        'link_speed': {'key': 'linkSpeed', 'type': 'long'},
        'status': {'key': 'status', 'type': 'str'},
        'rdma_status': {'key': 'rdmaStatus', 'type': 'str'},
        'dhcp_status': {'key': 'dhcpStatus', 'type': 'str'},
        'ipv4_configuration': {'key': 'ipv4Configuration', 'type': 'Ipv4Config'},
        'ipv6_configuration': {'key': 'ipv6Configuration', 'type': 'Ipv6Config'},
        'ipv6_link_local_address': {'key': 'ipv6LinkLocalAddress', 'type': 'str'},
        'dns_servers': {'key': 'dnsServers', 'type': '[str]'},
    }

    def __init__(
        self,
        *,
        rdma_status: Optional[Union[str, "NetworkAdapterRDMAStatus"]] = None,
        dhcp_status: Optional[Union[str, "NetworkAdapterDHCPStatus"]] = None,
        **kwargs
    ):
        super(NetworkAdapter, self).__init__(**kwargs)
        self.adapter_id = None
        self.adapter_position = None
        self.index = None
        self.node_id = None
        self.network_adapter_name = None
        self.label = None
        self.mac_address = None
        self.link_speed = None
        self.status = None
        self.rdma_status = rdma_status
        self.dhcp_status = dhcp_status
        self.ipv4_configuration = None
        self.ipv6_configuration = None
        self.ipv6_link_local_address = None
        self.dns_servers = None


class NetworkAdapterPosition(msrest.serialization.Model):
    """The network adapter position.

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

    :ivar network_group: The network group. Possible values include: "None", "NonRDMA", "RDMA".
    :vartype network_group: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.NetworkGroup
    :ivar port: The port.
    :vartype port: int
    """

    _validation = {
        'network_group': {'readonly': True},
        'port': {'readonly': True},
    }

    _attribute_map = {
        'network_group': {'key': 'networkGroup', 'type': 'str'},
        'port': {'key': 'port', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(NetworkAdapterPosition, self).__init__(**kwargs)
        self.network_group = None
        self.port = None


class NetworkSettings(ARMBaseModel):
    """The network settings of a device.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :ivar network_adapters: The network adapter list on the device.
    :vartype network_adapters:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.NetworkAdapter]
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'network_adapters': {'key': 'properties.networkAdapters', 'type': '[NetworkAdapter]'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(NetworkSettings, self).__init__(**kwargs)
        self.network_adapters = None


class Node(ARMBaseModel):
    """Represents a single node in a Data box Edge/Gateway device
Gateway devices, standalone Edge devices and a single node cluster Edge device will all have 1 node
Multi-node Edge devices will have more than 1 nodes.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :ivar node_status: The current status of the individual node. Possible values include:
     "Unknown", "Up", "Down", "Rebooting", "ShuttingDown".
    :vartype node_status: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.NodeStatus
    :ivar node_chassis_serial_number: Serial number of the Chassis.
    :vartype node_chassis_serial_number: str
    :ivar node_serial_number: Serial number of the individual node.
    :vartype node_serial_number: str
    :ivar node_display_name: Display Name of the individual node.
    :vartype node_display_name: str
    :ivar node_friendly_software_version: Friendly software version name that is currently
     installed on the node.
    :vartype node_friendly_software_version: str
    :ivar node_hcs_version: HCS version that is currently installed on the node.
    :vartype node_hcs_version: str
    :ivar node_instance_id: Guid instance id of the node.
    :vartype node_instance_id: str
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'node_status': {'readonly': True},
        'node_chassis_serial_number': {'readonly': True},
        'node_serial_number': {'readonly': True},
        'node_display_name': {'readonly': True},
        'node_friendly_software_version': {'readonly': True},
        'node_hcs_version': {'readonly': True},
        'node_instance_id': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'node_status': {'key': 'properties.nodeStatus', 'type': 'str'},
        'node_chassis_serial_number': {'key': 'properties.nodeChassisSerialNumber', 'type': 'str'},
        'node_serial_number': {'key': 'properties.nodeSerialNumber', 'type': 'str'},
        'node_display_name': {'key': 'properties.nodeDisplayName', 'type': 'str'},
        'node_friendly_software_version': {'key': 'properties.nodeFriendlySoftwareVersion', 'type': 'str'},
        'node_hcs_version': {'key': 'properties.nodeHcsVersion', 'type': 'str'},
        'node_instance_id': {'key': 'properties.nodeInstanceId', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Node, self).__init__(**kwargs)
        self.node_status = None
        self.node_chassis_serial_number = None
        self.node_serial_number = None
        self.node_display_name = None
        self.node_friendly_software_version = None
        self.node_hcs_version = None
        self.node_instance_id = None


class NodeList(msrest.serialization.Model):
    """Collection of Nodes.

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

    :ivar value: The list of Nodes.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.Node]
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(NodeList, self).__init__(**kwargs)
        self.value = None


class Operation(msrest.serialization.Model):
    """Operations.

    :param name: Name of the operation.
    :type name: str
    :param display: Properties displayed for the operation.
    :type display: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.OperationDisplay
    :param origin: Origin of the operation.
    :type origin: str
    :param service_specification: Service specification.
    :type service_specification:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ServiceSpecification
    """

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'display': {'key': 'display', 'type': 'OperationDisplay'},
        'origin': {'key': 'origin', 'type': 'str'},
        'service_specification': {'key': 'properties.serviceSpecification', 'type': 'ServiceSpecification'},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        display: Optional["OperationDisplay"] = None,
        origin: Optional[str] = None,
        service_specification: Optional["ServiceSpecification"] = None,
        **kwargs
    ):
        super(Operation, self).__init__(**kwargs)
        self.name = name
        self.display = display
        self.origin = origin
        self.service_specification = service_specification


class OperationDisplay(msrest.serialization.Model):
    """Operation display properties.

    :param provider: Provider name.
    :type provider: str
    :param resource: The type of resource in which the operation is performed.
    :type resource: str
    :param operation: Operation to be performed on the resource.
    :type operation: str
    :param description: Description of the operation to be performed.
    :type description: str
    """

    _attribute_map = {
        'provider': {'key': 'provider', 'type': 'str'},
        'resource': {'key': 'resource', 'type': 'str'},
        'operation': {'key': 'operation', 'type': 'str'},
        'description': {'key': 'description', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        provider: Optional[str] = None,
        resource: Optional[str] = None,
        operation: Optional[str] = None,
        description: Optional[str] = None,
        **kwargs
    ):
        super(OperationDisplay, self).__init__(**kwargs)
        self.provider = provider
        self.resource = resource
        self.operation = operation
        self.description = description


class OperationsList(msrest.serialization.Model):
    """The list of operations used for the discovery of available provider operations.

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

    :param value: Required. The value.
    :type value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.Operation]
    :param next_link: Link to the next set of results.
    :type next_link: str
    """

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

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

    def __init__(
        self,
        *,
        value: List["Operation"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        super(OperationsList, self).__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class Order(ARMBaseModel):
    """The order details.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param contact_information: The contact details.
    :type contact_information: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ContactDetails
    :param shipping_address: The shipping address.
    :type shipping_address: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.Address
    :param current_status: Current status of the order.
    :type current_status: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.OrderStatus
    :ivar order_history: List of status changes in the order.
    :vartype order_history: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.OrderStatus]
    :ivar serial_number: Serial number of the device.
    :vartype serial_number: str
    :ivar delivery_tracking_info: Tracking information for the package delivered to the customer
     whether it has an original or a replacement device.
    :vartype delivery_tracking_info:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.TrackingInfo]
    :ivar return_tracking_info: Tracking information for the package returned from the customer
     whether it has an original or a replacement device.
    :vartype return_tracking_info:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.TrackingInfo]
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'order_history': {'readonly': True},
        'serial_number': {'readonly': True},
        'delivery_tracking_info': {'readonly': True},
        'return_tracking_info': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'contact_information': {'key': 'properties.contactInformation', 'type': 'ContactDetails'},
        'shipping_address': {'key': 'properties.shippingAddress', 'type': 'Address'},
        'current_status': {'key': 'properties.currentStatus', 'type': 'OrderStatus'},
        'order_history': {'key': 'properties.orderHistory', 'type': '[OrderStatus]'},
        'serial_number': {'key': 'properties.serialNumber', 'type': 'str'},
        'delivery_tracking_info': {'key': 'properties.deliveryTrackingInfo', 'type': '[TrackingInfo]'},
        'return_tracking_info': {'key': 'properties.returnTrackingInfo', 'type': '[TrackingInfo]'},
    }

    def __init__(
        self,
        *,
        contact_information: Optional["ContactDetails"] = None,
        shipping_address: Optional["Address"] = None,
        current_status: Optional["OrderStatus"] = None,
        **kwargs
    ):
        super(Order, self).__init__(**kwargs)
        self.contact_information = contact_information
        self.shipping_address = shipping_address
        self.current_status = current_status
        self.order_history = None
        self.serial_number = None
        self.delivery_tracking_info = None
        self.return_tracking_info = None


class OrderList(msrest.serialization.Model):
    """List of order entities.

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

    :ivar value: The list of orders.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.Order]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(OrderList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class OrderStatus(msrest.serialization.Model):
    """Represents a single status change.

    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 status: Required. Status of the order as per the allowed status types. Possible values
     include: "Untracked", "AwaitingFulfilment", "AwaitingPreparation", "AwaitingShipment",
     "Shipped", "Arriving", "Delivered", "ReplacementRequested", "LostDevice", "Declined",
     "ReturnInitiated", "AwaitingReturnShipment", "ShippedBack", "CollectedAtMicrosoft".
    :type status: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.OrderState
    :ivar update_date_time: Time of status update.
    :vartype update_date_time: ~datetime.datetime
    :param comments: Comments related to this status change.
    :type comments: str
    :ivar additional_order_details: Dictionary to hold generic information which is not stored
     by the already existing properties.
    :vartype additional_order_details: dict[str, str]
    """

    _validation = {
        'status': {'required': True},
        'update_date_time': {'readonly': True},
        'additional_order_details': {'readonly': True},
    }

    _attribute_map = {
        'status': {'key': 'status', 'type': 'str'},
        'update_date_time': {'key': 'updateDateTime', 'type': 'iso-8601'},
        'comments': {'key': 'comments', 'type': 'str'},
        'additional_order_details': {'key': 'additionalOrderDetails', 'type': '{str}'},
    }

    def __init__(
        self,
        *,
        status: Union[str, "OrderState"],
        comments: Optional[str] = None,
        **kwargs
    ):
        super(OrderStatus, self).__init__(**kwargs)
        self.status = status
        self.update_date_time = None
        self.comments = comments
        self.additional_order_details = None


class PeriodicTimerEventTrigger(Trigger):
    """Trigger details.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param kind: Required. Trigger Kind.Constant filled by server.  Possible values include:
     "FileEvent", "PeriodicTimerEvent".
    :type kind: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.TriggerEventType
    :param source_info: Required. Periodic timer details.
    :type source_info: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.PeriodicTimerSourceInfo
    :param sink_info: Required. Role Sink information.
    :type sink_info: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RoleSinkInfo
    :param custom_context_tag: A custom context tag typically used to correlate the trigger against
     its usage. For example, if a periodic timer trigger is intended for certain specific IoT
     modules in the device, the tag can be the name or the image URL of the module.
    :type custom_context_tag: str
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'kind': {'required': True},
        'source_info': {'required': True},
        'sink_info': {'required': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'kind': {'key': 'kind', 'type': 'str'},
        'source_info': {'key': 'properties.sourceInfo', 'type': 'PeriodicTimerSourceInfo'},
        'sink_info': {'key': 'properties.sinkInfo', 'type': 'RoleSinkInfo'},
        'custom_context_tag': {'key': 'properties.customContextTag', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        source_info: "PeriodicTimerSourceInfo",
        sink_info: "RoleSinkInfo",
        custom_context_tag: Optional[str] = None,
        **kwargs
    ):
        super(PeriodicTimerEventTrigger, self).__init__(**kwargs)
        self.kind = 'PeriodicTimerEvent'  # type: str
        self.source_info = source_info
        self.sink_info = sink_info
        self.custom_context_tag = custom_context_tag


class PeriodicTimerSourceInfo(msrest.serialization.Model):
    """Periodic timer event source.

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

    :param start_time: Required. The time of the day that results in a valid trigger. Schedule is
     computed with reference to the time specified upto seconds. If timezone is not specified the
     time will considered to be in device timezone. The value will always be returned as UTC time.
    :type start_time: ~datetime.datetime
    :param schedule: Required. Periodic frequency at which timer event needs to be raised. Supports
     daily, hourly, minutes, and seconds.
    :type schedule: str
    :param topic: Topic where periodic events are published to IoT device.
    :type topic: str
    """

    _validation = {
        'start_time': {'required': True},
        'schedule': {'required': True},
    }

    _attribute_map = {
        'start_time': {'key': 'startTime', 'type': 'iso-8601'},
        'schedule': {'key': 'schedule', 'type': 'str'},
        'topic': {'key': 'topic', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        start_time: datetime.datetime,
        schedule: str,
        topic: Optional[str] = None,
        **kwargs
    ):
        super(PeriodicTimerSourceInfo, self).__init__(**kwargs)
        self.start_time = start_time
        self.schedule = schedule
        self.topic = topic


class RefreshDetails(msrest.serialization.Model):
    """Fields for tracking refresh job on the share or container.

    :param in_progress_refresh_job_id: If a refresh job is currently in progress on this share or
     container, this field indicates the ARM resource ID of that job. The field is empty if no job
     is in progress.
    :type in_progress_refresh_job_id: str
    :param last_completed_refresh_job_time_in_utc: Indicates the completed time for the last
     refresh job on this particular share or container, if any.This could be a failed job or a
     successful job.
    :type last_completed_refresh_job_time_in_utc: ~datetime.datetime
    :param error_manifest_file: Indicates the relative path of the error xml for the last refresh
     job on this particular share or container, if any. This could be a failed job or a successful
     job.
    :type error_manifest_file: str
    :param last_job: Indicates the id of the last refresh job on this particular share or
     container,if any. This could be a failed job or a successful job.
    :type last_job: str
    """

    _attribute_map = {
        'in_progress_refresh_job_id': {'key': 'inProgressRefreshJobId', 'type': 'str'},
        'last_completed_refresh_job_time_in_utc': {'key': 'lastCompletedRefreshJobTimeInUTC', 'type': 'iso-8601'},
        'error_manifest_file': {'key': 'errorManifestFile', 'type': 'str'},
        'last_job': {'key': 'lastJob', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        in_progress_refresh_job_id: Optional[str] = None,
        last_completed_refresh_job_time_in_utc: Optional[datetime.datetime] = None,
        error_manifest_file: Optional[str] = None,
        last_job: Optional[str] = None,
        **kwargs
    ):
        super(RefreshDetails, self).__init__(**kwargs)
        self.in_progress_refresh_job_id = in_progress_refresh_job_id
        self.last_completed_refresh_job_time_in_utc = last_completed_refresh_job_time_in_utc
        self.error_manifest_file = error_manifest_file
        self.last_job = last_job


class ResourceTypeSku(msrest.serialization.Model):
    """SkuInformation object.

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

    :ivar resource_type: The type of the resource.
    :vartype resource_type: str
    :ivar name: The Sku name. Possible values include: "Gateway", "Edge", "TEA_1Node",
     "TEA_1Node_UPS", "TEA_1Node_Heater", "TEA_1Node_UPS_Heater", "TEA_4Node_Heater",
     "TEA_4Node_UPS_Heater", "TMA", "TDC", "TCA_Large", "TCA_Small", "GPU".
    :vartype name: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuName
    :ivar kind: The Sku kind.
    :vartype kind: str
    :ivar tier: The Sku tier. Possible values include: "Standard".
    :vartype tier: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuTier
    :ivar family: The Sku family.
    :vartype family: str
    :ivar locations: Availability of the SKU for the region.
    :vartype locations: list[str]
    :ivar api_versions: The API versions in which SKU is available.
    :vartype api_versions: list[str]
    :ivar location_info: Availability of the SKU for the location/zone.
    :vartype location_info:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuLocationInfo]
    :ivar costs: The pricing info of the Sku.
    :vartype costs: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuCost]
    :ivar restrictions: Restrictions of the SKU availability.
    :vartype restrictions: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuRestriction]
    """

    _validation = {
        'resource_type': {'readonly': True},
        'name': {'readonly': True},
        'kind': {'readonly': True},
        'tier': {'readonly': True},
        'family': {'readonly': True},
        'locations': {'readonly': True},
        'api_versions': {'readonly': True},
        'location_info': {'readonly': True},
        'costs': {'readonly': True},
        'restrictions': {'readonly': True},
    }

    _attribute_map = {
        'resource_type': {'key': 'resourceType', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'kind': {'key': 'kind', 'type': 'str'},
        'tier': {'key': 'tier', 'type': 'str'},
        'family': {'key': 'family', 'type': 'str'},
        'locations': {'key': 'locations', 'type': '[str]'},
        'api_versions': {'key': 'apiVersions', 'type': '[str]'},
        'location_info': {'key': 'locationInfo', 'type': '[SkuLocationInfo]'},
        'costs': {'key': 'costs', 'type': '[SkuCost]'},
        'restrictions': {'key': 'restrictions', 'type': '[SkuRestriction]'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ResourceTypeSku, self).__init__(**kwargs)
        self.resource_type = None
        self.name = None
        self.kind = None
        self.tier = None
        self.family = None
        self.locations = None
        self.api_versions = None
        self.location_info = None
        self.costs = None
        self.restrictions = None


class RoleList(msrest.serialization.Model):
    """Collection of all the roles on the Data Box Edge device.

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

    :ivar value: The Value.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.Role]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(RoleList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class RoleSinkInfo(msrest.serialization.Model):
    """Compute role against which events will be raised.

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

    :param role_id: Required. Compute role ID.
    :type role_id: str
    """

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

    _attribute_map = {
        'role_id': {'key': 'roleId', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        role_id: str,
        **kwargs
    ):
        super(RoleSinkInfo, self).__init__(**kwargs)
        self.role_id = role_id


class SecuritySettings(ARMBaseModel):
    """The security settings of a device.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param device_admin_password: Required. Device administrator password as an encrypted string
     (encrypted using RSA PKCS #1) is used to sign into the  local web UI of the device. The Actual
     password should have at least 8 characters that are a combination of  uppercase, lowercase,
     numeric, and special characters.
    :type device_admin_password:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AsymmetricEncryptedSecret
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'device_admin_password': {'key': 'properties.deviceAdminPassword', 'type': 'AsymmetricEncryptedSecret'},
    }

    def __init__(
        self,
        *,
        device_admin_password: "AsymmetricEncryptedSecret",
        **kwargs
    ):
        super(SecuritySettings, self).__init__(**kwargs)
        self.device_admin_password = device_admin_password


class ServiceSpecification(msrest.serialization.Model):
    """Service specification.

    :param metric_specifications: Metric specification as defined by shoebox.
    :type metric_specifications:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.MetricSpecificationV1]
    """

    _attribute_map = {
        'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecificationV1]'},
    }

    def __init__(
        self,
        *,
        metric_specifications: Optional[List["MetricSpecificationV1"]] = None,
        **kwargs
    ):
        super(ServiceSpecification, self).__init__(**kwargs)
        self.metric_specifications = metric_specifications


class Share(ARMBaseModel):
    """Represents a share on the  Data Box Edge/Gateway device.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param description: Description for the share.
    :type description: str
    :param share_status: Required. Current status of the share. Possible values include: "Offline",
     "Unknown", "OK", "Updating", "NeedsAttention".
    :type share_status: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ShareStatus
    :param monitoring_status: Required. Current monitoring status of the share. Possible values
     include: "Enabled", "Disabled".
    :type monitoring_status: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.MonitoringStatus
    :param azure_container_info: Azure container mapping for the share.
    :type azure_container_info:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AzureContainerInfo
    :param access_protocol: Required. Access protocol to be used by the share. Possible values
     include: "SMB", "NFS".
    :type access_protocol: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ShareAccessProtocol
    :param user_access_rights: Mapping of users and corresponding access rights on the share
     (required for SMB protocol).
    :type user_access_rights:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.UserAccessRight]
    :param client_access_rights: List of IP addresses and corresponding access rights on the
     share(required for NFS protocol).
    :type client_access_rights:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.ClientAccessRight]
    :param refresh_details: Details of the refresh job on this share.
    :type refresh_details: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.RefreshDetails
    :ivar share_mappings: Share mount point to the role.
    :vartype share_mappings: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.MountPointMap]
    :param data_policy: Data policy of the share. Possible values include: "Cloud", "Local".
    :type data_policy: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.DataPolicy
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'share_status': {'required': True},
        'monitoring_status': {'required': True},
        'access_protocol': {'required': True},
        'share_mappings': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'description': {'key': 'properties.description', 'type': 'str'},
        'share_status': {'key': 'properties.shareStatus', 'type': 'str'},
        'monitoring_status': {'key': 'properties.monitoringStatus', 'type': 'str'},
        'azure_container_info': {'key': 'properties.azureContainerInfo', 'type': 'AzureContainerInfo'},
        'access_protocol': {'key': 'properties.accessProtocol', 'type': 'str'},
        'user_access_rights': {'key': 'properties.userAccessRights', 'type': '[UserAccessRight]'},
        'client_access_rights': {'key': 'properties.clientAccessRights', 'type': '[ClientAccessRight]'},
        'refresh_details': {'key': 'properties.refreshDetails', 'type': 'RefreshDetails'},
        'share_mappings': {'key': 'properties.shareMappings', 'type': '[MountPointMap]'},
        'data_policy': {'key': 'properties.dataPolicy', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        share_status: Union[str, "ShareStatus"],
        monitoring_status: Union[str, "MonitoringStatus"],
        access_protocol: Union[str, "ShareAccessProtocol"],
        description: Optional[str] = None,
        azure_container_info: Optional["AzureContainerInfo"] = None,
        user_access_rights: Optional[List["UserAccessRight"]] = None,
        client_access_rights: Optional[List["ClientAccessRight"]] = None,
        refresh_details: Optional["RefreshDetails"] = None,
        data_policy: Optional[Union[str, "DataPolicy"]] = None,
        **kwargs
    ):
        super(Share, self).__init__(**kwargs)
        self.description = description
        self.share_status = share_status
        self.monitoring_status = monitoring_status
        self.azure_container_info = azure_container_info
        self.access_protocol = access_protocol
        self.user_access_rights = user_access_rights
        self.client_access_rights = client_access_rights
        self.refresh_details = refresh_details
        self.share_mappings = None
        self.data_policy = data_policy


class ShareAccessRight(msrest.serialization.Model):
    """Specifies the mapping between this particular user and the type of access he has on shares on this device.

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

    :param share_id: Required. The share ID.
    :type share_id: str
    :param access_type: Required. Type of access to be allowed on the share for this user. Possible
     values include: "Change", "Read", "Custom".
    :type access_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ShareAccessType
    """

    _validation = {
        'share_id': {'required': True},
        'access_type': {'required': True},
    }

    _attribute_map = {
        'share_id': {'key': 'shareId', 'type': 'str'},
        'access_type': {'key': 'accessType', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        share_id: str,
        access_type: Union[str, "ShareAccessType"],
        **kwargs
    ):
        super(ShareAccessRight, self).__init__(**kwargs)
        self.share_id = share_id
        self.access_type = access_type


class ShareList(msrest.serialization.Model):
    """Collection of all the shares on the Data Box Edge/Gateway device.

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

    :ivar value: The list of shares.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.Share]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(ShareList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class Sku(msrest.serialization.Model):
    """The SKU type.

    :param name: SKU name. Possible values include: "Gateway", "Edge", "TEA_1Node",
     "TEA_1Node_UPS", "TEA_1Node_Heater", "TEA_1Node_UPS_Heater", "TEA_4Node_Heater",
     "TEA_4Node_UPS_Heater", "TMA", "TDC", "TCA_Large", "TCA_Small", "GPU".
    :type name: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuName
    :param tier: The SKU tier. This is based on the SKU name. Possible values include: "Standard".
    :type tier: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuTier
    """

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

    def __init__(
        self,
        *,
        name: Optional[Union[str, "SkuName"]] = None,
        tier: Optional[Union[str, "SkuTier"]] = None,
        **kwargs
    ):
        super(Sku, self).__init__(**kwargs)
        self.name = name
        self.tier = tier


class SKUCapability(msrest.serialization.Model):
    """The capabilities of the SKU.

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

    :ivar name: The capability name.
    :vartype name: str
    :ivar value: The capability value.
    :vartype value: str
    """

    _validation = {
        'name': {'readonly': True},
        'value': {'readonly': True},
    }

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

    def __init__(
        self,
        **kwargs
    ):
        super(SKUCapability, self).__init__(**kwargs)
        self.name = None
        self.value = None


class SkuCost(msrest.serialization.Model):
    """The metadata for retrieving price info.

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

    :ivar meter_id: Used for querying price from commerce.
    :vartype meter_id: str
    :ivar quantity: The cost quantity.
    :vartype quantity: long
    :ivar extended_unit: The extended unit.
    :vartype extended_unit: str
    """

    _validation = {
        'meter_id': {'readonly': True},
        'quantity': {'readonly': True},
        'extended_unit': {'readonly': True},
    }

    _attribute_map = {
        'meter_id': {'key': 'meterId', 'type': 'str'},
        'quantity': {'key': 'quantity', 'type': 'long'},
        'extended_unit': {'key': 'extendedUnit', 'type': 'str'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(SkuCost, self).__init__(**kwargs)
        self.meter_id = None
        self.quantity = None
        self.extended_unit = None


class SkuInformation(msrest.serialization.Model):
    """Sku information.

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

    :ivar resource_type: The resource type.
    :vartype resource_type: str
    :ivar name: The sku name.
    :vartype name: str
    :ivar tier: The sku tier.
    :vartype tier: str
    :ivar kind: The sku kind.
    :vartype kind: str
    :ivar size: The sku size.
    :vartype size: str
    :ivar family: The sku family.
    :vartype family: str
    :ivar locations: The locations where Sku is available.
    :vartype locations: list[str]
    :ivar location_info: The locations where Sku is available with zones and sites info.
    :vartype location_info:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuLocationInfo]
    :ivar required_quota_ids: The required quotaIds for the sku to be available.
    :vartype required_quota_ids: list[str]
    :ivar required_features: The required features for the sku to be available.
    :vartype required_features: list[str]
    :ivar costs: The cost of the SKU.
    :vartype costs: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuCost]
    :ivar capabilities: The capabilities of the SKU.
    :vartype capabilities: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.SKUCapability]
    """

    _validation = {
        'resource_type': {'readonly': True},
        'name': {'readonly': True},
        'tier': {'readonly': True},
        'kind': {'readonly': True},
        'size': {'readonly': True},
        'family': {'readonly': True},
        'locations': {'readonly': True},
        'location_info': {'readonly': True},
        'required_quota_ids': {'readonly': True},
        'required_features': {'readonly': True},
        'costs': {'readonly': True},
        'capabilities': {'readonly': True},
    }

    _attribute_map = {
        'resource_type': {'key': 'resourceType', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'tier': {'key': 'tier', 'type': 'str'},
        'kind': {'key': 'kind', 'type': 'str'},
        'size': {'key': 'size', 'type': 'str'},
        'family': {'key': 'family', 'type': 'str'},
        'locations': {'key': 'locations', 'type': '[str]'},
        'location_info': {'key': 'locationInfo', 'type': '[SkuLocationInfo]'},
        'required_quota_ids': {'key': 'requiredQuotaIds', 'type': '[str]'},
        'required_features': {'key': 'requiredFeatures', 'type': '[str]'},
        'costs': {'key': 'costs', 'type': '[SkuCost]'},
        'capabilities': {'key': 'capabilities', 'type': '[SKUCapability]'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(SkuInformation, self).__init__(**kwargs)
        self.resource_type = None
        self.name = None
        self.tier = None
        self.kind = None
        self.size = None
        self.family = None
        self.locations = None
        self.location_info = None
        self.required_quota_ids = None
        self.required_features = None
        self.costs = None
        self.capabilities = None


class SkuInformationList(msrest.serialization.Model):
    """List of SKU Information objects.

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

    :ivar value: List of ResourceType Sku.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.ResourceTypeSku]
    :ivar next_link: Links to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(SkuInformationList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class SkuLocationInfo(msrest.serialization.Model):
    """The location info.

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

    :ivar location: The location.
    :vartype location: str
    :ivar zones: The zones.
    :vartype zones: list[str]
    :ivar sites: The sites.
    :vartype sites: list[str]
    """

    _validation = {
        'location': {'readonly': True},
        'zones': {'readonly': True},
        'sites': {'readonly': True},
    }

    _attribute_map = {
        'location': {'key': 'location', 'type': 'str'},
        'zones': {'key': 'zones', 'type': '[str]'},
        'sites': {'key': 'sites', 'type': '[str]'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(SkuLocationInfo, self).__init__(**kwargs)
        self.location = None
        self.zones = None
        self.sites = None


class SkuRestriction(msrest.serialization.Model):
    """The restrictions because of which SKU cannot be used.

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

    :ivar type: The type of the restriction.
    :vartype type: str
    :ivar values: The locations where sku is restricted.
    :vartype values: list[str]
    :ivar reason_code: The SKU restriction reason. Possible values include:
     "NotAvailableForSubscription", "QuotaId".
    :vartype reason_code: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuRestrictionReasonCode
    :ivar restriction_info: Restriction of the SKU for the location/zone.
    :vartype restriction_info:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SkuRestrictionInfo
    """

    _validation = {
        'type': {'readonly': True},
        'values': {'readonly': True},
        'reason_code': {'readonly': True},
        'restriction_info': {'readonly': True},
    }

    _attribute_map = {
        'type': {'key': 'type', 'type': 'str'},
        'values': {'key': 'values', 'type': '[str]'},
        'reason_code': {'key': 'reasonCode', 'type': 'str'},
        'restriction_info': {'key': 'restrictionInfo', 'type': 'SkuRestrictionInfo'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(SkuRestriction, self).__init__(**kwargs)
        self.type = None
        self.values = None
        self.reason_code = None
        self.restriction_info = None


class SkuRestrictionInfo(msrest.serialization.Model):
    """The restriction info with locations and zones.

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

    :ivar locations: The locations.
    :vartype locations: list[str]
    :ivar zones: The zones.
    :vartype zones: list[str]
    """

    _validation = {
        'locations': {'readonly': True},
        'zones': {'readonly': True},
    }

    _attribute_map = {
        'locations': {'key': 'locations', 'type': '[str]'},
        'zones': {'key': 'zones', 'type': '[str]'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(SkuRestrictionInfo, self).__init__(**kwargs)
        self.locations = None
        self.zones = None


class StorageAccount(ARMBaseModel):
    """Represents a Storage Account on the  Data Box Edge/Gateway device.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param description: Description for the storage Account.
    :type description: str
    :param storage_account_status: Current status of the storage account. Possible values include:
     "OK", "Offline", "Unknown", "Updating", "NeedsAttention".
    :type storage_account_status: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.StorageAccountStatus
    :param data_policy: Data policy of the storage Account. Possible values include: "Cloud",
     "Local".
    :type data_policy: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.DataPolicy
    :param storage_account_credential_id: Storage Account Credential Id.
    :type storage_account_credential_id: str
    :ivar blob_endpoint: BlobEndpoint of Storage Account.
    :vartype blob_endpoint: str
    :ivar container_count: The Container Count. Present only for Storage Accounts with DataPolicy
     set to Cloud.
    :vartype container_count: int
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'description': {'key': 'properties.description', 'type': 'str'},
        'storage_account_status': {'key': 'properties.storageAccountStatus', 'type': 'str'},
        'data_policy': {'key': 'properties.dataPolicy', 'type': 'str'},
        'storage_account_credential_id': {'key': 'properties.storageAccountCredentialId', 'type': 'str'},
        'blob_endpoint': {'key': 'properties.blobEndpoint', 'type': 'str'},
        'container_count': {'key': 'properties.containerCount', 'type': 'int'},
    }

    def __init__(
        self,
        *,
        description: Optional[str] = None,
        storage_account_status: Optional[Union[str, "StorageAccountStatus"]] = None,
        data_policy: Optional[Union[str, "DataPolicy"]] = None,
        storage_account_credential_id: Optional[str] = None,
        **kwargs
    ):
        super(StorageAccount, self).__init__(**kwargs)
        self.description = description
        self.storage_account_status = storage_account_status
        self.data_policy = data_policy
        self.storage_account_credential_id = storage_account_credential_id
        self.blob_endpoint = None
        self.container_count = None


class StorageAccountCredential(ARMBaseModel):
    """The storage account credential.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param alias: Required. Alias for the storage account.
    :type alias: str
    :param user_name: Username for the storage account.
    :type user_name: str
    :param account_key: Encrypted storage key.
    :type account_key: ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AsymmetricEncryptedSecret
    :param connection_string: Connection string for the storage account. Use this string if
     username and account key are not specified.
    :type connection_string: str
    :param ssl_status: Required. Signifies whether SSL needs to be enabled or not. Possible values
     include: "Enabled", "Disabled".
    :type ssl_status: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.SSLStatus
    :param blob_domain_name: Blob end point for private clouds.
    :type blob_domain_name: str
    :param account_type: Required. Type of storage accessed on the storage account. Possible values
     include: "GeneralPurposeStorage", "BlobStorage".
    :type account_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AccountType
    :param storage_account_id: Id of the storage account.
    :type storage_account_id: str
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'alias': {'required': True},
        'ssl_status': {'required': True},
        'account_type': {'required': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'alias': {'key': 'properties.alias', 'type': 'str'},
        'user_name': {'key': 'properties.userName', 'type': 'str'},
        'account_key': {'key': 'properties.accountKey', 'type': 'AsymmetricEncryptedSecret'},
        'connection_string': {'key': 'properties.connectionString', 'type': 'str'},
        'ssl_status': {'key': 'properties.sslStatus', 'type': 'str'},
        'blob_domain_name': {'key': 'properties.blobDomainName', 'type': 'str'},
        'account_type': {'key': 'properties.accountType', 'type': 'str'},
        'storage_account_id': {'key': 'properties.storageAccountId', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        alias: str,
        ssl_status: Union[str, "SSLStatus"],
        account_type: Union[str, "AccountType"],
        user_name: Optional[str] = None,
        account_key: Optional["AsymmetricEncryptedSecret"] = None,
        connection_string: Optional[str] = None,
        blob_domain_name: Optional[str] = None,
        storage_account_id: Optional[str] = None,
        **kwargs
    ):
        super(StorageAccountCredential, self).__init__(**kwargs)
        self.alias = alias
        self.user_name = user_name
        self.account_key = account_key
        self.connection_string = connection_string
        self.ssl_status = ssl_status
        self.blob_domain_name = blob_domain_name
        self.account_type = account_type
        self.storage_account_id = storage_account_id


class StorageAccountCredentialList(msrest.serialization.Model):
    """The collection of storage account credentials.

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

    :ivar value: The value.
    :vartype value:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.StorageAccountCredential]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(StorageAccountCredentialList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class StorageAccountList(msrest.serialization.Model):
    """Collection of all the Storage Accounts on the Data Box Edge/Gateway device.

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

    :ivar value: The list of storageAccounts.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.StorageAccount]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(StorageAccountList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class SymmetricKey(msrest.serialization.Model):
    """Symmetric key for authentication.

    :param connection_string: Connection string based on the symmetric key.
    :type connection_string:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AsymmetricEncryptedSecret
    """

    _attribute_map = {
        'connection_string': {'key': 'connectionString', 'type': 'AsymmetricEncryptedSecret'},
    }

    def __init__(
        self,
        *,
        connection_string: Optional["AsymmetricEncryptedSecret"] = None,
        **kwargs
    ):
        super(SymmetricKey, self).__init__(**kwargs)
        self.connection_string = connection_string


class TrackingInfo(msrest.serialization.Model):
    """Tracking courier information.

    :param serial_number: Serial number of the device being tracked.
    :type serial_number: str
    :param carrier_name: Name of the carrier used in the delivery.
    :type carrier_name: str
    :param tracking_id: Tracking ID of the shipment.
    :type tracking_id: str
    :param tracking_url: Tracking URL of the shipment.
    :type tracking_url: str
    """

    _attribute_map = {
        'serial_number': {'key': 'serialNumber', 'type': 'str'},
        'carrier_name': {'key': 'carrierName', 'type': 'str'},
        'tracking_id': {'key': 'trackingId', 'type': 'str'},
        'tracking_url': {'key': 'trackingUrl', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        serial_number: Optional[str] = None,
        carrier_name: Optional[str] = None,
        tracking_id: Optional[str] = None,
        tracking_url: Optional[str] = None,
        **kwargs
    ):
        super(TrackingInfo, self).__init__(**kwargs)
        self.serial_number = serial_number
        self.carrier_name = carrier_name
        self.tracking_id = tracking_id
        self.tracking_url = tracking_url


class TriggerList(msrest.serialization.Model):
    """Collection of all trigger on the data box edge device.

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

    :ivar value: The list of triggers.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.Trigger]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(TriggerList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None


class UpdateDownloadProgress(msrest.serialization.Model):
    """Details about the download progress of update.

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

    :ivar download_phase: The download phase. Possible values include: "Unknown", "Initializing",
     "Downloading", "Verifying".
    :vartype download_phase: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.DownloadPhase
    :ivar percent_complete: Percentage of completion.
    :vartype percent_complete: int
    :ivar total_bytes_to_download: Total bytes to download.
    :vartype total_bytes_to_download: float
    :ivar total_bytes_downloaded: Total bytes downloaded.
    :vartype total_bytes_downloaded: float
    :ivar number_of_updates_to_download: Number of updates to download.
    :vartype number_of_updates_to_download: int
    :ivar number_of_updates_downloaded: Number of updates downloaded.
    :vartype number_of_updates_downloaded: int
    """

    _validation = {
        'download_phase': {'readonly': True},
        'percent_complete': {'readonly': True},
        'total_bytes_to_download': {'readonly': True},
        'total_bytes_downloaded': {'readonly': True},
        'number_of_updates_to_download': {'readonly': True},
        'number_of_updates_downloaded': {'readonly': True},
    }

    _attribute_map = {
        'download_phase': {'key': 'downloadPhase', 'type': 'str'},
        'percent_complete': {'key': 'percentComplete', 'type': 'int'},
        'total_bytes_to_download': {'key': 'totalBytesToDownload', 'type': 'float'},
        'total_bytes_downloaded': {'key': 'totalBytesDownloaded', 'type': 'float'},
        'number_of_updates_to_download': {'key': 'numberOfUpdatesToDownload', 'type': 'int'},
        'number_of_updates_downloaded': {'key': 'numberOfUpdatesDownloaded', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(UpdateDownloadProgress, self).__init__(**kwargs)
        self.download_phase = None
        self.percent_complete = None
        self.total_bytes_to_download = None
        self.total_bytes_downloaded = None
        self.number_of_updates_to_download = None
        self.number_of_updates_downloaded = None


class UpdateInstallProgress(msrest.serialization.Model):
    """Progress details during installation of updates.

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

    :ivar percent_complete: Percentage completed.
    :vartype percent_complete: int
    :ivar number_of_updates_to_install: Number of updates to install.
    :vartype number_of_updates_to_install: int
    :ivar number_of_updates_installed: Number of updates installed.
    :vartype number_of_updates_installed: int
    """

    _validation = {
        'percent_complete': {'readonly': True},
        'number_of_updates_to_install': {'readonly': True},
        'number_of_updates_installed': {'readonly': True},
    }

    _attribute_map = {
        'percent_complete': {'key': 'percentComplete', 'type': 'int'},
        'number_of_updates_to_install': {'key': 'numberOfUpdatesToInstall', 'type': 'int'},
        'number_of_updates_installed': {'key': 'numberOfUpdatesInstalled', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(UpdateInstallProgress, self).__init__(**kwargs)
        self.percent_complete = None
        self.number_of_updates_to_install = None
        self.number_of_updates_installed = None


class UpdateSummary(ARMBaseModel):
    """Details about ongoing updates and availability of updates on the device.

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param device_version_number: The current version of the device in format: 1.2.17312.13.",.
    :type device_version_number: str
    :param friendly_device_version_name: The current version of the device in text format.
    :type friendly_device_version_name: str
    :param device_last_scanned_date_time: The last time when a scan was done on the device.
    :type device_last_scanned_date_time: ~datetime.datetime
    :param last_completed_scan_job_date_time: The time when the last scan job was completed
     (success/cancelled/failed) on the appliance.
    :type last_completed_scan_job_date_time: ~datetime.datetime
    :ivar last_completed_download_job_date_time: The time when the last Download job was completed
     (success/cancelled/failed) on the appliance.
    :vartype last_completed_download_job_date_time: ~datetime.datetime
    :ivar last_completed_install_job_date_time: The time when the last Install job was completed
     (success/cancelled/failed) on the appliance.
    :vartype last_completed_install_job_date_time: ~datetime.datetime
    :ivar total_number_of_updates_available: The number of updates available for the current device
     version as per the last device scan.
    :vartype total_number_of_updates_available: int
    :ivar total_number_of_updates_pending_download: The total number of items pending download.
    :vartype total_number_of_updates_pending_download: int
    :ivar total_number_of_updates_pending_install: The total number of items pending install.
    :vartype total_number_of_updates_pending_install: int
    :ivar reboot_behavior: Indicates if updates are available and at least one of the updates needs
     a reboot. Possible values include: "NeverReboots", "RequiresReboot", "RequestReboot".
    :vartype reboot_behavior: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.InstallRebootBehavior
    :ivar ongoing_update_operation: The current update operation. Possible values include: "None",
     "Scan", "Download", "Install".
    :vartype ongoing_update_operation: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.UpdateOperation
    :ivar in_progress_download_job_id: The job ID of the download job in progress.
    :vartype in_progress_download_job_id: str
    :ivar in_progress_install_job_id: The job ID of the install job in progress.
    :vartype in_progress_install_job_id: str
    :ivar in_progress_download_job_started_date_time: The time when the currently running download
     (if any) started.
    :vartype in_progress_download_job_started_date_time: ~datetime.datetime
    :ivar in_progress_install_job_started_date_time: The time when the currently running install
     (if any) started.
    :vartype in_progress_install_job_started_date_time: ~datetime.datetime
    :ivar update_titles: The list of updates available for install.
    :vartype update_titles: list[str]
    :ivar total_update_size_in_bytes: The total size of updates available for download in bytes.
    :vartype total_update_size_in_bytes: float
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'last_completed_download_job_date_time': {'readonly': True},
        'last_completed_install_job_date_time': {'readonly': True},
        'total_number_of_updates_available': {'readonly': True},
        'total_number_of_updates_pending_download': {'readonly': True},
        'total_number_of_updates_pending_install': {'readonly': True},
        'reboot_behavior': {'readonly': True},
        'ongoing_update_operation': {'readonly': True},
        'in_progress_download_job_id': {'readonly': True},
        'in_progress_install_job_id': {'readonly': True},
        'in_progress_download_job_started_date_time': {'readonly': True},
        'in_progress_install_job_started_date_time': {'readonly': True},
        'update_titles': {'readonly': True},
        'total_update_size_in_bytes': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'device_version_number': {'key': 'properties.deviceVersionNumber', 'type': 'str'},
        'friendly_device_version_name': {'key': 'properties.friendlyDeviceVersionName', 'type': 'str'},
        'device_last_scanned_date_time': {'key': 'properties.deviceLastScannedDateTime', 'type': 'iso-8601'},
        'last_completed_scan_job_date_time': {'key': 'properties.lastCompletedScanJobDateTime', 'type': 'iso-8601'},
        'last_completed_download_job_date_time': {'key': 'properties.lastCompletedDownloadJobDateTime', 'type': 'iso-8601'},
        'last_completed_install_job_date_time': {'key': 'properties.lastCompletedInstallJobDateTime', 'type': 'iso-8601'},
        'total_number_of_updates_available': {'key': 'properties.totalNumberOfUpdatesAvailable', 'type': 'int'},
        'total_number_of_updates_pending_download': {'key': 'properties.totalNumberOfUpdatesPendingDownload', 'type': 'int'},
        'total_number_of_updates_pending_install': {'key': 'properties.totalNumberOfUpdatesPendingInstall', 'type': 'int'},
        'reboot_behavior': {'key': 'properties.rebootBehavior', 'type': 'str'},
        'ongoing_update_operation': {'key': 'properties.ongoingUpdateOperation', 'type': 'str'},
        'in_progress_download_job_id': {'key': 'properties.inProgressDownloadJobId', 'type': 'str'},
        'in_progress_install_job_id': {'key': 'properties.inProgressInstallJobId', 'type': 'str'},
        'in_progress_download_job_started_date_time': {'key': 'properties.inProgressDownloadJobStartedDateTime', 'type': 'iso-8601'},
        'in_progress_install_job_started_date_time': {'key': 'properties.inProgressInstallJobStartedDateTime', 'type': 'iso-8601'},
        'update_titles': {'key': 'properties.updateTitles', 'type': '[str]'},
        'total_update_size_in_bytes': {'key': 'properties.totalUpdateSizeInBytes', 'type': 'float'},
    }

    def __init__(
        self,
        *,
        device_version_number: Optional[str] = None,
        friendly_device_version_name: Optional[str] = None,
        device_last_scanned_date_time: Optional[datetime.datetime] = None,
        last_completed_scan_job_date_time: Optional[datetime.datetime] = None,
        **kwargs
    ):
        super(UpdateSummary, self).__init__(**kwargs)
        self.device_version_number = device_version_number
        self.friendly_device_version_name = friendly_device_version_name
        self.device_last_scanned_date_time = device_last_scanned_date_time
        self.last_completed_scan_job_date_time = last_completed_scan_job_date_time
        self.last_completed_download_job_date_time = None
        self.last_completed_install_job_date_time = None
        self.total_number_of_updates_available = None
        self.total_number_of_updates_pending_download = None
        self.total_number_of_updates_pending_install = None
        self.reboot_behavior = None
        self.ongoing_update_operation = None
        self.in_progress_download_job_id = None
        self.in_progress_install_job_id = None
        self.in_progress_download_job_started_date_time = None
        self.in_progress_install_job_started_date_time = None
        self.update_titles = None
        self.total_update_size_in_bytes = None


class UploadCertificateRequest(msrest.serialization.Model):
    """The upload certificate request.

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

    :param authentication_type: The authentication type. Possible values include: "Invalid",
     "AzureActiveDirectory".
    :type authentication_type: str or
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AuthenticationType
    :param certificate: Required. The base64 encoded certificate raw data.
    :type certificate: str
    """

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

    _attribute_map = {
        'authentication_type': {'key': 'properties.authenticationType', 'type': 'str'},
        'certificate': {'key': 'properties.certificate', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        certificate: str,
        authentication_type: Optional[Union[str, "AuthenticationType"]] = None,
        **kwargs
    ):
        super(UploadCertificateRequest, self).__init__(**kwargs)
        self.authentication_type = authentication_type
        self.certificate = certificate


class UploadCertificateResponse(msrest.serialization.Model):
    """The upload registration certificate response.

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

    :param auth_type: Specifies authentication type. Possible values include: "Invalid",
     "AzureActiveDirectory".
    :type auth_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AuthenticationType
    :ivar resource_id: The resource ID of the Data Box Edge/Gateway device.
    :vartype resource_id: str
    :ivar aad_authority: Azure Active Directory tenant authority.
    :vartype aad_authority: str
    :ivar aad_tenant_id: Azure Active Directory tenant ID.
    :vartype aad_tenant_id: str
    :ivar service_principal_client_id: Azure Active Directory service principal client ID.
    :vartype service_principal_client_id: str
    :ivar service_principal_object_id: Azure Active Directory service principal object ID.
    :vartype service_principal_object_id: str
    :ivar azure_management_endpoint_audience: The azure management endpoint audience.
    :vartype azure_management_endpoint_audience: str
    :ivar aad_audience: Identifier of the target resource that is the recipient of the requested
     token.
    :vartype aad_audience: str
    """

    _validation = {
        'resource_id': {'readonly': True},
        'aad_authority': {'readonly': True},
        'aad_tenant_id': {'readonly': True},
        'service_principal_client_id': {'readonly': True},
        'service_principal_object_id': {'readonly': True},
        'azure_management_endpoint_audience': {'readonly': True},
        'aad_audience': {'readonly': True},
    }

    _attribute_map = {
        'auth_type': {'key': 'authType', 'type': 'str'},
        'resource_id': {'key': 'resourceId', 'type': 'str'},
        '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'},
        'aad_audience': {'key': 'aadAudience', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        auth_type: Optional[Union[str, "AuthenticationType"]] = None,
        **kwargs
    ):
        super(UploadCertificateResponse, self).__init__(**kwargs)
        self.auth_type = auth_type
        self.resource_id = None
        self.aad_authority = None
        self.aad_tenant_id = None
        self.service_principal_client_id = None
        self.service_principal_object_id = None
        self.azure_management_endpoint_audience = None
        self.aad_audience = None


class User(ARMBaseModel):
    """Represents a user who has access to one or more shares on the Data Box Edge/Gateway device.

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

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

    :ivar id: The path ID that uniquely identifies the object.
    :vartype id: str
    :ivar name: The object name.
    :vartype name: str
    :ivar type: The hierarchical type of the object.
    :vartype type: str
    :param encrypted_password: The password details.
    :type encrypted_password:
     ~azure.mgmt.databoxedge.v2020_05_01_preview.models.AsymmetricEncryptedSecret
    :ivar share_access_rights: List of shares that the user has rights on. This field should not be
     specified during user creation.
    :vartype share_access_rights:
     list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.ShareAccessRight]
    :param user_type: Required. Type of the user. Possible values include: "Share",
     "LocalManagement", "ARM".
    :type user_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.UserType
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'encrypted_password': {'key': 'properties.encryptedPassword', 'type': 'AsymmetricEncryptedSecret'},
        'share_access_rights': {'key': 'properties.shareAccessRights', 'type': '[ShareAccessRight]'},
        'user_type': {'key': 'properties.userType', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        user_type: Union[str, "UserType"],
        encrypted_password: Optional["AsymmetricEncryptedSecret"] = None,
        **kwargs
    ):
        super(User, self).__init__(**kwargs)
        self.encrypted_password = encrypted_password
        self.share_access_rights = None
        self.user_type = user_type


class UserAccessRight(msrest.serialization.Model):
    """The mapping between a particular user and the access type on the SMB share.

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

    :param user_id: Required. User ID (already existing in the device).
    :type user_id: str
    :param access_type: Required. Type of access to be allowed for the user. Possible values
     include: "Change", "Read", "Custom".
    :type access_type: str or ~azure.mgmt.databoxedge.v2020_05_01_preview.models.ShareAccessType
    """

    _validation = {
        'user_id': {'required': True},
        'access_type': {'required': True},
    }

    _attribute_map = {
        'user_id': {'key': 'userId', 'type': 'str'},
        'access_type': {'key': 'accessType', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        user_id: str,
        access_type: Union[str, "ShareAccessType"],
        **kwargs
    ):
        super(UserAccessRight, self).__init__(**kwargs)
        self.user_id = user_id
        self.access_type = access_type


class UserList(msrest.serialization.Model):
    """Collection of users.

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

    :ivar value: The list of users.
    :vartype value: list[~azure.mgmt.databoxedge.v2020_05_01_preview.models.User]
    :ivar next_link: Link to the next set of results.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        **kwargs
    ):
        super(UserList, self).__init__(**kwargs)
        self.value = None
        self.next_link = None