# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
from . import outputs
from ._enums import *

__all__ = [
    'ManagedIdentityResponse',
    'ManagedIdentitySettingsResponse',
    'NetworkACLResponse',
    'PrivateEndpointACLResponse',
    'PrivateEndpointConnectionResponse',
    'PrivateEndpointResponse',
    'PrivateLinkServiceConnectionStateResponse',
    'ResourceSkuResponse',
    'ServerlessUpstreamSettingsResponse',
    'SignalRCorsSettingsResponse',
    'SignalRFeatureResponse',
    'SignalRNetworkACLsResponse',
    'SignalRTlsSettingsResponse',
    'UpstreamAuthSettingsResponse',
    'UpstreamTemplateResponse',
    'UserAssignedIdentityPropertyResponse',
]

@pulumi.output_type
class ManagedIdentityResponse(dict):
    """
    A class represent managed identities used for request and response
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "userAssignedIdentities":
            suggest = "user_assigned_identities"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagedIdentityResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagedIdentityResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagedIdentityResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 principal_id: str,
                 tenant_id: str,
                 type: Optional[str] = None,
                 user_assigned_identities: Optional[Mapping[str, 'outputs.UserAssignedIdentityPropertyResponse']] = None):
        """
        A class represent managed identities used for request and response
        :param str principal_id: Get the principal id for the system assigned identity.
               Only be used in response.
        :param str tenant_id: Get the tenant id for the system assigned identity.
               Only be used in response
        :param str type: Represent the identity type: systemAssigned, userAssigned, None
        :param Mapping[str, 'UserAssignedIdentityPropertyResponse'] user_assigned_identities: Get or set the user assigned identities
        """
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user_assigned_identities is not None:
            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        Get the principal id for the system assigned identity.
        Only be used in response.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        Get the tenant id for the system assigned identity.
        Only be used in response
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Represent the identity type: systemAssigned, userAssigned, None
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="userAssignedIdentities")
    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.UserAssignedIdentityPropertyResponse']]:
        """
        Get or set the user assigned identities
        """
        return pulumi.get(self, "user_assigned_identities")


@pulumi.output_type
class ManagedIdentitySettingsResponse(dict):
    """
    Managed identity settings for upstream.
    """
    def __init__(__self__, *,
                 resource: Optional[str] = None):
        """
        Managed identity settings for upstream.
        :param str resource: The Resource indicating the App ID URI of the target resource.
               It also appears in the aud (audience) claim of the issued token.
        """
        if resource is not None:
            pulumi.set(__self__, "resource", resource)

    @property
    @pulumi.getter
    def resource(self) -> Optional[str]:
        """
        The Resource indicating the App ID URI of the target resource.
        It also appears in the aud (audience) claim of the issued token.
        """
        return pulumi.get(self, "resource")


@pulumi.output_type
class NetworkACLResponse(dict):
    """
    Network ACL
    """
    def __init__(__self__, *,
                 allow: Optional[Sequence[str]] = None,
                 deny: Optional[Sequence[str]] = None):
        """
        Network ACL
        :param Sequence[str] allow: Allowed request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI.
        :param Sequence[str] deny: Denied request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI.
        """
        if allow is not None:
            pulumi.set(__self__, "allow", allow)
        if deny is not None:
            pulumi.set(__self__, "deny", deny)

    @property
    @pulumi.getter
    def allow(self) -> Optional[Sequence[str]]:
        """
        Allowed request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI.
        """
        return pulumi.get(self, "allow")

    @property
    @pulumi.getter
    def deny(self) -> Optional[Sequence[str]]:
        """
        Denied request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI.
        """
        return pulumi.get(self, "deny")


@pulumi.output_type
class PrivateEndpointACLResponse(dict):
    """
    ACL for a private endpoint
    """
    def __init__(__self__, *,
                 name: str,
                 allow: Optional[Sequence[str]] = None,
                 deny: Optional[Sequence[str]] = None):
        """
        ACL for a private endpoint
        :param str name: Name of the private endpoint connection
        :param Sequence[str] allow: Allowed request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI.
        :param Sequence[str] deny: Denied request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI.
        """
        pulumi.set(__self__, "name", name)
        if allow is not None:
            pulumi.set(__self__, "allow", allow)
        if deny is not None:
            pulumi.set(__self__, "deny", deny)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the private endpoint connection
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def allow(self) -> Optional[Sequence[str]]:
        """
        Allowed request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI.
        """
        return pulumi.get(self, "allow")

    @property
    @pulumi.getter
    def deny(self) -> Optional[Sequence[str]]:
        """
        Denied request types. The value can be one or more of: ClientConnection, ServerConnection, RESTAPI.
        """
        return pulumi.get(self, "deny")


@pulumi.output_type
class PrivateEndpointConnectionResponse(dict):
    """
    A private endpoint connection to SignalR resource
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "provisioningState":
            suggest = "provisioning_state"
        elif key == "privateEndpoint":
            suggest = "private_endpoint"
        elif key == "privateLinkServiceConnectionState":
            suggest = "private_link_service_connection_state"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateEndpointConnectionResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateEndpointConnectionResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateEndpointConnectionResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 name: str,
                 provisioning_state: str,
                 type: str,
                 private_endpoint: Optional['outputs.PrivateEndpointResponse'] = None,
                 private_link_service_connection_state: Optional['outputs.PrivateLinkServiceConnectionStateResponse'] = None):
        """
        A private endpoint connection to SignalR resource
        :param str id: Fully qualified resource Id for the resource.
        :param str name: The name of the resource.
        :param str provisioning_state: Provisioning state of the private endpoint connection
        :param str type: The type of the resource - e.g. "Microsoft.SignalRService/SignalR"
        :param 'PrivateEndpointResponse' private_endpoint: Private endpoint associated with the private endpoint connection
        :param 'PrivateLinkServiceConnectionStateResponse' private_link_service_connection_state: Connection state
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "provisioning_state", provisioning_state)
        pulumi.set(__self__, "type", type)
        if private_endpoint is not None:
            pulumi.set(__self__, "private_endpoint", private_endpoint)
        if private_link_service_connection_state is not None:
            pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Fully qualified resource Id for the resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the resource.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="provisioningState")
    def provisioning_state(self) -> str:
        """
        Provisioning state of the private endpoint connection
        """
        return pulumi.get(self, "provisioning_state")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the resource - e.g. "Microsoft.SignalRService/SignalR"
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="privateEndpoint")
    def private_endpoint(self) -> Optional['outputs.PrivateEndpointResponse']:
        """
        Private endpoint associated with the private endpoint connection
        """
        return pulumi.get(self, "private_endpoint")

    @property
    @pulumi.getter(name="privateLinkServiceConnectionState")
    def private_link_service_connection_state(self) -> Optional['outputs.PrivateLinkServiceConnectionStateResponse']:
        """
        Connection state
        """
        return pulumi.get(self, "private_link_service_connection_state")


@pulumi.output_type
class PrivateEndpointResponse(dict):
    """
    Private endpoint
    """
    def __init__(__self__, *,
                 id: Optional[str] = None):
        """
        Private endpoint
        :param str id: Full qualified Id of the private endpoint
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Full qualified Id of the private endpoint
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class PrivateLinkServiceConnectionStateResponse(dict):
    """
    Connection state of the private endpoint connection
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "actionsRequired":
            suggest = "actions_required"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkServiceConnectionStateResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateLinkServiceConnectionStateResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateLinkServiceConnectionStateResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 actions_required: Optional[str] = None,
                 description: Optional[str] = None,
                 status: Optional[str] = None):
        """
        Connection state of the private endpoint connection
        :param str actions_required: A message indicating if changes on the service provider require any updates on the consumer.
        :param str description: The reason for approval/rejection of the connection.
        :param str status: Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
        """
        if actions_required is not None:
            pulumi.set(__self__, "actions_required", actions_required)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="actionsRequired")
    def actions_required(self) -> Optional[str]:
        """
        A message indicating if changes on the service provider require any updates on the consumer.
        """
        return pulumi.get(self, "actions_required")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The reason for approval/rejection of the connection.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def status(self) -> Optional[str]:
        """
        Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class ResourceSkuResponse(dict):
    """
    The billing information of the resource.
    """
    def __init__(__self__, *,
                 family: str,
                 name: str,
                 size: str,
                 capacity: Optional[int] = None,
                 tier: Optional[str] = None):
        """
        The billing information of the resource.
        :param str family: Not used. Retained for future use.
        :param str name: The name of the SKU. Required.
               
               Allowed values: Standard_S1, Free_F1
        :param str size: Not used. Retained for future use.
        :param int capacity: Optional, integer. The unit count of SignalR resource. 1 by default.
               
               If present, following values are allowed:
                   Free: 1
                   Standard: 1,2,5,10,20,50,100
        :param str tier: Optional tier of this particular SKU. 'Standard' or 'Free'. 
               
               `Basic` is deprecated, use `Standard` instead.
        """
        pulumi.set(__self__, "family", family)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "size", size)
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if tier is not None:
            pulumi.set(__self__, "tier", tier)

    @property
    @pulumi.getter
    def family(self) -> str:
        """
        Not used. Retained for future use.
        """
        return pulumi.get(self, "family")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the SKU. Required.
        
        Allowed values: Standard_S1, Free_F1
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def size(self) -> str:
        """
        Not used. Retained for future use.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def capacity(self) -> Optional[int]:
        """
        Optional, integer. The unit count of SignalR resource. 1 by default.
        
        If present, following values are allowed:
            Free: 1
            Standard: 1,2,5,10,20,50,100
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def tier(self) -> Optional[str]:
        """
        Optional tier of this particular SKU. 'Standard' or 'Free'. 
        
        `Basic` is deprecated, use `Standard` instead.
        """
        return pulumi.get(self, "tier")


@pulumi.output_type
class ServerlessUpstreamSettingsResponse(dict):
    """
    The settings for the Upstream when the service is in server-less mode.
    """
    def __init__(__self__, *,
                 templates: Optional[Sequence['outputs.UpstreamTemplateResponse']] = None):
        """
        The settings for the Upstream when the service is in server-less mode.
        :param Sequence['UpstreamTemplateResponse'] templates: Gets or sets the list of Upstream URL templates. Order matters, and the first matching template takes effects.
        """
        if templates is not None:
            pulumi.set(__self__, "templates", templates)

    @property
    @pulumi.getter
    def templates(self) -> Optional[Sequence['outputs.UpstreamTemplateResponse']]:
        """
        Gets or sets the list of Upstream URL templates. Order matters, and the first matching template takes effects.
        """
        return pulumi.get(self, "templates")


@pulumi.output_type
class SignalRCorsSettingsResponse(dict):
    """
    Cross-Origin Resource Sharing (CORS) settings.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedOrigins":
            suggest = "allowed_origins"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SignalRCorsSettingsResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SignalRCorsSettingsResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SignalRCorsSettingsResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_origins: Optional[Sequence[str]] = None):
        """
        Cross-Origin Resource Sharing (CORS) settings.
        :param Sequence[str] allowed_origins: Gets or sets the list of origins that should be allowed to make cross-origin calls (for example: http://example.com:12345). Use "*" to allow all. If omitted, allow all by default.
        """
        if allowed_origins is not None:
            pulumi.set(__self__, "allowed_origins", allowed_origins)

    @property
    @pulumi.getter(name="allowedOrigins")
    def allowed_origins(self) -> Optional[Sequence[str]]:
        """
        Gets or sets the list of origins that should be allowed to make cross-origin calls (for example: http://example.com:12345). Use "*" to allow all. If omitted, allow all by default.
        """
        return pulumi.get(self, "allowed_origins")


@pulumi.output_type
class SignalRFeatureResponse(dict):
    """
    Feature of a SignalR resource, which controls the SignalR runtime behavior.
    """
    def __init__(__self__, *,
                 flag: str,
                 value: str,
                 properties: Optional[Mapping[str, str]] = None):
        """
        Feature of a SignalR resource, which controls the SignalR runtime behavior.
        :param str flag: 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.
        :param str value: Value of the feature flag. See Azure SignalR service document https://docs.microsoft.com/azure/azure-signalr/ for allowed values.
        :param Mapping[str, str] properties: Optional properties related to this feature.
        """
        pulumi.set(__self__, "flag", flag)
        pulumi.set(__self__, "value", value)
        if properties is not None:
            pulumi.set(__self__, "properties", properties)

    @property
    @pulumi.getter
    def flag(self) -> str:
        """
        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.
        """
        return pulumi.get(self, "flag")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Value of the feature flag. See Azure SignalR service document https://docs.microsoft.com/azure/azure-signalr/ for allowed values.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def properties(self) -> Optional[Mapping[str, str]]:
        """
        Optional properties related to this feature.
        """
        return pulumi.get(self, "properties")


@pulumi.output_type
class SignalRNetworkACLsResponse(dict):
    """
    Network ACLs for the resource
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultAction":
            suggest = "default_action"
        elif key == "privateEndpoints":
            suggest = "private_endpoints"
        elif key == "publicNetwork":
            suggest = "public_network"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SignalRNetworkACLsResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SignalRNetworkACLsResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SignalRNetworkACLsResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_action: Optional[str] = None,
                 private_endpoints: Optional[Sequence['outputs.PrivateEndpointACLResponse']] = None,
                 public_network: Optional['outputs.NetworkACLResponse'] = None):
        """
        Network ACLs for the resource
        :param str default_action: Default action when no other rule matches
        :param Sequence['PrivateEndpointACLResponse'] private_endpoints: ACLs for requests from private endpoints
        :param 'NetworkACLResponse' public_network: ACL for requests from public network
        """
        if default_action is None:
            default_action = 'Deny'
        if default_action is not None:
            pulumi.set(__self__, "default_action", default_action)
        if private_endpoints is not None:
            pulumi.set(__self__, "private_endpoints", private_endpoints)
        if public_network is not None:
            pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="defaultAction")
    def default_action(self) -> Optional[str]:
        """
        Default action when no other rule matches
        """
        return pulumi.get(self, "default_action")

    @property
    @pulumi.getter(name="privateEndpoints")
    def private_endpoints(self) -> Optional[Sequence['outputs.PrivateEndpointACLResponse']]:
        """
        ACLs for requests from private endpoints
        """
        return pulumi.get(self, "private_endpoints")

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> Optional['outputs.NetworkACLResponse']:
        """
        ACL for requests from public network
        """
        return pulumi.get(self, "public_network")


@pulumi.output_type
class SignalRTlsSettingsResponse(dict):
    """
    TLS settings for the resource
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCertEnabled":
            suggest = "client_cert_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SignalRTlsSettingsResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SignalRTlsSettingsResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SignalRTlsSettingsResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_cert_enabled: Optional[bool] = None):
        """
        TLS settings for the resource
        :param bool client_cert_enabled: Request client certificate during TLS handshake if enabled
        """
        if client_cert_enabled is not None:
            pulumi.set(__self__, "client_cert_enabled", client_cert_enabled)

    @property
    @pulumi.getter(name="clientCertEnabled")
    def client_cert_enabled(self) -> Optional[bool]:
        """
        Request client certificate during TLS handshake if enabled
        """
        return pulumi.get(self, "client_cert_enabled")


@pulumi.output_type
class UpstreamAuthSettingsResponse(dict):
    """
    Upstream auth settings.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "managedIdentity":
            suggest = "managed_identity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UpstreamAuthSettingsResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UpstreamAuthSettingsResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UpstreamAuthSettingsResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 managed_identity: Optional['outputs.ManagedIdentitySettingsResponse'] = None,
                 type: Optional[str] = None):
        """
        Upstream auth settings.
        :param 'ManagedIdentitySettingsResponse' managed_identity: Gets or sets the managed identity settings. It's required if the auth type is set to ManagedIdentity.
        :param str type: Gets or sets the type of auth. None or ManagedIdentity is supported now.
        """
        if managed_identity is not None:
            pulumi.set(__self__, "managed_identity", managed_identity)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="managedIdentity")
    def managed_identity(self) -> Optional['outputs.ManagedIdentitySettingsResponse']:
        """
        Gets or sets the managed identity settings. It's required if the auth type is set to ManagedIdentity.
        """
        return pulumi.get(self, "managed_identity")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Gets or sets the type of auth. None or ManagedIdentity is supported now.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class UpstreamTemplateResponse(dict):
    """
    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.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "urlTemplate":
            suggest = "url_template"
        elif key == "categoryPattern":
            suggest = "category_pattern"
        elif key == "eventPattern":
            suggest = "event_pattern"
        elif key == "hubPattern":
            suggest = "hub_pattern"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UpstreamTemplateResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UpstreamTemplateResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UpstreamTemplateResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url_template: str,
                 auth: Optional['outputs.UpstreamAuthSettingsResponse'] = None,
                 category_pattern: Optional[str] = None,
                 event_pattern: Optional[str] = None,
                 hub_pattern: Optional[str] = None):
        """
        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.
        :param str url_template: 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`.
        :param 'UpstreamAuthSettingsResponse' auth: Gets or sets the auth settings for an upstream. If not set, no auth is used for upstream messages.
        :param str 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:
                   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"
        :param str 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:
                   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"
        :param str 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:
                   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"
        """
        pulumi.set(__self__, "url_template", url_template)
        if auth is not None:
            pulumi.set(__self__, "auth", auth)
        if category_pattern is not None:
            pulumi.set(__self__, "category_pattern", category_pattern)
        if event_pattern is not None:
            pulumi.set(__self__, "event_pattern", event_pattern)
        if hub_pattern is not None:
            pulumi.set(__self__, "hub_pattern", hub_pattern)

    @property
    @pulumi.getter(name="urlTemplate")
    def url_template(self) -> str:
        """
        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`.
        """
        return pulumi.get(self, "url_template")

    @property
    @pulumi.getter
    def auth(self) -> Optional['outputs.UpstreamAuthSettingsResponse']:
        """
        Gets or sets the auth settings for an upstream. If not set, no auth is used for upstream messages.
        """
        return pulumi.get(self, "auth")

    @property
    @pulumi.getter(name="categoryPattern")
    def category_pattern(self) -> Optional[str]:
        """
        Gets or sets the matching pattern for category names. If not set, it matches any category.
        There are 3 kind of patterns supported:
            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"
        """
        return pulumi.get(self, "category_pattern")

    @property
    @pulumi.getter(name="eventPattern")
    def event_pattern(self) -> Optional[str]:
        """
        Gets or sets the matching pattern for event names. If not set, it matches any event.
        There are 3 kind of patterns supported:
            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"
        """
        return pulumi.get(self, "event_pattern")

    @property
    @pulumi.getter(name="hubPattern")
    def hub_pattern(self) -> Optional[str]:
        """
        Gets or sets the matching pattern for hub names. If not set, it matches any hub.
        There are 3 kind of patterns supported:
            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"
        """
        return pulumi.get(self, "hub_pattern")


@pulumi.output_type
class UserAssignedIdentityPropertyResponse(dict):
    """
    Properties of user assigned identity.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "principalId":
            suggest = "principal_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserAssignedIdentityPropertyResponse. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserAssignedIdentityPropertyResponse.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserAssignedIdentityPropertyResponse.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_id: str,
                 principal_id: str):
        """
        Properties of user assigned identity.
        :param str client_id: Get the client id for the user assigned identity
        :param str principal_id: Get the principal id for the user assigned identity
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "principal_id", principal_id)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        Get the client id for the user assigned identity
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        Get the principal id for the user assigned identity
        """
        return pulumi.get(self, "principal_id")


