# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'ServiceCorArgs',
    'ServiceIdentityArgs',
    'ServiceLiveTraceArgs',
    'ServiceNetworkAclPrivateEndpointArgs',
    'ServiceNetworkAclPublicNetworkArgs',
    'ServiceSkuArgs',
    'ServiceUpstreamEndpointArgs',
]

@pulumi.input_type
class ServiceCorArgs:
    def __init__(__self__, *,
                 allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_origins: A list of origins which should be able to make cross-origin calls. `*` can be used to allow all calls.
        """
        ServiceCorArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            allowed_origins=allowed_origins,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             allowed_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if allowed_origins is None and 'allowedOrigins' in kwargs:
            allowed_origins = kwargs['allowedOrigins']
        if allowed_origins is None:
            raise TypeError("Missing 'allowed_origins' argument")

        _setter("allowed_origins", allowed_origins)

    @property
    @pulumi.getter(name="allowedOrigins")
    def allowed_origins(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of origins which should be able to make cross-origin calls. `*` can be used to allow all calls.
        """
        return pulumi.get(self, "allowed_origins")

    @allowed_origins.setter
    def allowed_origins(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_origins", value)


@pulumi.input_type
class ServiceIdentityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 identity_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 principal_id: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Specifies the type of Managed Service Identity that should be configured on this signalR. Possible values are `SystemAssigned`, `UserAssigned`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] identity_ids: Specifies a list of User Assigned Managed Identity IDs to be assigned to this signalR.
               
               > **NOTE:** This is required when `type` is set to `UserAssigned`
        """
        ServiceIdentityArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            type=type,
            identity_ids=identity_ids,
            principal_id=principal_id,
            tenant_id=tenant_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             type: Optional[pulumi.Input[str]] = None,
             identity_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             principal_id: Optional[pulumi.Input[str]] = None,
             tenant_id: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if type is None:
            raise TypeError("Missing 'type' argument")
        if identity_ids is None and 'identityIds' in kwargs:
            identity_ids = kwargs['identityIds']
        if principal_id is None and 'principalId' in kwargs:
            principal_id = kwargs['principalId']
        if tenant_id is None and 'tenantId' in kwargs:
            tenant_id = kwargs['tenantId']

        _setter("type", type)
        if identity_ids is not None:
            _setter("identity_ids", identity_ids)
        if principal_id is not None:
            _setter("principal_id", principal_id)
        if tenant_id is not None:
            _setter("tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Specifies the type of Managed Service Identity that should be configured on this signalR. Possible values are `SystemAssigned`, `UserAssigned`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of User Assigned Managed Identity IDs to be assigned to this signalR.

        > **NOTE:** This is required when `type` is set to `UserAssigned`
        """
        return pulumi.get(self, "identity_ids")

    @identity_ids.setter
    def identity_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "identity_ids", value)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "principal_id")

    @principal_id.setter
    def principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "principal_id", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)


@pulumi.input_type
class ServiceLiveTraceArgs:
    def __init__(__self__, *,
                 connectivity_logs_enabled: Optional[pulumi.Input[bool]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 http_request_logs_enabled: Optional[pulumi.Input[bool]] = None,
                 messaging_logs_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] connectivity_logs_enabled: Whether the log category `ConnectivityLogs` is enabled? Defaults to `true`
        :param pulumi.Input[bool] enabled: Whether the live trace is enabled? Defaults to `true`.
        :param pulumi.Input[bool] http_request_logs_enabled: Whether the log category `HttpRequestLogs` is enabled? Defaults to `true`
        :param pulumi.Input[bool] messaging_logs_enabled: Whether the log category `MessagingLogs` is enabled? Defaults to `true`
        """
        ServiceLiveTraceArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            connectivity_logs_enabled=connectivity_logs_enabled,
            enabled=enabled,
            http_request_logs_enabled=http_request_logs_enabled,
            messaging_logs_enabled=messaging_logs_enabled,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             connectivity_logs_enabled: Optional[pulumi.Input[bool]] = None,
             enabled: Optional[pulumi.Input[bool]] = None,
             http_request_logs_enabled: Optional[pulumi.Input[bool]] = None,
             messaging_logs_enabled: Optional[pulumi.Input[bool]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if connectivity_logs_enabled is None and 'connectivityLogsEnabled' in kwargs:
            connectivity_logs_enabled = kwargs['connectivityLogsEnabled']
        if http_request_logs_enabled is None and 'httpRequestLogsEnabled' in kwargs:
            http_request_logs_enabled = kwargs['httpRequestLogsEnabled']
        if messaging_logs_enabled is None and 'messagingLogsEnabled' in kwargs:
            messaging_logs_enabled = kwargs['messagingLogsEnabled']

        if connectivity_logs_enabled is not None:
            _setter("connectivity_logs_enabled", connectivity_logs_enabled)
        if enabled is not None:
            _setter("enabled", enabled)
        if http_request_logs_enabled is not None:
            _setter("http_request_logs_enabled", http_request_logs_enabled)
        if messaging_logs_enabled is not None:
            _setter("messaging_logs_enabled", messaging_logs_enabled)

    @property
    @pulumi.getter(name="connectivityLogsEnabled")
    def connectivity_logs_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the log category `ConnectivityLogs` is enabled? Defaults to `true`
        """
        return pulumi.get(self, "connectivity_logs_enabled")

    @connectivity_logs_enabled.setter
    def connectivity_logs_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "connectivity_logs_enabled", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the live trace is enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="httpRequestLogsEnabled")
    def http_request_logs_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the log category `HttpRequestLogs` is enabled? Defaults to `true`
        """
        return pulumi.get(self, "http_request_logs_enabled")

    @http_request_logs_enabled.setter
    def http_request_logs_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "http_request_logs_enabled", value)

    @property
    @pulumi.getter(name="messagingLogsEnabled")
    def messaging_logs_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the log category `MessagingLogs` is enabled? Defaults to `true`
        """
        return pulumi.get(self, "messaging_logs_enabled")

    @messaging_logs_enabled.setter
    def messaging_logs_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "messaging_logs_enabled", value)


@pulumi.input_type
class ServiceNetworkAclPrivateEndpointArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 allowed_request_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 denied_request_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] id: The ID of the Private Endpoint which is based on the SignalR service.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_request_types: The allowed request types for the Private Endpoint Connection. Possible values are `ClientConnection`, `ServerConnection`, `RESTAPI` and `Trace`.
               
               > **Note:** When `default_action` is `Allow`, `allowed_request_types`cannot be set.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] denied_request_types: The denied request types for the Private Endpoint Connection. Possible values are `ClientConnection`, `ServerConnection`, `RESTAPI` and `Trace`.
               
               > **Note:** When `default_action` is `Deny`, `denied_request_types`cannot be set.
               
               > **Note:** `allowed_request_types` - (Optional) and `denied_request_types` cannot be set together.
        """
        ServiceNetworkAclPrivateEndpointArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            id=id,
            allowed_request_types=allowed_request_types,
            denied_request_types=denied_request_types,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             id: Optional[pulumi.Input[str]] = None,
             allowed_request_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             denied_request_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if id is None:
            raise TypeError("Missing 'id' argument")
        if allowed_request_types is None and 'allowedRequestTypes' in kwargs:
            allowed_request_types = kwargs['allowedRequestTypes']
        if denied_request_types is None and 'deniedRequestTypes' in kwargs:
            denied_request_types = kwargs['deniedRequestTypes']

        _setter("id", id)
        if allowed_request_types is not None:
            _setter("allowed_request_types", allowed_request_types)
        if denied_request_types is not None:
            _setter("denied_request_types", denied_request_types)

    @property
    @pulumi.getter
    def id(self) -> pulumi.Input[str]:
        """
        The ID of the Private Endpoint which is based on the SignalR service.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="allowedRequestTypes")
    def allowed_request_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The allowed request types for the Private Endpoint Connection. Possible values are `ClientConnection`, `ServerConnection`, `RESTAPI` and `Trace`.

        > **Note:** When `default_action` is `Allow`, `allowed_request_types`cannot be set.
        """
        return pulumi.get(self, "allowed_request_types")

    @allowed_request_types.setter
    def allowed_request_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_request_types", value)

    @property
    @pulumi.getter(name="deniedRequestTypes")
    def denied_request_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The denied request types for the Private Endpoint Connection. Possible values are `ClientConnection`, `ServerConnection`, `RESTAPI` and `Trace`.

        > **Note:** When `default_action` is `Deny`, `denied_request_types`cannot be set.

        > **Note:** `allowed_request_types` - (Optional) and `denied_request_types` cannot be set together.
        """
        return pulumi.get(self, "denied_request_types")

    @denied_request_types.setter
    def denied_request_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "denied_request_types", value)


@pulumi.input_type
class ServiceNetworkAclPublicNetworkArgs:
    def __init__(__self__, *,
                 allowed_request_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 denied_request_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_request_types: The allowed request types for the public network. Possible values are `ClientConnection`, `ServerConnection`, `RESTAPI` and `Trace`.
               
               > **Note:** When `default_action` is `Allow`, `allowed_request_types`cannot be set.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] denied_request_types: The denied request types for the public network. Possible values are `ClientConnection`, `ServerConnection`, `RESTAPI` and `Trace`.
               
               > **Note:** When `default_action` is `Deny`, `denied_request_types`cannot be set.
               
               > **Note:** `allowed_request_types` - (Optional) and `denied_request_types` cannot be set together.
        """
        ServiceNetworkAclPublicNetworkArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            allowed_request_types=allowed_request_types,
            denied_request_types=denied_request_types,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             allowed_request_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             denied_request_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if allowed_request_types is None and 'allowedRequestTypes' in kwargs:
            allowed_request_types = kwargs['allowedRequestTypes']
        if denied_request_types is None and 'deniedRequestTypes' in kwargs:
            denied_request_types = kwargs['deniedRequestTypes']

        if allowed_request_types is not None:
            _setter("allowed_request_types", allowed_request_types)
        if denied_request_types is not None:
            _setter("denied_request_types", denied_request_types)

    @property
    @pulumi.getter(name="allowedRequestTypes")
    def allowed_request_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The allowed request types for the public network. Possible values are `ClientConnection`, `ServerConnection`, `RESTAPI` and `Trace`.

        > **Note:** When `default_action` is `Allow`, `allowed_request_types`cannot be set.
        """
        return pulumi.get(self, "allowed_request_types")

    @allowed_request_types.setter
    def allowed_request_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_request_types", value)

    @property
    @pulumi.getter(name="deniedRequestTypes")
    def denied_request_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The denied request types for the public network. Possible values are `ClientConnection`, `ServerConnection`, `RESTAPI` and `Trace`.

        > **Note:** When `default_action` is `Deny`, `denied_request_types`cannot be set.

        > **Note:** `allowed_request_types` - (Optional) and `denied_request_types` cannot be set together.
        """
        return pulumi.get(self, "denied_request_types")

    @denied_request_types.setter
    def denied_request_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "denied_request_types", value)


@pulumi.input_type
class ServiceSkuArgs:
    def __init__(__self__, *,
                 capacity: pulumi.Input[int],
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[int] capacity: Specifies the number of units associated with this SignalR service. Valid values are `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90` and `100`.
        :param pulumi.Input[str] name: Specifies which tier to use. Valid values are `Free_F1`, `Standard_S1` and `Premium_P1`.
        """
        ServiceSkuArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            capacity=capacity,
            name=name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             capacity: Optional[pulumi.Input[int]] = None,
             name: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if capacity is None:
            raise TypeError("Missing 'capacity' argument")
        if name is None:
            raise TypeError("Missing 'name' argument")

        _setter("capacity", capacity)
        _setter("name", name)

    @property
    @pulumi.getter
    def capacity(self) -> pulumi.Input[int]:
        """
        Specifies the number of units associated with this SignalR service. Valid values are `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90` and `100`.
        """
        return pulumi.get(self, "capacity")

    @capacity.setter
    def capacity(self, value: pulumi.Input[int]):
        pulumi.set(self, "capacity", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Specifies which tier to use. Valid values are `Free_F1`, `Standard_S1` and `Premium_P1`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class ServiceUpstreamEndpointArgs:
    def __init__(__self__, *,
                 category_patterns: pulumi.Input[Sequence[pulumi.Input[str]]],
                 event_patterns: pulumi.Input[Sequence[pulumi.Input[str]]],
                 hub_patterns: pulumi.Input[Sequence[pulumi.Input[str]]],
                 url_template: pulumi.Input[str],
                 user_assigned_identity_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] category_patterns: The categories to match on, or `*` for all.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] event_patterns: The events to match on, or `*` for all.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] hub_patterns: The hubs to match on, or `*` for all.
        :param pulumi.Input[str] url_template: The upstream URL Template. This can be a url or a template such as `http://host.com/{hub}/api/{category}/{event}`.
        :param pulumi.Input[str] user_assigned_identity_id: Specifies the Managed Identity IDs to be assigned to this signalR upstream setting by using resource uuid as both system assigned and user assigned identity is supported.
        """
        ServiceUpstreamEndpointArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            category_patterns=category_patterns,
            event_patterns=event_patterns,
            hub_patterns=hub_patterns,
            url_template=url_template,
            user_assigned_identity_id=user_assigned_identity_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             category_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             event_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             hub_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             url_template: Optional[pulumi.Input[str]] = None,
             user_assigned_identity_id: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if category_patterns is None and 'categoryPatterns' in kwargs:
            category_patterns = kwargs['categoryPatterns']
        if category_patterns is None:
            raise TypeError("Missing 'category_patterns' argument")
        if event_patterns is None and 'eventPatterns' in kwargs:
            event_patterns = kwargs['eventPatterns']
        if event_patterns is None:
            raise TypeError("Missing 'event_patterns' argument")
        if hub_patterns is None and 'hubPatterns' in kwargs:
            hub_patterns = kwargs['hubPatterns']
        if hub_patterns is None:
            raise TypeError("Missing 'hub_patterns' argument")
        if url_template is None and 'urlTemplate' in kwargs:
            url_template = kwargs['urlTemplate']
        if url_template is None:
            raise TypeError("Missing 'url_template' argument")
        if user_assigned_identity_id is None and 'userAssignedIdentityId' in kwargs:
            user_assigned_identity_id = kwargs['userAssignedIdentityId']

        _setter("category_patterns", category_patterns)
        _setter("event_patterns", event_patterns)
        _setter("hub_patterns", hub_patterns)
        _setter("url_template", url_template)
        if user_assigned_identity_id is not None:
            _setter("user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="categoryPatterns")
    def category_patterns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The categories to match on, or `*` for all.
        """
        return pulumi.get(self, "category_patterns")

    @category_patterns.setter
    def category_patterns(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "category_patterns", value)

    @property
    @pulumi.getter(name="eventPatterns")
    def event_patterns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The events to match on, or `*` for all.
        """
        return pulumi.get(self, "event_patterns")

    @event_patterns.setter
    def event_patterns(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "event_patterns", value)

    @property
    @pulumi.getter(name="hubPatterns")
    def hub_patterns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The hubs to match on, or `*` for all.
        """
        return pulumi.get(self, "hub_patterns")

    @hub_patterns.setter
    def hub_patterns(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "hub_patterns", value)

    @property
    @pulumi.getter(name="urlTemplate")
    def url_template(self) -> pulumi.Input[str]:
        """
        The upstream URL Template. This can be a url or a template such as `http://host.com/{hub}/api/{category}/{event}`.
        """
        return pulumi.get(self, "url_template")

    @url_template.setter
    def url_template(self, value: pulumi.Input[str]):
        pulumi.set(self, "url_template", value)

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Managed Identity IDs to be assigned to this signalR upstream setting by using resource uuid as both system assigned and user assigned identity is supported.
        """
        return pulumi.get(self, "user_assigned_identity_id")

    @user_assigned_identity_id.setter
    def user_assigned_identity_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_assigned_identity_id", value)


