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

import datetime
from typing import Dict, List, Optional, Union

from azure.core.exceptions import HttpResponseError
import msrest.serialization

from ._microsoft_datadog_client_enums import *


class DatadogAgreementProperties(msrest.serialization.Model):
    """Terms properties.

    :param publisher: Publisher identifier string.
    :type publisher: str
    :param product: Product identifier string.
    :type product: str
    :param plan: Plan identifier string.
    :type plan: str
    :param license_text_link: Link to HTML with Microsoft and Publisher terms.
    :type license_text_link: str
    :param privacy_policy_link: Link to the privacy policy of the publisher.
    :type privacy_policy_link: str
    :param retrieve_datetime: Date and time in UTC of when the terms were accepted. This is empty
     if Accepted is false.
    :type retrieve_datetime: ~datetime.datetime
    :param signature: Terms signature.
    :type signature: str
    :param accepted: If any version of the terms have been accepted, otherwise false.
    :type accepted: bool
    """

    _attribute_map = {
        'publisher': {'key': 'publisher', 'type': 'str'},
        'product': {'key': 'product', 'type': 'str'},
        'plan': {'key': 'plan', 'type': 'str'},
        'license_text_link': {'key': 'licenseTextLink', 'type': 'str'},
        'privacy_policy_link': {'key': 'privacyPolicyLink', 'type': 'str'},
        'retrieve_datetime': {'key': 'retrieveDatetime', 'type': 'iso-8601'},
        'signature': {'key': 'signature', 'type': 'str'},
        'accepted': {'key': 'accepted', 'type': 'bool'},
    }

    def __init__(
        self,
        *,
        publisher: Optional[str] = None,
        product: Optional[str] = None,
        plan: Optional[str] = None,
        license_text_link: Optional[str] = None,
        privacy_policy_link: Optional[str] = None,
        retrieve_datetime: Optional[datetime.datetime] = None,
        signature: Optional[str] = None,
        accepted: Optional[bool] = None,
        **kwargs
    ):
        super(DatadogAgreementProperties, self).__init__(**kwargs)
        self.publisher = publisher
        self.product = product
        self.plan = plan
        self.license_text_link = license_text_link
        self.privacy_policy_link = privacy_policy_link
        self.retrieve_datetime = retrieve_datetime
        self.signature = signature
        self.accepted = accepted


class DatadogAgreementResource(msrest.serialization.Model):
    """DatadogAgreementResource.

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

    :ivar id: ARM id of the resource.
    :vartype id: str
    :ivar name: Name of the agreement.
    :vartype name: str
    :ivar type: The type of the resource.
    :vartype type: str
    :param properties: Represents the properties of the resource.
    :type properties: ~microsoft_datadog_client.models.DatadogAgreementProperties
    :ivar system_data: Metadata pertaining to creation and last modification of the resource.
    :vartype system_data: ~microsoft_datadog_client.models.SystemData
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'properties': {'key': 'properties', 'type': 'DatadogAgreementProperties'},
        'system_data': {'key': 'systemData', 'type': 'SystemData'},
    }

    def __init__(
        self,
        *,
        properties: Optional["DatadogAgreementProperties"] = None,
        **kwargs
    ):
        super(DatadogAgreementResource, self).__init__(**kwargs)
        self.id = None
        self.name = None
        self.type = None
        self.properties = properties
        self.system_data = None


class DatadogAgreementResourceListResponse(msrest.serialization.Model):
    """Response of a list operation.

    :param value: Results of a list operation.
    :type value: list[~microsoft_datadog_client.models.DatadogAgreementResource]
    :param next_link: Link to the next set of results, if any.
    :type next_link: str
    """

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

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


class DatadogApiKey(msrest.serialization.Model):
    """DatadogApiKey.

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

    :param created_by: The user that created the API key.
    :type created_by: str
    :param name: The name of the API key.
    :type name: str
    :param key: Required. The value of the API key.
    :type key: str
    :param created: The time of creation of the API key.
    :type created: str
    """

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

    _attribute_map = {
        'created_by': {'key': 'createdBy', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'key': {'key': 'key', 'type': 'str'},
        'created': {'key': 'created', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        key: str,
        created_by: Optional[str] = None,
        name: Optional[str] = None,
        created: Optional[str] = None,
        **kwargs
    ):
        super(DatadogApiKey, self).__init__(**kwargs)
        self.created_by = created_by
        self.name = name
        self.key = key
        self.created = created


class DatadogApiKeyListResponse(msrest.serialization.Model):
    """Response of a list operation.

    :param value: Results of a list operation.
    :type value: list[~microsoft_datadog_client.models.DatadogApiKey]
    :param next_link: Link to the next set of results, if any.
    :type next_link: str
    """

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

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


class DatadogHost(msrest.serialization.Model):
    """DatadogHost.

    :param name: The name of the host.
    :type name: str
    :param aliases: The aliases for the host.
    :type aliases: list[str]
    :param apps: The Datadog integrations reporting metrics for the host.
    :type apps: list[str]
    :param meta:
    :type meta: ~microsoft_datadog_client.models.DatadogHostMetadata
    """

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'aliases': {'key': 'aliases', 'type': '[str]'},
        'apps': {'key': 'apps', 'type': '[str]'},
        'meta': {'key': 'meta', 'type': 'DatadogHostMetadata'},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        aliases: Optional[List[str]] = None,
        apps: Optional[List[str]] = None,
        meta: Optional["DatadogHostMetadata"] = None,
        **kwargs
    ):
        super(DatadogHost, self).__init__(**kwargs)
        self.name = name
        self.aliases = aliases
        self.apps = apps
        self.meta = meta


class DatadogHostListResponse(msrest.serialization.Model):
    """Response of a list operation.

    :param value: Results of a list operation.
    :type value: list[~microsoft_datadog_client.models.DatadogHost]
    :param next_link: Link to the next set of results, if any.
    :type next_link: str
    """

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

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


class DatadogHostMetadata(msrest.serialization.Model):
    """DatadogHostMetadata.

    :param agent_version: The agent version.
    :type agent_version: str
    :param install_method:
    :type install_method: ~microsoft_datadog_client.models.DatadogInstallMethod
    :param logs_agent:
    :type logs_agent: ~microsoft_datadog_client.models.DatadogLogsAgent
    """

    _attribute_map = {
        'agent_version': {'key': 'agentVersion', 'type': 'str'},
        'install_method': {'key': 'installMethod', 'type': 'DatadogInstallMethod'},
        'logs_agent': {'key': 'logsAgent', 'type': 'DatadogLogsAgent'},
    }

    def __init__(
        self,
        *,
        agent_version: Optional[str] = None,
        install_method: Optional["DatadogInstallMethod"] = None,
        logs_agent: Optional["DatadogLogsAgent"] = None,
        **kwargs
    ):
        super(DatadogHostMetadata, self).__init__(**kwargs)
        self.agent_version = agent_version
        self.install_method = install_method
        self.logs_agent = logs_agent


class DatadogInstallMethod(msrest.serialization.Model):
    """DatadogInstallMethod.

    :param tool: The tool.
    :type tool: str
    :param tool_version: The tool version.
    :type tool_version: str
    :param installer_version: The installer version.
    :type installer_version: str
    """

    _attribute_map = {
        'tool': {'key': 'tool', 'type': 'str'},
        'tool_version': {'key': 'toolVersion', 'type': 'str'},
        'installer_version': {'key': 'installerVersion', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        tool: Optional[str] = None,
        tool_version: Optional[str] = None,
        installer_version: Optional[str] = None,
        **kwargs
    ):
        super(DatadogInstallMethod, self).__init__(**kwargs)
        self.tool = tool
        self.tool_version = tool_version
        self.installer_version = installer_version


class DatadogLogsAgent(msrest.serialization.Model):
    """DatadogLogsAgent.

    :param transport: The transport.
    :type transport: str
    """

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

    def __init__(
        self,
        *,
        transport: Optional[str] = None,
        **kwargs
    ):
        super(DatadogLogsAgent, self).__init__(**kwargs)
        self.transport = transport


class DatadogMonitorResource(msrest.serialization.Model):
    """DatadogMonitorResource.

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

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

    :ivar id: ARM id of the monitor resource.
    :vartype id: str
    :ivar name: Name of the monitor resource.
    :vartype name: str
    :ivar type: The type of the monitor resource.
    :vartype type: str
    :param sku:
    :type sku: ~microsoft_datadog_client.models.ResourceSku
    :param properties: Properties specific to the monitor resource.
    :type properties: ~microsoft_datadog_client.models.MonitorProperties
    :param identity:
    :type identity: ~microsoft_datadog_client.models.IdentityProperties
    :param tags: A set of tags. Dictionary of :code:`<string>`.
    :type tags: dict[str, str]
    :param location: Required.
    :type location: str
    :ivar system_data: Metadata pertaining to creation and last modification of the resource.
    :vartype system_data: ~microsoft_datadog_client.models.SystemData
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'sku': {'key': 'sku', 'type': 'ResourceSku'},
        'properties': {'key': 'properties', 'type': 'MonitorProperties'},
        'identity': {'key': 'identity', 'type': 'IdentityProperties'},
        'tags': {'key': 'tags', 'type': '{str}'},
        'location': {'key': 'location', 'type': 'str'},
        'system_data': {'key': 'systemData', 'type': 'SystemData'},
    }

    def __init__(
        self,
        *,
        location: str,
        sku: Optional["ResourceSku"] = None,
        properties: Optional["MonitorProperties"] = None,
        identity: Optional["IdentityProperties"] = None,
        tags: Optional[Dict[str, str]] = None,
        **kwargs
    ):
        super(DatadogMonitorResource, self).__init__(**kwargs)
        self.id = None
        self.name = None
        self.type = None
        self.sku = sku
        self.properties = properties
        self.identity = identity
        self.tags = tags
        self.location = location
        self.system_data = None


class DatadogMonitorResourceListResponse(msrest.serialization.Model):
    """Response of a list operation.

    :param value: Results of a list operation.
    :type value: list[~microsoft_datadog_client.models.DatadogMonitorResource]
    :param next_link: Link to the next set of results, if any.
    :type next_link: str
    """

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

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


class DatadogMonitorResourceUpdateParameters(msrest.serialization.Model):
    """The parameters for a PATCH request to a monitor resource.

    :param properties: The set of properties that can be update in a PATCH request to a monitor
     resource.
    :type properties: ~microsoft_datadog_client.models.MonitorUpdateProperties
    :param tags: A set of tags. The new tags of the monitor resource.
    :type tags: dict[str, str]
    :param sku:
    :type sku: ~microsoft_datadog_client.models.ResourceSku
    """

    _attribute_map = {
        'properties': {'key': 'properties', 'type': 'MonitorUpdateProperties'},
        'tags': {'key': 'tags', 'type': '{str}'},
        'sku': {'key': 'sku', 'type': 'ResourceSku'},
    }

    def __init__(
        self,
        *,
        properties: Optional["MonitorUpdateProperties"] = None,
        tags: Optional[Dict[str, str]] = None,
        sku: Optional["ResourceSku"] = None,
        **kwargs
    ):
        super(DatadogMonitorResourceUpdateParameters, self).__init__(**kwargs)
        self.properties = properties
        self.tags = tags
        self.sku = sku


class DatadogOrganizationProperties(msrest.serialization.Model):
    """Datadog organization properties.

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

    :ivar name: Name of the Datadog organization.
    :vartype name: str
    :ivar id: Id of the Datadog organization.
    :vartype id: str
    :param linking_auth_code: The auth code used to linking to an existing datadog organization.
    :type linking_auth_code: str
    :param linking_client_id: The client_id from an existing in exchange for an auth token to link
     organization.
    :type linking_client_id: str
    :param redirect_uri: The redirect uri for linking.
    :type redirect_uri: str
    :param api_key: Api key associated to the Datadog organization.
    :type api_key: str
    :param application_key: Application key associated to the Datadog organization.
    :type application_key: str
    :param enterprise_app_id: The Id of the Enterprise App used for Single sign on.
    :type enterprise_app_id: str
    """

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

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'id': {'key': 'id', 'type': 'str'},
        'linking_auth_code': {'key': 'linkingAuthCode', 'type': 'str'},
        'linking_client_id': {'key': 'linkingClientId', 'type': 'str'},
        'redirect_uri': {'key': 'redirectUri', 'type': 'str'},
        'api_key': {'key': 'apiKey', 'type': 'str'},
        'application_key': {'key': 'applicationKey', 'type': 'str'},
        'enterprise_app_id': {'key': 'enterpriseAppId', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        linking_auth_code: Optional[str] = None,
        linking_client_id: Optional[str] = None,
        redirect_uri: Optional[str] = None,
        api_key: Optional[str] = None,
        application_key: Optional[str] = None,
        enterprise_app_id: Optional[str] = None,
        **kwargs
    ):
        super(DatadogOrganizationProperties, self).__init__(**kwargs)
        self.name = None
        self.id = None
        self.linking_auth_code = linking_auth_code
        self.linking_client_id = linking_client_id
        self.redirect_uri = redirect_uri
        self.api_key = api_key
        self.application_key = application_key
        self.enterprise_app_id = enterprise_app_id


class DatadogSetPasswordLink(msrest.serialization.Model):
    """DatadogSetPasswordLink.

    :param set_password_link:
    :type set_password_link: str
    """

    _attribute_map = {
        'set_password_link': {'key': 'setPasswordLink', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        set_password_link: Optional[str] = None,
        **kwargs
    ):
        super(DatadogSetPasswordLink, self).__init__(**kwargs)
        self.set_password_link = set_password_link


class DatadogSingleSignOnProperties(msrest.serialization.Model):
    """DatadogSingleSignOnProperties.

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

    :ivar provisioning_state:  Possible values include: "Accepted", "Creating", "Updating",
     "Deleting", "Succeeded", "Failed", "Canceled", "Deleted", "NotSpecified".
    :vartype provisioning_state: str or ~microsoft_datadog_client.models.ProvisioningState
    :param single_sign_on_state: Various states of the SSO resource. Possible values include:
     "Initial", "Enable", "Disable", "Existing".
    :type single_sign_on_state: str or ~microsoft_datadog_client.models.SingleSignOnStates
    :param enterprise_app_id: The Id of the Enterprise App used for Single sign-on.
    :type enterprise_app_id: str
    :ivar single_sign_on_url: The login URL specific to this Datadog Organization.
    :vartype single_sign_on_url: str
    """

    _validation = {
        'provisioning_state': {'readonly': True},
        'single_sign_on_url': {'readonly': True},
    }

    _attribute_map = {
        'provisioning_state': {'key': 'provisioningState', 'type': 'str'},
        'single_sign_on_state': {'key': 'singleSignOnState', 'type': 'str'},
        'enterprise_app_id': {'key': 'enterpriseAppId', 'type': 'str'},
        'single_sign_on_url': {'key': 'singleSignOnUrl', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        single_sign_on_state: Optional[Union[str, "SingleSignOnStates"]] = None,
        enterprise_app_id: Optional[str] = None,
        **kwargs
    ):
        super(DatadogSingleSignOnProperties, self).__init__(**kwargs)
        self.provisioning_state = None
        self.single_sign_on_state = single_sign_on_state
        self.enterprise_app_id = enterprise_app_id
        self.single_sign_on_url = None


class DatadogSingleSignOnResource(msrest.serialization.Model):
    """DatadogSingleSignOnResource.

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

    :ivar id: ARM id of the resource.
    :vartype id: str
    :ivar name: Name of the configuration.
    :vartype name: str
    :ivar type: The type of the resource.
    :vartype type: str
    :param properties:
    :type properties: ~microsoft_datadog_client.models.DatadogSingleSignOnProperties
    :ivar system_data: Metadata pertaining to creation and last modification of the resource.
    :vartype system_data: ~microsoft_datadog_client.models.SystemData
    """

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

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'properties': {'key': 'properties', 'type': 'DatadogSingleSignOnProperties'},
        'system_data': {'key': 'systemData', 'type': 'SystemData'},
    }

    def __init__(
        self,
        *,
        properties: Optional["DatadogSingleSignOnProperties"] = None,
        **kwargs
    ):
        super(DatadogSingleSignOnResource, self).__init__(**kwargs)
        self.id = None
        self.name = None
        self.type = None
        self.properties = properties
        self.system_data = None


class DatadogSingleSignOnResourceListResponse(msrest.serialization.Model):
    """Response of a list operation.

    :param value: Results of a list operation.
    :type value: list[~microsoft_datadog_client.models.DatadogSingleSignOnResource]
    :param next_link: Link to the next set of results, if any.
    :type next_link: str
    """

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

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


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

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

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

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

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

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


class ErrorDetail(msrest.serialization.Model):
    """The error detail.

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

    :ivar code: The error code.
    :vartype code: str
    :ivar message: The error message.
    :vartype message: str
    :ivar target: The error target.
    :vartype target: str
    :ivar details: The error details.
    :vartype details: list[~microsoft_datadog_client.models.ErrorDetail]
    :ivar additional_info: The error additional info.
    :vartype additional_info: list[~microsoft_datadog_client.models.ErrorAdditionalInfo]
    """

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

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

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


class ErrorResponse(msrest.serialization.Model):
    """Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.).

    :param error: The error object.
    :type error: ~microsoft_datadog_client.models.ErrorDetail
    """

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

    def __init__(
        self,
        *,
        error: Optional["ErrorDetail"] = None,
        **kwargs
    ):
        super(ErrorResponse, self).__init__(**kwargs)
        self.error = error


class FilteringTag(msrest.serialization.Model):
    """The definition of a filtering tag. Filtering tags are used for capturing resources and include/exclude them from being monitored.

    :param name: The name (also known as the key) of the tag.
    :type name: str
    :param value: The value of the tag.
    :type value: str
    :param action: Valid actions for a filtering tag. Exclusion takes priority over inclusion.
     Possible values include: "Include", "Exclude".
    :type action: str or ~microsoft_datadog_client.models.TagAction
    """

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

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        value: Optional[str] = None,
        action: Optional[Union[str, "TagAction"]] = None,
        **kwargs
    ):
        super(FilteringTag, self).__init__(**kwargs)
        self.name = name
        self.value = value
        self.action = action


class IdentityProperties(msrest.serialization.Model):
    """IdentityProperties.

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

    :ivar principal_id: The identity ID.
    :vartype principal_id: str
    :ivar tenant_id: The tenant ID of resource.
    :vartype tenant_id: str
    :param type: Identity type. Possible values include: "SystemAssigned", "UserAssigned".
    :type type: str or ~microsoft_datadog_client.models.ManagedIdentityTypes
    """

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

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

    def __init__(
        self,
        *,
        type: Optional[Union[str, "ManagedIdentityTypes"]] = None,
        **kwargs
    ):
        super(IdentityProperties, self).__init__(**kwargs)
        self.principal_id = None
        self.tenant_id = None
        self.type = type


class LinkedResource(msrest.serialization.Model):
    """The definition of a linked resource.

    :param id: The ARM id of the linked resource.
    :type id: str
    """

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

    def __init__(
        self,
        *,
        id: Optional[str] = None,
        **kwargs
    ):
        super(LinkedResource, self).__init__(**kwargs)
        self.id = id


class LinkedResourceListResponse(msrest.serialization.Model):
    """Response of a list operation.

    :param value: Results of a list operation.
    :type value: list[~microsoft_datadog_client.models.LinkedResource]
    :param next_link: Link to the next set of results, if any.
    :type next_link: str
    """

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

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


class LogRules(msrest.serialization.Model):
    """Set of rules for sending logs for the Monitor resource.

    :param send_aad_logs: Flag specifying if AAD logs should be sent for the Monitor resource.
    :type send_aad_logs: bool
    :param send_subscription_logs: Flag specifying if Azure subscription logs should be sent for
     the Monitor resource.
    :type send_subscription_logs: bool
    :param send_resource_logs: Flag specifying if Azure resource logs should be sent for the
     Monitor resource.
    :type send_resource_logs: bool
    :param filtering_tags: List of filtering tags to be used for capturing logs. This only takes
     effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only
     Exclude action is specified, the rules will apply to the list of all available resources. If
     Include actions are specified, the rules will only include resources with the associated tags.
    :type filtering_tags: list[~microsoft_datadog_client.models.FilteringTag]
    """

    _attribute_map = {
        'send_aad_logs': {'key': 'sendAadLogs', 'type': 'bool'},
        'send_subscription_logs': {'key': 'sendSubscriptionLogs', 'type': 'bool'},
        'send_resource_logs': {'key': 'sendResourceLogs', 'type': 'bool'},
        'filtering_tags': {'key': 'filteringTags', 'type': '[FilteringTag]'},
    }

    def __init__(
        self,
        *,
        send_aad_logs: Optional[bool] = None,
        send_subscription_logs: Optional[bool] = None,
        send_resource_logs: Optional[bool] = None,
        filtering_tags: Optional[List["FilteringTag"]] = None,
        **kwargs
    ):
        super(LogRules, self).__init__(**kwargs)
        self.send_aad_logs = send_aad_logs
        self.send_subscription_logs = send_subscription_logs
        self.send_resource_logs = send_resource_logs
        self.filtering_tags = filtering_tags


class MetricRules(msrest.serialization.Model):
    """Set of rules for sending metrics for the Monitor resource.

    :param filtering_tags: List of filtering tags to be used for capturing metrics. If empty, all
     resources will be captured. If only Exclude action is specified, the rules will apply to the
     list of all available resources. If Include actions are specified, the rules will only include
     resources with the associated tags.
    :type filtering_tags: list[~microsoft_datadog_client.models.FilteringTag]
    """

    _attribute_map = {
        'filtering_tags': {'key': 'filteringTags', 'type': '[FilteringTag]'},
    }

    def __init__(
        self,
        *,
        filtering_tags: Optional[List["FilteringTag"]] = None,
        **kwargs
    ):
        super(MetricRules, self).__init__(**kwargs)
        self.filtering_tags = filtering_tags


class MonitoredResource(msrest.serialization.Model):
    """The properties of a resource currently being monitored by the Datadog monitor resource.

    :param id: The ARM id of the resource.
    :type id: str
    :param sending_metrics: Flag indicating if resource is sending metrics to Datadog.
    :type sending_metrics: bool
    :param reason_for_metrics_status: Reason for why the resource is sending metrics (or why it is
     not sending).
    :type reason_for_metrics_status: str
    :param sending_logs: Flag indicating if resource is sending logs to Datadog.
    :type sending_logs: bool
    :param reason_for_logs_status: Reason for why the resource is sending logs (or why it is not
     sending).
    :type reason_for_logs_status: str
    """

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'sending_metrics': {'key': 'sendingMetrics', 'type': 'bool'},
        'reason_for_metrics_status': {'key': 'reasonForMetricsStatus', 'type': 'str'},
        'sending_logs': {'key': 'sendingLogs', 'type': 'bool'},
        'reason_for_logs_status': {'key': 'reasonForLogsStatus', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        id: Optional[str] = None,
        sending_metrics: Optional[bool] = None,
        reason_for_metrics_status: Optional[str] = None,
        sending_logs: Optional[bool] = None,
        reason_for_logs_status: Optional[str] = None,
        **kwargs
    ):
        super(MonitoredResource, self).__init__(**kwargs)
        self.id = id
        self.sending_metrics = sending_metrics
        self.reason_for_metrics_status = reason_for_metrics_status
        self.sending_logs = sending_logs
        self.reason_for_logs_status = reason_for_logs_status


class MonitoredResourceListResponse(msrest.serialization.Model):
    """Response of a list operation.

    :param value: Results of a list operation.
    :type value: list[~microsoft_datadog_client.models.MonitoredResource]
    :param next_link: Link to the next set of results, if any.
    :type next_link: str
    """

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

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


class MonitoringTagRules(msrest.serialization.Model):
    """Capture logs and metrics of Azure resources based on ARM tags.

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

    :ivar name: Name of the rule set.
    :vartype name: str
    :ivar id: The id of the rule set.
    :vartype id: str
    :ivar type: The type of the rule set.
    :vartype type: str
    :param properties: Definition of the properties for a TagRules resource.
    :type properties: ~microsoft_datadog_client.models.MonitoringTagRulesProperties
    :ivar system_data: Metadata pertaining to creation and last modification of the resource.
    :vartype system_data: ~microsoft_datadog_client.models.SystemData
    """

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

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'id': {'key': 'id', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'properties': {'key': 'properties', 'type': 'MonitoringTagRulesProperties'},
        'system_data': {'key': 'systemData', 'type': 'SystemData'},
    }

    def __init__(
        self,
        *,
        properties: Optional["MonitoringTagRulesProperties"] = None,
        **kwargs
    ):
        super(MonitoringTagRules, self).__init__(**kwargs)
        self.name = None
        self.id = None
        self.type = None
        self.properties = properties
        self.system_data = None


class MonitoringTagRulesListResponse(msrest.serialization.Model):
    """Response of a list operation.

    :param value: Results of a list operation.
    :type value: list[~microsoft_datadog_client.models.MonitoringTagRules]
    :param next_link: Link to the next set of results, if any.
    :type next_link: str
    """

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

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


class MonitoringTagRulesProperties(msrest.serialization.Model):
    """Definition of the properties for a TagRules resource.

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

    :ivar provisioning_state:  Possible values include: "Accepted", "Creating", "Updating",
     "Deleting", "Succeeded", "Failed", "Canceled", "Deleted", "NotSpecified".
    :vartype provisioning_state: str or ~microsoft_datadog_client.models.ProvisioningState
    :param log_rules: Set of rules for sending logs for the Monitor resource.
    :type log_rules: ~microsoft_datadog_client.models.LogRules
    :param metric_rules: Set of rules for sending metrics for the Monitor resource.
    :type metric_rules: ~microsoft_datadog_client.models.MetricRules
    """

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

    _attribute_map = {
        'provisioning_state': {'key': 'provisioningState', 'type': 'str'},
        'log_rules': {'key': 'logRules', 'type': 'LogRules'},
        'metric_rules': {'key': 'metricRules', 'type': 'MetricRules'},
    }

    def __init__(
        self,
        *,
        log_rules: Optional["LogRules"] = None,
        metric_rules: Optional["MetricRules"] = None,
        **kwargs
    ):
        super(MonitoringTagRulesProperties, self).__init__(**kwargs)
        self.provisioning_state = None
        self.log_rules = log_rules
        self.metric_rules = metric_rules


class MonitorProperties(msrest.serialization.Model):
    """Properties specific to the monitor resource.

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

    :ivar provisioning_state:  Possible values include: "Accepted", "Creating", "Updating",
     "Deleting", "Succeeded", "Failed", "Canceled", "Deleted", "NotSpecified".
    :vartype provisioning_state: str or ~microsoft_datadog_client.models.ProvisioningState
    :param monitoring_status: Flag specifying if the resource monitoring is enabled or disabled.
     Possible values include: "Enabled", "Disabled". Default value: "Enabled".
    :type monitoring_status: str or ~microsoft_datadog_client.models.MonitoringStatus
    :ivar marketplace_subscription_status: Flag specifying the Marketplace Subscription Status of
     the resource. If payment is not made in time, the resource will go in Suspended state. Possible
     values include: "Provisioning", "Active", "Suspended", "Unsubscribed".
    :vartype marketplace_subscription_status: str or
     ~microsoft_datadog_client.models.MarketplaceSubscriptionStatus
    :param datadog_organization_properties: Datadog organization properties.
    :type datadog_organization_properties:
     ~microsoft_datadog_client.models.DatadogOrganizationProperties
    :param user_info: User info.
    :type user_info: ~microsoft_datadog_client.models.UserInfo
    :ivar liftr_resource_category:  Possible values include: "Unknown", "MonitorLogs".
    :vartype liftr_resource_category: str or
     ~microsoft_datadog_client.models.LiftrResourceCategories
    :ivar liftr_resource_preference: The priority of the resource.
    :vartype liftr_resource_preference: int
    """

    _validation = {
        'provisioning_state': {'readonly': True},
        'marketplace_subscription_status': {'readonly': True},
        'liftr_resource_category': {'readonly': True},
        'liftr_resource_preference': {'readonly': True},
    }

    _attribute_map = {
        'provisioning_state': {'key': 'provisioningState', 'type': 'str'},
        'monitoring_status': {'key': 'monitoringStatus', 'type': 'str'},
        'marketplace_subscription_status': {'key': 'marketplaceSubscriptionStatus', 'type': 'str'},
        'datadog_organization_properties': {'key': 'datadogOrganizationProperties', 'type': 'DatadogOrganizationProperties'},
        'user_info': {'key': 'userInfo', 'type': 'UserInfo'},
        'liftr_resource_category': {'key': 'liftrResourceCategory', 'type': 'str'},
        'liftr_resource_preference': {'key': 'liftrResourcePreference', 'type': 'int'},
    }

    def __init__(
        self,
        *,
        monitoring_status: Optional[Union[str, "MonitoringStatus"]] = "Enabled",
        datadog_organization_properties: Optional["DatadogOrganizationProperties"] = None,
        user_info: Optional["UserInfo"] = None,
        **kwargs
    ):
        super(MonitorProperties, self).__init__(**kwargs)
        self.provisioning_state = None
        self.monitoring_status = monitoring_status
        self.marketplace_subscription_status = None
        self.datadog_organization_properties = datadog_organization_properties
        self.user_info = user_info
        self.liftr_resource_category = None
        self.liftr_resource_preference = None


class MonitorUpdateProperties(msrest.serialization.Model):
    """The set of properties that can be update in a PATCH request to a monitor resource.

    :param monitoring_status: Flag specifying if the resource monitoring is enabled or disabled.
     Possible values include: "Enabled", "Disabled". Default value: "Enabled".
    :type monitoring_status: str or ~microsoft_datadog_client.models.MonitoringStatus
    """

    _attribute_map = {
        'monitoring_status': {'key': 'monitoringStatus', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        monitoring_status: Optional[Union[str, "MonitoringStatus"]] = "Enabled",
        **kwargs
    ):
        super(MonitorUpdateProperties, self).__init__(**kwargs)
        self.monitoring_status = monitoring_status


class OperationDisplay(msrest.serialization.Model):
    """The object that represents the operation.

    :param provider: Service provider, i.e., Microsoft.Datadog.
    :type provider: str
    :param resource: Type on which the operation is performed, e.g., 'monitors'.
    :type resource: str
    :param operation: Operation type, e.g., read, write, delete, etc.
    :type operation: str
    :param description: Description of the operation, e.g., 'Write monitors'.
    :type description: str
    """

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

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


class OperationListResult(msrest.serialization.Model):
    """Result of GET request to list the Microsoft.Datadog operations.

    :param value: List of operations supported by the Microsoft.Datadog provider.
    :type value: list[~microsoft_datadog_client.models.OperationResult]
    :param next_link: URL to get the next set of operation list results if there are any.
    :type next_link: str
    """

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

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


class OperationResult(msrest.serialization.Model):
    """A Microsoft.Datadog REST API operation.

    :param name: Operation name, i.e., {provider}/{resource}/{operation}.
    :type name: str
    :param display: The object that represents the operation.
    :type display: ~microsoft_datadog_client.models.OperationDisplay
    :param is_data_action: Indicates whether the operation is a data action.
    :type is_data_action: bool
    """

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'display': {'key': 'display', 'type': 'OperationDisplay'},
        'is_data_action': {'key': 'isDataAction', 'type': 'bool'},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        display: Optional["OperationDisplay"] = None,
        is_data_action: Optional[bool] = None,
        **kwargs
    ):
        super(OperationResult, self).__init__(**kwargs)
        self.name = name
        self.display = display
        self.is_data_action = is_data_action


class ResourceSku(msrest.serialization.Model):
    """ResourceSku.

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

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

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

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

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


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

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

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

    def __init__(
        self,
        *,
        created_by: Optional[str] = None,
        created_by_type: Optional[Union[str, "CreatedByType"]] = None,
        created_at: Optional[datetime.datetime] = None,
        last_modified_by: Optional[str] = None,
        last_modified_by_type: Optional[Union[str, "CreatedByType"]] = None,
        last_modified_at: Optional[datetime.datetime] = None,
        **kwargs
    ):
        super(SystemData, self).__init__(**kwargs)
        self.created_by = created_by
        self.created_by_type = created_by_type
        self.created_at = created_at
        self.last_modified_by = last_modified_by
        self.last_modified_by_type = last_modified_by_type
        self.last_modified_at = last_modified_at


class UserInfo(msrest.serialization.Model):
    """User info.

    :param name: Name of the user.
    :type name: str
    :param email_address: Email of the user used by Datadog for contacting them if needed.
    :type email_address: str
    :param phone_number: Phone number of the user used by Datadog for contacting them if needed.
    :type phone_number: str
    """

    _validation = {
        'name': {'max_length': 50, 'min_length': 0},
        'email_address': {'pattern': r'^[A-Za-z0-9._%+-]+@(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}$'},
        'phone_number': {'max_length': 40, 'min_length': 0},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'email_address': {'key': 'emailAddress', 'type': 'str'},
        'phone_number': {'key': 'phoneNumber', 'type': 'str'},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        email_address: Optional[str] = None,
        phone_number: Optional[str] = None,
        **kwargs
    ):
        super(UserInfo, self).__init__(**kwargs)
        self.name = name
        self.email_address = email_address
        self.phone_number = phone_number
