# --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# --------------------------------------------------------------------------------------------
# Generated file, DO NOT EDIT
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------------------------

from msrest.serialization import Model


class BaseSubscriptionFilter(Model):
    """BaseSubscriptionFilter.

    :param event_type:
    :type event_type: str
    :param type:
    :type type: str
    """

    _attribute_map = {
        'event_type': {'key': 'eventType', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'}
    }

    def __init__(self, event_type=None, type=None):
        super(BaseSubscriptionFilter, self).__init__()
        self.event_type = event_type
        self.type = type


class BatchNotificationOperation(Model):
    """BatchNotificationOperation.

    :param notification_operation:
    :type notification_operation: object
    :param notification_query_conditions:
    :type notification_query_conditions: list of :class:`NotificationQueryCondition <azure.devops.v5_0.notification.models.NotificationQueryCondition>`
    """

    _attribute_map = {
        'notification_operation': {'key': 'notificationOperation', 'type': 'object'},
        'notification_query_conditions': {'key': 'notificationQueryConditions', 'type': '[NotificationQueryCondition]'}
    }

    def __init__(self, notification_operation=None, notification_query_conditions=None):
        super(BatchNotificationOperation, self).__init__()
        self.notification_operation = notification_operation
        self.notification_query_conditions = notification_query_conditions


class EventActor(Model):
    """EventActor.

    :param id: Required: This is the identity of the user for the specified role.
    :type id: str
    :param role: Required: The event specific name of a role.
    :type role: str
    """

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

    def __init__(self, id=None, role=None):
        super(EventActor, self).__init__()
        self.id = id
        self.role = role


class EventScope(Model):
    """EventScope.

    :param id: Required: This is the identity of the scope for the type.
    :type id: str
    :param name: Optional: The display name of the scope
    :type name: str
    :param type: Required: The event specific type of a scope.
    :type type: str
    """

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

    def __init__(self, id=None, name=None, type=None):
        super(EventScope, self).__init__()
        self.id = id
        self.name = name
        self.type = type


class EventsEvaluationResult(Model):
    """EventsEvaluationResult.

    :param count: Count of events evaluated.
    :type count: int
    :param matched_count: Count of matched events.
    :type matched_count: int
    """

    _attribute_map = {
        'count': {'key': 'count', 'type': 'int'},
        'matched_count': {'key': 'matchedCount', 'type': 'int'}
    }

    def __init__(self, count=None, matched_count=None):
        super(EventsEvaluationResult, self).__init__()
        self.count = count
        self.matched_count = matched_count


class EventTransformRequest(Model):
    """EventTransformRequest.

    :param event_payload: Event payload.
    :type event_payload: str
    :param event_type: Event type.
    :type event_type: str
    :param system_inputs: System inputs.
    :type system_inputs: dict
    """

    _attribute_map = {
        'event_payload': {'key': 'eventPayload', 'type': 'str'},
        'event_type': {'key': 'eventType', 'type': 'str'},
        'system_inputs': {'key': 'systemInputs', 'type': '{str}'}
    }

    def __init__(self, event_payload=None, event_type=None, system_inputs=None):
        super(EventTransformRequest, self).__init__()
        self.event_payload = event_payload
        self.event_type = event_type
        self.system_inputs = system_inputs


class EventTransformResult(Model):
    """EventTransformResult.

    :param content: Transformed html content.
    :type content: str
    :param data: Calculated data.
    :type data: object
    :param system_inputs: Calculated system inputs.
    :type system_inputs: dict
    """

    _attribute_map = {
        'content': {'key': 'content', 'type': 'str'},
        'data': {'key': 'data', 'type': 'object'},
        'system_inputs': {'key': 'systemInputs', 'type': '{str}'}
    }

    def __init__(self, content=None, data=None, system_inputs=None):
        super(EventTransformResult, self).__init__()
        self.content = content
        self.data = data
        self.system_inputs = system_inputs


class ExpressionFilterClause(Model):
    """ExpressionFilterClause.

    :param field_name:
    :type field_name: str
    :param index: The order in which this clause appeared in the filter query
    :type index: int
    :param logical_operator: Logical Operator 'AND', 'OR' or NULL (only for the first clause in the filter)
    :type logical_operator: str
    :param operator:
    :type operator: str
    :param value:
    :type value: str
    """

    _attribute_map = {
        'field_name': {'key': 'fieldName', 'type': 'str'},
        'index': {'key': 'index', 'type': 'int'},
        'logical_operator': {'key': 'logicalOperator', 'type': 'str'},
        'operator': {'key': 'operator', 'type': 'str'},
        'value': {'key': 'value', 'type': 'str'}
    }

    def __init__(self, field_name=None, index=None, logical_operator=None, operator=None, value=None):
        super(ExpressionFilterClause, self).__init__()
        self.field_name = field_name
        self.index = index
        self.logical_operator = logical_operator
        self.operator = operator
        self.value = value


class ExpressionFilterGroup(Model):
    """ExpressionFilterGroup.

    :param end: The index of the last FilterClause in this group
    :type end: int
    :param level: Level of the group, since groups can be nested for each nested group the level will increase by 1
    :type level: int
    :param start: The index of the first FilterClause in this group
    :type start: int
    """

    _attribute_map = {
        'end': {'key': 'end', 'type': 'int'},
        'level': {'key': 'level', 'type': 'int'},
        'start': {'key': 'start', 'type': 'int'}
    }

    def __init__(self, end=None, level=None, start=None):
        super(ExpressionFilterGroup, self).__init__()
        self.end = end
        self.level = level
        self.start = start


class ExpressionFilterModel(Model):
    """ExpressionFilterModel.

    :param clauses: Flat list of clauses in this subscription
    :type clauses: list of :class:`ExpressionFilterClause <azure.devops.v5_0.notification.models.ExpressionFilterClause>`
    :param groups: Grouping of clauses in the subscription
    :type groups: list of :class:`ExpressionFilterGroup <azure.devops.v5_0.notification.models.ExpressionFilterGroup>`
    :param max_group_level: Max depth of the Subscription tree
    :type max_group_level: int
    """

    _attribute_map = {
        'clauses': {'key': 'clauses', 'type': '[ExpressionFilterClause]'},
        'groups': {'key': 'groups', 'type': '[ExpressionFilterGroup]'},
        'max_group_level': {'key': 'maxGroupLevel', 'type': 'int'}
    }

    def __init__(self, clauses=None, groups=None, max_group_level=None):
        super(ExpressionFilterModel, self).__init__()
        self.clauses = clauses
        self.groups = groups
        self.max_group_level = max_group_level


class GraphSubjectBase(Model):
    """GraphSubjectBase.

    :param _links: This field contains zero or more interesting links about the graph subject. These links may be invoked to obtain additional relationships or more detailed information about this graph subject.
    :type _links: :class:`ReferenceLinks <azure.devops.v5_0.microsoft._visual_studio._services._web_api.models.ReferenceLinks>`
    :param descriptor: The descriptor is the primary way to reference the graph subject while the system is running. This field will uniquely identify the same graph subject across both Accounts and Organizations.
    :type descriptor: str
    :param display_name: This is the non-unique display name of the graph subject. To change this field, you must alter its value in the source provider.
    :type display_name: str
    :param url: This url is the full route to the source resource of this graph subject.
    :type url: str
    """

    _attribute_map = {
        '_links': {'key': '_links', 'type': 'ReferenceLinks'},
        'descriptor': {'key': 'descriptor', 'type': 'str'},
        'display_name': {'key': 'displayName', 'type': 'str'},
        'url': {'key': 'url', 'type': 'str'}
    }

    def __init__(self, _links=None, descriptor=None, display_name=None, url=None):
        super(GraphSubjectBase, self).__init__()
        self._links = _links
        self.descriptor = descriptor
        self.display_name = display_name
        self.url = url


class IdentityRef(GraphSubjectBase):
    """IdentityRef.

    :param _links: This field contains zero or more interesting links about the graph subject. These links may be invoked to obtain additional relationships or more detailed information about this graph subject.
    :type _links: :class:`ReferenceLinks <azure.devops.v5_0.microsoft._visual_studio._services._web_api.models.ReferenceLinks>`
    :param descriptor: The descriptor is the primary way to reference the graph subject while the system is running. This field will uniquely identify the same graph subject across both Accounts and Organizations.
    :type descriptor: str
    :param display_name: This is the non-unique display name of the graph subject. To change this field, you must alter its value in the source provider.
    :type display_name: str
    :param url: This url is the full route to the source resource of this graph subject.
    :type url: str
    :param directory_alias:
    :type directory_alias: str
    :param id:
    :type id: str
    :param image_url:
    :type image_url: str
    :param inactive:
    :type inactive: bool
    :param is_aad_identity:
    :type is_aad_identity: bool
    :param is_container:
    :type is_container: bool
    :param is_deleted_in_origin:
    :type is_deleted_in_origin: bool
    :param profile_url:
    :type profile_url: str
    :param unique_name:
    :type unique_name: str
    """

    _attribute_map = {
        '_links': {'key': '_links', 'type': 'ReferenceLinks'},
        'descriptor': {'key': 'descriptor', 'type': 'str'},
        'display_name': {'key': 'displayName', 'type': 'str'},
        'url': {'key': 'url', 'type': 'str'},
        'directory_alias': {'key': 'directoryAlias', 'type': 'str'},
        'id': {'key': 'id', 'type': 'str'},
        'image_url': {'key': 'imageUrl', 'type': 'str'},
        'inactive': {'key': 'inactive', 'type': 'bool'},
        'is_aad_identity': {'key': 'isAadIdentity', 'type': 'bool'},
        'is_container': {'key': 'isContainer', 'type': 'bool'},
        'is_deleted_in_origin': {'key': 'isDeletedInOrigin', 'type': 'bool'},
        'profile_url': {'key': 'profileUrl', 'type': 'str'},
        'unique_name': {'key': 'uniqueName', 'type': 'str'}
    }

    def __init__(self, _links=None, descriptor=None, display_name=None, url=None, directory_alias=None, id=None, image_url=None, inactive=None, is_aad_identity=None, is_container=None, is_deleted_in_origin=None, profile_url=None, unique_name=None):
        super(IdentityRef, self).__init__(_links=_links, descriptor=descriptor, display_name=display_name, url=url)
        self.directory_alias = directory_alias
        self.id = id
        self.image_url = image_url
        self.inactive = inactive
        self.is_aad_identity = is_aad_identity
        self.is_container = is_container
        self.is_deleted_in_origin = is_deleted_in_origin
        self.profile_url = profile_url
        self.unique_name = unique_name


class INotificationDiagnosticLog(Model):
    """INotificationDiagnosticLog.

    :param activity_id:
    :type activity_id: str
    :param description:
    :type description: str
    :param end_time:
    :type end_time: datetime
    :param id:
    :type id: str
    :param log_type:
    :type log_type: str
    :param messages:
    :type messages: list of :class:`NotificationDiagnosticLogMessage <azure.devops.v5_0.notification.models.NotificationDiagnosticLogMessage>`
    :param properties:
    :type properties: dict
    :param source:
    :type source: str
    :param start_time:
    :type start_time: datetime
    """

    _attribute_map = {
        'activity_id': {'key': 'activityId', 'type': 'str'},
        'description': {'key': 'description', 'type': 'str'},
        'end_time': {'key': 'endTime', 'type': 'iso-8601'},
        'id': {'key': 'id', 'type': 'str'},
        'log_type': {'key': 'logType', 'type': 'str'},
        'messages': {'key': 'messages', 'type': '[NotificationDiagnosticLogMessage]'},
        'properties': {'key': 'properties', 'type': '{str}'},
        'source': {'key': 'source', 'type': 'str'},
        'start_time': {'key': 'startTime', 'type': 'iso-8601'}
    }

    def __init__(self, activity_id=None, description=None, end_time=None, id=None, log_type=None, messages=None, properties=None, source=None, start_time=None):
        super(INotificationDiagnosticLog, self).__init__()
        self.activity_id = activity_id
        self.description = description
        self.end_time = end_time
        self.id = id
        self.log_type = log_type
        self.messages = messages
        self.properties = properties
        self.source = source
        self.start_time = start_time


class InputValue(Model):
    """InputValue.

    :param data: Any other data about this input
    :type data: dict
    :param display_value: The text to show for the display of this value
    :type display_value: str
    :param value: The value to store for this input
    :type value: str
    """

    _attribute_map = {
        'data': {'key': 'data', 'type': '{object}'},
        'display_value': {'key': 'displayValue', 'type': 'str'},
        'value': {'key': 'value', 'type': 'str'}
    }

    def __init__(self, data=None, display_value=None, value=None):
        super(InputValue, self).__init__()
        self.data = data
        self.display_value = display_value
        self.value = value


class InputValues(Model):
    """InputValues.

    :param default_value: The default value to use for this input
    :type default_value: str
    :param error: Errors encountered while computing dynamic values.
    :type error: :class:`InputValuesError <azure.devops.v5_0.microsoft._visual_studio._services._web_api.models.InputValuesError>`
    :param input_id: The id of the input
    :type input_id: str
    :param is_disabled: Should this input be disabled
    :type is_disabled: bool
    :param is_limited_to_possible_values: Should the value be restricted to one of the values in the PossibleValues (True) or are the values in PossibleValues just a suggestion (False)
    :type is_limited_to_possible_values: bool
    :param is_read_only: Should this input be made read-only
    :type is_read_only: bool
    :param possible_values: Possible values that this input can take
    :type possible_values: list of :class:`InputValue <azure.devops.v5_0.microsoft._visual_studio._services._web_api.models.InputValue>`
    """

    _attribute_map = {
        'default_value': {'key': 'defaultValue', 'type': 'str'},
        'error': {'key': 'error', 'type': 'InputValuesError'},
        'input_id': {'key': 'inputId', 'type': 'str'},
        'is_disabled': {'key': 'isDisabled', 'type': 'bool'},
        'is_limited_to_possible_values': {'key': 'isLimitedToPossibleValues', 'type': 'bool'},
        'is_read_only': {'key': 'isReadOnly', 'type': 'bool'},
        'possible_values': {'key': 'possibleValues', 'type': '[InputValue]'}
    }

    def __init__(self, default_value=None, error=None, input_id=None, is_disabled=None, is_limited_to_possible_values=None, is_read_only=None, possible_values=None):
        super(InputValues, self).__init__()
        self.default_value = default_value
        self.error = error
        self.input_id = input_id
        self.is_disabled = is_disabled
        self.is_limited_to_possible_values = is_limited_to_possible_values
        self.is_read_only = is_read_only
        self.possible_values = possible_values


class InputValuesError(Model):
    """InputValuesError.

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

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

    def __init__(self, message=None):
        super(InputValuesError, self).__init__()
        self.message = message


class InputValuesQuery(Model):
    """InputValuesQuery.

    :param current_values:
    :type current_values: dict
    :param input_values: The input values to return on input, and the result from the consumer on output.
    :type input_values: list of :class:`InputValues <azure.devops.v5_0.microsoft._visual_studio._services._web_api.models.InputValues>`
    :param resource: Subscription containing information about the publisher/consumer and the current input values
    :type resource: object
    """

    _attribute_map = {
        'current_values': {'key': 'currentValues', 'type': '{str}'},
        'input_values': {'key': 'inputValues', 'type': '[InputValues]'},
        'resource': {'key': 'resource', 'type': 'object'}
    }

    def __init__(self, current_values=None, input_values=None, resource=None):
        super(InputValuesQuery, self).__init__()
        self.current_values = current_values
        self.input_values = input_values
        self.resource = resource


class ISubscriptionChannel(Model):
    """ISubscriptionChannel.

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

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

    def __init__(self, type=None):
        super(ISubscriptionChannel, self).__init__()
        self.type = type


class ISubscriptionFilter(Model):
    """ISubscriptionFilter.

    :param event_type:
    :type event_type: str
    :param type:
    :type type: str
    """

    _attribute_map = {
        'event_type': {'key': 'eventType', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'}
    }

    def __init__(self, event_type=None, type=None):
        super(ISubscriptionFilter, self).__init__()
        self.event_type = event_type
        self.type = type


class NotificationAdminSettings(Model):
    """NotificationAdminSettings.

    :param default_group_delivery_preference: The default group delivery preference for groups in this collection
    :type default_group_delivery_preference: object
    """

    _attribute_map = {
        'default_group_delivery_preference': {'key': 'defaultGroupDeliveryPreference', 'type': 'object'}
    }

    def __init__(self, default_group_delivery_preference=None):
        super(NotificationAdminSettings, self).__init__()
        self.default_group_delivery_preference = default_group_delivery_preference


class NotificationAdminSettingsUpdateParameters(Model):
    """NotificationAdminSettingsUpdateParameters.

    :param default_group_delivery_preference:
    :type default_group_delivery_preference: object
    """

    _attribute_map = {
        'default_group_delivery_preference': {'key': 'defaultGroupDeliveryPreference', 'type': 'object'}
    }

    def __init__(self, default_group_delivery_preference=None):
        super(NotificationAdminSettingsUpdateParameters, self).__init__()
        self.default_group_delivery_preference = default_group_delivery_preference


class NotificationDiagnosticLogMessage(Model):
    """NotificationDiagnosticLogMessage.

    :param level: Corresponds to .Net TraceLevel enumeration
    :type level: int
    :param message:
    :type message: str
    :param time:
    :type time: object
    """

    _attribute_map = {
        'level': {'key': 'level', 'type': 'int'},
        'message': {'key': 'message', 'type': 'str'},
        'time': {'key': 'time', 'type': 'object'}
    }

    def __init__(self, level=None, message=None, time=None):
        super(NotificationDiagnosticLogMessage, self).__init__()
        self.level = level
        self.message = message
        self.time = time


class NotificationEventField(Model):
    """NotificationEventField.

    :param field_type: Gets or sets the type of this field.
    :type field_type: :class:`NotificationEventFieldType <azure.devops.v5_0.notification.models.NotificationEventFieldType>`
    :param id: Gets or sets the unique identifier of this field.
    :type id: str
    :param name: Gets or sets the name of this field.
    :type name: str
    :param path: Gets or sets the path to the field in the event object. This path can be either Json Path or XPath, depending on if the event will be serialized into Json or XML
    :type path: str
    :param supported_scopes: Gets or sets the scopes that this field supports. If not specified then the event type scopes apply.
    :type supported_scopes: list of str
    """

    _attribute_map = {
        'field_type': {'key': 'fieldType', 'type': 'NotificationEventFieldType'},
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'path': {'key': 'path', 'type': 'str'},
        'supported_scopes': {'key': 'supportedScopes', 'type': '[str]'}
    }

    def __init__(self, field_type=None, id=None, name=None, path=None, supported_scopes=None):
        super(NotificationEventField, self).__init__()
        self.field_type = field_type
        self.id = id
        self.name = name
        self.path = path
        self.supported_scopes = supported_scopes


class NotificationEventFieldOperator(Model):
    """NotificationEventFieldOperator.

    :param display_name: Gets or sets the display name of an operator
    :type display_name: str
    :param id: Gets or sets the id of an operator
    :type id: str
    """

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

    def __init__(self, display_name=None, id=None):
        super(NotificationEventFieldOperator, self).__init__()
        self.display_name = display_name
        self.id = id


class NotificationEventFieldType(Model):
    """NotificationEventFieldType.

    :param id: Gets or sets the unique identifier of this field type.
    :type id: str
    :param operator_constraints:
    :type operator_constraints: list of :class:`OperatorConstraint <azure.devops.v5_0.notification.models.OperatorConstraint>`
    :param operators: Gets or sets the list of operators that this type supports.
    :type operators: list of :class:`NotificationEventFieldOperator <azure.devops.v5_0.notification.models.NotificationEventFieldOperator>`
    :param subscription_field_type:
    :type subscription_field_type: object
    :param value: Gets or sets the value definition of this field like the getValuesMethod and template to display in the UI
    :type value: :class:`ValueDefinition <azure.devops.v5_0.notification.models.ValueDefinition>`
    """

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'operator_constraints': {'key': 'operatorConstraints', 'type': '[OperatorConstraint]'},
        'operators': {'key': 'operators', 'type': '[NotificationEventFieldOperator]'},
        'subscription_field_type': {'key': 'subscriptionFieldType', 'type': 'object'},
        'value': {'key': 'value', 'type': 'ValueDefinition'}
    }

    def __init__(self, id=None, operator_constraints=None, operators=None, subscription_field_type=None, value=None):
        super(NotificationEventFieldType, self).__init__()
        self.id = id
        self.operator_constraints = operator_constraints
        self.operators = operators
        self.subscription_field_type = subscription_field_type
        self.value = value


class NotificationEventPublisher(Model):
    """NotificationEventPublisher.

    :param id:
    :type id: str
    :param subscription_management_info:
    :type subscription_management_info: :class:`SubscriptionManagement <azure.devops.v5_0.notification.models.SubscriptionManagement>`
    :param url:
    :type url: str
    """

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'subscription_management_info': {'key': 'subscriptionManagementInfo', 'type': 'SubscriptionManagement'},
        'url': {'key': 'url', 'type': 'str'}
    }

    def __init__(self, id=None, subscription_management_info=None, url=None):
        super(NotificationEventPublisher, self).__init__()
        self.id = id
        self.subscription_management_info = subscription_management_info
        self.url = url


class NotificationEventRole(Model):
    """NotificationEventRole.

    :param id: Gets or sets an Id for that role, this id is used by the event.
    :type id: str
    :param name: Gets or sets the Name for that role, this name is used for UI display.
    :type name: str
    :param supports_groups: Gets or sets whether this role can be a group or just an individual user
    :type supports_groups: bool
    """

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

    def __init__(self, id=None, name=None, supports_groups=None):
        super(NotificationEventRole, self).__init__()
        self.id = id
        self.name = name
        self.supports_groups = supports_groups


class NotificationEventType(Model):
    """NotificationEventType.

    :param category:
    :type category: :class:`NotificationEventTypeCategory <azure.devops.v5_0.notification.models.NotificationEventTypeCategory>`
    :param color: Gets or sets the color representing this event type. Example: rgb(128,245,211) or #fafafa
    :type color: str
    :param custom_subscriptions_allowed:
    :type custom_subscriptions_allowed: bool
    :param event_publisher:
    :type event_publisher: :class:`NotificationEventPublisher <azure.devops.v5_0.notification.models.NotificationEventPublisher>`
    :param fields:
    :type fields: dict
    :param has_initiator:
    :type has_initiator: bool
    :param icon: Gets or sets the icon representing this event type. Can be a URL or a CSS class. Example: css://some-css-class
    :type icon: str
    :param id: Gets or sets the unique identifier of this event definition.
    :type id: str
    :param name: Gets or sets the name of this event definition.
    :type name: str
    :param roles:
    :type roles: list of :class:`NotificationEventRole <azure.devops.v5_0.notification.models.NotificationEventRole>`
    :param supported_scopes: Gets or sets the scopes that this event type supports
    :type supported_scopes: list of str
    :param url: Gets or sets the rest end point to get this event type details (fields, fields types)
    :type url: str
    """

    _attribute_map = {
        'category': {'key': 'category', 'type': 'NotificationEventTypeCategory'},
        'color': {'key': 'color', 'type': 'str'},
        'custom_subscriptions_allowed': {'key': 'customSubscriptionsAllowed', 'type': 'bool'},
        'event_publisher': {'key': 'eventPublisher', 'type': 'NotificationEventPublisher'},
        'fields': {'key': 'fields', 'type': '{NotificationEventField}'},
        'has_initiator': {'key': 'hasInitiator', 'type': 'bool'},
        'icon': {'key': 'icon', 'type': 'str'},
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'roles': {'key': 'roles', 'type': '[NotificationEventRole]'},
        'supported_scopes': {'key': 'supportedScopes', 'type': '[str]'},
        'url': {'key': 'url', 'type': 'str'}
    }

    def __init__(self, category=None, color=None, custom_subscriptions_allowed=None, event_publisher=None, fields=None, has_initiator=None, icon=None, id=None, name=None, roles=None, supported_scopes=None, url=None):
        super(NotificationEventType, self).__init__()
        self.category = category
        self.color = color
        self.custom_subscriptions_allowed = custom_subscriptions_allowed
        self.event_publisher = event_publisher
        self.fields = fields
        self.has_initiator = has_initiator
        self.icon = icon
        self.id = id
        self.name = name
        self.roles = roles
        self.supported_scopes = supported_scopes
        self.url = url


class NotificationEventTypeCategory(Model):
    """NotificationEventTypeCategory.

    :param id: Gets or sets the unique identifier of this category.
    :type id: str
    :param name: Gets or sets the friendly name of this category.
    :type name: str
    """

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

    def __init__(self, id=None, name=None):
        super(NotificationEventTypeCategory, self).__init__()
        self.id = id
        self.name = name


class NotificationQueryCondition(Model):
    """NotificationQueryCondition.

    :param event_initiator:
    :type event_initiator: str
    :param event_type:
    :type event_type: str
    :param subscriber:
    :type subscriber: str
    :param subscription_id:
    :type subscription_id: str
    """

    _attribute_map = {
        'event_initiator': {'key': 'eventInitiator', 'type': 'str'},
        'event_type': {'key': 'eventType', 'type': 'str'},
        'subscriber': {'key': 'subscriber', 'type': 'str'},
        'subscription_id': {'key': 'subscriptionId', 'type': 'str'}
    }

    def __init__(self, event_initiator=None, event_type=None, subscriber=None, subscription_id=None):
        super(NotificationQueryCondition, self).__init__()
        self.event_initiator = event_initiator
        self.event_type = event_type
        self.subscriber = subscriber
        self.subscription_id = subscription_id


class NotificationReason(Model):
    """NotificationReason.

    :param notification_reason_type:
    :type notification_reason_type: object
    :param target_identities:
    :type target_identities: list of :class:`IdentityRef <azure.devops.v5_0.notification.models.IdentityRef>`
    """

    _attribute_map = {
        'notification_reason_type': {'key': 'notificationReasonType', 'type': 'object'},
        'target_identities': {'key': 'targetIdentities', 'type': '[IdentityRef]'}
    }

    def __init__(self, notification_reason_type=None, target_identities=None):
        super(NotificationReason, self).__init__()
        self.notification_reason_type = notification_reason_type
        self.target_identities = target_identities


class NotificationsEvaluationResult(Model):
    """NotificationsEvaluationResult.

    :param count: Count of generated notifications
    :type count: int
    """

    _attribute_map = {
        'count': {'key': 'count', 'type': 'int'}
    }

    def __init__(self, count=None):
        super(NotificationsEvaluationResult, self).__init__()
        self.count = count


class NotificationStatistic(Model):
    """NotificationStatistic.

    :param date:
    :type date: datetime
    :param hit_count:
    :type hit_count: int
    :param path:
    :type path: str
    :param type:
    :type type: object
    :param user:
    :type user: :class:`IdentityRef <azure.devops.v5_0.notification.models.IdentityRef>`
    """

    _attribute_map = {
        'date': {'key': 'date', 'type': 'iso-8601'},
        'hit_count': {'key': 'hitCount', 'type': 'int'},
        'path': {'key': 'path', 'type': 'str'},
        'type': {'key': 'type', 'type': 'object'},
        'user': {'key': 'user', 'type': 'IdentityRef'}
    }

    def __init__(self, date=None, hit_count=None, path=None, type=None, user=None):
        super(NotificationStatistic, self).__init__()
        self.date = date
        self.hit_count = hit_count
        self.path = path
        self.type = type
        self.user = user


class NotificationStatisticsQuery(Model):
    """NotificationStatisticsQuery.

    :param conditions:
    :type conditions: list of :class:`NotificationStatisticsQueryConditions <azure.devops.v5_0.notification.models.NotificationStatisticsQueryConditions>`
    """

    _attribute_map = {
        'conditions': {'key': 'conditions', 'type': '[NotificationStatisticsQueryConditions]'}
    }

    def __init__(self, conditions=None):
        super(NotificationStatisticsQuery, self).__init__()
        self.conditions = conditions


class NotificationStatisticsQueryConditions(Model):
    """NotificationStatisticsQueryConditions.

    :param end_date:
    :type end_date: datetime
    :param hit_count_minimum:
    :type hit_count_minimum: int
    :param path:
    :type path: str
    :param start_date:
    :type start_date: datetime
    :param type:
    :type type: object
    :param user:
    :type user: :class:`IdentityRef <azure.devops.v5_0.notification.models.IdentityRef>`
    """

    _attribute_map = {
        'end_date': {'key': 'endDate', 'type': 'iso-8601'},
        'hit_count_minimum': {'key': 'hitCountMinimum', 'type': 'int'},
        'path': {'key': 'path', 'type': 'str'},
        'start_date': {'key': 'startDate', 'type': 'iso-8601'},
        'type': {'key': 'type', 'type': 'object'},
        'user': {'key': 'user', 'type': 'IdentityRef'}
    }

    def __init__(self, end_date=None, hit_count_minimum=None, path=None, start_date=None, type=None, user=None):
        super(NotificationStatisticsQueryConditions, self).__init__()
        self.end_date = end_date
        self.hit_count_minimum = hit_count_minimum
        self.path = path
        self.start_date = start_date
        self.type = type
        self.user = user


class NotificationSubscriber(Model):
    """NotificationSubscriber.

    :param delivery_preference: Indicates how the subscriber should be notified by default.
    :type delivery_preference: object
    :param flags:
    :type flags: object
    :param id: Identifier of the subscriber.
    :type id: str
    :param preferred_email_address: Preferred email address of the subscriber. A null or empty value indicates no preferred email address has been set.
    :type preferred_email_address: str
    """

    _attribute_map = {
        'delivery_preference': {'key': 'deliveryPreference', 'type': 'object'},
        'flags': {'key': 'flags', 'type': 'object'},
        'id': {'key': 'id', 'type': 'str'},
        'preferred_email_address': {'key': 'preferredEmailAddress', 'type': 'str'}
    }

    def __init__(self, delivery_preference=None, flags=None, id=None, preferred_email_address=None):
        super(NotificationSubscriber, self).__init__()
        self.delivery_preference = delivery_preference
        self.flags = flags
        self.id = id
        self.preferred_email_address = preferred_email_address


class NotificationSubscriberUpdateParameters(Model):
    """NotificationSubscriberUpdateParameters.

    :param delivery_preference: New delivery preference for the subscriber (indicates how the subscriber should be notified).
    :type delivery_preference: object
    :param preferred_email_address: New preferred email address for the subscriber. Specify an empty string to clear the current address.
    :type preferred_email_address: str
    """

    _attribute_map = {
        'delivery_preference': {'key': 'deliveryPreference', 'type': 'object'},
        'preferred_email_address': {'key': 'preferredEmailAddress', 'type': 'str'}
    }

    def __init__(self, delivery_preference=None, preferred_email_address=None):
        super(NotificationSubscriberUpdateParameters, self).__init__()
        self.delivery_preference = delivery_preference
        self.preferred_email_address = preferred_email_address


class NotificationSubscription(Model):
    """NotificationSubscription.

    :param _links: Links to related resources, APIs, and views for the subscription.
    :type _links: :class:`ReferenceLinks <azure.devops.v5_0.notification.models.ReferenceLinks>`
    :param admin_settings: Admin-managed settings for the subscription. Only applies when the subscriber is a group.
    :type admin_settings: :class:`SubscriptionAdminSettings <azure.devops.v5_0.notification.models.SubscriptionAdminSettings>`
    :param channel: Channel for delivering notifications triggered by the subscription.
    :type channel: :class:`ISubscriptionChannel <azure.devops.v5_0.notification.models.ISubscriptionChannel>`
    :param description: Description of the subscription. Typically describes filter criteria which helps identity the subscription.
    :type description: str
    :param diagnostics: Diagnostics for this subscription.
    :type diagnostics: :class:`SubscriptionDiagnostics <azure.devops.v5_0.notification.models.SubscriptionDiagnostics>`
    :param extended_properties: Any extra properties like detailed description for different contexts, user/group contexts
    :type extended_properties: dict
    :param filter: Matching criteria for the subscription. ExpressionFilter
    :type filter: :class:`ISubscriptionFilter <azure.devops.v5_0.notification.models.ISubscriptionFilter>`
    :param flags: Read-only indicators that further describe the subscription.
    :type flags: object
    :param id: Subscription identifier.
    :type id: str
    :param last_modified_by: User that last modified (or created) the subscription.
    :type last_modified_by: :class:`IdentityRef <azure.devops.v5_0.notification.models.IdentityRef>`
    :param modified_date: Date when the subscription was last modified. If the subscription has not been updated since it was created, this value will indicate when the subscription was created.
    :type modified_date: datetime
    :param permissions: The permissions the user have for this subscriptions.
    :type permissions: object
    :param scope: The container in which events must be published from in order to be matched by the subscription. If empty, the scope is the current host (typically an account or project collection). For example, a subscription scoped to project A will not produce notifications for events published from project B.
    :type scope: :class:`SubscriptionScope <azure.devops.v5_0.notification.models.SubscriptionScope>`
    :param status: Status of the subscription. Typically indicates whether the subscription is enabled or not.
    :type status: object
    :param status_message: Message that provides more details about the status of the subscription.
    :type status_message: str
    :param subscriber: User or group that will receive notifications for events matching the subscription's filter criteria.
    :type subscriber: :class:`IdentityRef <azure.devops.v5_0.notification.models.IdentityRef>`
    :param url: REST API URL of the subscriotion.
    :type url: str
    :param user_settings: User-managed settings for the subscription. Only applies when the subscriber is a group. Typically used to indicate whether the calling user is opted in or out of a group subscription.
    :type user_settings: :class:`SubscriptionUserSettings <azure.devops.v5_0.notification.models.SubscriptionUserSettings>`
    """

    _attribute_map = {
        '_links': {'key': '_links', 'type': 'ReferenceLinks'},
        'admin_settings': {'key': 'adminSettings', 'type': 'SubscriptionAdminSettings'},
        'channel': {'key': 'channel', 'type': 'ISubscriptionChannel'},
        'description': {'key': 'description', 'type': 'str'},
        'diagnostics': {'key': 'diagnostics', 'type': 'SubscriptionDiagnostics'},
        'extended_properties': {'key': 'extendedProperties', 'type': '{str}'},
        'filter': {'key': 'filter', 'type': 'ISubscriptionFilter'},
        'flags': {'key': 'flags', 'type': 'object'},
        'id': {'key': 'id', 'type': 'str'},
        'last_modified_by': {'key': 'lastModifiedBy', 'type': 'IdentityRef'},
        'modified_date': {'key': 'modifiedDate', 'type': 'iso-8601'},
        'permissions': {'key': 'permissions', 'type': 'object'},
        'scope': {'key': 'scope', 'type': 'SubscriptionScope'},
        'status': {'key': 'status', 'type': 'object'},
        'status_message': {'key': 'statusMessage', 'type': 'str'},
        'subscriber': {'key': 'subscriber', 'type': 'IdentityRef'},
        'url': {'key': 'url', 'type': 'str'},
        'user_settings': {'key': 'userSettings', 'type': 'SubscriptionUserSettings'}
    }

    def __init__(self, _links=None, admin_settings=None, channel=None, description=None, diagnostics=None, extended_properties=None, filter=None, flags=None, id=None, last_modified_by=None, modified_date=None, permissions=None, scope=None, status=None, status_message=None, subscriber=None, url=None, user_settings=None):
        super(NotificationSubscription, self).__init__()
        self._links = _links
        self.admin_settings = admin_settings
        self.channel = channel
        self.description = description
        self.diagnostics = diagnostics
        self.extended_properties = extended_properties
        self.filter = filter
        self.flags = flags
        self.id = id
        self.last_modified_by = last_modified_by
        self.modified_date = modified_date
        self.permissions = permissions
        self.scope = scope
        self.status = status
        self.status_message = status_message
        self.subscriber = subscriber
        self.url = url
        self.user_settings = user_settings


class NotificationSubscriptionCreateParameters(Model):
    """NotificationSubscriptionCreateParameters.

    :param channel: Channel for delivering notifications triggered by the new subscription.
    :type channel: :class:`ISubscriptionChannel <azure.devops.v5_0.notification.models.ISubscriptionChannel>`
    :param description: Brief description for the new subscription. Typically describes filter criteria which helps identity the subscription.
    :type description: str
    :param filter: Matching criteria for the new subscription. ExpressionFilter
    :type filter: :class:`ISubscriptionFilter <azure.devops.v5_0.notification.models.ISubscriptionFilter>`
    :param scope: The container in which events must be published from in order to be matched by the new subscription. If not specified, defaults to the current host (typically an account or project collection). For example, a subscription scoped to project A will not produce notifications for events published from project B.
    :type scope: :class:`SubscriptionScope <azure.devops.v5_0.notification.models.SubscriptionScope>`
    :param subscriber: User or group that will receive notifications for events matching the subscription's filter criteria. If not specified, defaults to the calling user.
    :type subscriber: :class:`IdentityRef <azure.devops.v5_0.notification.models.IdentityRef>`
    """

    _attribute_map = {
        'channel': {'key': 'channel', 'type': 'ISubscriptionChannel'},
        'description': {'key': 'description', 'type': 'str'},
        'filter': {'key': 'filter', 'type': 'ISubscriptionFilter'},
        'scope': {'key': 'scope', 'type': 'SubscriptionScope'},
        'subscriber': {'key': 'subscriber', 'type': 'IdentityRef'}
    }

    def __init__(self, channel=None, description=None, filter=None, scope=None, subscriber=None):
        super(NotificationSubscriptionCreateParameters, self).__init__()
        self.channel = channel
        self.description = description
        self.filter = filter
        self.scope = scope
        self.subscriber = subscriber


class NotificationSubscriptionTemplate(Model):
    """NotificationSubscriptionTemplate.

    :param description:
    :type description: str
    :param filter:
    :type filter: :class:`ISubscriptionFilter <azure.devops.v5_0.notification.models.ISubscriptionFilter>`
    :param id:
    :type id: str
    :param notification_event_information:
    :type notification_event_information: :class:`NotificationEventType <azure.devops.v5_0.notification.models.NotificationEventType>`
    :param type:
    :type type: object
    """

    _attribute_map = {
        'description': {'key': 'description', 'type': 'str'},
        'filter': {'key': 'filter', 'type': 'ISubscriptionFilter'},
        'id': {'key': 'id', 'type': 'str'},
        'notification_event_information': {'key': 'notificationEventInformation', 'type': 'NotificationEventType'},
        'type': {'key': 'type', 'type': 'object'}
    }

    def __init__(self, description=None, filter=None, id=None, notification_event_information=None, type=None):
        super(NotificationSubscriptionTemplate, self).__init__()
        self.description = description
        self.filter = filter
        self.id = id
        self.notification_event_information = notification_event_information
        self.type = type


class NotificationSubscriptionUpdateParameters(Model):
    """NotificationSubscriptionUpdateParameters.

    :param admin_settings: Admin-managed settings for the subscription. Only applies to subscriptions where the subscriber is a group.
    :type admin_settings: :class:`SubscriptionAdminSettings <azure.devops.v5_0.notification.models.SubscriptionAdminSettings>`
    :param channel: Channel for delivering notifications triggered by the subscription.
    :type channel: :class:`ISubscriptionChannel <azure.devops.v5_0.notification.models.ISubscriptionChannel>`
    :param description: Updated description for the subscription. Typically describes filter criteria which helps identity the subscription.
    :type description: str
    :param filter: Matching criteria for the subscription. ExpressionFilter
    :type filter: :class:`ISubscriptionFilter <azure.devops.v5_0.notification.models.ISubscriptionFilter>`
    :param scope: The container in which events must be published from in order to be matched by the new subscription. If not specified, defaults to the current host (typically the current account or project collection). For example, a subscription scoped to project A will not produce notifications for events published from project B.
    :type scope: :class:`SubscriptionScope <azure.devops.v5_0.notification.models.SubscriptionScope>`
    :param status: Updated status for the subscription. Typically used to enable or disable a subscription.
    :type status: object
    :param status_message: Optional message that provides more details about the updated status.
    :type status_message: str
    :param user_settings: User-managed settings for the subscription. Only applies to subscriptions where the subscriber is a group. Typically used to opt-in or opt-out a user from a group subscription.
    :type user_settings: :class:`SubscriptionUserSettings <azure.devops.v5_0.notification.models.SubscriptionUserSettings>`
    """

    _attribute_map = {
        'admin_settings': {'key': 'adminSettings', 'type': 'SubscriptionAdminSettings'},
        'channel': {'key': 'channel', 'type': 'ISubscriptionChannel'},
        'description': {'key': 'description', 'type': 'str'},
        'filter': {'key': 'filter', 'type': 'ISubscriptionFilter'},
        'scope': {'key': 'scope', 'type': 'SubscriptionScope'},
        'status': {'key': 'status', 'type': 'object'},
        'status_message': {'key': 'statusMessage', 'type': 'str'},
        'user_settings': {'key': 'userSettings', 'type': 'SubscriptionUserSettings'}
    }

    def __init__(self, admin_settings=None, channel=None, description=None, filter=None, scope=None, status=None, status_message=None, user_settings=None):
        super(NotificationSubscriptionUpdateParameters, self).__init__()
        self.admin_settings = admin_settings
        self.channel = channel
        self.description = description
        self.filter = filter
        self.scope = scope
        self.status = status
        self.status_message = status_message
        self.user_settings = user_settings


class OperatorConstraint(Model):
    """OperatorConstraint.

    :param operator:
    :type operator: str
    :param supported_scopes: Gets or sets the list of scopes that this type supports.
    :type supported_scopes: list of str
    """

    _attribute_map = {
        'operator': {'key': 'operator', 'type': 'str'},
        'supported_scopes': {'key': 'supportedScopes', 'type': '[str]'}
    }

    def __init__(self, operator=None, supported_scopes=None):
        super(OperatorConstraint, self).__init__()
        self.operator = operator
        self.supported_scopes = supported_scopes


class ReferenceLinks(Model):
    """ReferenceLinks.

    :param links: The readonly view of the links.  Because Reference links are readonly, we only want to expose them as read only.
    :type links: dict
    """

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

    def __init__(self, links=None):
        super(ReferenceLinks, self).__init__()
        self.links = links


class SubscriptionAdminSettings(Model):
    """SubscriptionAdminSettings.

    :param block_user_opt_out: If true, members of the group subscribed to the associated subscription cannot opt (choose not to get notified)
    :type block_user_opt_out: bool
    """

    _attribute_map = {
        'block_user_opt_out': {'key': 'blockUserOptOut', 'type': 'bool'}
    }

    def __init__(self, block_user_opt_out=None):
        super(SubscriptionAdminSettings, self).__init__()
        self.block_user_opt_out = block_user_opt_out


class SubscriptionChannelWithAddress(Model):
    """SubscriptionChannelWithAddress.

    :param address:
    :type address: str
    :param type:
    :type type: str
    :param use_custom_address:
    :type use_custom_address: bool
    """

    _attribute_map = {
        'address': {'key': 'address', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'use_custom_address': {'key': 'useCustomAddress', 'type': 'bool'}
    }

    def __init__(self, address=None, type=None, use_custom_address=None):
        super(SubscriptionChannelWithAddress, self).__init__()
        self.address = address
        self.type = type
        self.use_custom_address = use_custom_address


class SubscriptionDiagnostics(Model):
    """SubscriptionDiagnostics.

    :param delivery_results:
    :type delivery_results: :class:`SubscriptionTracing <azure.devops.v5_0.notification.models.SubscriptionTracing>`
    :param delivery_tracing:
    :type delivery_tracing: :class:`SubscriptionTracing <azure.devops.v5_0.notification.models.SubscriptionTracing>`
    :param evaluation_tracing:
    :type evaluation_tracing: :class:`SubscriptionTracing <azure.devops.v5_0.notification.models.SubscriptionTracing>`
    """

    _attribute_map = {
        'delivery_results': {'key': 'deliveryResults', 'type': 'SubscriptionTracing'},
        'delivery_tracing': {'key': 'deliveryTracing', 'type': 'SubscriptionTracing'},
        'evaluation_tracing': {'key': 'evaluationTracing', 'type': 'SubscriptionTracing'}
    }

    def __init__(self, delivery_results=None, delivery_tracing=None, evaluation_tracing=None):
        super(SubscriptionDiagnostics, self).__init__()
        self.delivery_results = delivery_results
        self.delivery_tracing = delivery_tracing
        self.evaluation_tracing = evaluation_tracing


class SubscriptionEvaluationRequest(Model):
    """SubscriptionEvaluationRequest.

    :param min_events_created_date: The min created date for the events used for matching in UTC. Use all events created since this date
    :type min_events_created_date: datetime
    :param subscription_create_parameters: User or group that will receive notifications for events matching the subscription's filter criteria. If not specified, defaults to the calling user.
    :type subscription_create_parameters: :class:`NotificationSubscriptionCreateParameters <azure.devops.v5_0.notification.models.NotificationSubscriptionCreateParameters>`
    """

    _attribute_map = {
        'min_events_created_date': {'key': 'minEventsCreatedDate', 'type': 'iso-8601'},
        'subscription_create_parameters': {'key': 'subscriptionCreateParameters', 'type': 'NotificationSubscriptionCreateParameters'}
    }

    def __init__(self, min_events_created_date=None, subscription_create_parameters=None):
        super(SubscriptionEvaluationRequest, self).__init__()
        self.min_events_created_date = min_events_created_date
        self.subscription_create_parameters = subscription_create_parameters


class SubscriptionEvaluationResult(Model):
    """SubscriptionEvaluationResult.

    :param evaluation_job_status: Subscription evaluation job status
    :type evaluation_job_status: object
    :param events: Subscription evaluation events results.
    :type events: :class:`EventsEvaluationResult <azure.devops.v5_0.notification.models.EventsEvaluationResult>`
    :param id: The requestId which is the subscription evaluation jobId
    :type id: str
    :param notifications: Subscription evaluation  notification results.
    :type notifications: :class:`NotificationsEvaluationResult <azure.devops.v5_0.notification.models.NotificationsEvaluationResult>`
    """

    _attribute_map = {
        'evaluation_job_status': {'key': 'evaluationJobStatus', 'type': 'object'},
        'events': {'key': 'events', 'type': 'EventsEvaluationResult'},
        'id': {'key': 'id', 'type': 'str'},
        'notifications': {'key': 'notifications', 'type': 'NotificationsEvaluationResult'}
    }

    def __init__(self, evaluation_job_status=None, events=None, id=None, notifications=None):
        super(SubscriptionEvaluationResult, self).__init__()
        self.evaluation_job_status = evaluation_job_status
        self.events = events
        self.id = id
        self.notifications = notifications


class SubscriptionEvaluationSettings(Model):
    """SubscriptionEvaluationSettings.

    :param enabled: Indicates whether subscription evaluation before saving is enabled or not
    :type enabled: bool
    :param interval: Time interval to check on subscription evaluation job in seconds
    :type interval: int
    :param threshold: Threshold on the number of notifications for considering a subscription too noisy
    :type threshold: int
    :param time_out: Time out for the subscription evaluation check in seconds
    :type time_out: int
    """

    _attribute_map = {
        'enabled': {'key': 'enabled', 'type': 'bool'},
        'interval': {'key': 'interval', 'type': 'int'},
        'threshold': {'key': 'threshold', 'type': 'int'},
        'time_out': {'key': 'timeOut', 'type': 'int'}
    }

    def __init__(self, enabled=None, interval=None, threshold=None, time_out=None):
        super(SubscriptionEvaluationSettings, self).__init__()
        self.enabled = enabled
        self.interval = interval
        self.threshold = threshold
        self.time_out = time_out


class SubscriptionManagement(Model):
    """SubscriptionManagement.

    :param service_instance_type:
    :type service_instance_type: str
    :param url:
    :type url: str
    """

    _attribute_map = {
        'service_instance_type': {'key': 'serviceInstanceType', 'type': 'str'},
        'url': {'key': 'url', 'type': 'str'}
    }

    def __init__(self, service_instance_type=None, url=None):
        super(SubscriptionManagement, self).__init__()
        self.service_instance_type = service_instance_type
        self.url = url


class SubscriptionQuery(Model):
    """SubscriptionQuery.

    :param conditions: One or more conditions to query on. If more than 2 conditions are specified, the combined results of each condition is returned (i.e. conditions are logically OR'ed).
    :type conditions: list of :class:`SubscriptionQueryCondition <azure.devops.v5_0.notification.models.SubscriptionQueryCondition>`
    :param query_flags: Flags the refine the types of subscriptions that will be returned from the query.
    :type query_flags: object
    """

    _attribute_map = {
        'conditions': {'key': 'conditions', 'type': '[SubscriptionQueryCondition]'},
        'query_flags': {'key': 'queryFlags', 'type': 'object'}
    }

    def __init__(self, conditions=None, query_flags=None):
        super(SubscriptionQuery, self).__init__()
        self.conditions = conditions
        self.query_flags = query_flags


class SubscriptionQueryCondition(Model):
    """SubscriptionQueryCondition.

    :param filter: Filter conditions that matching subscriptions must have. Typically only the filter's type and event type are used for matching.
    :type filter: :class:`ISubscriptionFilter <azure.devops.v5_0.notification.models.ISubscriptionFilter>`
    :param flags: Flags to specify the the type subscriptions to query for.
    :type flags: object
    :param scope: Scope that matching subscriptions must have.
    :type scope: str
    :param subscriber_id: ID of the subscriber (user or group) that matching subscriptions must be subscribed to.
    :type subscriber_id: str
    :param subscription_id: ID of the subscription to query for.
    :type subscription_id: str
    """

    _attribute_map = {
        'filter': {'key': 'filter', 'type': 'ISubscriptionFilter'},
        'flags': {'key': 'flags', 'type': 'object'},
        'scope': {'key': 'scope', 'type': 'str'},
        'subscriber_id': {'key': 'subscriberId', 'type': 'str'},
        'subscription_id': {'key': 'subscriptionId', 'type': 'str'}
    }

    def __init__(self, filter=None, flags=None, scope=None, subscriber_id=None, subscription_id=None):
        super(SubscriptionQueryCondition, self).__init__()
        self.filter = filter
        self.flags = flags
        self.scope = scope
        self.subscriber_id = subscriber_id
        self.subscription_id = subscription_id


class SubscriptionScope(EventScope):
    """SubscriptionScope.

    :param id: Required: This is the identity of the scope for the type.
    :type id: str
    :param name: Optional: The display name of the scope
    :type name: str
    :param type: Required: The event specific type of a scope.
    :type type: str
    """

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

    def __init__(self, id=None, name=None, type=None):
        super(SubscriptionScope, self).__init__(id=id, name=name, type=type)


class SubscriptionTracing(Model):
    """SubscriptionTracing.

    :param enabled:
    :type enabled: bool
    :param end_date: Trace until the specified end date.
    :type end_date: datetime
    :param max_traced_entries: The maximum number of result details to trace.
    :type max_traced_entries: int
    :param start_date: The date and time tracing started.
    :type start_date: datetime
    :param traced_entries: Trace until remaining count reaches 0.
    :type traced_entries: int
    """

    _attribute_map = {
        'enabled': {'key': 'enabled', 'type': 'bool'},
        'end_date': {'key': 'endDate', 'type': 'iso-8601'},
        'max_traced_entries': {'key': 'maxTracedEntries', 'type': 'int'},
        'start_date': {'key': 'startDate', 'type': 'iso-8601'},
        'traced_entries': {'key': 'tracedEntries', 'type': 'int'}
    }

    def __init__(self, enabled=None, end_date=None, max_traced_entries=None, start_date=None, traced_entries=None):
        super(SubscriptionTracing, self).__init__()
        self.enabled = enabled
        self.end_date = end_date
        self.max_traced_entries = max_traced_entries
        self.start_date = start_date
        self.traced_entries = traced_entries


class SubscriptionUserSettings(Model):
    """SubscriptionUserSettings.

    :param opted_out: Indicates whether the user will receive notifications for the associated group subscription.
    :type opted_out: bool
    """

    _attribute_map = {
        'opted_out': {'key': 'optedOut', 'type': 'bool'}
    }

    def __init__(self, opted_out=None):
        super(SubscriptionUserSettings, self).__init__()
        self.opted_out = opted_out


class UpdateSubscripitonDiagnosticsParameters(Model):
    """UpdateSubscripitonDiagnosticsParameters.

    :param delivery_results:
    :type delivery_results: :class:`UpdateSubscripitonTracingParameters <azure.devops.v5_0.notification.models.UpdateSubscripitonTracingParameters>`
    :param delivery_tracing:
    :type delivery_tracing: :class:`UpdateSubscripitonTracingParameters <azure.devops.v5_0.notification.models.UpdateSubscripitonTracingParameters>`
    :param evaluation_tracing:
    :type evaluation_tracing: :class:`UpdateSubscripitonTracingParameters <azure.devops.v5_0.notification.models.UpdateSubscripitonTracingParameters>`
    """

    _attribute_map = {
        'delivery_results': {'key': 'deliveryResults', 'type': 'UpdateSubscripitonTracingParameters'},
        'delivery_tracing': {'key': 'deliveryTracing', 'type': 'UpdateSubscripitonTracingParameters'},
        'evaluation_tracing': {'key': 'evaluationTracing', 'type': 'UpdateSubscripitonTracingParameters'}
    }

    def __init__(self, delivery_results=None, delivery_tracing=None, evaluation_tracing=None):
        super(UpdateSubscripitonDiagnosticsParameters, self).__init__()
        self.delivery_results = delivery_results
        self.delivery_tracing = delivery_tracing
        self.evaluation_tracing = evaluation_tracing


class UpdateSubscripitonTracingParameters(Model):
    """UpdateSubscripitonTracingParameters.

    :param enabled:
    :type enabled: bool
    """

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

    def __init__(self, enabled=None):
        super(UpdateSubscripitonTracingParameters, self).__init__()
        self.enabled = enabled


class ValueDefinition(Model):
    """ValueDefinition.

    :param data_source: Gets or sets the data source.
    :type data_source: list of :class:`InputValue <azure.devops.v5_0.notification.models.InputValue>`
    :param end_point: Gets or sets the rest end point.
    :type end_point: str
    :param result_template: Gets or sets the result template.
    :type result_template: str
    """

    _attribute_map = {
        'data_source': {'key': 'dataSource', 'type': '[InputValue]'},
        'end_point': {'key': 'endPoint', 'type': 'str'},
        'result_template': {'key': 'resultTemplate', 'type': 'str'}
    }

    def __init__(self, data_source=None, end_point=None, result_template=None):
        super(ValueDefinition, self).__init__()
        self.data_source = data_source
        self.end_point = end_point
        self.result_template = result_template


class VssNotificationEvent(Model):
    """VssNotificationEvent.

    :param actors: Optional: A list of actors which are additional identities with corresponding roles that are relevant to the event.
    :type actors: list of :class:`EventActor <azure.devops.v5_0.microsoft._visual_studio._services._web_api.models.EventActor>`
    :param artifact_uris: Optional: A list of artifacts referenced or impacted by this event.
    :type artifact_uris: list of str
    :param data: Required: The event payload.  If Data is a string, it must be in Json or XML format.  Otherwise it must have a serialization format attribute.
    :type data: object
    :param event_type: Required: The name of the event.  This event must be registered in the context it is being fired.
    :type event_type: str
    :param expires_in: How long before the event expires and will be cleaned up.  The default is to use the system default.
    :type expires_in: object
    :param item_id: The id of the item, artifact, extension, project, etc.
    :type item_id: str
    :param process_delay: How long to wait before processing this event.  The default is to process immediately.
    :type process_delay: object
    :param scopes: Optional: A list of scopes which are are relevant to the event.
    :type scopes: list of :class:`EventScope <azure.devops.v5_0.microsoft._visual_studio._services._web_api.models.EventScope>`
    :param source_event_created_time: This is the time the original source event for this VssNotificationEvent was created.  For example, for something like a build completion notification SourceEventCreatedTime should be the time the build finished not the time this event was raised.
    :type source_event_created_time: datetime
    """

    _attribute_map = {
        'actors': {'key': 'actors', 'type': '[EventActor]'},
        'artifact_uris': {'key': 'artifactUris', 'type': '[str]'},
        'data': {'key': 'data', 'type': 'object'},
        'event_type': {'key': 'eventType', 'type': 'str'},
        'expires_in': {'key': 'expiresIn', 'type': 'object'},
        'item_id': {'key': 'itemId', 'type': 'str'},
        'process_delay': {'key': 'processDelay', 'type': 'object'},
        'scopes': {'key': 'scopes', 'type': '[EventScope]'},
        'source_event_created_time': {'key': 'sourceEventCreatedTime', 'type': 'iso-8601'}
    }

    def __init__(self, actors=None, artifact_uris=None, data=None, event_type=None, expires_in=None, item_id=None, process_delay=None, scopes=None, source_event_created_time=None):
        super(VssNotificationEvent, self).__init__()
        self.actors = actors
        self.artifact_uris = artifact_uris
        self.data = data
        self.event_type = event_type
        self.expires_in = expires_in
        self.item_id = item_id
        self.process_delay = process_delay
        self.scopes = scopes
        self.source_event_created_time = source_event_created_time


class ArtifactFilter(BaseSubscriptionFilter):
    """ArtifactFilter.

    :param event_type:
    :type event_type: str
    :param artifact_id:
    :type artifact_id: str
    :param artifact_type:
    :type artifact_type: str
    :param artifact_uri:
    :type artifact_uri: str
    :param type:
    :type type: str
    """

    _attribute_map = {
        'event_type': {'key': 'eventType', 'type': 'str'},
        'artifact_id': {'key': 'artifactId', 'type': 'str'},
        'artifact_type': {'key': 'artifactType', 'type': 'str'},
        'artifact_uri': {'key': 'artifactUri', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'}
    }

    def __init__(self, event_type=None, artifact_id=None, artifact_type=None, artifact_uri=None, type=None):
        super(ArtifactFilter, self).__init__(event_type=event_type)
        self.artifact_id = artifact_id
        self.artifact_type = artifact_type
        self.artifact_uri = artifact_uri
        self.type = type


class FieldInputValues(InputValues):
    """FieldInputValues.

    :param default_value: The default value to use for this input
    :type default_value: str
    :param error: Errors encountered while computing dynamic values.
    :type error: :class:`InputValuesError <azure.devops.v5_0.notification.models.InputValuesError>`
    :param input_id: The id of the input
    :type input_id: str
    :param is_disabled: Should this input be disabled
    :type is_disabled: bool
    :param is_limited_to_possible_values: Should the value be restricted to one of the values in the PossibleValues (True) or are the values in PossibleValues just a suggestion (False)
    :type is_limited_to_possible_values: bool
    :param is_read_only: Should this input be made read-only
    :type is_read_only: bool
    :param possible_values: Possible values that this input can take
    :type possible_values: list of :class:`InputValue <azure.devops.v5_0.notification.models.InputValue>`
    :param operators:
    :type operators: str
    """

    _attribute_map = {
        'default_value': {'key': 'defaultValue', 'type': 'str'},
        'error': {'key': 'error', 'type': 'InputValuesError'},
        'input_id': {'key': 'inputId', 'type': 'str'},
        'is_disabled': {'key': 'isDisabled', 'type': 'bool'},
        'is_limited_to_possible_values': {'key': 'isLimitedToPossibleValues', 'type': 'bool'},
        'is_read_only': {'key': 'isReadOnly', 'type': 'bool'},
        'possible_values': {'key': 'possibleValues', 'type': '[InputValue]'},
        'operators': {'key': 'operators', 'type': 'str'}
    }

    def __init__(self, default_value=None, error=None, input_id=None, is_disabled=None, is_limited_to_possible_values=None, is_read_only=None, possible_values=None, operators=None):
        super(FieldInputValues, self).__init__(default_value=default_value, error=error, input_id=input_id, is_disabled=is_disabled, is_limited_to_possible_values=is_limited_to_possible_values, is_read_only=is_read_only, possible_values=possible_values)
        self.operators = operators


class FieldValuesQuery(InputValuesQuery):
    """FieldValuesQuery.

    :param current_values:
    :type current_values: dict
    :param resource: Subscription containing information about the publisher/consumer and the current input values
    :type resource: object
    :param input_values:
    :type input_values: list of :class:`FieldInputValues <azure.devops.v5_0.notification.models.FieldInputValues>`
    :param scope:
    :type scope: str
    """

    _attribute_map = {
        'current_values': {'key': 'currentValues', 'type': '{str}'},
        'resource': {'key': 'resource', 'type': 'object'},
        'input_values': {'key': 'inputValues', 'type': '[FieldInputValues]'},
        'scope': {'key': 'scope', 'type': 'str'}
    }

    def __init__(self, current_values=None, resource=None, input_values=None, scope=None):
        super(FieldValuesQuery, self).__init__(current_values=current_values, resource=resource)
        self.input_values = input_values
        self.scope = scope


__all__ = [
    'BaseSubscriptionFilter',
    'BatchNotificationOperation',
    'EventActor',
    'EventScope',
    'EventsEvaluationResult',
    'EventTransformRequest',
    'EventTransformResult',
    'ExpressionFilterClause',
    'ExpressionFilterGroup',
    'ExpressionFilterModel',
    'GraphSubjectBase',
    'IdentityRef',
    'INotificationDiagnosticLog',
    'InputValue',
    'InputValues',
    'InputValuesError',
    'InputValuesQuery',
    'ISubscriptionChannel',
    'ISubscriptionFilter',
    'NotificationAdminSettings',
    'NotificationAdminSettingsUpdateParameters',
    'NotificationDiagnosticLogMessage',
    'NotificationEventField',
    'NotificationEventFieldOperator',
    'NotificationEventFieldType',
    'NotificationEventPublisher',
    'NotificationEventRole',
    'NotificationEventType',
    'NotificationEventTypeCategory',
    'NotificationQueryCondition',
    'NotificationReason',
    'NotificationsEvaluationResult',
    'NotificationStatistic',
    'NotificationStatisticsQuery',
    'NotificationStatisticsQueryConditions',
    'NotificationSubscriber',
    'NotificationSubscriberUpdateParameters',
    'NotificationSubscription',
    'NotificationSubscriptionCreateParameters',
    'NotificationSubscriptionTemplate',
    'NotificationSubscriptionUpdateParameters',
    'OperatorConstraint',
    'ReferenceLinks',
    'SubscriptionAdminSettings',
    'SubscriptionChannelWithAddress',
    'SubscriptionDiagnostics',
    'SubscriptionEvaluationRequest',
    'SubscriptionEvaluationResult',
    'SubscriptionEvaluationSettings',
    'SubscriptionManagement',
    'SubscriptionQuery',
    'SubscriptionQueryCondition',
    'SubscriptionScope',
    'SubscriptionTracing',
    'SubscriptionUserSettings',
    'UpdateSubscripitonDiagnosticsParameters',
    'UpdateSubscripitonTracingParameters',
    'ValueDefinition',
    'VssNotificationEvent',
    'ArtifactFilter',
    'FieldInputValues',
    'FieldValuesQuery',
]
