# 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 ._signal_rmanagement_client_enums import *
[docs]class Dimension(msrest.serialization.Model):
"""Specifications of the Dimension of metrics.
:param name: The public facing name of the dimension.
:type name: str
:param display_name: Localized friendly display name of the dimension.
:type display_name: str
:param internal_name: Name of the dimension as it appears in MDM.
:type internal_name: str
:param to_be_exported_for_shoebox: A Boolean flag indicating whether this dimension should be
included for the shoebox export scenario.
:type to_be_exported_for_shoebox: bool
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'display_name': {'key': 'displayName', 'type': 'str'},
'internal_name': {'key': 'internalName', 'type': 'str'},
'to_be_exported_for_shoebox': {'key': 'toBeExportedForShoebox', 'type': 'bool'},
}
def __init__(
self,
*,
name: Optional[str] = None,
display_name: Optional[str] = None,
internal_name: Optional[str] = None,
to_be_exported_for_shoebox: Optional[bool] = None,
**kwargs
):
super(Dimension, self).__init__(**kwargs)
self.name = name
self.display_name = display_name
self.internal_name = internal_name
self.to_be_exported_for_shoebox = to_be_exported_for_shoebox
[docs]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: any
"""
_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
[docs]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[~azure.mgmt.signalr.models.ErrorDetail]
:ivar additional_info: The error additional info.
:vartype additional_info: list[~azure.mgmt.signalr.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
[docs]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: ~azure.mgmt.signalr.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
[docs]class LogSpecification(msrest.serialization.Model):
"""Specifications of the Logs for Azure Monitoring.
:param name: Name of the log.
:type name: str
:param display_name: Localized friendly display name of the log.
:type display_name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'display_name': {'key': 'displayName', 'type': 'str'},
}
def __init__(
self,
*,
name: Optional[str] = None,
display_name: Optional[str] = None,
**kwargs
):
super(LogSpecification, self).__init__(**kwargs)
self.name = name
self.display_name = display_name
[docs]class ManagedIdentity(msrest.serialization.Model):
"""A class represent managed identities used for request and response.
Variables are only populated by the server, and will be ignored when sending a request.
:param type: Represent the identity type: systemAssigned, userAssigned, None. Possible values
include: "None", "SystemAssigned", "UserAssigned".
:type type: str or ~azure.mgmt.signalr.models.ManagedIdentityType
:param user_assigned_identities: Get or set the user assigned identities.
:type user_assigned_identities: dict[str,
~azure.mgmt.signalr.models.UserAssignedIdentityProperty]
:ivar principal_id: Get the principal id for the system assigned identity.
Only be used in response.
:vartype principal_id: str
:ivar tenant_id: Get the tenant id for the system assigned identity.
Only be used in response.
:vartype tenant_id: str
"""
_validation = {
'principal_id': {'readonly': True},
'tenant_id': {'readonly': True},
}
_attribute_map = {
'type': {'key': 'type', 'type': 'str'},
'user_assigned_identities': {'key': 'userAssignedIdentities', 'type': '{UserAssignedIdentityProperty}'},
'principal_id': {'key': 'principalId', 'type': 'str'},
'tenant_id': {'key': 'tenantId', 'type': 'str'},
}
def __init__(
self,
*,
type: Optional[Union[str, "ManagedIdentityType"]] = None,
user_assigned_identities: Optional[Dict[str, "UserAssignedIdentityProperty"]] = None,
**kwargs
):
super(ManagedIdentity, self).__init__(**kwargs)
self.type = type
self.user_assigned_identities = user_assigned_identities
self.principal_id = None
self.tenant_id = None
[docs]class ManagedIdentitySettings(msrest.serialization.Model):
"""Managed identity settings for upstream.
:param resource: The Resource indicating the App ID URI of the target resource.
It also appears in the aud (audience) claim of the issued token.
:type resource: str
"""
_attribute_map = {
'resource': {'key': 'resource', 'type': 'str'},
}
def __init__(
self,
*,
resource: Optional[str] = None,
**kwargs
):
super(ManagedIdentitySettings, self).__init__(**kwargs)
self.resource = resource
[docs]class MetricSpecification(msrest.serialization.Model):
"""Specifications of the Metrics for Azure Monitoring.
:param name: Name of the metric.
:type name: str
:param display_name: Localized friendly display name of the metric.
:type display_name: str
:param display_description: Localized friendly description of the metric.
:type display_description: str
:param unit: The unit that makes sense for the metric.
:type unit: str
:param aggregation_type: Only provide one value for this field. Valid values: Average, Minimum,
Maximum, Total, Count.
:type aggregation_type: str
:param fill_gap_with_zero: Optional. If set to true, then zero will be returned for time
duration where no metric is emitted/published.
Ex. a metric that returns the number of times a particular error code was emitted. The error
code may not appear
often, instead of the RP publishing 0, Shoebox can auto fill in 0s for time periods where
nothing was emitted.
:type fill_gap_with_zero: str
:param category: The name of the metric category that the metric belongs to. A metric can only
belong to a single category.
:type category: str
:param dimensions: The dimensions of the metrics.
:type dimensions: list[~azure.mgmt.signalr.models.Dimension]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'display_name': {'key': 'displayName', 'type': 'str'},
'display_description': {'key': 'displayDescription', 'type': 'str'},
'unit': {'key': 'unit', 'type': 'str'},
'aggregation_type': {'key': 'aggregationType', 'type': 'str'},
'fill_gap_with_zero': {'key': 'fillGapWithZero', 'type': 'str'},
'category': {'key': 'category', 'type': 'str'},
'dimensions': {'key': 'dimensions', 'type': '[Dimension]'},
}
def __init__(
self,
*,
name: Optional[str] = None,
display_name: Optional[str] = None,
display_description: Optional[str] = None,
unit: Optional[str] = None,
aggregation_type: Optional[str] = None,
fill_gap_with_zero: Optional[str] = None,
category: Optional[str] = None,
dimensions: Optional[List["Dimension"]] = None,
**kwargs
):
super(MetricSpecification, self).__init__(**kwargs)
self.name = name
self.display_name = display_name
self.display_description = display_description
self.unit = unit
self.aggregation_type = aggregation_type
self.fill_gap_with_zero = fill_gap_with_zero
self.category = category
self.dimensions = dimensions
[docs]class NameAvailability(msrest.serialization.Model):
"""Result of the request to check name availability. It contains a flag and possible reason of failure.
:param name_available: Indicates whether the name is available or not.
:type name_available: bool
:param reason: The reason of the availability. Required if name is not available.
:type reason: str
:param message: The message of the operation.
:type message: str
"""
_attribute_map = {
'name_available': {'key': 'nameAvailable', 'type': 'bool'},
'reason': {'key': 'reason', 'type': 'str'},
'message': {'key': 'message', 'type': 'str'},
}
def __init__(
self,
*,
name_available: Optional[bool] = None,
reason: Optional[str] = None,
message: Optional[str] = None,
**kwargs
):
super(NameAvailability, self).__init__(**kwargs)
self.name_available = name_available
self.reason = reason
self.message = message
[docs]class NameAvailabilityParameters(msrest.serialization.Model):
"""Data POST-ed to the nameAvailability action.
All required parameters must be populated in order to send to Azure.
:param type: Required. The resource type. Can be "Microsoft.SignalRService/SignalR" or
"Microsoft.SignalRService/webPubSub".
:type type: str
:param name: Required. The resource name to validate. e.g."my-resource-name".
:type name: str
"""
_validation = {
'type': {'required': True},
'name': {'required': True},
}
_attribute_map = {
'type': {'key': 'type', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(
self,
*,
type: str,
name: str,
**kwargs
):
super(NameAvailabilityParameters, self).__init__(**kwargs)
self.type = type
self.name = name
[docs]class NetworkACL(msrest.serialization.Model):
"""Network ACL.
:param allow: Allowed request types. The value can be one or more of: ClientConnection,
ServerConnection, RESTAPI.
:type allow: list[str or ~azure.mgmt.signalr.models.SignalRRequestType]
:param deny: Denied request types. The value can be one or more of: ClientConnection,
ServerConnection, RESTAPI.
:type deny: list[str or ~azure.mgmt.signalr.models.SignalRRequestType]
"""
_attribute_map = {
'allow': {'key': 'allow', 'type': '[str]'},
'deny': {'key': 'deny', 'type': '[str]'},
}
def __init__(
self,
*,
allow: Optional[List[Union[str, "SignalRRequestType"]]] = None,
deny: Optional[List[Union[str, "SignalRRequestType"]]] = None,
**kwargs
):
super(NetworkACL, self).__init__(**kwargs)
self.allow = allow
self.deny = deny
[docs]class Operation(msrest.serialization.Model):
"""REST API operation supported by resource provider.
:param name: Name of the operation with format: {provider}/{resource}/{operation}.
:type name: str
:param is_data_action: If the operation is a data action. (for data plane rbac).
:type is_data_action: bool
:param display: The object that describes the operation.
:type display: ~azure.mgmt.signalr.models.OperationDisplay
:param origin: Optional. The intended executor of the operation; governs the display of the
operation in the RBAC UX and the audit logs UX.
:type origin: str
:param properties: Extra properties for the operation.
:type properties: ~azure.mgmt.signalr.models.OperationProperties
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'is_data_action': {'key': 'isDataAction', 'type': 'bool'},
'display': {'key': 'display', 'type': 'OperationDisplay'},
'origin': {'key': 'origin', 'type': 'str'},
'properties': {'key': 'properties', 'type': 'OperationProperties'},
}
def __init__(
self,
*,
name: Optional[str] = None,
is_data_action: Optional[bool] = None,
display: Optional["OperationDisplay"] = None,
origin: Optional[str] = None,
properties: Optional["OperationProperties"] = None,
**kwargs
):
super(Operation, self).__init__(**kwargs)
self.name = name
self.is_data_action = is_data_action
self.display = display
self.origin = origin
self.properties = properties
[docs]class OperationDisplay(msrest.serialization.Model):
"""The object that describes a operation.
:param provider: Friendly name of the resource provider.
:type provider: str
:param resource: Resource type on which the operation is performed.
:type resource: str
:param operation: The localized friendly name for the operation.
:type operation: str
:param description: The localized friendly description for the operation.
: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
[docs]class OperationList(msrest.serialization.Model):
"""Result of the request to list REST API operations. It contains a list of operations.
:param value: List of operations supported by the resource provider.
:type value: list[~azure.mgmt.signalr.models.Operation]
:param next_link: The URL the client should use to fetch the next page (per server side
paging).
It's null for now, added for future use.
:type next_link: str
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[Operation]'},
'next_link': {'key': 'nextLink', 'type': 'str'},
}
def __init__(
self,
*,
value: Optional[List["Operation"]] = None,
next_link: Optional[str] = None,
**kwargs
):
super(OperationList, self).__init__(**kwargs)
self.value = value
self.next_link = next_link
[docs]class OperationProperties(msrest.serialization.Model):
"""Extra Operation properties.
:param service_specification: The service specifications.
:type service_specification: ~azure.mgmt.signalr.models.ServiceSpecification
"""
_attribute_map = {
'service_specification': {'key': 'serviceSpecification', 'type': 'ServiceSpecification'},
}
def __init__(
self,
*,
service_specification: Optional["ServiceSpecification"] = None,
**kwargs
):
super(OperationProperties, self).__init__(**kwargs)
self.service_specification = service_specification
[docs]class PrivateEndpoint(msrest.serialization.Model):
"""Private endpoint.
:param id: Full qualified Id of the private endpoint.
:type id: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
}
def __init__(
self,
*,
id: Optional[str] = None,
**kwargs
):
super(PrivateEndpoint, self).__init__(**kwargs)
self.id = id
[docs]class PrivateEndpointACL(NetworkACL):
"""ACL for a private endpoint.
All required parameters must be populated in order to send to Azure.
:param allow: Allowed request types. The value can be one or more of: ClientConnection,
ServerConnection, RESTAPI.
:type allow: list[str or ~azure.mgmt.signalr.models.SignalRRequestType]
:param deny: Denied request types. The value can be one or more of: ClientConnection,
ServerConnection, RESTAPI.
:type deny: list[str or ~azure.mgmt.signalr.models.SignalRRequestType]
:param name: Required. Name of the private endpoint connection.
:type name: str
"""
_validation = {
'name': {'required': True},
}
_attribute_map = {
'allow': {'key': 'allow', 'type': '[str]'},
'deny': {'key': 'deny', 'type': '[str]'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(
self,
*,
name: str,
allow: Optional[List[Union[str, "SignalRRequestType"]]] = None,
deny: Optional[List[Union[str, "SignalRRequestType"]]] = None,
**kwargs
):
super(PrivateEndpointACL, self).__init__(allow=allow, deny=deny, **kwargs)
self.name = name
[docs]class Resource(msrest.serialization.Model):
"""The core properties of ARM resources.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource - e.g. "Microsoft.SignalRService/SignalR".
:vartype type: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(Resource, self).__init__(**kwargs)
self.id = None
self.name = None
self.type = None
[docs]class ProxyResource(Resource):
"""The resource model definition for a ARM proxy resource. It will have everything other than required location and tags.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource - e.g. "Microsoft.SignalRService/SignalR".
:vartype type: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(ProxyResource, self).__init__(**kwargs)
[docs]class PrivateEndpointConnection(ProxyResource):
"""A private endpoint connection to an azure resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource - e.g. "Microsoft.SignalRService/SignalR".
:vartype type: str
:ivar system_data: Metadata pertaining to creation and last modification of the resource.
:vartype system_data: ~azure.mgmt.signalr.models.SystemData
:ivar provisioning_state: Provisioning state of the private endpoint connection. Possible
values include: "Unknown", "Succeeded", "Failed", "Canceled", "Running", "Creating",
"Updating", "Deleting", "Moving".
:vartype provisioning_state: str or ~azure.mgmt.signalr.models.ProvisioningState
:param private_endpoint: Private endpoint associated with the private endpoint connection.
:type private_endpoint: ~azure.mgmt.signalr.models.PrivateEndpoint
:param private_link_service_connection_state: Connection state.
:type private_link_service_connection_state:
~azure.mgmt.signalr.models.PrivateLinkServiceConnectionState
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'system_data': {'readonly': True},
'provisioning_state': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'system_data': {'key': 'systemData', 'type': 'SystemData'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
'private_endpoint': {'key': 'properties.privateEndpoint', 'type': 'PrivateEndpoint'},
'private_link_service_connection_state': {'key': 'properties.privateLinkServiceConnectionState', 'type': 'PrivateLinkServiceConnectionState'},
}
def __init__(
self,
*,
private_endpoint: Optional["PrivateEndpoint"] = None,
private_link_service_connection_state: Optional["PrivateLinkServiceConnectionState"] = None,
**kwargs
):
super(PrivateEndpointConnection, self).__init__(**kwargs)
self.system_data = None
self.provisioning_state = None
self.private_endpoint = private_endpoint
self.private_link_service_connection_state = private_link_service_connection_state
[docs]class PrivateEndpointConnectionList(msrest.serialization.Model):
"""A list of private endpoint connections.
:param value: The list of the private endpoint connections.
:type value: list[~azure.mgmt.signalr.models.PrivateEndpointConnection]
:param next_link: Request URL that can be used to query next page of private endpoint
connections. Returned when the total number of requested private endpoint connections exceed
maximum page size.
:type next_link: str
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[PrivateEndpointConnection]'},
'next_link': {'key': 'nextLink', 'type': 'str'},
}
def __init__(
self,
*,
value: Optional[List["PrivateEndpointConnection"]] = None,
next_link: Optional[str] = None,
**kwargs
):
super(PrivateEndpointConnectionList, self).__init__(**kwargs)
self.value = value
self.next_link = next_link
[docs]class PrivateLinkResource(ProxyResource):
"""Private link resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource - e.g. "Microsoft.SignalRService/SignalR".
:vartype type: str
:param group_id: Group Id of the private link resource.
:type group_id: str
:param required_members: Required members of the private link resource.
:type required_members: list[str]
:param required_zone_names: Required private DNS zone names.
:type required_zone_names: list[str]
:param shareable_private_link_resource_types: The list of resources that are onboarded to
private link service.
:type shareable_private_link_resource_types:
list[~azure.mgmt.signalr.models.ShareablePrivateLinkResourceType]
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'group_id': {'key': 'properties.groupId', 'type': 'str'},
'required_members': {'key': 'properties.requiredMembers', 'type': '[str]'},
'required_zone_names': {'key': 'properties.requiredZoneNames', 'type': '[str]'},
'shareable_private_link_resource_types': {'key': 'properties.shareablePrivateLinkResourceTypes', 'type': '[ShareablePrivateLinkResourceType]'},
}
def __init__(
self,
*,
group_id: Optional[str] = None,
required_members: Optional[List[str]] = None,
required_zone_names: Optional[List[str]] = None,
shareable_private_link_resource_types: Optional[List["ShareablePrivateLinkResourceType"]] = None,
**kwargs
):
super(PrivateLinkResource, self).__init__(**kwargs)
self.group_id = group_id
self.required_members = required_members
self.required_zone_names = required_zone_names
self.shareable_private_link_resource_types = shareable_private_link_resource_types
[docs]class PrivateLinkResourceList(msrest.serialization.Model):
"""Contains a list of PrivateLinkResource and a possible link to query more results.
:param value: List of PrivateLinkResource.
:type value: list[~azure.mgmt.signalr.models.PrivateLinkResource]
:param next_link: The URL the client should use to fetch the next page (per server side
paging).
It's null for now, added for future use.
:type next_link: str
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[PrivateLinkResource]'},
'next_link': {'key': 'nextLink', 'type': 'str'},
}
def __init__(
self,
*,
value: Optional[List["PrivateLinkResource"]] = None,
next_link: Optional[str] = None,
**kwargs
):
super(PrivateLinkResourceList, self).__init__(**kwargs)
self.value = value
self.next_link = next_link
[docs]class PrivateLinkServiceConnectionState(msrest.serialization.Model):
"""Connection state of the private endpoint connection.
:param status: Indicates whether the connection has been Approved/Rejected/Removed by the owner
of the service. Possible values include: "Pending", "Approved", "Rejected", "Disconnected".
:type status: str or ~azure.mgmt.signalr.models.PrivateLinkServiceConnectionStatus
:param description: The reason for approval/rejection of the connection.
:type description: str
:param actions_required: A message indicating if changes on the service provider require any
updates on the consumer.
:type actions_required: str
"""
_attribute_map = {
'status': {'key': 'status', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
'actions_required': {'key': 'actionsRequired', 'type': 'str'},
}
def __init__(
self,
*,
status: Optional[Union[str, "PrivateLinkServiceConnectionStatus"]] = None,
description: Optional[str] = None,
actions_required: Optional[str] = None,
**kwargs
):
super(PrivateLinkServiceConnectionState, self).__init__(**kwargs)
self.status = status
self.description = description
self.actions_required = actions_required
[docs]class RegenerateKeyParameters(msrest.serialization.Model):
"""Parameters describes the request to regenerate access keys.
:param key_type: The keyType to regenerate. Must be either 'primary' or
'secondary'(case-insensitive). Possible values include: "Primary", "Secondary".
:type key_type: str or ~azure.mgmt.signalr.models.KeyType
"""
_attribute_map = {
'key_type': {'key': 'keyType', 'type': 'str'},
}
def __init__(
self,
*,
key_type: Optional[Union[str, "KeyType"]] = None,
**kwargs
):
super(RegenerateKeyParameters, self).__init__(**kwargs)
self.key_type = key_type
[docs]class ResourceSku(msrest.serialization.Model):
"""The billing information of the resource.
Variables are only populated by the server, and will be ignored when sending a request.
All required parameters must be populated in order to send to Azure.
:param name: Required. The name of the SKU. Required.
Allowed values: Standard_S1, Free_F1.
:type name: str
:param tier: Optional tier of this particular SKU. 'Standard' or 'Free'.
``Basic`` is deprecated, use ``Standard`` instead. Possible values include: "Free", "Basic",
"Standard", "Premium".
:type tier: str or ~azure.mgmt.signalr.models.SignalRSkuTier
:ivar size: Not used. Retained for future use.
:vartype size: str
:ivar family: Not used. Retained for future use.
:vartype family: str
:param capacity: Optional, integer. The unit count of the resource. 1 by default.
If present, following values are allowed:
Free: 1
Standard: 1,2,5,10,20,50,100.
:type capacity: int
"""
_validation = {
'name': {'required': True},
'size': {'readonly': True},
'family': {'readonly': True},
}
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'tier': {'key': 'tier', 'type': 'str'},
'size': {'key': 'size', 'type': 'str'},
'family': {'key': 'family', 'type': 'str'},
'capacity': {'key': 'capacity', 'type': 'int'},
}
def __init__(
self,
*,
name: str,
tier: Optional[Union[str, "SignalRSkuTier"]] = None,
capacity: Optional[int] = None,
**kwargs
):
super(ResourceSku, self).__init__(**kwargs)
self.name = name
self.tier = tier
self.size = None
self.family = None
self.capacity = capacity
[docs]class ServerlessUpstreamSettings(msrest.serialization.Model):
"""The settings for the Upstream when the service is in server-less mode.
:param templates: Gets or sets the list of Upstream URL templates. Order matters, and the first
matching template takes effects.
:type templates: list[~azure.mgmt.signalr.models.UpstreamTemplate]
"""
_attribute_map = {
'templates': {'key': 'templates', 'type': '[UpstreamTemplate]'},
}
def __init__(
self,
*,
templates: Optional[List["UpstreamTemplate"]] = None,
**kwargs
):
super(ServerlessUpstreamSettings, self).__init__(**kwargs)
self.templates = templates
[docs]class ServiceSpecification(msrest.serialization.Model):
"""An object that describes a specification.
:param metric_specifications: Specifications of the Metrics for Azure Monitoring.
:type metric_specifications: list[~azure.mgmt.signalr.models.MetricSpecification]
:param log_specifications: Specifications of the Logs for Azure Monitoring.
:type log_specifications: list[~azure.mgmt.signalr.models.LogSpecification]
"""
_attribute_map = {
'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecification]'},
'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'},
}
def __init__(
self,
*,
metric_specifications: Optional[List["MetricSpecification"]] = None,
log_specifications: Optional[List["LogSpecification"]] = None,
**kwargs
):
super(ServiceSpecification, self).__init__(**kwargs)
self.metric_specifications = metric_specifications
self.log_specifications = log_specifications
[docs]class ShareablePrivateLinkResourceProperties(msrest.serialization.Model):
"""Describes the properties of a resource type that has been onboarded to private link service.
:param description: The description of the resource type that has been onboarded to private
link service.
:type description: str
:param group_id: The resource provider group id for the resource that has been onboarded to
private link service.
:type group_id: str
:param type: The resource provider type for the resource that has been onboarded to private
link service.
:type type: str
"""
_attribute_map = {
'description': {'key': 'description', 'type': 'str'},
'group_id': {'key': 'groupId', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
}
def __init__(
self,
*,
description: Optional[str] = None,
group_id: Optional[str] = None,
type: Optional[str] = None,
**kwargs
):
super(ShareablePrivateLinkResourceProperties, self).__init__(**kwargs)
self.description = description
self.group_id = group_id
self.type = type
[docs]class ShareablePrivateLinkResourceType(msrest.serialization.Model):
"""Describes a resource type that has been onboarded to private link service.
:param name: The name of the resource type that has been onboarded to private link service.
:type name: str
:param properties: Describes the properties of a resource type that has been onboarded to
private link service.
:type properties: ~azure.mgmt.signalr.models.ShareablePrivateLinkResourceProperties
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'properties': {'key': 'properties', 'type': 'ShareablePrivateLinkResourceProperties'},
}
def __init__(
self,
*,
name: Optional[str] = None,
properties: Optional["ShareablePrivateLinkResourceProperties"] = None,
**kwargs
):
super(ShareablePrivateLinkResourceType, self).__init__(**kwargs)
self.name = name
self.properties = properties
[docs]class SharedPrivateLinkResource(ProxyResource):
"""Describes a Shared Private Link Resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource - e.g. "Microsoft.SignalRService/SignalR".
:vartype type: str
:ivar system_data: Metadata pertaining to creation and last modification of the resource.
:vartype system_data: ~azure.mgmt.signalr.models.SystemData
:param group_id: The group id from the provider of resource the shared private link resource is
for.
:type group_id: str
:param private_link_resource_id: The resource id of the resource the shared private link
resource is for.
:type private_link_resource_id: str
:ivar provisioning_state: Provisioning state of the shared private link resource. Possible
values include: "Unknown", "Succeeded", "Failed", "Canceled", "Running", "Creating",
"Updating", "Deleting", "Moving".
:vartype provisioning_state: str or ~azure.mgmt.signalr.models.ProvisioningState
:param request_message: The request message for requesting approval of the shared private link
resource.
:type request_message: str
:ivar status: Status of the shared private link resource. Possible values include: "Pending",
"Approved", "Rejected", "Disconnected", "Timeout".
:vartype status: str or ~azure.mgmt.signalr.models.SharedPrivateLinkResourceStatus
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'system_data': {'readonly': True},
'provisioning_state': {'readonly': True},
'status': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'system_data': {'key': 'systemData', 'type': 'SystemData'},
'group_id': {'key': 'properties.groupId', 'type': 'str'},
'private_link_resource_id': {'key': 'properties.privateLinkResourceId', 'type': 'str'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
'request_message': {'key': 'properties.requestMessage', 'type': 'str'},
'status': {'key': 'properties.status', 'type': 'str'},
}
def __init__(
self,
*,
group_id: Optional[str] = None,
private_link_resource_id: Optional[str] = None,
request_message: Optional[str] = None,
**kwargs
):
super(SharedPrivateLinkResource, self).__init__(**kwargs)
self.system_data = None
self.group_id = group_id
self.private_link_resource_id = private_link_resource_id
self.provisioning_state = None
self.request_message = request_message
self.status = None
[docs]class SharedPrivateLinkResourceList(msrest.serialization.Model):
"""A list of shared private link resources.
:param value: The list of the shared private link resources.
:type value: list[~azure.mgmt.signalr.models.SharedPrivateLinkResource]
:param next_link: Request URL that can be used to query next page of private endpoint
connections. Returned when the total number of requested private endpoint connections exceed
maximum page size.
:type next_link: str
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[SharedPrivateLinkResource]'},
'next_link': {'key': 'nextLink', 'type': 'str'},
}
def __init__(
self,
*,
value: Optional[List["SharedPrivateLinkResource"]] = None,
next_link: Optional[str] = None,
**kwargs
):
super(SharedPrivateLinkResourceList, self).__init__(**kwargs)
self.value = value
self.next_link = next_link
[docs]class SignalRFeature(msrest.serialization.Model):
"""Feature of a SignalR resource, which controls the SignalR runtime behavior.
All required parameters must be populated in order to send to Azure.
:param flag: Required. FeatureFlags is the supported features of Azure SignalR service.
* ServiceMode: Flag for backend server for SignalR service. Values allowed: "Default": have
your own backend server; "Serverless": your application doesn't have a backend server;
"Classic": for backward compatibility. Support both Default and Serverless mode but not
recommended; "PredefinedOnly": for future use.
* EnableConnectivityLogs: "true"/"false", to enable/disable the connectivity log category
respectively.
* EnableMessagingLogs: "true"/"false", to enable/disable the connectivity log category
respectively.
* EnableLiveTrace: Live Trace allows you to know what's happening inside Azure SignalR
service, it will give you live traces in real time, it will be helpful when you developing your
own Azure SignalR based web application or self-troubleshooting some issues. Please note that
live traces are counted as outbound messages that will be charged. Values allowed:
"true"/"false", to enable/disable live trace feature. Possible values include: "ServiceMode",
"EnableConnectivityLogs", "EnableMessagingLogs", "EnableLiveTrace".
:type flag: str or ~azure.mgmt.signalr.models.FeatureFlags
:param value: Required. Value of the feature flag. See Azure SignalR service document
https://docs.microsoft.com/azure/azure-signalr/ for allowed values.
:type value: str
:param properties: Optional properties related to this feature.
:type properties: dict[str, str]
"""
_validation = {
'flag': {'required': True},
'value': {'required': True, 'max_length': 128, 'min_length': 1},
}
_attribute_map = {
'flag': {'key': 'flag', 'type': 'str'},
'value': {'key': 'value', 'type': 'str'},
'properties': {'key': 'properties', 'type': '{str}'},
}
def __init__(
self,
*,
flag: Union[str, "FeatureFlags"],
value: str,
properties: Optional[Dict[str, str]] = None,
**kwargs
):
super(SignalRFeature, self).__init__(**kwargs)
self.flag = flag
self.value = value
self.properties = properties
[docs]class SignalRKeys(msrest.serialization.Model):
"""A class represents the access keys of the resource.
:param primary_key: The primary access key.
:type primary_key: str
:param secondary_key: The secondary access key.
:type secondary_key: str
:param primary_connection_string: Connection string constructed via the primaryKey.
:type primary_connection_string: str
:param secondary_connection_string: Connection string constructed via the secondaryKey.
:type secondary_connection_string: str
"""
_attribute_map = {
'primary_key': {'key': 'primaryKey', 'type': 'str'},
'secondary_key': {'key': 'secondaryKey', 'type': 'str'},
'primary_connection_string': {'key': 'primaryConnectionString', 'type': 'str'},
'secondary_connection_string': {'key': 'secondaryConnectionString', 'type': 'str'},
}
def __init__(
self,
*,
primary_key: Optional[str] = None,
secondary_key: Optional[str] = None,
primary_connection_string: Optional[str] = None,
secondary_connection_string: Optional[str] = None,
**kwargs
):
super(SignalRKeys, self).__init__(**kwargs)
self.primary_key = primary_key
self.secondary_key = secondary_key
self.primary_connection_string = primary_connection_string
self.secondary_connection_string = secondary_connection_string
[docs]class SignalRNetworkACLs(msrest.serialization.Model):
"""Network ACLs for the resource.
:param default_action: Default action when no other rule matches. Possible values include:
"Allow", "Deny".
:type default_action: str or ~azure.mgmt.signalr.models.ACLAction
:param public_network: ACL for requests from public network.
:type public_network: ~azure.mgmt.signalr.models.NetworkACL
:param private_endpoints: ACLs for requests from private endpoints.
:type private_endpoints: list[~azure.mgmt.signalr.models.PrivateEndpointACL]
"""
_attribute_map = {
'default_action': {'key': 'defaultAction', 'type': 'str'},
'public_network': {'key': 'publicNetwork', 'type': 'NetworkACL'},
'private_endpoints': {'key': 'privateEndpoints', 'type': '[PrivateEndpointACL]'},
}
def __init__(
self,
*,
default_action: Optional[Union[str, "ACLAction"]] = None,
public_network: Optional["NetworkACL"] = None,
private_endpoints: Optional[List["PrivateEndpointACL"]] = None,
**kwargs
):
super(SignalRNetworkACLs, self).__init__(**kwargs)
self.default_action = default_action
self.public_network = public_network
self.private_endpoints = private_endpoints
[docs]class TrackedResource(Resource):
"""The resource model definition for a ARM tracked top level resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource - e.g. "Microsoft.SignalRService/SignalR".
:vartype type: str
:param location: The GEO location of the resource. e.g. West US | East US | North Central US |
South Central US.
:type location: str
:param tags: A set of tags. Tags of the service which is a list of key value pairs that
describe the resource.
:type tags: dict[str, str]
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
**kwargs
):
super(TrackedResource, self).__init__(**kwargs)
self.location = location
self.tags = tags
[docs]class SignalRResource(TrackedResource):
"""A class represent a resource.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar id: Fully qualified resource Id for the resource.
:vartype id: str
:ivar name: The name of the resource.
:vartype name: str
:ivar type: The type of the resource - e.g. "Microsoft.SignalRService/SignalR".
:vartype type: str
:param location: The GEO location of the resource. e.g. West US | East US | North Central US |
South Central US.
:type location: str
:param tags: A set of tags. Tags of the service which is a list of key value pairs that
describe the resource.
:type tags: dict[str, str]
:param sku: The billing information of the resource.(e.g. Free, Standard).
:type sku: ~azure.mgmt.signalr.models.ResourceSku
:param kind: The kind of the service - e.g. "SignalR" for "Microsoft.SignalRService/SignalR".
Possible values include: "SignalR", "RawWebSockets".
:type kind: str or ~azure.mgmt.signalr.models.ServiceKind
:param identity: The managed identity response.
:type identity: ~azure.mgmt.signalr.models.ManagedIdentity
:ivar system_data: Metadata pertaining to creation and last modification of the resource.
:vartype system_data: ~azure.mgmt.signalr.models.SystemData
:ivar provisioning_state: Provisioning state of the resource. Possible values include:
"Unknown", "Succeeded", "Failed", "Canceled", "Running", "Creating", "Updating", "Deleting",
"Moving".
:vartype provisioning_state: str or ~azure.mgmt.signalr.models.ProvisioningState
:ivar external_ip: The publicly accessible IP of the resource.
:vartype external_ip: str
:ivar host_name: FQDN of the service instance.
:vartype host_name: str
:ivar public_port: The publicly accessible port of the resource which is designed for
browser/client side usage.
:vartype public_port: int
:ivar server_port: The publicly accessible port of the resource which is designed for customer
server side usage.
:vartype server_port: int
:ivar version: Version of the resource. Probably you need the same or higher version of client
SDKs.
:vartype version: str
:ivar private_endpoint_connections: Private endpoint connections to the resource.
:vartype private_endpoint_connections:
list[~azure.mgmt.signalr.models.PrivateEndpointConnection]
:ivar shared_private_link_resources: The list of shared private link resources.
:vartype shared_private_link_resources:
list[~azure.mgmt.signalr.models.SharedPrivateLinkResource]
:param tls: TLS settings.
:type tls: ~azure.mgmt.signalr.models.SignalRTlsSettings
:param features: List of the featureFlags.
FeatureFlags that are not included in the parameters for the update operation will not be
modified.
And the response will only include featureFlags that are explicitly set.
When a featureFlag is not explicitly set, its globally default value will be used
But keep in mind, the default value doesn't mean "false". It varies in terms of different
FeatureFlags.
:type features: list[~azure.mgmt.signalr.models.SignalRFeature]
:param cors: Cross-Origin Resource Sharing (CORS) settings.
:type cors: ~azure.mgmt.signalr.models.SignalRCorsSettings
:param upstream: Upstream settings when the service is in server-less mode.
:type upstream: ~azure.mgmt.signalr.models.ServerlessUpstreamSettings
:param network_ac_ls: Network ACLs.
:type network_ac_ls: ~azure.mgmt.signalr.models.SignalRNetworkACLs
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'system_data': {'readonly': True},
'provisioning_state': {'readonly': True},
'external_ip': {'readonly': True},
'host_name': {'readonly': True},
'public_port': {'readonly': True},
'server_port': {'readonly': True},
'version': {'readonly': True},
'private_endpoint_connections': {'readonly': True},
'shared_private_link_resources': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'sku': {'key': 'sku', 'type': 'ResourceSku'},
'kind': {'key': 'kind', 'type': 'str'},
'identity': {'key': 'identity', 'type': 'ManagedIdentity'},
'system_data': {'key': 'systemData', 'type': 'SystemData'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
'external_ip': {'key': 'properties.externalIP', 'type': 'str'},
'host_name': {'key': 'properties.hostName', 'type': 'str'},
'public_port': {'key': 'properties.publicPort', 'type': 'int'},
'server_port': {'key': 'properties.serverPort', 'type': 'int'},
'version': {'key': 'properties.version', 'type': 'str'},
'private_endpoint_connections': {'key': 'properties.privateEndpointConnections', 'type': '[PrivateEndpointConnection]'},
'shared_private_link_resources': {'key': 'properties.sharedPrivateLinkResources', 'type': '[SharedPrivateLinkResource]'},
'tls': {'key': 'properties.tls', 'type': 'SignalRTlsSettings'},
'features': {'key': 'properties.features', 'type': '[SignalRFeature]'},
'cors': {'key': 'properties.cors', 'type': 'SignalRCorsSettings'},
'upstream': {'key': 'properties.upstream', 'type': 'ServerlessUpstreamSettings'},
'network_ac_ls': {'key': 'properties.networkACLs', 'type': 'SignalRNetworkACLs'},
}
def __init__(
self,
*,
location: Optional[str] = None,
tags: Optional[Dict[str, str]] = None,
sku: Optional["ResourceSku"] = None,
kind: Optional[Union[str, "ServiceKind"]] = None,
identity: Optional["ManagedIdentity"] = None,
tls: Optional["SignalRTlsSettings"] = None,
features: Optional[List["SignalRFeature"]] = None,
cors: Optional["SignalRCorsSettings"] = None,
upstream: Optional["ServerlessUpstreamSettings"] = None,
network_ac_ls: Optional["SignalRNetworkACLs"] = None,
**kwargs
):
super(SignalRResource, self).__init__(location=location, tags=tags, **kwargs)
self.sku = sku
self.kind = kind
self.identity = identity
self.system_data = None
self.provisioning_state = None
self.external_ip = None
self.host_name = None
self.public_port = None
self.server_port = None
self.version = None
self.private_endpoint_connections = None
self.shared_private_link_resources = None
self.tls = tls
self.features = features
self.cors = cors
self.upstream = upstream
self.network_ac_ls = network_ac_ls
[docs]class SignalRResourceList(msrest.serialization.Model):
"""Object that includes an array of resources and a possible link for next set.
:param value: List of the resources.
:type value: list[~azure.mgmt.signalr.models.SignalRResource]
:param next_link: The URL the client should use to fetch the next page (per server side
paging).
It's null for now, added for future use.
:type next_link: str
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[SignalRResource]'},
'next_link': {'key': 'nextLink', 'type': 'str'},
}
def __init__(
self,
*,
value: Optional[List["SignalRResource"]] = None,
next_link: Optional[str] = None,
**kwargs
):
super(SignalRResourceList, self).__init__(**kwargs)
self.value = value
self.next_link = next_link
[docs]class SignalRTlsSettings(msrest.serialization.Model):
"""TLS settings for the resource.
:param client_cert_enabled: Request client certificate during TLS handshake if enabled.
:type client_cert_enabled: bool
"""
_attribute_map = {
'client_cert_enabled': {'key': 'clientCertEnabled', 'type': 'bool'},
}
def __init__(
self,
*,
client_cert_enabled: Optional[bool] = None,
**kwargs
):
super(SignalRTlsSettings, self).__init__(**kwargs)
self.client_cert_enabled = client_cert_enabled
[docs]class SignalRUsage(msrest.serialization.Model):
"""Object that describes a specific usage of the resources.
:param id: Fully qualified ARM resource id.
:type id: str
:param current_value: Current value for the usage quota.
:type current_value: long
:param limit: The maximum permitted value for the usage quota. If there is no limit, this value
will be -1.
:type limit: long
:param name: Localizable String object containing the name and a localized value.
:type name: ~azure.mgmt.signalr.models.SignalRUsageName
:param unit: Representing the units of the usage quota. Possible values are: Count, Bytes,
Seconds, Percent, CountPerSecond, BytesPerSecond.
:type unit: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'current_value': {'key': 'currentValue', 'type': 'long'},
'limit': {'key': 'limit', 'type': 'long'},
'name': {'key': 'name', 'type': 'SignalRUsageName'},
'unit': {'key': 'unit', 'type': 'str'},
}
def __init__(
self,
*,
id: Optional[str] = None,
current_value: Optional[int] = None,
limit: Optional[int] = None,
name: Optional["SignalRUsageName"] = None,
unit: Optional[str] = None,
**kwargs
):
super(SignalRUsage, self).__init__(**kwargs)
self.id = id
self.current_value = current_value
self.limit = limit
self.name = name
self.unit = unit
[docs]class SignalRUsageList(msrest.serialization.Model):
"""Object that includes an array of the resource usages and a possible link for next set.
:param value: List of the resource usages.
:type value: list[~azure.mgmt.signalr.models.SignalRUsage]
:param next_link: The URL the client should use to fetch the next page (per server side
paging).
It's null for now, added for future use.
:type next_link: str
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[SignalRUsage]'},
'next_link': {'key': 'nextLink', 'type': 'str'},
}
def __init__(
self,
*,
value: Optional[List["SignalRUsage"]] = None,
next_link: Optional[str] = None,
**kwargs
):
super(SignalRUsageList, self).__init__(**kwargs)
self.value = value
self.next_link = next_link
[docs]class SignalRUsageName(msrest.serialization.Model):
"""Localizable String object containing the name and a localized value.
:param value: The identifier of the usage.
:type value: str
:param localized_value: Localized name of the usage.
:type localized_value: str
"""
_attribute_map = {
'value': {'key': 'value', 'type': 'str'},
'localized_value': {'key': 'localizedValue', 'type': 'str'},
}
def __init__(
self,
*,
value: Optional[str] = None,
localized_value: Optional[str] = None,
**kwargs
):
super(SignalRUsageName, self).__init__(**kwargs)
self.value = value
self.localized_value = localized_value
[docs]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 ~azure.mgmt.signalr.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 ~azure.mgmt.signalr.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
[docs]class UpstreamAuthSettings(msrest.serialization.Model):
"""Upstream auth settings.
:param type: Gets or sets the type of auth. None or ManagedIdentity is supported now. Possible
values include: "None", "ManagedIdentity".
:type type: str or ~azure.mgmt.signalr.models.UpstreamAuthType
:param managed_identity: Gets or sets the managed identity settings. It's required if the auth
type is set to ManagedIdentity.
:type managed_identity: ~azure.mgmt.signalr.models.ManagedIdentitySettings
"""
_attribute_map = {
'type': {'key': 'type', 'type': 'str'},
'managed_identity': {'key': 'managedIdentity', 'type': 'ManagedIdentitySettings'},
}
def __init__(
self,
*,
type: Optional[Union[str, "UpstreamAuthType"]] = None,
managed_identity: Optional["ManagedIdentitySettings"] = None,
**kwargs
):
super(UpstreamAuthSettings, self).__init__(**kwargs)
self.type = type
self.managed_identity = managed_identity
[docs]class UpstreamTemplate(msrest.serialization.Model):
"""Upstream template item settings. It defines the Upstream URL of the incoming requests.
The template defines the pattern of the event, the hub or the category of the incoming request that matches current URL template.
All required parameters must be populated in order to send to Azure.
:param hub_pattern: Gets or sets the matching pattern for hub names. If not set, it matches any
hub.
There are 3 kind of patterns supported:
.. code-block::
1. "*", it to matches any hub name
2. Combine multiple hubs with ",", for example "hub1,hub2", it matches "hub1" and "hub2"
3. The single hub name, for example, "hub1", it matches "hub1".
:type hub_pattern: str
:param event_pattern: Gets or sets the matching pattern for event names. If not set, it matches
any event.
There are 3 kind of patterns supported:
.. code-block::
1. "*", it to matches any event name
2. Combine multiple events with ",", for example "connect,disconnect", it matches event
"connect" and "disconnect"
3. The single event name, for example, "connect", it matches "connect".
:type event_pattern: str
:param category_pattern: Gets or sets the matching pattern for category names. If not set, it
matches any category.
There are 3 kind of patterns supported:
.. code-block::
1. "*", it to matches any category name
2. Combine multiple categories with ",", for example "connections,messages", it matches
category "connections" and "messages"
3. The single category name, for example, "connections", it matches the category
"connections".
:type category_pattern: str
:param url_template: Required. Gets or sets the Upstream URL template. You can use 3 predefined
parameters {hub}, {category} {event} inside the template, the value of the Upstream URL is
dynamically calculated when the client request comes in.
For example, if the urlTemplate is ``http://example.com/{hub}/api/{event}``\ , with a client
request from hub ``chat`` connects, it will first POST to this URL:
``http://example.com/chat/api/connect``.
:type url_template: str
:param auth: Gets or sets the auth settings for an upstream. If not set, no auth is used for
upstream messages.
:type auth: ~azure.mgmt.signalr.models.UpstreamAuthSettings
"""
_validation = {
'url_template': {'required': True},
}
_attribute_map = {
'hub_pattern': {'key': 'hubPattern', 'type': 'str'},
'event_pattern': {'key': 'eventPattern', 'type': 'str'},
'category_pattern': {'key': 'categoryPattern', 'type': 'str'},
'url_template': {'key': 'urlTemplate', 'type': 'str'},
'auth': {'key': 'auth', 'type': 'UpstreamAuthSettings'},
}
def __init__(
self,
*,
url_template: str,
hub_pattern: Optional[str] = None,
event_pattern: Optional[str] = None,
category_pattern: Optional[str] = None,
auth: Optional["UpstreamAuthSettings"] = None,
**kwargs
):
super(UpstreamTemplate, self).__init__(**kwargs)
self.hub_pattern = hub_pattern
self.event_pattern = event_pattern
self.category_pattern = category_pattern
self.url_template = url_template
self.auth = auth
[docs]class UserAssignedIdentityProperty(msrest.serialization.Model):
"""Properties of user assigned identity.
Variables are only populated by the server, and will be ignored when sending a request.
:ivar principal_id: Get the principal id for the user assigned identity.
:vartype principal_id: str
:ivar client_id: Get the client id for the user assigned identity.
:vartype client_id: str
"""
_validation = {
'principal_id': {'readonly': True},
'client_id': {'readonly': True},
}
_attribute_map = {
'principal_id': {'key': 'principalId', 'type': 'str'},
'client_id': {'key': 'clientId', 'type': 'str'},
}
def __init__(
self,
**kwargs
):
super(UserAssignedIdentityProperty, self).__init__(**kwargs)
self.principal_id = None
self.client_id = None