azext_iot/sdk/deviceupdate/dataplane/models/_models_py3.py

# coding=utf-8
# pylint: disable=too-many-lines
# --------------------------------------------------------------------------
# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.9.2, generator: @autorest/python@5.19.0)
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------

import datetime
import sys
from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union

from .. import _serialization

if TYPE_CHECKING:
    # pylint: disable=unused-import,ungrouped-imports
    from .. import models as _models
if sys.version_info >= (3, 9):
    from collections.abc import MutableMapping
else:
    from typing import MutableMapping  # type: ignore  # pylint: disable=ungrouped-imports
JSON = MutableMapping[str, Any] # pylint: disable=unsubscriptable-object


class AccessCondition(_serialization.Model):
    """Parameter group.

    :ivar if_none_match: Defines the If-None-Match condition. The operation will be performed only
     if the ETag on the server does not match this value.
    :vartype if_none_match: str
    """

    _attribute_map = {
        "if_none_match": {"key": "If-None-Match", "type": "str"},
    }

    def __init__(
        self,
        *,
        if_none_match: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword if_none_match: Defines the If-None-Match condition. The operation will be performed
         only if the ETag on the server does not match this value.
        :paramtype if_none_match: str
        """
        super().__init__(**kwargs)
        self.if_none_match = if_none_match


class CloudInitiatedRollbackPolicy(_serialization.Model):
    """Rollback policy for deployment.

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

    :ivar update: Update to rollback to. Required.
    :vartype update: ~deviceupdateclient.models.UpdateInfo
    :ivar failure: Failure conditions to initiate rollback policy. Required.
    :vartype failure: ~deviceupdateclient.models.CloudInitiatedRollbackPolicyFailure
    """

    _validation = {
        'update': {'required': True},
        'failure': {'required': True},
    }

    _attribute_map = {
        "update": {"key": "update", "type": "UpdateInfo"},
        "failure": {"key": "failure", "type": "CloudInitiatedRollbackPolicyFailure"},
    }

    def __init__(
        self,
        *,
        update: "_models.UpdateInfo",
        failure: "_models.CloudInitiatedRollbackPolicyFailure",
        **kwargs
    ):
        """
        :keyword update: Update to rollback to. Required.
        :paramtype update: ~deviceupdateclient.models.UpdateInfo
        :keyword failure: Failure conditions to initiate rollback policy. Required.
        :paramtype failure: ~deviceupdateclient.models.CloudInitiatedRollbackPolicyFailure
        """
        super().__init__(**kwargs)
        self.update = update
        self.failure = failure


class CloudInitiatedRollbackPolicyFailure(_serialization.Model):
    """Failure conditions to initiate rollback policy.

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

    :ivar devices_failed_percentage: Percentage of devices that failed. Required.
    :vartype devices_failed_percentage: int
    :ivar devices_failed_count: Number of devices that failed. Required.
    :vartype devices_failed_count: int
    """

    _validation = {
        'devices_failed_percentage': {'required': True},
        'devices_failed_count': {'required': True},
    }

    _attribute_map = {
        "devices_failed_percentage": {"key": "devicesFailedPercentage", "type": "int"},
        "devices_failed_count": {"key": "devicesFailedCount", "type": "int"},
    }

    def __init__(
        self,
        *,
        devices_failed_percentage: int,
        devices_failed_count: int,
        **kwargs
    ):
        """
        :keyword devices_failed_percentage: Percentage of devices that failed. Required.
        :paramtype devices_failed_percentage: int
        :keyword devices_failed_count: Number of devices that failed. Required.
        :paramtype devices_failed_count: int
        """
        super().__init__(**kwargs)
        self.devices_failed_percentage = devices_failed_percentage
        self.devices_failed_count = devices_failed_count


class ContractModel(_serialization.Model):
    """The Device Update agent contract model.

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

    :ivar id: The Device Update agent contract model Id of the device class. This is also used to
     calculate the device class Id. Required.
    :vartype id: str
    :ivar name: The Device Update agent contract model name of the device class. Intended to be a
     more readable form of the contract model Id. Required.
    :vartype name: str
    """

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

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

    def __init__(
        self,
        *,
        id: str,  # pylint: disable=redefined-builtin
        name: str,
        **kwargs
    ):
        """
        :keyword id: The Device Update agent contract model Id of the device class. This is also used
         to calculate the device class Id. Required.
        :paramtype id: str
        :keyword name: The Device Update agent contract model name of the device class. Intended to be
         a more readable form of the contract model Id. Required.
        :paramtype name: str
        """
        super().__init__(**kwargs)
        self.id = id
        self.name = name


class Deployment(_serialization.Model):
    """Deployment metadata.

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

    :ivar deployment_id: The caller-provided deployment identifier. This cannot be longer than 73
     characters, must be all lower-case, and cannot contain '&', '^', '[', ']', '{', '}', '|', '<',
     '>', forward slash, backslash, or double quote. The Updates view in the Azure Portal IoT Hub
     resource generates a GUID for deploymentId when you create a deployment. Required.
    :vartype deployment_id: str
    :ivar start_date_time: The deployment start datetime. Required.
    :vartype start_date_time: ~datetime.datetime
    :ivar update: Update information for the update in the deployment. Required.
    :vartype update: ~deviceupdateclient.models.UpdateInfo
    :ivar group_id: The group identity for the devices the deployment is intended to update.
     Required.
    :vartype group_id: str
    :ivar device_class_subgroups: The device class subgroups the deployment is compatible with and
     subgroup deployments have been created for. This is not provided by the caller during
     CreateOrUpdateDeployment but is automatically determined by Device Update.
    :vartype device_class_subgroups: list[str]
    :ivar is_canceled: Boolean flag indicating whether the deployment was canceled.
    :vartype is_canceled: bool
    :ivar is_retried: Boolean flag indicating whether the deployment has been retried.
    :vartype is_retried: bool
    :ivar rollback_policy: The rollback policy for the deployment.
    :vartype rollback_policy: ~deviceupdateclient.models.CloudInitiatedRollbackPolicy
    :ivar is_cloud_initiated_rollback: Boolean flag indicating whether the deployment is a rollback
     deployment.
    :vartype is_cloud_initiated_rollback: bool
    """

    _validation = {
        'deployment_id': {'required': True},
        'start_date_time': {'required': True},
        'update': {'required': True},
        'group_id': {'required': True},
    }

    _attribute_map = {
        "deployment_id": {"key": "deploymentId", "type": "str"},
        "start_date_time": {"key": "startDateTime", "type": "iso-8601"},
        "update": {"key": "update", "type": "UpdateInfo"},
        "group_id": {"key": "groupId", "type": "str"},
        "device_class_subgroups": {"key": "deviceClassSubgroups", "type": "[str]"},
        "is_canceled": {"key": "isCanceled", "type": "bool"},
        "is_retried": {"key": "isRetried", "type": "bool"},
        "rollback_policy": {"key": "rollbackPolicy", "type": "CloudInitiatedRollbackPolicy"},
        "is_cloud_initiated_rollback": {"key": "isCloudInitiatedRollback", "type": "bool"},
    }

    def __init__(
        self,
        *,
        deployment_id: str,
        start_date_time: datetime.datetime,
        update: "_models.UpdateInfo",
        group_id: str,
        device_class_subgroups: Optional[List[str]] = None,
        is_canceled: Optional[bool] = None,
        is_retried: Optional[bool] = None,
        rollback_policy: Optional["_models.CloudInitiatedRollbackPolicy"] = None,
        is_cloud_initiated_rollback: Optional[bool] = None,
        **kwargs
    ):
        """
        :keyword deployment_id: The caller-provided deployment identifier. This cannot be longer than
         73 characters, must be all lower-case, and cannot contain '&', '^', '[', ']', '{', '}', '|',
         '<', '>', forward slash, backslash, or double quote. The Updates view in the Azure Portal IoT
         Hub resource generates a GUID for deploymentId when you create a deployment. Required.
        :paramtype deployment_id: str
        :keyword start_date_time: The deployment start datetime. Required.
        :paramtype start_date_time: ~datetime.datetime
        :keyword update: Update information for the update in the deployment. Required.
        :paramtype update: ~deviceupdateclient.models.UpdateInfo
        :keyword group_id: The group identity for the devices the deployment is intended to update.
         Required.
        :paramtype group_id: str
        :keyword device_class_subgroups: The device class subgroups the deployment is compatible with
         and subgroup deployments have been created for. This is not provided by the caller during
         CreateOrUpdateDeployment but is automatically determined by Device Update.
        :paramtype device_class_subgroups: list[str]
        :keyword is_canceled: Boolean flag indicating whether the deployment was canceled.
        :paramtype is_canceled: bool
        :keyword is_retried: Boolean flag indicating whether the deployment has been retried.
        :paramtype is_retried: bool
        :keyword rollback_policy: The rollback policy for the deployment.
        :paramtype rollback_policy: ~deviceupdateclient.models.CloudInitiatedRollbackPolicy
        :keyword is_cloud_initiated_rollback: Boolean flag indicating whether the deployment is a
         rollback deployment.
        :paramtype is_cloud_initiated_rollback: bool
        """
        super().__init__(**kwargs)
        self.deployment_id = deployment_id
        self.start_date_time = start_date_time
        self.update = update
        self.group_id = group_id
        self.device_class_subgroups = device_class_subgroups
        self.is_canceled = is_canceled
        self.is_retried = is_retried
        self.rollback_policy = rollback_policy
        self.is_cloud_initiated_rollback = is_cloud_initiated_rollback


class DeploymentDeviceState(_serialization.Model):
    """Deployment device status.

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

    :ivar device_id: Device identity. Required.
    :vartype device_id: str
    :ivar module_id: Device module identity.
    :vartype module_id: str
    :ivar retry_count: The number of times this deployment has been retried on this device.
     Required.
    :vartype retry_count: int
    :ivar moved_on_to_new_deployment: Boolean flag indicating whether this device is in a newer
     deployment and can no longer retry this deployment. Required.
    :vartype moved_on_to_new_deployment: bool
    :ivar device_state: Deployment device state. Required. Known values are: "Succeeded",
     "InProgress", "Canceled", and "Failed".
    :vartype device_state: str or ~deviceupdateclient.models.DeviceDeploymentState
    """

    _validation = {
        'device_id': {'required': True},
        'retry_count': {'required': True},
        'moved_on_to_new_deployment': {'required': True},
        'device_state': {'required': True},
    }

    _attribute_map = {
        "device_id": {"key": "deviceId", "type": "str"},
        "module_id": {"key": "moduleId", "type": "str"},
        "retry_count": {"key": "retryCount", "type": "int"},
        "moved_on_to_new_deployment": {"key": "movedOnToNewDeployment", "type": "bool"},
        "device_state": {"key": "deviceState", "type": "str"},
    }

    def __init__(
        self,
        *,
        device_id: str,
        retry_count: int,
        moved_on_to_new_deployment: bool,
        device_state: Union[str, "_models.DeviceDeploymentState"],
        module_id: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword device_id: Device identity. Required.
        :paramtype device_id: str
        :keyword module_id: Device module identity.
        :paramtype module_id: str
        :keyword retry_count: The number of times this deployment has been retried on this device.
         Required.
        :paramtype retry_count: int
        :keyword moved_on_to_new_deployment: Boolean flag indicating whether this device is in a newer
         deployment and can no longer retry this deployment. Required.
        :paramtype moved_on_to_new_deployment: bool
        :keyword device_state: Deployment device state. Required. Known values are: "Succeeded",
         "InProgress", "Canceled", and "Failed".
        :paramtype device_state: str or ~deviceupdateclient.models.DeviceDeploymentState
        """
        super().__init__(**kwargs)
        self.device_id = device_id
        self.module_id = module_id
        self.retry_count = retry_count
        self.moved_on_to_new_deployment = moved_on_to_new_deployment
        self.device_state = device_state


class DeploymentDeviceStatesFilter(_serialization.Model):
    """Deployment device state filter.

    :ivar device_id: Device Identifier.
    :vartype device_id: str
    :ivar module_id: Device module Identifier.
    :vartype module_id: str
    :ivar device_state: The deployment device state. Known values are: "Succeeded", "InProgress",
     "Canceled", and "Failed".
    :vartype device_state: str or ~deviceupdateclient.models.DeviceDeploymentState
    """

    _attribute_map = {
        "device_id": {"key": "deviceId", "type": "str"},
        "module_id": {"key": "moduleId", "type": "str"},
        "device_state": {"key": "deviceState", "type": "str"},
    }

    def __init__(
        self,
        *,
        device_id: Optional[str] = None,
        module_id: Optional[str] = None,
        device_state: Optional[Union[str, "_models.DeviceDeploymentState"]] = None,
        **kwargs
    ):
        """
        :keyword device_id: Device Identifier.
        :paramtype device_id: str
        :keyword module_id: Device module Identifier.
        :paramtype module_id: str
        :keyword device_state: The deployment device state. Known values are: "Succeeded",
         "InProgress", "Canceled", and "Failed".
        :paramtype device_state: str or ~deviceupdateclient.models.DeviceDeploymentState
        """
        super().__init__(**kwargs)
        self.device_id = device_id
        self.module_id = module_id
        self.device_state = device_state


class DeploymentDeviceStatesList(_serialization.Model):
    """The list of deployment device states.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.DeploymentDeviceState]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[DeploymentDeviceState]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.DeploymentDeviceState"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.DeploymentDeviceState]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class DeploymentOrderBy(_serialization.Model):
    """Deployment order by.

    :ivar start_date_time: The deployment start datetime.
    :vartype start_date_time: ~datetime.datetime
    """

    _attribute_map = {
        "start_date_time": {"key": "startDateTime", "type": "iso-8601"},
    }

    def __init__(
        self,
        *,
        start_date_time: Optional[datetime.datetime] = None,
        **kwargs
    ):
        """
        :keyword start_date_time: The deployment start datetime.
        :paramtype start_date_time: ~datetime.datetime
        """
        super().__init__(**kwargs)
        self.start_date_time = start_date_time


class DeploymentsList(_serialization.Model):
    """The list of deployments.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.Deployment]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[Deployment]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.Deployment"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.Deployment]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class DeploymentStatus(_serialization.Model):
    """Deployment status metadata.

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

    :ivar group_id: The group identity. Required.
    :vartype group_id: str
    :ivar deployment_state: The state of the deployment. Required. Known values are: "Active",
     "ActiveWithSubgroupFailures", "Failed", "Inactive", and "Canceled".
    :vartype deployment_state: str or ~deviceupdateclient.models.DeploymentState
    :ivar error: The error details of the Failed state.  This is not present if the deployment
     state is not Failed.
    :vartype error: ~deviceupdateclient.models.Error
    :ivar subgroup_status: The collection of device class subgroup status objects. Required.
    :vartype subgroup_status: list[~deviceupdateclient.models.DeviceClassSubgroupDeploymentStatus]
    """

    _validation = {
        'group_id': {'required': True},
        'deployment_state': {'required': True},
        'subgroup_status': {'required': True},
    }

    _attribute_map = {
        "group_id": {"key": "groupId", "type": "str"},
        "deployment_state": {"key": "deploymentState", "type": "str"},
        "error": {"key": "error", "type": "Error"},
        "subgroup_status": {"key": "subgroupStatus", "type": "[DeviceClassSubgroupDeploymentStatus]"},
    }

    def __init__(
        self,
        *,
        group_id: str,
        deployment_state: Union[str, "_models.DeploymentState"],
        subgroup_status: List["_models.DeviceClassSubgroupDeploymentStatus"],
        error: Optional["_models.Error"] = None,
        **kwargs
    ):
        """
        :keyword group_id: The group identity. Required.
        :paramtype group_id: str
        :keyword deployment_state: The state of the deployment. Required. Known values are: "Active",
         "ActiveWithSubgroupFailures", "Failed", "Inactive", and "Canceled".
        :paramtype deployment_state: str or ~deviceupdateclient.models.DeploymentState
        :keyword error: The error details of the Failed state.  This is not present if the deployment
         state is not Failed.
        :paramtype error: ~deviceupdateclient.models.Error
        :keyword subgroup_status: The collection of device class subgroup status objects. Required.
        :paramtype subgroup_status:
         list[~deviceupdateclient.models.DeviceClassSubgroupDeploymentStatus]
        """
        super().__init__(**kwargs)
        self.group_id = group_id
        self.deployment_state = deployment_state
        self.error = error
        self.subgroup_status = subgroup_status


class Device(_serialization.Model):
    """Device metadata.

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

    :ivar device_id: Device identity. Required.
    :vartype device_id: str
    :ivar module_id: Device module identity.
    :vartype module_id: str
    :ivar device_class_id: Device class identity. Required.
    :vartype device_class_id: str
    :ivar group_id: Device group identity.
    :vartype group_id: str
    :ivar last_attempted_update: The update that device last attempted to install.
    :vartype last_attempted_update: ~deviceupdateclient.models.UpdateInfo
    :ivar deployment_status: State of the device in its last deployment. Known values are:
     "Succeeded", "InProgress", "Canceled", and "Failed".
    :vartype deployment_status: str or ~deviceupdateclient.models.DeviceDeploymentState
    :ivar installed_update: Currently installed update on device.
    :vartype installed_update: ~deviceupdateclient.models.UpdateInfo
    :ivar on_latest_update: Boolean flag indicating whether the latest update (the best compatible
     update for the device's device class and group) is installed on the device. Required.
    :vartype on_latest_update: bool
    :ivar last_deployment_id: The deployment identifier for the last deployment to the device.
    :vartype last_deployment_id: str
    :ivar last_install_result: Last install result.
    :vartype last_install_result: ~deviceupdateclient.models.InstallResult
    """

    _validation = {
        'device_id': {'required': True},
        'device_class_id': {'required': True},
        'on_latest_update': {'required': True},
    }

    _attribute_map = {
        "device_id": {"key": "deviceId", "type": "str"},
        "module_id": {"key": "moduleId", "type": "str"},
        "device_class_id": {"key": "deviceClassId", "type": "str"},
        "group_id": {"key": "groupId", "type": "str"},
        "last_attempted_update": {"key": "lastAttemptedUpdate", "type": "UpdateInfo"},
        "deployment_status": {"key": "deploymentStatus", "type": "str"},
        "installed_update": {"key": "installedUpdate", "type": "UpdateInfo"},
        "on_latest_update": {"key": "onLatestUpdate", "type": "bool"},
        "last_deployment_id": {"key": "lastDeploymentId", "type": "str"},
        "last_install_result": {"key": "lastInstallResult", "type": "InstallResult"},
    }

    def __init__(
        self,
        *,
        device_id: str,
        device_class_id: str,
        on_latest_update: bool,
        module_id: Optional[str] = None,
        group_id: Optional[str] = None,
        last_attempted_update: Optional["_models.UpdateInfo"] = None,
        deployment_status: Optional[Union[str, "_models.DeviceDeploymentState"]] = None,
        installed_update: Optional["_models.UpdateInfo"] = None,
        last_deployment_id: Optional[str] = None,
        last_install_result: Optional["_models.InstallResult"] = None,
        **kwargs
    ):
        """
        :keyword device_id: Device identity. Required.
        :paramtype device_id: str
        :keyword module_id: Device module identity.
        :paramtype module_id: str
        :keyword device_class_id: Device class identity. Required.
        :paramtype device_class_id: str
        :keyword group_id: Device group identity.
        :paramtype group_id: str
        :keyword last_attempted_update: The update that device last attempted to install.
        :paramtype last_attempted_update: ~deviceupdateclient.models.UpdateInfo
        :keyword deployment_status: State of the device in its last deployment. Known values are:
         "Succeeded", "InProgress", "Canceled", and "Failed".
        :paramtype deployment_status: str or ~deviceupdateclient.models.DeviceDeploymentState
        :keyword installed_update: Currently installed update on device.
        :paramtype installed_update: ~deviceupdateclient.models.UpdateInfo
        :keyword on_latest_update: Boolean flag indicating whether the latest update (the best
         compatible update for the device's device class and group) is installed on the device.
         Required.
        :paramtype on_latest_update: bool
        :keyword last_deployment_id: The deployment identifier for the last deployment to the device.
        :paramtype last_deployment_id: str
        :keyword last_install_result: Last install result.
        :paramtype last_install_result: ~deviceupdateclient.models.InstallResult
        """
        super().__init__(**kwargs)
        self.device_id = device_id
        self.module_id = module_id
        self.device_class_id = device_class_id
        self.group_id = group_id
        self.last_attempted_update = last_attempted_update
        self.deployment_status = deployment_status
        self.installed_update = installed_update
        self.on_latest_update = on_latest_update
        self.last_deployment_id = last_deployment_id
        self.last_install_result = last_install_result


class DeviceClass(_serialization.Model):
    """Device class metadata.

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

    :ivar device_class_id: The device class identifier. This is generated from the model Id and the
     compat properties reported by the device update agent in the Device Update PnP interface in IoT
     Hub. It is a hex-encoded SHA1 hash. Required.
    :vartype device_class_id: str
    :ivar friendly_name: The device class friendly name. This can be updated by callers after the
     device class has been automatically created.
    :vartype friendly_name: str
    :ivar device_class_properties: The device class properties that are used to calculate the
     device class Id. Required.
    :vartype device_class_properties: ~deviceupdateclient.models.DeviceClassProperties
    :ivar best_compatible_update: Update that is the highest version compatible with this device
     class.
    :vartype best_compatible_update: ~deviceupdateclient.models.UpdateInfo
    """

    _validation = {
        'device_class_id': {'required': True},
        'device_class_properties': {'required': True},
    }

    _attribute_map = {
        "device_class_id": {"key": "deviceClassId", "type": "str"},
        "friendly_name": {"key": "friendlyName", "type": "str"},
        "device_class_properties": {"key": "deviceClassProperties", "type": "DeviceClassProperties"},
        "best_compatible_update": {"key": "bestCompatibleUpdate", "type": "UpdateInfo"},
    }

    def __init__(
        self,
        *,
        device_class_id: str,
        device_class_properties: "_models.DeviceClassProperties",
        friendly_name: Optional[str] = None,
        best_compatible_update: Optional["_models.UpdateInfo"] = None,
        **kwargs
    ):
        """
        :keyword device_class_id: The device class identifier. This is generated from the model Id and
         the compat properties reported by the device update agent in the Device Update PnP interface in
         IoT Hub. It is a hex-encoded SHA1 hash. Required.
        :paramtype device_class_id: str
        :keyword friendly_name: The device class friendly name. This can be updated by callers after
         the device class has been automatically created.
        :paramtype friendly_name: str
        :keyword device_class_properties: The device class properties that are used to calculate the
         device class Id. Required.
        :paramtype device_class_properties: ~deviceupdateclient.models.DeviceClassProperties
        :keyword best_compatible_update: Update that is the highest version compatible with this device
         class.
        :paramtype best_compatible_update: ~deviceupdateclient.models.UpdateInfo
        """
        super().__init__(**kwargs)
        self.device_class_id = device_class_id
        self.friendly_name = friendly_name
        self.device_class_properties = device_class_properties
        self.best_compatible_update = best_compatible_update


class DeviceClassesList(_serialization.Model):
    """The list of device classes.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.DeviceClass]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[DeviceClass]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.DeviceClass"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.DeviceClass]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class DeviceClassFilter(_serialization.Model):
    """Device class filter. Filters device classes based on device class friendly name.

    :ivar friendly_name: The friendly name of the device class to use in the filter.
    :vartype friendly_name: str
    """

    _attribute_map = {
        "friendly_name": {"key": "friendlyName", "type": "str"},
    }

    def __init__(
        self,
        *,
        friendly_name: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword friendly_name: The friendly name of the device class to use in the filter.
        :paramtype friendly_name: str
        """
        super().__init__(**kwargs)
        self.friendly_name = friendly_name


class DeviceClassProperties(_serialization.Model):
    """The device class properties that are used to calculate the device class Id.

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

    :ivar contract_model: The Device Update agent contract model.
    :vartype contract_model: ~deviceupdateclient.models.ContractModel
    :ivar compat_properties: The compat properties of the device class. This object can be thought
     of as a set of key-value pairs where the key is the name of the compatibility property and the
     value is the value of the compatibility property. There will always be at least 1 compat
     property. Required.
    :vartype compat_properties: dict[str, str]
    """

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

    _attribute_map = {
        "contract_model": {"key": "contractModel", "type": "ContractModel"},
        "compat_properties": {"key": "compatProperties", "type": "{str}"},
    }

    def __init__(
        self,
        *,
        compat_properties: Dict[str, str],
        contract_model: Optional["_models.ContractModel"] = None,
        **kwargs
    ):
        """
        :keyword contract_model: The Device Update agent contract model.
        :paramtype contract_model: ~deviceupdateclient.models.ContractModel
        :keyword compat_properties: The compat properties of the device class. This object can be
         thought of as a set of key-value pairs where the key is the name of the compatibility property
         and the value is the value of the compatibility property. There will always be at least 1
         compat property. Required.
        :paramtype compat_properties: dict[str, str]
        """
        super().__init__(**kwargs)
        self.contract_model = contract_model
        self.compat_properties = compat_properties


class DeviceClassSubgroup(_serialization.Model):
    """Device class subgroup details. A device class subgroup is a subset of devices in a group that share the same device class id.

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

    :ivar device_class_id: Device class subgroup identity. This is generated from the model Id and
     the compat properties reported by the device update agent in the Device Update PnP interface in
     IoT Hub. It is a hex-encoded SHA1 hash. Required.
    :vartype device_class_id: str
    :ivar group_id: Group identity. Required.
    :vartype group_id: str
    :ivar created_date_time: Date and time when the device class subgroup was created. Required.
    :vartype created_date_time: str
    :ivar device_count: The number of devices in the device class subgroup.
    :vartype device_count: int
    :ivar deployment_id: The active deployment Id for the device class subgroup.
    :vartype deployment_id: str
    """

    _validation = {
        'device_class_id': {'required': True},
        'group_id': {'required': True},
        'created_date_time': {'required': True},
    }

    _attribute_map = {
        "device_class_id": {"key": "deviceClassId", "type": "str"},
        "group_id": {"key": "groupId", "type": "str"},
        "created_date_time": {"key": "createdDateTime", "type": "str"},
        "device_count": {"key": "deviceCount", "type": "int"},
        "deployment_id": {"key": "deploymentId", "type": "str"},
    }

    def __init__(
        self,
        *,
        device_class_id: str,
        group_id: str,
        created_date_time: str,
        device_count: Optional[int] = None,
        deployment_id: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword device_class_id: Device class subgroup identity. This is generated from the model Id
         and the compat properties reported by the device update agent in the Device Update PnP
         interface in IoT Hub. It is a hex-encoded SHA1 hash. Required.
        :paramtype device_class_id: str
        :keyword group_id: Group identity. Required.
        :paramtype group_id: str
        :keyword created_date_time: Date and time when the device class subgroup was created. Required.
        :paramtype created_date_time: str
        :keyword device_count: The number of devices in the device class subgroup.
        :paramtype device_count: int
        :keyword deployment_id: The active deployment Id for the device class subgroup.
        :paramtype deployment_id: str
        """
        super().__init__(**kwargs)
        self.device_class_id = device_class_id
        self.group_id = group_id
        self.created_date_time = created_date_time
        self.device_count = device_count
        self.deployment_id = deployment_id


class DeviceClassSubgroupDeploymentStatus(_serialization.Model):
    """Device class subgroup deployment status metadata.

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

    :ivar group_id: The group identity. Required.
    :vartype group_id: str
    :ivar device_class_id: The device class subgroup identity. Required.
    :vartype device_class_id: str
    :ivar deployment_state: The state of the subgroup deployment. Required. Known values are:
     "Active", "Failed", "Inactive", and "Canceled".
    :vartype deployment_state: str or ~deviceupdateclient.models.DeviceClassSubgroupDeploymentState
    :ivar error: The error details of the Failed state.  This is not present if the deployment
     state is not Failed.
    :vartype error: ~deviceupdateclient.models.Error
    :ivar total_devices: The total number of devices in the deployment.
    :vartype total_devices: int
    :ivar devices_in_progress_count: The number of devices that are currently in deployment.
    :vartype devices_in_progress_count: int
    :ivar devices_completed_failed_count: The number of devices that have completed deployment with
     a failure.
    :vartype devices_completed_failed_count: int
    :ivar devices_completed_succeeded_count: The number of devices which have successfully
     completed deployment.
    :vartype devices_completed_succeeded_count: int
    :ivar devices_canceled_count: The number of devices which have had their deployment canceled.
    :vartype devices_canceled_count: int
    """

    _validation = {
        'group_id': {'required': True},
        'device_class_id': {'required': True},
        'deployment_state': {'required': True},
    }

    _attribute_map = {
        "group_id": {"key": "groupId", "type": "str"},
        "device_class_id": {"key": "deviceClassId", "type": "str"},
        "deployment_state": {"key": "deploymentState", "type": "str"},
        "error": {"key": "error", "type": "Error"},
        "total_devices": {"key": "totalDevices", "type": "int"},
        "devices_in_progress_count": {"key": "devicesInProgressCount", "type": "int"},
        "devices_completed_failed_count": {"key": "devicesCompletedFailedCount", "type": "int"},
        "devices_completed_succeeded_count": {"key": "devicesCompletedSucceededCount", "type": "int"},
        "devices_canceled_count": {"key": "devicesCanceledCount", "type": "int"},
    }

    def __init__(
        self,
        *,
        group_id: str,
        device_class_id: str,
        deployment_state: Union[str, "_models.DeviceClassSubgroupDeploymentState"],
        error: Optional["_models.Error"] = None,
        total_devices: Optional[int] = None,
        devices_in_progress_count: Optional[int] = None,
        devices_completed_failed_count: Optional[int] = None,
        devices_completed_succeeded_count: Optional[int] = None,
        devices_canceled_count: Optional[int] = None,
        **kwargs
    ):
        """
        :keyword group_id: The group identity. Required.
        :paramtype group_id: str
        :keyword device_class_id: The device class subgroup identity. Required.
        :paramtype device_class_id: str
        :keyword deployment_state: The state of the subgroup deployment. Required. Known values are:
         "Active", "Failed", "Inactive", and "Canceled".
        :paramtype deployment_state: str or
         ~deviceupdateclient.models.DeviceClassSubgroupDeploymentState
        :keyword error: The error details of the Failed state.  This is not present if the deployment
         state is not Failed.
        :paramtype error: ~deviceupdateclient.models.Error
        :keyword total_devices: The total number of devices in the deployment.
        :paramtype total_devices: int
        :keyword devices_in_progress_count: The number of devices that are currently in deployment.
        :paramtype devices_in_progress_count: int
        :keyword devices_completed_failed_count: The number of devices that have completed deployment
         with a failure.
        :paramtype devices_completed_failed_count: int
        :keyword devices_completed_succeeded_count: The number of devices which have successfully
         completed deployment.
        :paramtype devices_completed_succeeded_count: int
        :keyword devices_canceled_count: The number of devices which have had their deployment
         canceled.
        :paramtype devices_canceled_count: int
        """
        super().__init__(**kwargs)
        self.group_id = group_id
        self.device_class_id = device_class_id
        self.deployment_state = deployment_state
        self.error = error
        self.total_devices = total_devices
        self.devices_in_progress_count = devices_in_progress_count
        self.devices_completed_failed_count = devices_completed_failed_count
        self.devices_completed_succeeded_count = devices_completed_succeeded_count
        self.devices_canceled_count = devices_canceled_count


class DeviceClassSubgroupFilter(_serialization.Model):
    """Device class subgroups filter. Filters device class subgroups based on device class compat property names and values.

    :ivar compat_property_name: The name of the compat property to use in the filter. E.g.
     compatProperties/manufacturer.
    :vartype compat_property_name: str
    :ivar compat_property_value: The value the compat property to use in the filter. E.g. Contoso.
    :vartype compat_property_value: str
    """

    _attribute_map = {
        "compat_property_name": {"key": "compatPropertyName", "type": "str"},
        "compat_property_value": {"key": "compatPropertyValue", "type": "str"},
    }

    def __init__(
        self,
        *,
        compat_property_name: Optional[str] = None,
        compat_property_value: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword compat_property_name: The name of the compat property to use in the filter. E.g.
         compatProperties/manufacturer.
        :paramtype compat_property_name: str
        :keyword compat_property_value: The value the compat property to use in the filter. E.g.
         Contoso.
        :paramtype compat_property_value: str
        """
        super().__init__(**kwargs)
        self.compat_property_name = compat_property_name
        self.compat_property_value = compat_property_value


class DeviceClassSubgroupsList(_serialization.Model):
    """The list of device class subgroups within a group.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.DeviceClassSubgroup]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[DeviceClassSubgroup]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.DeviceClassSubgroup"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.DeviceClassSubgroup]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class DeviceClassSubgroupUpdatableDevices(_serialization.Model):
    """Device class subgroup, update information, and the number of devices for which the update is applicable.

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

    :ivar group_id: The group Id. Required.
    :vartype group_id: str
    :ivar device_class_id: The device class subgroup's device class Id. Required.
    :vartype device_class_id: str
    :ivar update: Update information. Required.
    :vartype update: ~deviceupdateclient.models.UpdateInfo
    :ivar device_count: Total number of devices for which the update is applicable. Required.
    :vartype device_count: int
    """

    _validation = {
        'group_id': {'required': True},
        'device_class_id': {'required': True},
        'update': {'required': True},
        'device_count': {'required': True},
    }

    _attribute_map = {
        "group_id": {"key": "groupId", "type": "str"},
        "device_class_id": {"key": "deviceClassId", "type": "str"},
        "update": {"key": "update", "type": "UpdateInfo"},
        "device_count": {"key": "deviceCount", "type": "int"},
    }

    def __init__(
        self,
        *,
        group_id: str,
        device_class_id: str,
        update: "_models.UpdateInfo",
        device_count: int,
        **kwargs
    ):
        """
        :keyword group_id: The group Id. Required.
        :paramtype group_id: str
        :keyword device_class_id: The device class subgroup's device class Id. Required.
        :paramtype device_class_id: str
        :keyword update: Update information. Required.
        :paramtype update: ~deviceupdateclient.models.UpdateInfo
        :keyword device_count: Total number of devices for which the update is applicable. Required.
        :paramtype device_count: int
        """
        super().__init__(**kwargs)
        self.group_id = group_id
        self.device_class_id = device_class_id
        self.update = update
        self.device_count = device_count


class DeviceClassSubgroupUpdatableDevicesList(_serialization.Model):
    """The list of updatable devices for a device class subgroup.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.DeviceClassSubgroupUpdatableDevices]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[DeviceClassSubgroupUpdatableDevices]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.DeviceClassSubgroupUpdatableDevices"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.DeviceClassSubgroupUpdatableDevices]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class DeviceFilter(_serialization.Model):
    """Device filter.

    :ivar group_id: Device group identity.
    :vartype group_id: str
    :ivar device_class_id: Device class identity.
    :vartype device_class_id: str
    :ivar deployment_status: State of the device in its last deployment. Known values are:
     "Succeeded", "InProgress", "Canceled", and "Failed".
    :vartype deployment_status: str or ~deviceupdateclient.models.DeviceDeploymentState
    """

    _attribute_map = {
        "group_id": {"key": "groupId", "type": "str"},
        "device_class_id": {"key": "deviceClassId", "type": "str"},
        "deployment_status": {"key": "deploymentStatus", "type": "str"},
    }

    def __init__(
        self,
        *,
        group_id: Optional[str] = None,
        device_class_id: Optional[str] = None,
        deployment_status: Optional[Union[str, "_models.DeviceDeploymentState"]] = None,
        **kwargs
    ):
        """
        :keyword group_id: Device group identity.
        :paramtype group_id: str
        :keyword device_class_id: Device class identity.
        :paramtype device_class_id: str
        :keyword deployment_status: State of the device in its last deployment. Known values are:
         "Succeeded", "InProgress", "Canceled", and "Failed".
        :paramtype deployment_status: str or ~deviceupdateclient.models.DeviceDeploymentState
        """
        super().__init__(**kwargs)
        self.group_id = group_id
        self.device_class_id = device_class_id
        self.deployment_status = deployment_status


class DeviceHealth(_serialization.Model):
    """Device Health.

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

    :ivar device_id: Device id. Required.
    :vartype device_id: str
    :ivar module_id: Module id.
    :vartype module_id: str
    :ivar state: Aggregate device health state. Required. Known values are: "healthy" and
     "unhealthy".
    :vartype state: str or ~deviceupdateclient.models.DeviceHealthState
    :ivar digital_twin_model_id: Digital twin model Id.
    :vartype digital_twin_model_id: str
    :ivar health_checks: Array of health checks and their results. Required.
    :vartype health_checks: list[~deviceupdateclient.models.HealthCheck]
    """

    _validation = {
        'device_id': {'required': True},
        'state': {'required': True},
        'health_checks': {'required': True},
    }

    _attribute_map = {
        "device_id": {"key": "deviceId", "type": "str"},
        "module_id": {"key": "moduleId", "type": "str"},
        "state": {"key": "state", "type": "str"},
        "digital_twin_model_id": {"key": "digitalTwinModelId", "type": "str"},
        "health_checks": {"key": "healthChecks", "type": "[HealthCheck]"},
    }

    def __init__(
        self,
        *,
        device_id: str,
        state: Union[str, "_models.DeviceHealthState"],
        health_checks: List["_models.HealthCheck"],
        module_id: Optional[str] = None,
        digital_twin_model_id: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword device_id: Device id. Required.
        :paramtype device_id: str
        :keyword module_id: Module id.
        :paramtype module_id: str
        :keyword state: Aggregate device health state. Required. Known values are: "healthy" and
         "unhealthy".
        :paramtype state: str or ~deviceupdateclient.models.DeviceHealthState
        :keyword digital_twin_model_id: Digital twin model Id.
        :paramtype digital_twin_model_id: str
        :keyword health_checks: Array of health checks and their results. Required.
        :paramtype health_checks: list[~deviceupdateclient.models.HealthCheck]
        """
        super().__init__(**kwargs)
        self.device_id = device_id
        self.module_id = module_id
        self.state = state
        self.digital_twin_model_id = digital_twin_model_id
        self.health_checks = health_checks


class DeviceHealthFilter(_serialization.Model):
    """Device health filter.

    :ivar state: Device health state. Known values are: "healthy" and "unhealthy".
    :vartype state: str or ~deviceupdateclient.models.DeviceHealthState
    :ivar device_id: Device Id.
    :vartype device_id: str
    :ivar module_id: Module Id.
    :vartype module_id: str
    """

    _attribute_map = {
        "state": {"key": "state", "type": "str"},
        "device_id": {"key": "deviceId", "type": "str"},
        "module_id": {"key": "moduleId", "type": "str"},
    }

    def __init__(
        self,
        *,
        state: Optional[Union[str, "_models.DeviceHealthState"]] = None,
        device_id: Optional[str] = None,
        module_id: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword state: Device health state. Known values are: "healthy" and "unhealthy".
        :paramtype state: str or ~deviceupdateclient.models.DeviceHealthState
        :keyword device_id: Device Id.
        :paramtype device_id: str
        :keyword module_id: Module Id.
        :paramtype module_id: str
        """
        super().__init__(**kwargs)
        self.state = state
        self.device_id = device_id
        self.module_id = module_id


class DeviceHealthList(_serialization.Model):
    """Array of Device Health, with server paging support.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.DeviceHealth]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[DeviceHealth]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.DeviceHealth"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.DeviceHealth]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class DeviceOperation(_serialization.Model):
    """Operation metadata.

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

    :ivar operation_id: Operation Id. Required.
    :vartype operation_id: str
    :ivar status: Operation status. Required. Known values are: "NotStarted", "Running",
     "Succeeded", and "Failed".
    :vartype status: str or ~deviceupdateclient.models.OperationStatus
    :ivar error: Operation error encountered, if any.
    :vartype error: ~deviceupdateclient.models.Error
    :ivar trace_id: Operation correlation identity that can used by Microsoft Support for
     troubleshooting.
    :vartype trace_id: str
    :ivar last_action_date_time: Date and time in UTC when the operation status was last updated.
     Required.
    :vartype last_action_date_time: ~datetime.datetime
    :ivar created_date_time: Date and time in UTC when the operation was created. Required.
    :vartype created_date_time: ~datetime.datetime
    :ivar etag: Operation ETag.
    :vartype etag: str
    """

    _validation = {
        'operation_id': {'required': True},
        'status': {'required': True},
        'last_action_date_time': {'required': True},
        'created_date_time': {'required': True},
    }

    _attribute_map = {
        "operation_id": {"key": "operationId", "type": "str"},
        "status": {"key": "status", "type": "str"},
        "error": {"key": "error", "type": "Error"},
        "trace_id": {"key": "traceId", "type": "str"},
        "last_action_date_time": {"key": "lastActionDateTime", "type": "iso-8601"},
        "created_date_time": {"key": "createdDateTime", "type": "iso-8601"},
        "etag": {"key": "etag", "type": "str"},
    }

    def __init__(
        self,
        *,
        operation_id: str,
        status: Union[str, "_models.OperationStatus"],
        last_action_date_time: datetime.datetime,
        created_date_time: datetime.datetime,
        error: Optional["_models.Error"] = None,
        trace_id: Optional[str] = None,
        etag: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword operation_id: Operation Id. Required.
        :paramtype operation_id: str
        :keyword status: Operation status. Required. Known values are: "NotStarted", "Running",
         "Succeeded", and "Failed".
        :paramtype status: str or ~deviceupdateclient.models.OperationStatus
        :keyword error: Operation error encountered, if any.
        :paramtype error: ~deviceupdateclient.models.Error
        :keyword trace_id: Operation correlation identity that can used by Microsoft Support for
         troubleshooting.
        :paramtype trace_id: str
        :keyword last_action_date_time: Date and time in UTC when the operation status was last
         updated. Required.
        :paramtype last_action_date_time: ~datetime.datetime
        :keyword created_date_time: Date and time in UTC when the operation was created. Required.
        :paramtype created_date_time: ~datetime.datetime
        :keyword etag: Operation ETag.
        :paramtype etag: str
        """
        super().__init__(**kwargs)
        self.operation_id = operation_id
        self.status = status
        self.error = error
        self.trace_id = trace_id
        self.last_action_date_time = last_action_date_time
        self.created_date_time = created_date_time
        self.etag = etag


class DeviceOperationsList(_serialization.Model):
    """The list of device operations with server paging support.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.DeviceOperation]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[DeviceOperation]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.DeviceOperation"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.DeviceOperation]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class DevicesList(_serialization.Model):
    """The list of devices.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.Device]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[Device]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.Device"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.Device]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class DeviceUpdateAgentId(_serialization.Model):
    """Device Update agent id.

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

    :ivar device_id: Device Id. Required.
    :vartype device_id: str
    :ivar module_id: Module Id.
    :vartype module_id: str
    """

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

    _attribute_map = {
        "device_id": {"key": "deviceId", "type": "str"},
        "module_id": {"key": "moduleId", "type": "str"},
    }

    def __init__(
        self,
        *,
        device_id: str,
        module_id: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword device_id: Device Id. Required.
        :paramtype device_id: str
        :keyword module_id: Module Id.
        :paramtype module_id: str
        """
        super().__init__(**kwargs)
        self.device_id = device_id
        self.module_id = module_id


class Error(_serialization.Model):
    """Error details.

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

    :ivar code: Server defined error code. Required.
    :vartype code: str
    :ivar message: A human-readable representation of the error. Required.
    :vartype message: str
    :ivar target: The target of the error.
    :vartype target: str
    :ivar details: An array of errors that led to the reported error.
    :vartype details: list[~deviceupdateclient.models.Error]
    :ivar innererror: An object containing more specific information than the current object about
     the error.
    :vartype innererror: ~deviceupdateclient.models.InnerError
    :ivar occurred_date_time: Date and time in UTC when the error occurred.
    :vartype occurred_date_time: ~datetime.datetime
    """

    _validation = {
        'code': {'required': True},
        'message': {'required': True},
    }

    _attribute_map = {
        "code": {"key": "code", "type": "str"},
        "message": {"key": "message", "type": "str"},
        "target": {"key": "target", "type": "str"},
        "details": {"key": "details", "type": "[Error]"},
        "innererror": {"key": "innererror", "type": "InnerError"},
        "occurred_date_time": {"key": "occurredDateTime", "type": "iso-8601"},
    }

    def __init__(
        self,
        *,
        code: str,
        message: str,
        target: Optional[str] = None,
        details: Optional[List["_models.Error"]] = None,
        innererror: Optional["_models.InnerError"] = None,
        occurred_date_time: Optional[datetime.datetime] = None,
        **kwargs
    ):
        """
        :keyword code: Server defined error code. Required.
        :paramtype code: str
        :keyword message: A human-readable representation of the error. Required.
        :paramtype message: str
        :keyword target: The target of the error.
        :paramtype target: str
        :keyword details: An array of errors that led to the reported error.
        :paramtype details: list[~deviceupdateclient.models.Error]
        :keyword innererror: An object containing more specific information than the current object
         about the error.
        :paramtype innererror: ~deviceupdateclient.models.InnerError
        :keyword occurred_date_time: Date and time in UTC when the error occurred.
        :paramtype occurred_date_time: ~datetime.datetime
        """
        super().__init__(**kwargs)
        self.code = code
        self.message = message
        self.target = target
        self.details = details
        self.innererror = innererror
        self.occurred_date_time = occurred_date_time


class ErrorResponse(_serialization.Model):
    """Common error response.

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

    :ivar error: The error details. Required.
    :vartype error: ~deviceupdateclient.models.Error
    """

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

    _attribute_map = {
        "error": {"key": "error", "type": "Error"},
    }

    def __init__(
        self,
        *,
        error: "_models.Error",
        **kwargs
    ):
        """
        :keyword error: The error details. Required.
        :paramtype error: ~deviceupdateclient.models.Error
        """
        super().__init__(**kwargs)
        self.error = error


class FileImportMetadata(_serialization.Model):
    """Metadata describing an update file.

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

    :ivar filename: Update file name as specified inside import manifest. Required.
    :vartype filename: str
    :ivar url: Azure Blob location from which the update file can be downloaded by Device Update
     for IoT Hub. This is typically a read-only SAS-protected blob URL with an expiration set to at
     least 4 hours. Required.
    :vartype url: str
    """

    _validation = {
        'filename': {'required': True},
        'url': {'required': True},
    }

    _attribute_map = {
        "filename": {"key": "filename", "type": "str"},
        "url": {"key": "url", "type": "str"},
    }

    def __init__(
        self,
        *,
        filename: str,
        url: str,
        **kwargs
    ):
        """
        :keyword filename: Update file name as specified inside import manifest. Required.
        :paramtype filename: str
        :keyword url: Azure Blob location from which the update file can be downloaded by Device Update
         for IoT Hub. This is typically a read-only SAS-protected blob URL with an expiration set to at
         least 4 hours. Required.
        :paramtype url: str
        """
        super().__init__(**kwargs)
        self.filename = filename
        self.url = url


class Group(_serialization.Model):
    """Group details.

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

    :ivar group_id: Group identity. This is created from the value of the ADUGroup tag in the Iot
     Hub's device/module twin or $default for devices with no tag. Required.
    :vartype group_id: str
    :ivar group_type: Group type. Required. Known values are: "IoTHubTag" and "DefaultNoTag".
    :vartype group_type: str or ~deviceupdateclient.models.GroupType
    :ivar created_date_time: Date and time when the update was created. Required.
    :vartype created_date_time: str
    :ivar device_count: The number of devices in the group.
    :vartype device_count: int
    :ivar subgroups_with_new_updates_available_count: The count of subgroups with new updates
     available.
    :vartype subgroups_with_new_updates_available_count: int
    :ivar subgroups_with_updates_in_progress_count: The count of subgroups with updates in
     progress.
    :vartype subgroups_with_updates_in_progress_count: int
    :ivar subgroups_with_on_latest_update_count: The count of subgroups with devices on the latest
     update.
    :vartype subgroups_with_on_latest_update_count: int
    :ivar deployments: The active deployment Ids for the group.
    :vartype deployments: list[str]
    """

    _validation = {
        'group_id': {'required': True},
        'group_type': {'required': True},
        'created_date_time': {'required': True},
    }

    _attribute_map = {
        "group_id": {"key": "groupId", "type": "str"},
        "group_type": {"key": "groupType", "type": "str"},
        "created_date_time": {"key": "createdDateTime", "type": "str"},
        "device_count": {"key": "deviceCount", "type": "int"},
        "subgroups_with_new_updates_available_count": {"key": "subgroupsWithNewUpdatesAvailableCount", "type": "int"},
        "subgroups_with_updates_in_progress_count": {"key": "subgroupsWithUpdatesInProgressCount", "type": "int"},
        "subgroups_with_on_latest_update_count": {"key": "subgroupsWithOnLatestUpdateCount", "type": "int"},
        "deployments": {"key": "deployments", "type": "[str]"},
    }

    def __init__(
        self,
        *,
        group_id: str,
        group_type: Union[str, "_models.GroupType"],
        created_date_time: str,
        device_count: Optional[int] = None,
        subgroups_with_new_updates_available_count: Optional[int] = None,
        subgroups_with_updates_in_progress_count: Optional[int] = None,
        subgroups_with_on_latest_update_count: Optional[int] = None,
        deployments: Optional[List[str]] = None,
        **kwargs
    ):
        """
        :keyword group_id: Group identity. This is created from the value of the ADUGroup tag in the
         Iot Hub's device/module twin or $default for devices with no tag. Required.
        :paramtype group_id: str
        :keyword group_type: Group type. Required. Known values are: "IoTHubTag" and "DefaultNoTag".
        :paramtype group_type: str or ~deviceupdateclient.models.GroupType
        :keyword created_date_time: Date and time when the update was created. Required.
        :paramtype created_date_time: str
        :keyword device_count: The number of devices in the group.
        :paramtype device_count: int
        :keyword subgroups_with_new_updates_available_count: The count of subgroups with new updates
         available.
        :paramtype subgroups_with_new_updates_available_count: int
        :keyword subgroups_with_updates_in_progress_count: The count of subgroups with updates in
         progress.
        :paramtype subgroups_with_updates_in_progress_count: int
        :keyword subgroups_with_on_latest_update_count: The count of subgroups with devices on the
         latest update.
        :paramtype subgroups_with_on_latest_update_count: int
        :keyword deployments: The active deployment Ids for the group.
        :paramtype deployments: list[str]
        """
        super().__init__(**kwargs)
        self.group_id = group_id
        self.group_type = group_type
        self.created_date_time = created_date_time
        self.device_count = device_count
        self.subgroups_with_new_updates_available_count = subgroups_with_new_updates_available_count
        self.subgroups_with_updates_in_progress_count = subgroups_with_updates_in_progress_count
        self.subgroups_with_on_latest_update_count = subgroups_with_on_latest_update_count
        self.deployments = deployments


class GroupOrderBy(_serialization.Model):
    """Groups order by.

    :ivar group_id: The group Id.
    :vartype group_id: str
    :ivar device_count: The group device count.
    :vartype device_count: str
    :ivar created_date: The group created date.
    :vartype created_date: str
    :ivar subgroups_with_new_updates_available_count: The number of subgroups with new updates
     available.
    :vartype subgroups_with_new_updates_available_count: str
    :ivar subgroups_with_updates_in_progress_count: The number of subgroups with updates in
     progress.
    :vartype subgroups_with_updates_in_progress_count: str
    :ivar subgroups_on_latest_update_count: The number of subgroups with devices on the latest
     update.
    :vartype subgroups_on_latest_update_count: str
    """

    _attribute_map = {
        "group_id": {"key": "groupId", "type": "str"},
        "device_count": {"key": "deviceCount", "type": "str"},
        "created_date": {"key": "createdDate", "type": "str"},
        "subgroups_with_new_updates_available_count": {"key": "subgroupsWithNewUpdatesAvailableCount", "type": "str"},
        "subgroups_with_updates_in_progress_count": {"key": "subgroupsWithUpdatesInProgressCount", "type": "str"},
        "subgroups_on_latest_update_count": {"key": "subgroupsOnLatestUpdateCount", "type": "str"},
    }

    def __init__(
        self,
        *,
        group_id: Optional[str] = None,
        device_count: Optional[str] = None,
        created_date: Optional[str] = None,
        subgroups_with_new_updates_available_count: Optional[str] = None,
        subgroups_with_updates_in_progress_count: Optional[str] = None,
        subgroups_on_latest_update_count: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword group_id: The group Id.
        :paramtype group_id: str
        :keyword device_count: The group device count.
        :paramtype device_count: str
        :keyword created_date: The group created date.
        :paramtype created_date: str
        :keyword subgroups_with_new_updates_available_count: The number of subgroups with new updates
         available.
        :paramtype subgroups_with_new_updates_available_count: str
        :keyword subgroups_with_updates_in_progress_count: The number of subgroups with updates in
         progress.
        :paramtype subgroups_with_updates_in_progress_count: str
        :keyword subgroups_on_latest_update_count: The number of subgroups with devices on the latest
         update.
        :paramtype subgroups_on_latest_update_count: str
        """
        super().__init__(**kwargs)
        self.group_id = group_id
        self.device_count = device_count
        self.created_date = created_date
        self.subgroups_with_new_updates_available_count = subgroups_with_new_updates_available_count
        self.subgroups_with_updates_in_progress_count = subgroups_with_updates_in_progress_count
        self.subgroups_on_latest_update_count = subgroups_on_latest_update_count


class GroupsList(_serialization.Model):
    """The list of groups.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.Group]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[Group]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.Group"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.Group]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class HealthCheck(_serialization.Model):
    """Health check.

    :ivar name: Health check name.
    :vartype name: str
    :ivar result: Health check result. Known values are: "success" and "userError".
    :vartype result: str or ~deviceupdateclient.models.HealthCheckResult
    """

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
        "result": {"key": "result", "type": "str"},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        result: Optional[Union[str, "_models.HealthCheckResult"]] = None,
        **kwargs
    ):
        """
        :keyword name: Health check name.
        :paramtype name: str
        :keyword result: Health check result. Known values are: "success" and "userError".
        :paramtype result: str or ~deviceupdateclient.models.HealthCheckResult
        """
        super().__init__(**kwargs)
        self.name = name
        self.result = result


class ImportManifestMetadata(_serialization.Model):
    """Metadata describing the import manifest, a document which describes the files and other metadata about an update version.

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

    :ivar url: Azure Blob location from which the import manifest can be downloaded by Device
     Update for IoT Hub. This is typically a read-only SAS-protected blob URL with an expiration set
     to at least 4 hours. Required.
    :vartype url: str
    :ivar size_in_bytes: File size in number of bytes. Required.
    :vartype size_in_bytes: int
    :ivar hashes: A JSON object containing the hash(es) of the file. At least SHA256 hash is
     required. This object can be thought of as a set of key-value pairs where the key is the hash
     algorithm, and the value is the hash of the file calculated using that algorithm. Required.
    :vartype hashes: dict[str, str]
    """

    _validation = {
        'url': {'required': True},
        'size_in_bytes': {'required': True},
        'hashes': {'required': True},
    }

    _attribute_map = {
        "url": {"key": "url", "type": "str"},
        "size_in_bytes": {"key": "sizeInBytes", "type": "int"},
        "hashes": {"key": "hashes", "type": "{str}"},
    }

    def __init__(
        self,
        *,
        url: str,
        size_in_bytes: int,
        hashes: Dict[str, str],
        **kwargs
    ):
        """
        :keyword url: Azure Blob location from which the import manifest can be downloaded by Device
         Update for IoT Hub. This is typically a read-only SAS-protected blob URL with an expiration set
         to at least 4 hours. Required.
        :paramtype url: str
        :keyword size_in_bytes: File size in number of bytes. Required.
        :paramtype size_in_bytes: int
        :keyword hashes: A JSON object containing the hash(es) of the file. At least SHA256 hash is
         required. This object can be thought of as a set of key-value pairs where the key is the hash
         algorithm, and the value is the hash of the file calculated using that algorithm. Required.
        :paramtype hashes: dict[str, str]
        """
        super().__init__(**kwargs)
        self.url = url
        self.size_in_bytes = size_in_bytes
        self.hashes = hashes


class ImportUpdateInputItem(_serialization.Model):
    """Import update input item metadata.

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

    :ivar import_manifest: Import manifest metadata like source URL, file size/hashes, etc.
     Required.
    :vartype import_manifest: ~deviceupdateclient.models.ImportManifestMetadata
    :ivar friendly_name: Friendly update name.
    :vartype friendly_name: str
    :ivar files: One or more update file properties like filename and source URL.
    :vartype files: list[~deviceupdateclient.models.FileImportMetadata]
    """

    _validation = {
        'import_manifest': {'required': True},
        'friendly_name': {'max_length': 512, 'min_length': 1},
        'files': {'max_items': 5, 'min_items': 1},
    }

    _attribute_map = {
        "import_manifest": {"key": "importManifest", "type": "ImportManifestMetadata"},
        "friendly_name": {"key": "friendlyName", "type": "str"},
        "files": {"key": "files", "type": "[FileImportMetadata]"},
    }

    def __init__(
        self,
        *,
        import_manifest: "_models.ImportManifestMetadata",
        friendly_name: Optional[str] = None,
        files: Optional[List["_models.FileImportMetadata"]] = None,
        **kwargs
    ):
        """
        :keyword import_manifest: Import manifest metadata like source URL, file size/hashes, etc.
         Required.
        :paramtype import_manifest: ~deviceupdateclient.models.ImportManifestMetadata
        :keyword friendly_name: Friendly update name.
        :paramtype friendly_name: str
        :keyword files: One or more update file properties like filename and source URL.
        :paramtype files: list[~deviceupdateclient.models.FileImportMetadata]
        """
        super().__init__(**kwargs)
        self.import_manifest = import_manifest
        self.friendly_name = friendly_name
        self.files = files


class InnerError(_serialization.Model):
    """An object containing more specific information than the current object about the error.

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

    :ivar code: A more specific error code than what was provided by the containing error.
     Required.
    :vartype code: str
    :ivar message: A human-readable representation of the error.
    :vartype message: str
    :ivar error_detail: The internal error or exception message.
    :vartype error_detail: str
    :ivar inner_error: An object containing more specific information than the current object about
     the error.
    :vartype inner_error: ~deviceupdateclient.models.InnerError
    """

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

    _attribute_map = {
        "code": {"key": "code", "type": "str"},
        "message": {"key": "message", "type": "str"},
        "error_detail": {"key": "errorDetail", "type": "str"},
        "inner_error": {"key": "innerError", "type": "InnerError"},
    }

    def __init__(
        self,
        *,
        code: str,
        message: Optional[str] = None,
        error_detail: Optional[str] = None,
        inner_error: Optional["_models.InnerError"] = None,
        **kwargs
    ):
        """
        :keyword code: A more specific error code than what was provided by the containing error.
         Required.
        :paramtype code: str
        :keyword message: A human-readable representation of the error.
        :paramtype message: str
        :keyword error_detail: The internal error or exception message.
        :paramtype error_detail: str
        :keyword inner_error: An object containing more specific information than the current object
         about the error.
        :paramtype inner_error: ~deviceupdateclient.models.InnerError
        """
        super().__init__(**kwargs)
        self.code = code
        self.message = message
        self.error_detail = error_detail
        self.inner_error = inner_error


class InstallResult(_serialization.Model):
    """The install result of an update and any step results under it.

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

    :ivar result_code: Install result code. Required.
    :vartype result_code: int
    :ivar extended_result_code: Install extended result code. Required.
    :vartype extended_result_code: int
    :ivar result_details: A string containing further details about the install result.
    :vartype result_details: str
    :ivar step_results: Array of step results.
    :vartype step_results: list[~deviceupdateclient.models.StepResult]
    """

    _validation = {
        'result_code': {'required': True},
        'extended_result_code': {'required': True},
    }

    _attribute_map = {
        "result_code": {"key": "resultCode", "type": "int"},
        "extended_result_code": {"key": "extendedResultCode", "type": "int"},
        "result_details": {"key": "resultDetails", "type": "str"},
        "step_results": {"key": "stepResults", "type": "[StepResult]"},
    }

    def __init__(
        self,
        *,
        result_code: int,
        extended_result_code: int,
        result_details: Optional[str] = None,
        step_results: Optional[List["_models.StepResult"]] = None,
        **kwargs
    ):
        """
        :keyword result_code: Install result code. Required.
        :paramtype result_code: int
        :keyword extended_result_code: Install extended result code. Required.
        :paramtype extended_result_code: int
        :keyword result_details: A string containing further details about the install result.
        :paramtype result_details: str
        :keyword step_results: Array of step results.
        :paramtype step_results: list[~deviceupdateclient.models.StepResult]
        """
        super().__init__(**kwargs)
        self.result_code = result_code
        self.extended_result_code = extended_result_code
        self.result_details = result_details
        self.step_results = step_results


class Instructions(_serialization.Model):
    """Instructions.

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

    :ivar steps: Collection of installation steps. Required.
    :vartype steps: list[~deviceupdateclient.models.Step]
    """

    _validation = {
        'steps': {'required': True, 'max_items': 10, 'min_items': 1},
    }

    _attribute_map = {
        "steps": {"key": "steps", "type": "[Step]"},
    }

    def __init__(
        self,
        *,
        steps: List["_models.Step"],
        **kwargs
    ):
        """
        :keyword steps: Collection of installation steps. Required.
        :paramtype steps: list[~deviceupdateclient.models.Step]
        """
        super().__init__(**kwargs)
        self.steps = steps


class LogCollection(_serialization.Model):
    """Diagnostics request body.

    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 log_collection_id: The log collection id.
    :vartype log_collection_id: str
    :ivar device_list: Array of Device Update agent ids. Required.
    :vartype device_list: list[~deviceupdateclient.models.DeviceUpdateAgentId]
    :ivar description: Description of the diagnostics operation.
    :vartype description: str
    :ivar created_date_time: The timestamp when the operation was created.
    :vartype created_date_time: str
    :ivar last_action_date_time: A timestamp for when the current state was entered.
    :vartype last_action_date_time: str
    :ivar status: Operation status. Known values are: "NotStarted", "Running", "Succeeded", and
     "Failed".
    :vartype status: str or ~deviceupdateclient.models.OperationStatus
    """

    _validation = {
        'device_list': {'required': True},
        'description': {'max_length': 512},
        'created_date_time': {'readonly': True},
        'last_action_date_time': {'readonly': True},
        'status': {'readonly': True},
    }

    _attribute_map = {
        "log_collection_id": {"key": "operationId", "type": "str"},
        "device_list": {"key": "deviceList", "type": "[DeviceUpdateAgentId]"},
        "description": {"key": "description", "type": "str"},
        "created_date_time": {"key": "createdDateTime", "type": "str"},
        "last_action_date_time": {"key": "lastActionDateTime", "type": "str"},
        "status": {"key": "status", "type": "str"},
    }

    def __init__(
        self,
        *,
        device_list: List["_models.DeviceUpdateAgentId"],
        log_collection_id: Optional[str] = None,
        description: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword log_collection_id: The log collection id.
        :paramtype log_collection_id: str
        :keyword device_list: Array of Device Update agent ids. Required.
        :paramtype device_list: list[~deviceupdateclient.models.DeviceUpdateAgentId]
        :keyword description: Description of the diagnostics operation.
        :paramtype description: str
        """
        super().__init__(**kwargs)
        self.log_collection_id = log_collection_id
        self.device_list = device_list
        self.description = description
        self.created_date_time = None
        self.last_action_date_time = None
        self.status = None


class LogCollectionDetailedStatusList(_serialization.Model):
    """The list of log collections with detailed status, with server paging support.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.LogCollectionOperationDetailedStatus]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[LogCollectionOperationDetailedStatus]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.LogCollectionOperationDetailedStatus"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.LogCollectionOperationDetailedStatus]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class LogCollectionList(_serialization.Model):
    """The list of log collections with server paging support.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.LogCollection]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[LogCollection]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.LogCollection"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.LogCollection]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class LogCollectionOperationDetailedStatus(_serialization.Model):
    """Device diagnostics operation detailed status.

    :ivar log_collection_id: The device diagnostics operation id.
    :vartype log_collection_id: str
    :ivar created_date_time: The timestamp when the operation was created.
    :vartype created_date_time: str
    :ivar last_action_date_time: A timestamp for when the current state was entered.
    :vartype last_action_date_time: str
    :ivar status: Operation status. Known values are: "NotStarted", "Running", "Succeeded", and
     "Failed".
    :vartype status: str or ~deviceupdateclient.models.OperationStatus
    :ivar device_status: Status of the devices in the operation.
    :vartype device_status: list[~deviceupdateclient.models.LogCollectionOperationDeviceStatus]
    :ivar description: Device diagnostics operation description.
    :vartype description: str
    """

    _attribute_map = {
        "log_collection_id": {"key": "operationId", "type": "str"},
        "created_date_time": {"key": "createdDateTime", "type": "str"},
        "last_action_date_time": {"key": "lastActionDateTime", "type": "str"},
        "status": {"key": "status", "type": "str"},
        "device_status": {"key": "deviceStatus", "type": "[LogCollectionOperationDeviceStatus]"},
        "description": {"key": "description", "type": "str"},
    }

    def __init__(
        self,
        *,
        log_collection_id: Optional[str] = None,
        created_date_time: Optional[str] = None,
        last_action_date_time: Optional[str] = None,
        status: Optional[Union[str, "_models.OperationStatus"]] = None,
        device_status: Optional[List["_models.LogCollectionOperationDeviceStatus"]] = None,
        description: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword log_collection_id: The device diagnostics operation id.
        :paramtype log_collection_id: str
        :keyword created_date_time: The timestamp when the operation was created.
        :paramtype created_date_time: str
        :keyword last_action_date_time: A timestamp for when the current state was entered.
        :paramtype last_action_date_time: str
        :keyword status: Operation status. Known values are: "NotStarted", "Running", "Succeeded", and
         "Failed".
        :paramtype status: str or ~deviceupdateclient.models.OperationStatus
        :keyword device_status: Status of the devices in the operation.
        :paramtype device_status: list[~deviceupdateclient.models.LogCollectionOperationDeviceStatus]
        :keyword description: Device diagnostics operation description.
        :paramtype description: str
        """
        super().__init__(**kwargs)
        self.log_collection_id = log_collection_id
        self.created_date_time = created_date_time
        self.last_action_date_time = last_action_date_time
        self.status = status
        self.device_status = device_status
        self.description = description


class LogCollectionOperationDeviceStatus(_serialization.Model):
    """Diagnostics operation device status.

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

    :ivar device_id: Device id. Required.
    :vartype device_id: str
    :ivar module_id: Module id.
    :vartype module_id: str
    :ivar status: Log upload status. Required. Known values are: "NotStarted", "Running",
     "Succeeded", and "Failed".
    :vartype status: str or ~deviceupdateclient.models.OperationStatus
    :ivar result_code: Log upload result code.
    :vartype result_code: str
    :ivar extended_result_code: Log upload extended result code.
    :vartype extended_result_code: str
    :ivar log_location: Log upload location.
    :vartype log_location: str
    """

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

    _attribute_map = {
        "device_id": {"key": "deviceId", "type": "str"},
        "module_id": {"key": "moduleId", "type": "str"},
        "status": {"key": "status", "type": "str"},
        "result_code": {"key": "resultCode", "type": "str"},
        "extended_result_code": {"key": "extendedResultCode", "type": "str"},
        "log_location": {"key": "logLocation", "type": "str"},
    }

    def __init__(
        self,
        *,
        device_id: str,
        status: Union[str, "_models.OperationStatus"],
        module_id: Optional[str] = None,
        result_code: Optional[str] = None,
        extended_result_code: Optional[str] = None,
        log_location: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword device_id: Device id. Required.
        :paramtype device_id: str
        :keyword module_id: Module id.
        :paramtype module_id: str
        :keyword status: Log upload status. Required. Known values are: "NotStarted", "Running",
         "Succeeded", and "Failed".
        :paramtype status: str or ~deviceupdateclient.models.OperationStatus
        :keyword result_code: Log upload result code.
        :paramtype result_code: str
        :keyword extended_result_code: Log upload extended result code.
        :paramtype extended_result_code: str
        :keyword log_location: Log upload location.
        :paramtype log_location: str
        """
        super().__init__(**kwargs)
        self.device_id = device_id
        self.module_id = module_id
        self.status = status
        self.result_code = result_code
        self.extended_result_code = extended_result_code
        self.log_location = log_location


class OperationFilter(_serialization.Model):
    """Operation status filter.

    :ivar status: Operation status filter. Known values are: "Running" and "NotStarted".
    :vartype status: str or ~deviceupdateclient.models.OperationFilterStatus
    """

    _attribute_map = {
        "status": {"key": "status", "type": "str"},
    }

    def __init__(
        self,
        *,
        status: Optional[Union[str, "_models.OperationFilterStatus"]] = None,
        **kwargs
    ):
        """
        :keyword status: Operation status filter. Known values are: "Running" and "NotStarted".
        :paramtype status: str or ~deviceupdateclient.models.OperationFilterStatus
        """
        super().__init__(**kwargs)
        self.status = status


class PatchBody(_serialization.Model):
    """Device Class JSON Merge Patch request body.

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

    :ivar friendly_name: The device class friendly name. Friendly name can be 1-100 characters,
     alphanumeric, dot, and dash. Required.
    :vartype friendly_name: str
    """

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

    _attribute_map = {
        "friendly_name": {"key": "friendlyName", "type": "str"},
    }

    def __init__(
        self,
        *,
        friendly_name: str,
        **kwargs
    ):
        """
        :keyword friendly_name: The device class friendly name. Friendly name can be 1-100 characters,
         alphanumeric, dot, and dash. Required.
        :paramtype friendly_name: str
        """
        super().__init__(**kwargs)
        self.friendly_name = friendly_name


class Step(_serialization.Model):
    """Update install instruction step.

    :ivar type: Step type. Known values are: "Inline" and "Reference".
    :vartype type: str or ~deviceupdateclient.models.StepType
    :ivar description: Step description.
    :vartype description: str
    :ivar handler: Identity of handler that will execute this step. Required if step type is
     inline.
    :vartype handler: str
    :ivar handler_properties: Parameters to be passed to handler during execution.
    :vartype handler_properties: JSON
    :ivar files: Collection of file names to be passed to handler during execution. Required if
     step type is inline.
    :vartype files: list[str]
    :ivar update_id: Referenced child update identity.  Required if step type is reference.
    :vartype update_id: ~deviceupdateclient.models.UpdateId
    """

    _validation = {
        'description': {'max_length': 64, 'min_length': 1},
        'handler': {'max_length': 32, 'min_length': 1},
        'files': {'max_items': 5, 'min_items': 1},
    }

    _attribute_map = {
        "type": {"key": "type", "type": "str"},
        "description": {"key": "description", "type": "str"},
        "handler": {"key": "handler", "type": "str"},
        "handler_properties": {"key": "handlerProperties", "type": "object"},
        "files": {"key": "files", "type": "[str]"},
        "update_id": {"key": "updateId", "type": "UpdateId"},
    }

    def __init__(
        self,
        *,
        type: Union[str, "_models.StepType"] = "inline",
        description: Optional[str] = None,
        handler: Optional[str] = None,
        handler_properties: Optional[JSON] = None,
        files: Optional[List[str]] = None,
        update_id: Optional["_models.UpdateId"] = None,
        **kwargs
    ):
        """
        :keyword type: Step type. Known values are: "Inline" and "Reference".
        :paramtype type: str or ~deviceupdateclient.models.StepType
        :keyword description: Step description.
        :paramtype description: str
        :keyword handler: Identity of handler that will execute this step. Required if step type is
         inline.
        :paramtype handler: str
        :keyword handler_properties: Parameters to be passed to handler during execution.
        :paramtype handler_properties: JSON
        :keyword files: Collection of file names to be passed to handler during execution. Required if
         step type is inline.
        :paramtype files: list[str]
        :keyword update_id: Referenced child update identity.  Required if step type is reference.
        :paramtype update_id: ~deviceupdateclient.models.UpdateId
        """
        super().__init__(**kwargs)
        self.type = type
        self.description = description
        self.handler = handler
        self.handler_properties = handler_properties
        self.files = files
        self.update_id = update_id


class StepResult(_serialization.Model):
    """The step result under an update.

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

    :ivar update: The update that this step installs if it is of reference type.
    :vartype update: ~deviceupdateclient.models.UpdateInfo
    :ivar description: Step description.
    :vartype description: str
    :ivar result_code: Install result code. Required.
    :vartype result_code: int
    :ivar extended_result_code: Install extended result code. Required.
    :vartype extended_result_code: int
    :ivar result_details: A string containing further details about the install result.
    :vartype result_details: str
    """

    _validation = {
        'result_code': {'required': True},
        'extended_result_code': {'required': True},
    }

    _attribute_map = {
        "update": {"key": "update", "type": "UpdateInfo"},
        "description": {"key": "description", "type": "str"},
        "result_code": {"key": "resultCode", "type": "int"},
        "extended_result_code": {"key": "extendedResultCode", "type": "int"},
        "result_details": {"key": "resultDetails", "type": "str"},
    }

    def __init__(
        self,
        *,
        result_code: int,
        extended_result_code: int,
        update: Optional["_models.UpdateInfo"] = None,
        description: Optional[str] = None,
        result_details: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword update: The update that this step installs if it is of reference type.
        :paramtype update: ~deviceupdateclient.models.UpdateInfo
        :keyword description: Step description.
        :paramtype description: str
        :keyword result_code: Install result code. Required.
        :paramtype result_code: int
        :keyword extended_result_code: Install extended result code. Required.
        :paramtype extended_result_code: int
        :keyword result_details: A string containing further details about the install result.
        :paramtype result_details: str
        """
        super().__init__(**kwargs)
        self.update = update
        self.description = description
        self.result_code = result_code
        self.extended_result_code = extended_result_code
        self.result_details = result_details


class StringsList(_serialization.Model):
    """The list of strings with server paging support.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[str]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

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

    def __init__(
        self,
        *,
        value: List[str],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[str]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class Update(_serialization.Model):  # pylint: disable=too-many-instance-attributes
    """Update metadata.

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

    :ivar update_id: Update identity. Required.
    :vartype update_id: ~deviceupdateclient.models.UpdateId
    :ivar description: Update description specified by creator.
    :vartype description: str
    :ivar friendly_name: Friendly update name specified by importer.
    :vartype friendly_name: str
    :ivar is_deployable: Whether the update can be deployed to a device on its own.
    :vartype is_deployable: bool
    :ivar update_type: Update type. Deprecated in latest import manifest schema.
    :vartype update_type: str
    :ivar installed_criteria: String interpreted by Device Update client to determine if the update
     is installed on the device. Deprecated in latest import manifest schema.
    :vartype installed_criteria: str
    :ivar compatibility: List of update compatibility information. Required.
    :vartype compatibility: list[dict[str, str]]
    :ivar instructions: Update install instructions.
    :vartype instructions: ~deviceupdateclient.models.Instructions
    :ivar referenced_by: List of update identities that reference this update.
    :vartype referenced_by: list[~deviceupdateclient.models.UpdateId]
    :ivar scan_result: Update aggregate scan result (calculated from payload file scan results).
    :vartype scan_result: str
    :ivar manifest_version: Schema version of manifest used to import the update. Required.
    :vartype manifest_version: str
    :ivar imported_date_time: Date and time in UTC when the update was imported. Required.
    :vartype imported_date_time: ~datetime.datetime
    :ivar created_date_time: Date and time in UTC when the update was created. Required.
    :vartype created_date_time: ~datetime.datetime
    :ivar etag: Update ETag.
    :vartype etag: str
    """

    _validation = {
        'update_id': {'required': True},
        'description': {'max_length': 512, 'min_length': 1},
        'friendly_name': {'max_length': 512, 'min_length': 1},
        'compatibility': {'required': True, 'max_items': 10, 'min_items': 1},
        'referenced_by': {'min_items': 1},
        'manifest_version': {'required': True},
        'imported_date_time': {'required': True},
        'created_date_time': {'required': True},
    }

    _attribute_map = {
        "update_id": {"key": "updateId", "type": "UpdateId"},
        "description": {"key": "description", "type": "str"},
        "friendly_name": {"key": "friendlyName", "type": "str"},
        "is_deployable": {"key": "isDeployable", "type": "bool"},
        "update_type": {"key": "updateType", "type": "str"},
        "installed_criteria": {"key": "installedCriteria", "type": "str"},
        "compatibility": {"key": "compatibility", "type": "[{str}]"},
        "instructions": {"key": "instructions", "type": "Instructions"},
        "referenced_by": {"key": "referencedBy", "type": "[UpdateId]"},
        "scan_result": {"key": "scanResult", "type": "str"},
        "manifest_version": {"key": "manifestVersion", "type": "str"},
        "imported_date_time": {"key": "importedDateTime", "type": "iso-8601"},
        "created_date_time": {"key": "createdDateTime", "type": "iso-8601"},
        "etag": {"key": "etag", "type": "str"},
    }

    def __init__(
        self,
        *,
        update_id: "_models.UpdateId",
        compatibility: List[Dict[str, str]],
        manifest_version: str,
        imported_date_time: datetime.datetime,
        created_date_time: datetime.datetime,
        description: Optional[str] = None,
        friendly_name: Optional[str] = None,
        is_deployable: bool = True,
        update_type: Optional[str] = None,
        installed_criteria: Optional[str] = None,
        instructions: Optional["_models.Instructions"] = None,
        referenced_by: Optional[List["_models.UpdateId"]] = None,
        scan_result: Optional[str] = None,
        etag: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword update_id: Update identity. Required.
        :paramtype update_id: ~deviceupdateclient.models.UpdateId
        :keyword description: Update description specified by creator.
        :paramtype description: str
        :keyword friendly_name: Friendly update name specified by importer.
        :paramtype friendly_name: str
        :keyword is_deployable: Whether the update can be deployed to a device on its own.
        :paramtype is_deployable: bool
        :keyword update_type: Update type. Deprecated in latest import manifest schema.
        :paramtype update_type: str
        :keyword installed_criteria: String interpreted by Device Update client to determine if the
         update is installed on the device. Deprecated in latest import manifest schema.
        :paramtype installed_criteria: str
        :keyword compatibility: List of update compatibility information. Required.
        :paramtype compatibility: list[dict[str, str]]
        :keyword instructions: Update install instructions.
        :paramtype instructions: ~deviceupdateclient.models.Instructions
        :keyword referenced_by: List of update identities that reference this update.
        :paramtype referenced_by: list[~deviceupdateclient.models.UpdateId]
        :keyword scan_result: Update aggregate scan result (calculated from payload file scan results).
        :paramtype scan_result: str
        :keyword manifest_version: Schema version of manifest used to import the update. Required.
        :paramtype manifest_version: str
        :keyword imported_date_time: Date and time in UTC when the update was imported. Required.
        :paramtype imported_date_time: ~datetime.datetime
        :keyword created_date_time: Date and time in UTC when the update was created. Required.
        :paramtype created_date_time: ~datetime.datetime
        :keyword etag: Update ETag.
        :paramtype etag: str
        """
        super().__init__(**kwargs)
        self.update_id = update_id
        self.description = description
        self.friendly_name = friendly_name
        self.is_deployable = is_deployable
        self.update_type = update_type
        self.installed_criteria = installed_criteria
        self.compatibility = compatibility
        self.instructions = instructions
        self.referenced_by = referenced_by
        self.scan_result = scan_result
        self.manifest_version = manifest_version
        self.imported_date_time = imported_date_time
        self.created_date_time = created_date_time
        self.etag = etag


class UpdateCompliance(_serialization.Model):
    """Update compliance information.

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

    :ivar total_device_count: Total number of devices. Required.
    :vartype total_device_count: int
    :ivar on_latest_update_device_count: Number of devices on the latest update. Required.
    :vartype on_latest_update_device_count: int
    :ivar new_updates_available_device_count: Number of devices with a newer update available.
     Required.
    :vartype new_updates_available_device_count: int
    :ivar updates_in_progress_device_count: Number of devices with update in-progress. Required.
    :vartype updates_in_progress_device_count: int
    """

    _validation = {
        'total_device_count': {'required': True},
        'on_latest_update_device_count': {'required': True},
        'new_updates_available_device_count': {'required': True},
        'updates_in_progress_device_count': {'required': True},
    }

    _attribute_map = {
        "total_device_count": {"key": "totalDeviceCount", "type": "int"},
        "on_latest_update_device_count": {"key": "onLatestUpdateDeviceCount", "type": "int"},
        "new_updates_available_device_count": {"key": "newUpdatesAvailableDeviceCount", "type": "int"},
        "updates_in_progress_device_count": {"key": "updatesInProgressDeviceCount", "type": "int"},
    }

    def __init__(
        self,
        *,
        total_device_count: int,
        on_latest_update_device_count: int,
        new_updates_available_device_count: int,
        updates_in_progress_device_count: int,
        **kwargs
    ):
        """
        :keyword total_device_count: Total number of devices. Required.
        :paramtype total_device_count: int
        :keyword on_latest_update_device_count: Number of devices on the latest update. Required.
        :paramtype on_latest_update_device_count: int
        :keyword new_updates_available_device_count: Number of devices with a newer update available.
         Required.
        :paramtype new_updates_available_device_count: int
        :keyword updates_in_progress_device_count: Number of devices with update in-progress. Required.
        :paramtype updates_in_progress_device_count: int
        """
        super().__init__(**kwargs)
        self.total_device_count = total_device_count
        self.on_latest_update_device_count = on_latest_update_device_count
        self.new_updates_available_device_count = new_updates_available_device_count
        self.updates_in_progress_device_count = updates_in_progress_device_count


class UpdateFileBase(_serialization.Model):
    """Update file basic metadata.

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

    :ivar file_name: File name. Required.
    :vartype file_name: str
    :ivar size_in_bytes: File size in number of bytes. Required.
    :vartype size_in_bytes: int
    :ivar hashes: Mapping of hashing algorithm to base64 encoded hash values. Required.
    :vartype hashes: dict[str, str]
    :ivar mime_type: File MIME type.
    :vartype mime_type: str
    :ivar scan_result: Anti-malware scan result.
    :vartype scan_result: str
    :ivar scan_details: Anti-malware scan details.
    :vartype scan_details: str
    :ivar properties: Optional file properties (not consumed by service but pass-through to
     device).
    :vartype properties: dict[str, str]
    """

    _validation = {
        'file_name': {'required': True},
        'size_in_bytes': {'required': True},
        'hashes': {'required': True},
    }

    _attribute_map = {
        "file_name": {"key": "fileName", "type": "str"},
        "size_in_bytes": {"key": "sizeInBytes", "type": "int"},
        "hashes": {"key": "hashes", "type": "{str}"},
        "mime_type": {"key": "mimeType", "type": "str"},
        "scan_result": {"key": "scanResult", "type": "str"},
        "scan_details": {"key": "scanDetails", "type": "str"},
        "properties": {"key": "properties", "type": "{str}"},
    }

    def __init__(
        self,
        *,
        file_name: str,
        size_in_bytes: int,
        hashes: Dict[str, str],
        mime_type: Optional[str] = None,
        scan_result: Optional[str] = None,
        scan_details: Optional[str] = None,
        properties: Optional[Dict[str, str]] = None,
        **kwargs
    ):
        """
        :keyword file_name: File name. Required.
        :paramtype file_name: str
        :keyword size_in_bytes: File size in number of bytes. Required.
        :paramtype size_in_bytes: int
        :keyword hashes: Mapping of hashing algorithm to base64 encoded hash values. Required.
        :paramtype hashes: dict[str, str]
        :keyword mime_type: File MIME type.
        :paramtype mime_type: str
        :keyword scan_result: Anti-malware scan result.
        :paramtype scan_result: str
        :keyword scan_details: Anti-malware scan details.
        :paramtype scan_details: str
        :keyword properties: Optional file properties (not consumed by service but pass-through to
         device).
        :paramtype properties: dict[str, str]
        """
        super().__init__(**kwargs)
        self.file_name = file_name
        self.size_in_bytes = size_in_bytes
        self.hashes = hashes
        self.mime_type = mime_type
        self.scan_result = scan_result
        self.scan_details = scan_details
        self.properties = properties


class UpdateFile(UpdateFileBase):  # pylint: disable=too-many-instance-attributes
    """Update file metadata.

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

    :ivar file_name: File name. Required.
    :vartype file_name: str
    :ivar size_in_bytes: File size in number of bytes. Required.
    :vartype size_in_bytes: int
    :ivar hashes: Mapping of hashing algorithm to base64 encoded hash values. Required.
    :vartype hashes: dict[str, str]
    :ivar mime_type: File MIME type.
    :vartype mime_type: str
    :ivar scan_result: Anti-malware scan result.
    :vartype scan_result: str
    :ivar scan_details: Anti-malware scan details.
    :vartype scan_details: str
    :ivar properties: Optional file properties (not consumed by service but pass-through to
     device).
    :vartype properties: dict[str, str]
    :ivar file_id: File identity, generated by server at import time. Required.
    :vartype file_id: str
    :ivar related_files: Optional related files metadata used together DownloadHandler metadata to
     download payload file.
    :vartype related_files: list[~deviceupdateclient.models.UpdateFileBase]
    :ivar download_handler: Optional download handler for utilizing related files to download
     payload file.
    :vartype download_handler: ~deviceupdateclient.models.UpdateFileDownloadHandler
    :ivar etag: File ETag.
    :vartype etag: str
    """

    _validation = {
        'file_name': {'required': True},
        'size_in_bytes': {'required': True},
        'hashes': {'required': True},
        'file_id': {'required': True},
    }

    _attribute_map = {
        "file_name": {"key": "fileName", "type": "str"},
        "size_in_bytes": {"key": "sizeInBytes", "type": "int"},
        "hashes": {"key": "hashes", "type": "{str}"},
        "mime_type": {"key": "mimeType", "type": "str"},
        "scan_result": {"key": "scanResult", "type": "str"},
        "scan_details": {"key": "scanDetails", "type": "str"},
        "properties": {"key": "properties", "type": "{str}"},
        "file_id": {"key": "fileId", "type": "str"},
        "related_files": {"key": "relatedFiles", "type": "[UpdateFileBase]"},
        "download_handler": {"key": "downloadHandler", "type": "UpdateFileDownloadHandler"},
        "etag": {"key": "etag", "type": "str"},
    }

    def __init__(
        self,
        *,
        file_name: str,
        size_in_bytes: int,
        hashes: Dict[str, str],
        file_id: str,
        mime_type: Optional[str] = None,
        scan_result: Optional[str] = None,
        scan_details: Optional[str] = None,
        properties: Optional[Dict[str, str]] = None,
        related_files: Optional[List["_models.UpdateFileBase"]] = None,
        download_handler: Optional["_models.UpdateFileDownloadHandler"] = None,
        etag: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword file_name: File name. Required.
        :paramtype file_name: str
        :keyword size_in_bytes: File size in number of bytes. Required.
        :paramtype size_in_bytes: int
        :keyword hashes: Mapping of hashing algorithm to base64 encoded hash values. Required.
        :paramtype hashes: dict[str, str]
        :keyword mime_type: File MIME type.
        :paramtype mime_type: str
        :keyword scan_result: Anti-malware scan result.
        :paramtype scan_result: str
        :keyword scan_details: Anti-malware scan details.
        :paramtype scan_details: str
        :keyword properties: Optional file properties (not consumed by service but pass-through to
         device).
        :paramtype properties: dict[str, str]
        :keyword file_id: File identity, generated by server at import time. Required.
        :paramtype file_id: str
        :keyword related_files: Optional related files metadata used together DownloadHandler metadata
         to download payload file.
        :paramtype related_files: list[~deviceupdateclient.models.UpdateFileBase]
        :keyword download_handler: Optional download handler for utilizing related files to download
         payload file.
        :paramtype download_handler: ~deviceupdateclient.models.UpdateFileDownloadHandler
        :keyword etag: File ETag.
        :paramtype etag: str
        """
        super().__init__(file_name=file_name, size_in_bytes=size_in_bytes, hashes=hashes, mime_type=mime_type, scan_result=scan_result, scan_details=scan_details, properties=properties, **kwargs)
        self.file_id = file_id
        self.related_files = related_files
        self.download_handler = download_handler
        self.etag = etag


class UpdateFileDownloadHandler(_serialization.Model):
    """Download handler for utilizing related files to download payload file.

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

    :ivar id: Download handler identifier. Required.
    :vartype id: str
    """

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

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

    def __init__(
        self,
        *,
        id: str,  # pylint: disable=redefined-builtin
        **kwargs
    ):
        """
        :keyword id: Download handler identifier. Required.
        :paramtype id: str
        """
        super().__init__(**kwargs)
        self.id = id


class UpdateFilter(_serialization.Model):
    """Update filter.

    :ivar is_deployable: Update isDeployable property.
    :vartype is_deployable: bool
    """

    _attribute_map = {
        "is_deployable": {"key": "isDeployable", "type": "bool"},
    }

    def __init__(
        self,
        *,
        is_deployable: Optional[bool] = None,
        **kwargs
    ):
        """
        :keyword is_deployable: Update isDeployable property.
        :paramtype is_deployable: bool
        """
        super().__init__(**kwargs)
        self.is_deployable = is_deployable


class UpdateId(_serialization.Model):
    """Update identifier.

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

    :ivar provider: Update provider. Required.
    :vartype provider: str
    :ivar name: Update name. Required.
    :vartype name: str
    :ivar version: Update version. Required.
    :vartype version: str
    """

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

    _attribute_map = {
        "provider": {"key": "provider", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "version": {"key": "version", "type": "str"},
    }

    def __init__(
        self,
        *,
        provider: str,
        name: str,
        version: str,
        **kwargs
    ):
        """
        :keyword provider: Update provider. Required.
        :paramtype provider: str
        :keyword name: Update name. Required.
        :paramtype name: str
        :keyword version: Update version. Required.
        :paramtype version: str
        """
        super().__init__(**kwargs)
        self.provider = provider
        self.name = name
        self.version = version


class UpdateInfo(_serialization.Model):
    """Update information.

    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 update_id: Update identifier. Required.
    :vartype update_id: ~deviceupdateclient.models.UpdateId
    :ivar description: Update description.
    :vartype description: str
    :ivar friendly_name: Friendly update name.
    :vartype friendly_name: str
    """

    _validation = {
        'update_id': {'required': True},
        'description': {'readonly': True},
        'friendly_name': {'readonly': True},
    }

    _attribute_map = {
        "update_id": {"key": "updateId", "type": "UpdateId"},
        "description": {"key": "description", "type": "str"},
        "friendly_name": {"key": "friendlyName", "type": "str"},
    }

    def __init__(
        self,
        *,
        update_id: "_models.UpdateId",
        **kwargs
    ):
        """
        :keyword update_id: Update identifier. Required.
        :paramtype update_id: ~deviceupdateclient.models.UpdateId
        """
        super().__init__(**kwargs)
        self.update_id = update_id
        self.description = None
        self.friendly_name = None


class UpdateInfoList(_serialization.Model):
    """List of update information.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.UpdateInfo]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[UpdateInfo]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.UpdateInfo"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.UpdateInfo]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class UpdateList(_serialization.Model):
    """The list of updates.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.Update]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[Update]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.Update"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.Update]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link


class UpdateOperation(_serialization.Model):
    """Operation metadata.

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

    :ivar operation_id: Operation Id. Required.
    :vartype operation_id: str
    :ivar status: Operation status. Required. Known values are: "NotStarted", "Running",
     "Succeeded", and "Failed".
    :vartype status: str or ~deviceupdateclient.models.OperationStatus
    :ivar update: The update being imported or deleted. For import, this property will only be
     populated after import manifest is processed successfully.
    :vartype update: ~deviceupdateclient.models.UpdateInfo
    :ivar resource_location: Location of the imported update when operation is successful.
    :vartype resource_location: str
    :ivar error: Operation error encountered, if any.
    :vartype error: ~deviceupdateclient.models.Error
    :ivar trace_id: Operation correlation identity that can used by Microsoft Support for
     troubleshooting.
    :vartype trace_id: str
    :ivar last_action_date_time: Date and time in UTC when the operation status was last updated.
     Required.
    :vartype last_action_date_time: ~datetime.datetime
    :ivar created_date_time: Date and time in UTC when the operation was created. Required.
    :vartype created_date_time: ~datetime.datetime
    :ivar etag: Operation ETag.
    :vartype etag: str
    """

    _validation = {
        'operation_id': {'required': True},
        'status': {'required': True},
        'last_action_date_time': {'required': True},
        'created_date_time': {'required': True},
    }

    _attribute_map = {
        "operation_id": {"key": "operationId", "type": "str"},
        "status": {"key": "status", "type": "str"},
        "update": {"key": "update", "type": "UpdateInfo"},
        "resource_location": {"key": "resourceLocation", "type": "str"},
        "error": {"key": "error", "type": "Error"},
        "trace_id": {"key": "traceId", "type": "str"},
        "last_action_date_time": {"key": "lastActionDateTime", "type": "iso-8601"},
        "created_date_time": {"key": "createdDateTime", "type": "iso-8601"},
        "etag": {"key": "etag", "type": "str"},
    }

    def __init__(
        self,
        *,
        operation_id: str,
        status: Union[str, "_models.OperationStatus"],
        last_action_date_time: datetime.datetime,
        created_date_time: datetime.datetime,
        update: Optional["_models.UpdateInfo"] = None,
        resource_location: Optional[str] = None,
        error: Optional["_models.Error"] = None,
        trace_id: Optional[str] = None,
        etag: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword operation_id: Operation Id. Required.
        :paramtype operation_id: str
        :keyword status: Operation status. Required. Known values are: "NotStarted", "Running",
         "Succeeded", and "Failed".
        :paramtype status: str or ~deviceupdateclient.models.OperationStatus
        :keyword update: The update being imported or deleted. For import, this property will only be
         populated after import manifest is processed successfully.
        :paramtype update: ~deviceupdateclient.models.UpdateInfo
        :keyword resource_location: Location of the imported update when operation is successful.
        :paramtype resource_location: str
        :keyword error: Operation error encountered, if any.
        :paramtype error: ~deviceupdateclient.models.Error
        :keyword trace_id: Operation correlation identity that can used by Microsoft Support for
         troubleshooting.
        :paramtype trace_id: str
        :keyword last_action_date_time: Date and time in UTC when the operation status was last
         updated. Required.
        :paramtype last_action_date_time: ~datetime.datetime
        :keyword created_date_time: Date and time in UTC when the operation was created. Required.
        :paramtype created_date_time: ~datetime.datetime
        :keyword etag: Operation ETag.
        :paramtype etag: str
        """
        super().__init__(**kwargs)
        self.operation_id = operation_id
        self.status = status
        self.update = update
        self.resource_location = resource_location
        self.error = error
        self.trace_id = trace_id
        self.last_action_date_time = last_action_date_time
        self.created_date_time = created_date_time
        self.etag = etag


class UpdateOperationsList(_serialization.Model):
    """The list of operations with server paging support.

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

    :ivar value: The collection of pageable items. Required.
    :vartype value: list[~deviceupdateclient.models.UpdateOperation]
    :ivar next_link: The link to the next page of items.
    :vartype next_link: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "[UpdateOperation]"},
        "next_link": {"key": "nextLink", "type": "str"},
    }

    def __init__(
        self,
        *,
        value: List["_models.UpdateOperation"],
        next_link: Optional[str] = None,
        **kwargs
    ):
        """
        :keyword value: The collection of pageable items. Required.
        :paramtype value: list[~deviceupdateclient.models.UpdateOperation]
        :keyword next_link: The link to the next page of items.
        :paramtype next_link: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.next_link = next_link