# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------

import datetime
from typing import List, Optional, Union

import msrest.serialization

from ._dev_center_dataplane_client_enums import *


class Artifact(msrest.serialization.Model):
    """Properties of an Artifact.

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

    :ivar id: Artifact identifier.
    :vartype id: str
    :ivar name: Artifact name.
    :vartype name: str
    :ivar is_directory: Whether artifact is a directory.
    :vartype is_directory: bool
    :ivar download_uri: Uri where the file contents can be downloaded.
    :vartype download_uri: str
    :ivar file_size: Size of file in bytes, if the artifact is a file.
    :vartype file_size: float
    :ivar created_time: Time the artifact was created.
    :vartype created_time: ~datetime.datetime
    :ivar last_modified_time: Time the artifact was last modified.
    :vartype last_modified_time: ~datetime.datetime
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'is_directory': {'readonly': True},
        'download_uri': {'readonly': True},
        'file_size': {'readonly': True},
        'created_time': {'readonly': True},
        'last_modified_time': {'readonly': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'is_directory': {'key': 'isDirectory', 'type': 'bool'},
        'download_uri': {'key': 'downloadUri', 'type': 'str'},
        'file_size': {'key': 'fileSize', 'type': 'float'},
        'created_time': {'key': 'createdTime', 'type': 'iso-8601'},
        'last_modified_time': {'key': 'lastModifiedTime', 'type': 'iso-8601'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(Artifact, self).__init__(**kwargs)
        self.id = None
        self.name = None
        self.is_directory = None
        self.download_uri = None
        self.file_size = None
        self.created_time = None
        self.last_modified_time = None


class ArtifactListResult(msrest.serialization.Model):
    """Results of the artifact list operation.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.Artifact]
    :param next_link: URL to get the next set of results if there are any.
    :type next_link: str
    """

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

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

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


class Catalog(msrest.serialization.Model):
    """A catalog.

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

    :param name: Required. Name of the catalog.
    :type name: str
    """

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

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

    def __init__(
        self,
        *,
        name: str,
        **kwargs
    ):
        super(Catalog, self).__init__(**kwargs)
        self.name = name


class CatalogListResult(msrest.serialization.Model):
    """Results of the catalog list operation.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.Catalog]
    :param next_link: URL to get the next set of results if there are any.
    :type next_link: str
    """

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

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

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


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

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

    :param code: Required. An identifier for the error. Codes are invariant and are intended to be
     consumed programmatically.
    :type code: str
    :param message: Required. A message describing the error, intended to be suitable for display
     in a user interface.
    :type message: str
    :param target: The target of the particular error. For example, the name of the property in
     error.
    :type target: str
    :param details: A list of additional details about the error.
    :type details: list[~dev_center_dataplane_client.models.CloudErrorBody]
    """

    _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': '[CloudErrorBody]'},
    }

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


class DevBox(msrest.serialization.Model):
    """A Dev Box.

    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 name: Display name for the Dev Box.
    :vartype name: str
    :ivar project_name: Name of the project this Dev Box belongs to.
    :vartype project_name: str
    :param pool_name: Required. The name of the Dev Box pool this machine belongs to.
    :type pool_name: str
    :ivar hibernate_support: Indicates whether hibernate is enabled/disabled or unknown. Possible
     values include: "Enabled", "Disabled", "OsUnsupported".
    :vartype hibernate_support: str or ~dev_center_dataplane_client.models.HibernateSupport
    :ivar provisioning_state: The current provisioning state of the Dev Box.
    :vartype provisioning_state: str
    :ivar action_state: The current action state of the Dev Box. This is state is based on previous
     action performed by user.
    :vartype action_state: str
    :ivar power_state: The current power state of the Dev Box. Possible values include: "Unknown",
     "Running", "Deallocated", "PoweredOff", "Hibernated".
    :vartype power_state: str or ~dev_center_dataplane_client.models.PowerState
    :ivar unique_id: A unique identifier for the Dev Box. This is a GUID-formatted string (e.g.
     00000000-0000-0000-0000-000000000000).
    :vartype unique_id: str
    :ivar error: Provisioning or action error details. Populated only for error states.
    :vartype error: ~dev_center_dataplane_client.models.CloudErrorBody
    :ivar location: Azure region where this Dev Box is located. This will be the same region as the
     Virtual Network it is attached to.
    :vartype location: str
    :ivar os_type: The operating system type of this Dev Box. Possible values include: "Windows".
    :vartype os_type: str or ~dev_center_dataplane_client.models.OsType
    :ivar user: The AAD object id of the user this Dev Box is assigned to.
    :vartype user: str
    :ivar hardware_profile: Information about the Dev Box's hardware resources.
    :vartype hardware_profile: ~dev_center_dataplane_client.models.HardwareProfile
    :ivar storage_profile: Storage settings for this Dev Box.
    :vartype storage_profile: ~dev_center_dataplane_client.models.StorageProfile
    :ivar image_reference: Information about the image used for this Dev Box.
    :vartype image_reference: ~dev_center_dataplane_client.models.ImageReference
    :ivar created_time: Creation time of this Dev Box.
    :vartype created_time: ~datetime.datetime
    :param local_administrator: Indicates whether the owner of the Dev Box is a local
     administrator. Possible values include: "Enabled", "Disabled".
    :type local_administrator: str or ~dev_center_dataplane_client.models.LocalAdminStatus
    """

    _validation = {
        'name': {'readonly': True},
        'project_name': {'readonly': True},
        'pool_name': {'required': True, 'max_length': 63, 'min_length': 3, 'pattern': r'^[a-zA-Z0-9][a-zA-Z0-9-_.]{2,62}$'},
        'hibernate_support': {'readonly': True},
        'provisioning_state': {'readonly': True},
        'action_state': {'readonly': True},
        'power_state': {'readonly': True},
        'unique_id': {'readonly': True},
        'error': {'readonly': True},
        'location': {'readonly': True},
        'os_type': {'readonly': True},
        'user': {'readonly': True},
        'hardware_profile': {'readonly': True},
        'storage_profile': {'readonly': True},
        'image_reference': {'readonly': True},
        'created_time': {'readonly': True},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'project_name': {'key': 'projectName', 'type': 'str'},
        'pool_name': {'key': 'poolName', 'type': 'str'},
        'hibernate_support': {'key': 'hibernateSupport', 'type': 'str'},
        'provisioning_state': {'key': 'provisioningState', 'type': 'str'},
        'action_state': {'key': 'actionState', 'type': 'str'},
        'power_state': {'key': 'powerState', 'type': 'str'},
        'unique_id': {'key': 'uniqueId', 'type': 'str'},
        'error': {'key': 'error', 'type': 'CloudErrorBody'},
        'location': {'key': 'location', 'type': 'str'},
        'os_type': {'key': 'osType', 'type': 'str'},
        'user': {'key': 'user', 'type': 'str'},
        'hardware_profile': {'key': 'hardwareProfile', 'type': 'HardwareProfile'},
        'storage_profile': {'key': 'storageProfile', 'type': 'StorageProfile'},
        'image_reference': {'key': 'imageReference', 'type': 'ImageReference'},
        'created_time': {'key': 'createdTime', 'type': 'iso-8601'},
        'local_administrator': {'key': 'localAdministrator', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        pool_name: str,
        local_administrator: Optional[Union[str, "LocalAdminStatus"]] = None,
        **kwargs
    ):
        super(DevBox, self).__init__(**kwargs)
        self.name = None
        self.project_name = None
        self.pool_name = pool_name
        self.hibernate_support = None
        self.provisioning_state = None
        self.action_state = None
        self.power_state = None
        self.unique_id = None
        self.error = None
        self.location = None
        self.os_type = None
        self.user = None
        self.hardware_profile = None
        self.storage_profile = None
        self.image_reference = None
        self.created_time = None
        self.local_administrator = local_administrator


class DevBoxAction(msrest.serialization.Model):
    """An action which will take place on a Dev Box.

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

    :param name: Required. The name of the action.
    :type name: str
    :param action_type: Required. The action that will be taken. Possible values include: "Stop".
    :type action_type: str or ~dev_center_dataplane_client.models.DevBoxActionType
    :param source_id: Required. The id of the resource which triggered this action.
    :type source_id: str
    :param suspended_until: The earliest time that the action could occur (UTC).
    :type suspended_until: ~datetime.datetime
    :param next: Details about the next run of this action.
    :type next: ~dev_center_dataplane_client.models.DevBoxNextAction
    """

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

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'action_type': {'key': 'actionType', 'type': 'str'},
        'source_id': {'key': 'sourceId', 'type': 'str'},
        'suspended_until': {'key': 'suspendedUntil', 'type': 'iso-8601'},
        'next': {'key': 'next', 'type': 'DevBoxNextAction'},
    }

    def __init__(
        self,
        *,
        name: str,
        action_type: Union[str, "DevBoxActionType"],
        source_id: str,
        suspended_until: Optional[datetime.datetime] = None,
        next: Optional["DevBoxNextAction"] = None,
        **kwargs
    ):
        super(DevBoxAction, self).__init__(**kwargs)
        self.name = name
        self.action_type = action_type
        self.source_id = source_id
        self.suspended_until = suspended_until
        self.next = next


class DevBoxActionDelayResult(msrest.serialization.Model):
    """The action delay result.

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

    :param name: Required. The name of the action.
    :type name: str
    :param result: Required. The result of the delay operation on this action. Possible values
     include: "Succeeded", "Failed".
    :type result: str or ~dev_center_dataplane_client.models.DevBoxActionDelayResultStatus
    :param action: The delayed action.
    :type action: ~dev_center_dataplane_client.models.DevBoxAction
    :param error: Information about the error that occurred. Only populated on error.
    :type error: ~dev_center_dataplane_client.models.CloudErrorBody
    """

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

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'result': {'key': 'result', 'type': 'str'},
        'action': {'key': 'action', 'type': 'DevBoxAction'},
        'error': {'key': 'error', 'type': 'CloudErrorBody'},
    }

    def __init__(
        self,
        *,
        name: str,
        result: Union[str, "DevBoxActionDelayResultStatus"],
        action: Optional["DevBoxAction"] = None,
        error: Optional["CloudErrorBody"] = None,
        **kwargs
    ):
        super(DevBoxActionDelayResult, self).__init__(**kwargs)
        self.name = name
        self.result = result
        self.action = action
        self.error = error


class DevBoxActionsDelayMultipleResult(msrest.serialization.Model):
    """The actions list result.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.DevBoxActionDelayResult]
    :param next_link: The URL to get the next set of results.
    :type next_link: str
    """

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

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

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


class DevBoxActionsListResult(msrest.serialization.Model):
    """The actions list result.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.DevBoxAction]
    :param next_link: The URL to get the next set of results.
    :type next_link: str
    """

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

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

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


class DevBoxListResult(msrest.serialization.Model):
    """The Dev Box list result.

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

    :param value: Required. The list of DevBox Dev Boxes.
    :type value: list[~dev_center_dataplane_client.models.DevBox]
    :param next_link: The URL to get the next set of results.
    :type next_link: str
    """

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

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

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


class DevBoxNextAction(msrest.serialization.Model):
    """Details about the next run of an action.

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

    :param scheduled_time: Required. The time the action will be triggered (UTC).
    :type scheduled_time: ~datetime.datetime
    """

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

    _attribute_map = {
        'scheduled_time': {'key': 'scheduledTime', 'type': 'iso-8601'},
    }

    def __init__(
        self,
        *,
        scheduled_time: datetime.datetime,
        **kwargs
    ):
        super(DevBoxNextAction, self).__init__(**kwargs)
        self.scheduled_time = scheduled_time


class DevBoxProvisioningNotification(msrest.serialization.Model):
    """The notification configured for DevBox provisioning.

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

    :param enabled: Required. If notification is enabled for DevBox provisioning.
    :type enabled: bool
    :param notification_channel: Required. The channel of the notification.
    :type notification_channel: ~dev_center_dataplane_client.models.NotificationChannel
    """

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

    _attribute_map = {
        'enabled': {'key': 'enabled', 'type': 'bool'},
        'notification_channel': {'key': 'notificationChannel', 'type': 'NotificationChannel'},
    }

    def __init__(
        self,
        *,
        enabled: bool,
        notification_channel: "NotificationChannel",
        **kwargs
    ):
        super(DevBoxProvisioningNotification, self).__init__(**kwargs)
        self.enabled = enabled
        self.notification_channel = notification_channel


class EmailNotification(msrest.serialization.Model):
    """The email notification.

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

    :param enabled: Required. If email notification is enabled.
    :type enabled: bool
    :param recipients: The recipients of the email notification.
    :type recipients: str
    :param cc: The cc of the email notification.
    :type cc: str
    """

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

    _attribute_map = {
        'enabled': {'key': 'enabled', 'type': 'bool'},
        'recipients': {'key': 'recipients', 'type': 'str'},
        'cc': {'key': 'cc', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        enabled: bool,
        recipients: Optional[str] = None,
        cc: Optional[str] = None,
        **kwargs
    ):
        super(EmailNotification, self).__init__(**kwargs)
        self.enabled = enabled
        self.recipients = recipients
        self.cc = cc


class EnvironmentUpdateProperties(msrest.serialization.Model):
    """Properties of an environment. These properties can be updated after the resource has been created.

    :param parameters: Parameters object for the environment.
    :type parameters: object
    """

    _attribute_map = {
        'parameters': {'key': 'parameters', 'type': 'object'},
    }

    def __init__(
        self,
        *,
        parameters: Optional[object] = None,
        **kwargs
    ):
        super(EnvironmentUpdateProperties, self).__init__(**kwargs)
        self.parameters = parameters


class Environment(EnvironmentUpdateProperties):
    """Properties of an environment.

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

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

    :param parameters: Parameters object for the environment.
    :type parameters: object
    :ivar name: Environment name.
    :vartype name: str
    :param environment_type: Required. Environment type.
    :type environment_type: str
    :ivar user: The AAD object id of the owner of this Environment.
    :vartype user: str
    :ivar provisioning_state: The provisioning state of the environment.
    :vartype provisioning_state: str
    :ivar resource_group_id: The identifier of the resource group containing the environment's
     resources.
    :vartype resource_group_id: str
    :param catalog_name: Required. Name of the catalog.
    :type catalog_name: str
    :param environment_definition_name: Required. Name of the environment definition.
    :type environment_definition_name: str
    :ivar error: Provisioning error details. Populated only for error states.
    :vartype error: ~dev_center_dataplane_client.models.CloudErrorBody
    """

    _validation = {
        'name': {'readonly': True},
        'environment_type': {'required': True},
        'user': {'readonly': True},
        'provisioning_state': {'readonly': True},
        'resource_group_id': {'readonly': True},
        'catalog_name': {'required': True},
        'environment_definition_name': {'required': True},
        'error': {'readonly': True},
    }

    _attribute_map = {
        'parameters': {'key': 'parameters', 'type': 'object'},
        'name': {'key': 'name', 'type': 'str'},
        'environment_type': {'key': 'environmentType', 'type': 'str'},
        'user': {'key': 'user', 'type': 'str'},
        'provisioning_state': {'key': 'provisioningState', 'type': 'str'},
        'resource_group_id': {'key': 'resourceGroupId', 'type': 'str'},
        'catalog_name': {'key': 'catalogName', 'type': 'str'},
        'environment_definition_name': {'key': 'environmentDefinitionName', 'type': 'str'},
        'error': {'key': 'error', 'type': 'CloudErrorBody'},
    }

    def __init__(
        self,
        *,
        environment_type: str,
        catalog_name: str,
        environment_definition_name: str,
        parameters: Optional[object] = None,
        **kwargs
    ):
        super(Environment, self).__init__(parameters=parameters, **kwargs)
        self.name = None
        self.environment_type = environment_type
        self.user = None
        self.provisioning_state = None
        self.resource_group_id = None
        self.catalog_name = catalog_name
        self.environment_definition_name = environment_definition_name
        self.error = None


class EnvironmentDefinition(msrest.serialization.Model):
    """An environment definition.

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

    :param id: Required. The ID of the environment definition.
    :type id: str
    :param name: Required. Name of the environment definition.
    :type name: str
    :param catalog_name: Required. Name of the catalog.
    :type catalog_name: str
    :param description: A short description of the environment definition.
    :type description: str
    :param parameters: Input parameters passed to an environment.
    :type parameters: list[~dev_center_dataplane_client.models.EnvironmentDefinitionParameter]
    :param parameters_schema: JSON schema defining the parameters object passed to an environment.
    :type parameters_schema: str
    :param template_path: Path to the Environment Definition entrypoint file.
    :type template_path: str
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'catalog_name': {'key': 'catalogName', 'type': 'str'},
        'description': {'key': 'description', 'type': 'str'},
        'parameters': {'key': 'parameters', 'type': '[EnvironmentDefinitionParameter]'},
        'parameters_schema': {'key': 'parametersSchema', 'type': 'str'},
        'template_path': {'key': 'templatePath', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        id: str,
        name: str,
        catalog_name: str,
        description: Optional[str] = None,
        parameters: Optional[List["EnvironmentDefinitionParameter"]] = None,
        parameters_schema: Optional[str] = None,
        template_path: Optional[str] = None,
        **kwargs
    ):
        super(EnvironmentDefinition, self).__init__(**kwargs)
        self.id = id
        self.name = name
        self.catalog_name = catalog_name
        self.description = description
        self.parameters = parameters
        self.parameters_schema = parameters_schema
        self.template_path = template_path


class EnvironmentDefinitionListResult(msrest.serialization.Model):
    """Results of the environment definition list operation.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.EnvironmentDefinition]
    :param next_link: URL to get the next set of results if there are any.
    :type next_link: str
    """

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

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

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


class EnvironmentDefinitionParameter(msrest.serialization.Model):
    """Properties of an Environment Definition parameter.

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

    :param id: Required. Unique ID of the parameter.
    :type id: str
    :param name: Display name of the parameter.
    :type name: str
    :param description: Description of the parameter.
    :type description: str
    :param default: Default value of the parameter.
    :type default: str
    :param type: Required. A string of one of the basic JSON types (number, integer, array, object,
     boolean, string). Possible values include: "array", "boolean", "integer", "number", "object",
     "string".
    :type type: str or ~dev_center_dataplane_client.models.ParameterType
    :param read_only: Whether or not this parameter is read-only.  If true, default should have a
     value.
    :type read_only: bool
    :param required: Required. Whether or not this parameter is required.
    :type required: bool
    :param allowed: An array of allowed values.
    :type allowed: list[str]
    """

    _validation = {
        'id': {'required': True},
        'type': {'required': True},
        'required': {'required': True},
        'allowed': {'min_items': 1, 'unique': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'description': {'key': 'description', 'type': 'str'},
        'default': {'key': 'default', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'read_only': {'key': 'readOnly', 'type': 'bool'},
        'required': {'key': 'required', 'type': 'bool'},
        'allowed': {'key': 'allowed', 'type': '[str]'},
    }

    def __init__(
        self,
        *,
        id: str,
        type: Union[str, "ParameterType"],
        required: bool,
        name: Optional[str] = None,
        description: Optional[str] = None,
        default: Optional[str] = None,
        read_only: Optional[bool] = None,
        allowed: Optional[List[str]] = None,
        **kwargs
    ):
        super(EnvironmentDefinitionParameter, self).__init__(**kwargs)
        self.id = id
        self.name = name
        self.description = description
        self.default = default
        self.type = type
        self.read_only = read_only
        self.required = required
        self.allowed = allowed


class EnvironmentListResult(msrest.serialization.Model):
    """Results of the environment list operation.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.Environment]
    :param next_link: URL to get the next set of results if there are any.
    :type next_link: str
    """

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

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

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


class EnvironmentType(msrest.serialization.Model):
    """Properties of an environment type.

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

    :param name: Required. Name of the environment type.
    :type name: str
    :param deployment_target_id: Required. Id of a subscription or management group that the
     environment type will be mapped to. The environment's resources will be deployed into this
     subscription or management group.
    :type deployment_target_id: str
    :param status: Required. Indicates whether this environment type is enabled for use in this
     project. Possible values include: "Enabled", "Disabled".
    :type status: str or ~dev_center_dataplane_client.models.EnvironmentTypeEnableStatus
    """

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

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'deployment_target_id': {'key': 'deploymentTargetId', 'type': 'str'},
        'status': {'key': 'status', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        name: str,
        deployment_target_id: str,
        status: Union[str, "EnvironmentTypeEnableStatus"],
        **kwargs
    ):
        super(EnvironmentType, self).__init__(**kwargs)
        self.name = name
        self.deployment_target_id = deployment_target_id
        self.status = status


class EnvironmentTypeListResult(msrest.serialization.Model):
    """Result of the environment type list operation.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.EnvironmentType]
    :param next_link: URL to get the next set of results if there are any.
    :type next_link: str
    """

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

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

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


class HardwareProfile(msrest.serialization.Model):
    """Hardware specifications for the Dev Box.

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

    :ivar sku_name: The name of the SKU.
    :vartype sku_name: str
    :ivar v_cp_us: The number of vCPUs available for the Dev Box.
    :vartype v_cp_us: int
    :ivar memory_gb: The amount of memory available for the Dev Box.
    :vartype memory_gb: int
    """

    _validation = {
        'sku_name': {'readonly': True},
        'v_cp_us': {'readonly': True},
        'memory_gb': {'readonly': True},
    }

    _attribute_map = {
        'sku_name': {'key': 'skuName', 'type': 'str'},
        'v_cp_us': {'key': 'vCPUs', 'type': 'int'},
        'memory_gb': {'key': 'memoryGB', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(HardwareProfile, self).__init__(**kwargs)
        self.sku_name = None
        self.v_cp_us = None
        self.memory_gb = None


class ImageReference(msrest.serialization.Model):
    """Specifies information about the image used.

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

    :ivar name: The name of the image used.
    :vartype name: str
    :ivar version: The version of the image.
    :vartype version: str
    :ivar operating_system: The operating system of the image.
    :vartype operating_system: str
    :ivar os_build_number: The operating system build number of the image.
    :vartype os_build_number: str
    :ivar published_date: The datetime that the backing image version was published.
    :vartype published_date: ~datetime.datetime
    """

    _validation = {
        'name': {'readonly': True},
        'version': {'readonly': True},
        'operating_system': {'readonly': True},
        'os_build_number': {'readonly': True},
        'published_date': {'readonly': True},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'version': {'key': 'version', 'type': 'str'},
        'operating_system': {'key': 'operatingSystem', 'type': 'str'},
        'os_build_number': {'key': 'osBuildNumber', 'type': 'str'},
        'published_date': {'key': 'publishedDate', 'type': 'iso-8601'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(ImageReference, self).__init__(**kwargs)
        self.name = None
        self.version = None
        self.operating_system = None
        self.os_build_number = None
        self.published_date = None


class NotificationChannel(msrest.serialization.Model):
    """The channel of the notification.

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

    :param email_notification: Required. The email notification.
    :type email_notification: ~dev_center_dataplane_client.models.EmailNotification
    :param webhook_notification: Required. The webhook notification.
    :type webhook_notification: ~dev_center_dataplane_client.models.WebhookNotification
    """

    _validation = {
        'email_notification': {'required': True},
        'webhook_notification': {'required': True},
    }

    _attribute_map = {
        'email_notification': {'key': 'emailNotification', 'type': 'EmailNotification'},
        'webhook_notification': {'key': 'webhookNotification', 'type': 'WebhookNotification'},
    }

    def __init__(
        self,
        *,
        email_notification: "EmailNotification",
        webhook_notification: "WebhookNotification",
        **kwargs
    ):
        super(NotificationChannel, self).__init__(**kwargs)
        self.email_notification = email_notification
        self.webhook_notification = webhook_notification


class NotificationSettings(msrest.serialization.Model):
    """The NotificationSettings configured for user.

    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 name: Required. The name of the notification settings. Default value: "default".
    :vartype name: str
    :param enabled: Required. If notification is enabled for the user.
    :type enabled: bool
    :param culture: Required. The culture that MEO can accommdate requests to send emails in.
    :type culture: str
    :param notification_type: Required. The type of the notification.
    :type notification_type: ~dev_center_dataplane_client.models.NotificationType
    """

    _validation = {
        'name': {'required': True, 'constant': True},
        'enabled': {'required': True},
        'culture': {'required': True},
        'notification_type': {'required': True},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'enabled': {'key': 'enabled', 'type': 'bool'},
        'culture': {'key': 'culture', 'type': 'str'},
        'notification_type': {'key': 'notificationType', 'type': 'NotificationType'},
    }

    name = "default"

    def __init__(
        self,
        *,
        enabled: bool,
        culture: str,
        notification_type: "NotificationType",
        **kwargs
    ):
        super(NotificationSettings, self).__init__(**kwargs)
        self.enabled = enabled
        self.culture = culture
        self.notification_type = notification_type


class NotificationSettingsAllowedCulturesListResult(msrest.serialization.Model):
    """The allowed cultures list result for NotificationSettings.

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

    :param value: Required. Allowed culture codes for NotificationSettings.
    :type value: list[str]
    """

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

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

    def __init__(
        self,
        *,
        value: List[str],
        **kwargs
    ):
        super(NotificationSettingsAllowedCulturesListResult, self).__init__(**kwargs)
        self.value = value


class NotificationType(msrest.serialization.Model):
    """The type of the notification.

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

    :param dev_box_provisioning_notification: Required. The notification configured for DevBox
     provisioning.
    :type dev_box_provisioning_notification:
     ~dev_center_dataplane_client.models.DevBoxProvisioningNotification
    """

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

    _attribute_map = {
        'dev_box_provisioning_notification': {'key': 'devBoxProvisioningNotification', 'type': 'DevBoxProvisioningNotification'},
    }

    def __init__(
        self,
        *,
        dev_box_provisioning_notification: "DevBoxProvisioningNotification",
        **kwargs
    ):
        super(NotificationType, self).__init__(**kwargs)
        self.dev_box_provisioning_notification = dev_box_provisioning_notification


class OperationStatus(msrest.serialization.Model):
    """The current status of an async operation.

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

    :param id: Fully qualified ID for the operation status.
    :type id: str
    :param name: The operation id name.
    :type name: str
    :param status: Required. Provisioning state of the resource.
    :type status: str
    :param resource_id: The id of the resource.
    :type resource_id: str
    :param start_time: The start time of the operation.
    :type start_time: ~datetime.datetime
    :param end_time: The end time of the operation.
    :type end_time: ~datetime.datetime
    :param percent_complete: Percent of the operation that is complete.
    :type percent_complete: float
    :param properties: Custom operation properties, populated only for a successful operation.
    :type properties: object
    :param error: Operation Error message.
    :type error: ~dev_center_dataplane_client.models.OperationStatusError
    """

    _validation = {
        'status': {'required': True},
        'percent_complete': {'maximum': 100, 'minimum': 0},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'status': {'key': 'status', 'type': 'str'},
        'resource_id': {'key': 'resourceId', 'type': 'str'},
        'start_time': {'key': 'startTime', 'type': 'iso-8601'},
        'end_time': {'key': 'endTime', 'type': 'iso-8601'},
        'percent_complete': {'key': 'percentComplete', 'type': 'float'},
        'properties': {'key': 'properties', 'type': 'object'},
        'error': {'key': 'error', 'type': 'OperationStatusError'},
    }

    def __init__(
        self,
        *,
        status: str,
        id: Optional[str] = None,
        name: Optional[str] = None,
        resource_id: Optional[str] = None,
        start_time: Optional[datetime.datetime] = None,
        end_time: Optional[datetime.datetime] = None,
        percent_complete: Optional[float] = None,
        properties: Optional[object] = None,
        error: Optional["OperationStatusError"] = None,
        **kwargs
    ):
        super(OperationStatus, self).__init__(**kwargs)
        self.id = id
        self.name = name
        self.status = status
        self.resource_id = resource_id
        self.start_time = start_time
        self.end_time = end_time
        self.percent_complete = percent_complete
        self.properties = properties
        self.error = error


class OperationStatusError(msrest.serialization.Model):
    """Operation Error message.

    :param code: The error code.
    :type code: str
    :param message: The error message.
    :type message: str
    """

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

    def __init__(
        self,
        *,
        code: Optional[str] = None,
        message: Optional[str] = None,
        **kwargs
    ):
        super(OperationStatusError, self).__init__(**kwargs)
        self.code = code
        self.message = message


class OsDisk(msrest.serialization.Model):
    """Settings for the operating system disk.

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

    :ivar disk_size_gb: The size of the OS Disk in gigabytes.
    :vartype disk_size_gb: int
    """

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

    _attribute_map = {
        'disk_size_gb': {'key': 'diskSizeGB', 'type': 'int'},
    }

    def __init__(
        self,
        **kwargs
    ):
        super(OsDisk, self).__init__(**kwargs)
        self.disk_size_gb = None


class Pool(msrest.serialization.Model):
    """A pool of Dev Boxes.

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

    :param name: Required. Pool name.
    :type name: str
    :param location: Required. Azure region where Dev Boxes in the pool are located.
    :type location: str
    :param os_type: The operating system type of Dev Boxes in this pool. Possible values include:
     "Windows".
    :type os_type: str or ~dev_center_dataplane_client.models.OsType
    :param hardware_profile: Hardware settings for the Dev Boxes created in this pool.
    :type hardware_profile: ~dev_center_dataplane_client.models.HardwareProfile
    :param hibernate_support: Indicates whether hibernate is enabled/disabled or unknown. Possible
     values include: "Enabled", "Disabled", "OsUnsupported".
    :type hibernate_support: str or ~dev_center_dataplane_client.models.HibernateSupport
    :param storage_profile: Storage settings for Dev Box created in this pool.
    :type storage_profile: ~dev_center_dataplane_client.models.StorageProfile
    :param image_reference: Image settings for Dev Boxes create in this pool.
    :type image_reference: ~dev_center_dataplane_client.models.ImageReference
    :param local_administrator: Indicates whether owners of Dev Boxes in this pool are local
     administrators on the Dev Boxes. Possible values include: "Enabled", "Disabled".
    :type local_administrator: str or ~dev_center_dataplane_client.models.LocalAdminStatus
    :param stop_on_disconnect: Stop on disconnect configuration settings for Dev Boxes created in
     this pool.
    :type stop_on_disconnect: ~dev_center_dataplane_client.models.StopOnDisconnectConfiguration
    :param health_status: Required. Overall health status of the Pool. Indicates whether or not the
     Pool is available to create Dev Boxes. Possible values include: "Unknown", "Pending",
     "Healthy", "Warning", "Unhealthy".
    :type health_status: str or ~dev_center_dataplane_client.models.PoolHealthStatus
    """

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

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'location': {'key': 'location', 'type': 'str'},
        'os_type': {'key': 'osType', 'type': 'str'},
        'hardware_profile': {'key': 'hardwareProfile', 'type': 'HardwareProfile'},
        'hibernate_support': {'key': 'hibernateSupport', 'type': 'str'},
        'storage_profile': {'key': 'storageProfile', 'type': 'StorageProfile'},
        'image_reference': {'key': 'imageReference', 'type': 'ImageReference'},
        'local_administrator': {'key': 'localAdministrator', 'type': 'str'},
        'stop_on_disconnect': {'key': 'stopOnDisconnect', 'type': 'StopOnDisconnectConfiguration'},
        'health_status': {'key': 'healthStatus', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        name: str,
        location: str,
        health_status: Union[str, "PoolHealthStatus"],
        os_type: Optional[Union[str, "OsType"]] = None,
        hardware_profile: Optional["HardwareProfile"] = None,
        hibernate_support: Optional[Union[str, "HibernateSupport"]] = None,
        storage_profile: Optional["StorageProfile"] = None,
        image_reference: Optional["ImageReference"] = None,
        local_administrator: Optional[Union[str, "LocalAdminStatus"]] = None,
        stop_on_disconnect: Optional["StopOnDisconnectConfiguration"] = None,
        **kwargs
    ):
        super(Pool, self).__init__(**kwargs)
        self.name = name
        self.location = location
        self.os_type = os_type
        self.hardware_profile = hardware_profile
        self.hibernate_support = hibernate_support
        self.storage_profile = storage_profile
        self.image_reference = image_reference
        self.local_administrator = local_administrator
        self.stop_on_disconnect = stop_on_disconnect
        self.health_status = health_status


class PoolListResult(msrest.serialization.Model):
    """The Pool list result.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.Pool]
    :param next_link: The URL to get the next set of results.
    :type next_link: str
    """

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

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

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


class Project(msrest.serialization.Model):
    """Project details.

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

    :param name: Required. Name of the project.
    :type name: str
    :param description: Description of the project.
    :type description: str
    :param max_dev_boxes_per_user: When specified, indicates the maximum number of Dev Boxes a
     single user can create across all pools in the project.
    :type max_dev_boxes_per_user: int
    """

    _validation = {
        'name': {'required': True},
        'max_dev_boxes_per_user': {'minimum': 0},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'description': {'key': 'description', 'type': 'str'},
        'max_dev_boxes_per_user': {'key': 'maxDevBoxesPerUser', 'type': 'int'},
    }

    def __init__(
        self,
        *,
        name: str,
        description: Optional[str] = None,
        max_dev_boxes_per_user: Optional[int] = None,
        **kwargs
    ):
        super(Project, self).__init__(**kwargs)
        self.name = name
        self.description = description
        self.max_dev_boxes_per_user = max_dev_boxes_per_user


class ProjectListResult(msrest.serialization.Model):
    """Results of the project list operation.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.Project]
    :param next_link: URL to get the next set of results if there are any.
    :type next_link: str
    """

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

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

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


class RemoteConnection(msrest.serialization.Model):
    """Provides remote connection information for a Dev Box.

    :param web_url: URL to open a browser based RDP session.
    :type web_url: str
    :param rdp_connection_url: Link to open a Remote Desktop session.
    :type rdp_connection_url: str
    """

    _attribute_map = {
        'web_url': {'key': 'webUrl', 'type': 'str'},
        'rdp_connection_url': {'key': 'rdpConnectionUrl', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        web_url: Optional[str] = None,
        rdp_connection_url: Optional[str] = None,
        **kwargs
    ):
        super(RemoteConnection, self).__init__(**kwargs)
        self.web_url = web_url
        self.rdp_connection_url = rdp_connection_url


class Schedule(msrest.serialization.Model):
    """A Schedule to execute action.

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

    :param name: Required. Display name for the Schedule.
    :type name: str
    :param type: Required. Supported type this scheduled task represents. Possible values include:
     "StopDevBox".
    :type type: str or ~dev_center_dataplane_client.models.ScheduledType
    :param frequency: Required. The frequency of this scheduled task. Possible values include:
     "Daily".
    :type frequency: str or ~dev_center_dataplane_client.models.ScheduledFrequency
    :param time: Required. The target time to trigger the action. The format is HH:MM.
    :type time: str
    :param time_zone: Required. The IANA timezone id at which the schedule should execute.
    :type time_zone: str
    """

    _validation = {
        'name': {'required': True},
        'type': {'required': True},
        'frequency': {'required': True},
        'time': {'required': True},
        'time_zone': {'required': True},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'frequency': {'key': 'frequency', 'type': 'str'},
        'time': {'key': 'time', 'type': 'str'},
        'time_zone': {'key': 'timeZone', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        name: str,
        type: Union[str, "ScheduledType"],
        frequency: Union[str, "ScheduledFrequency"],
        time: str,
        time_zone: str,
        **kwargs
    ):
        super(Schedule, self).__init__(**kwargs)
        self.name = name
        self.type = type
        self.frequency = frequency
        self.time = time
        self.time_zone = time_zone


class ScheduleListResult(msrest.serialization.Model):
    """The Schedule list result.

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

    :param value: Required. Current page of results.
    :type value: list[~dev_center_dataplane_client.models.Schedule]
    :param next_link: The URL to get the next set of results.
    :type next_link: str
    """

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

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

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


class StopOnDisconnectConfiguration(msrest.serialization.Model):
    """Stop on disconnect configuration settings for Dev Boxes created in this pool.

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

    :param status: Required. Indicates whether the feature to stop the devbox on disconnect once
     the grace period has lapsed is enabled. Possible values include: "Enabled", "Disabled".
    :type status: str or ~dev_center_dataplane_client.models.StopOnDisconnectEnableStatus
    :param grace_period_minutes: The specified time in minutes to wait before stopping a Dev Box
     once disconnect is detected.
    :type grace_period_minutes: int
    """

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

    _attribute_map = {
        'status': {'key': 'status', 'type': 'str'},
        'grace_period_minutes': {'key': 'gracePeriodMinutes', 'type': 'int'},
    }

    def __init__(
        self,
        *,
        status: Union[str, "StopOnDisconnectEnableStatus"],
        grace_period_minutes: Optional[int] = None,
        **kwargs
    ):
        super(StopOnDisconnectConfiguration, self).__init__(**kwargs)
        self.status = status
        self.grace_period_minutes = grace_period_minutes


class StorageProfile(msrest.serialization.Model):
    """Storage settings for the Dev Box's disks.

    :param os_disk: Settings for the operating system disk.
    :type os_disk: ~dev_center_dataplane_client.models.OsDisk
    """

    _attribute_map = {
        'os_disk': {'key': 'osDisk', 'type': 'OsDisk'},
    }

    def __init__(
        self,
        *,
        os_disk: Optional["OsDisk"] = None,
        **kwargs
    ):
        super(StorageProfile, self).__init__(**kwargs)
        self.os_disk = os_disk


class WebhookNotification(msrest.serialization.Model):
    """The webhook notification.

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

    :param enabled: Required. If webhook notification is enabled.
    :type enabled: bool
    :param url: The url of the webhook.
    :type url: str
    """

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

    _attribute_map = {
        'enabled': {'key': 'enabled', 'type': 'bool'},
        'url': {'key': 'url', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        enabled: bool,
        url: Optional[str] = None,
        **kwargs
    ):
        super(WebhookNotification, self).__init__(**kwargs)
        self.enabled = enabled
        self.url = url
