# 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 ._enums import *

__all__ = [
    'AuthorizationActionMappingArgs',
    'DefaultRolloutPropertiesSpecificationArgs',
    'DefaultRolloutPropertiesStatusArgs',
    'DefaultRolloutPropertiesArgs',
    'DefaultRolloutSpecificationCanaryArgs',
    'DefaultRolloutSpecificationExpeditedRolloutArgs',
    'DefaultRolloutSpecificationHighTrafficArgs',
    'DefaultRolloutSpecificationLowTrafficArgs',
    'DefaultRolloutSpecificationMediumTrafficArgs',
    'DefaultRolloutSpecificationProviderRegistrationArgs',
    'DefaultRolloutSpecificationRestOfTheWorldGroupOneArgs',
    'DefaultRolloutSpecificationRestOfTheWorldGroupTwoArgs',
    'ExtendedErrorInfoArgs',
    'ExtendedLocationOptionsArgs',
    'LightHouseAuthorizationArgs',
    'LinkedAccessCheckArgs',
    'LoggingRuleHiddenPropertyPathsArgs',
    'LoggingRuleArgs',
    'NotificationEndpointArgs',
    'NotificationRegistrationPropertiesArgs',
    'OpenApiConfigurationArgs',
    'OpenApiValidationArgs',
    'ProviderHubMetadataProviderAuthenticationArgs',
    'ProviderHubMetadataThirdPartyProviderAuthorizationArgs',
    'ProviderRegistrationPropertiesProviderHubMetadataArgs',
    'ProviderRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs',
    'ProviderRegistrationPropertiesArgs',
    'ResourceConcurrencyControlOptionArgs',
    'ResourceProviderAuthorizationArgs',
    'ResourceProviderCapabilitiesArgs',
    'ResourceProviderManifestPropertiesFeaturesRuleArgs',
    'ResourceProviderManifestPropertiesManagementArgs',
    'ResourceProviderManifestPropertiesProviderAuthenticationArgs',
    'ResourceProviderManifestPropertiesRequestHeaderOptionsArgs',
    'ResourceProviderManifestPropertiesTemplateDeploymentOptionsArgs',
    'ResourceTypeEndpointFeaturesRuleArgs',
    'ResourceTypeEndpointArgs',
    'ResourceTypeExtensionOptionsResourceCreationBeginArgs',
    'ResourceTypeExtensionArgs',
    'ResourceTypeRegistrationPropertiesCheckNameAvailabilitySpecificationsArgs',
    'ResourceTypeRegistrationPropertiesExtensionOptionsArgs',
    'ResourceTypeRegistrationPropertiesFeaturesRuleArgs',
    'ResourceTypeRegistrationPropertiesIdentityManagementArgs',
    'ResourceTypeRegistrationPropertiesManagementArgs',
    'ResourceTypeRegistrationPropertiesRequestHeaderOptionsArgs',
    'ResourceTypeRegistrationPropertiesResourceGraphConfigurationArgs',
    'ResourceTypeRegistrationPropertiesResourceMovePolicyArgs',
    'ResourceTypeRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs',
    'ResourceTypeRegistrationPropertiesTemplateDeploymentOptionsArgs',
    'ResourceTypeRegistrationPropertiesArgs',
    'ResourceTypeRegistrationArgs',
    'ServiceTreeInfoArgs',
    'SkuCapabilityArgs',
    'SkuCostArgs',
    'SkuLocationInfoArgs',
    'SkuSettingCapacityArgs',
    'SkuSettingArgs',
    'SkuZoneDetailArgs',
    'SubscriptionStateOverrideActionArgs',
    'SubscriptionStateRuleArgs',
    'SwaggerSpecificationArgs',
    'ThrottlingMetricArgs',
    'ThrottlingRuleArgs',
    'TypedErrorInfoArgs',
]

@pulumi.input_type
class AuthorizationActionMappingArgs:
    def __init__(__self__, *,
                 desired: Optional[pulumi.Input[str]] = None,
                 original: Optional[pulumi.Input[str]] = None):
        if desired is not None:
            pulumi.set(__self__, "desired", desired)
        if original is not None:
            pulumi.set(__self__, "original", original)

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

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

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

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


@pulumi.input_type
class DefaultRolloutPropertiesSpecificationArgs:
    def __init__(__self__, *,
                 canary: Optional[pulumi.Input['DefaultRolloutSpecificationCanaryArgs']] = None,
                 expedited_rollout: Optional[pulumi.Input['DefaultRolloutSpecificationExpeditedRolloutArgs']] = None,
                 high_traffic: Optional[pulumi.Input['DefaultRolloutSpecificationHighTrafficArgs']] = None,
                 low_traffic: Optional[pulumi.Input['DefaultRolloutSpecificationLowTrafficArgs']] = None,
                 medium_traffic: Optional[pulumi.Input['DefaultRolloutSpecificationMediumTrafficArgs']] = None,
                 provider_registration: Optional[pulumi.Input['DefaultRolloutSpecificationProviderRegistrationArgs']] = None,
                 resource_type_registrations: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeRegistrationArgs']]]] = None,
                 rest_of_the_world_group_one: Optional[pulumi.Input['DefaultRolloutSpecificationRestOfTheWorldGroupOneArgs']] = None,
                 rest_of_the_world_group_two: Optional[pulumi.Input['DefaultRolloutSpecificationRestOfTheWorldGroupTwoArgs']] = None):
        if canary is not None:
            pulumi.set(__self__, "canary", canary)
        if expedited_rollout is not None:
            pulumi.set(__self__, "expedited_rollout", expedited_rollout)
        if high_traffic is not None:
            pulumi.set(__self__, "high_traffic", high_traffic)
        if low_traffic is not None:
            pulumi.set(__self__, "low_traffic", low_traffic)
        if medium_traffic is not None:
            pulumi.set(__self__, "medium_traffic", medium_traffic)
        if provider_registration is not None:
            pulumi.set(__self__, "provider_registration", provider_registration)
        if resource_type_registrations is not None:
            pulumi.set(__self__, "resource_type_registrations", resource_type_registrations)
        if rest_of_the_world_group_one is not None:
            pulumi.set(__self__, "rest_of_the_world_group_one", rest_of_the_world_group_one)
        if rest_of_the_world_group_two is not None:
            pulumi.set(__self__, "rest_of_the_world_group_two", rest_of_the_world_group_two)

    @property
    @pulumi.getter
    def canary(self) -> Optional[pulumi.Input['DefaultRolloutSpecificationCanaryArgs']]:
        return pulumi.get(self, "canary")

    @canary.setter
    def canary(self, value: Optional[pulumi.Input['DefaultRolloutSpecificationCanaryArgs']]):
        pulumi.set(self, "canary", value)

    @property
    @pulumi.getter(name="expeditedRollout")
    def expedited_rollout(self) -> Optional[pulumi.Input['DefaultRolloutSpecificationExpeditedRolloutArgs']]:
        return pulumi.get(self, "expedited_rollout")

    @expedited_rollout.setter
    def expedited_rollout(self, value: Optional[pulumi.Input['DefaultRolloutSpecificationExpeditedRolloutArgs']]):
        pulumi.set(self, "expedited_rollout", value)

    @property
    @pulumi.getter(name="highTraffic")
    def high_traffic(self) -> Optional[pulumi.Input['DefaultRolloutSpecificationHighTrafficArgs']]:
        return pulumi.get(self, "high_traffic")

    @high_traffic.setter
    def high_traffic(self, value: Optional[pulumi.Input['DefaultRolloutSpecificationHighTrafficArgs']]):
        pulumi.set(self, "high_traffic", value)

    @property
    @pulumi.getter(name="lowTraffic")
    def low_traffic(self) -> Optional[pulumi.Input['DefaultRolloutSpecificationLowTrafficArgs']]:
        return pulumi.get(self, "low_traffic")

    @low_traffic.setter
    def low_traffic(self, value: Optional[pulumi.Input['DefaultRolloutSpecificationLowTrafficArgs']]):
        pulumi.set(self, "low_traffic", value)

    @property
    @pulumi.getter(name="mediumTraffic")
    def medium_traffic(self) -> Optional[pulumi.Input['DefaultRolloutSpecificationMediumTrafficArgs']]:
        return pulumi.get(self, "medium_traffic")

    @medium_traffic.setter
    def medium_traffic(self, value: Optional[pulumi.Input['DefaultRolloutSpecificationMediumTrafficArgs']]):
        pulumi.set(self, "medium_traffic", value)

    @property
    @pulumi.getter(name="providerRegistration")
    def provider_registration(self) -> Optional[pulumi.Input['DefaultRolloutSpecificationProviderRegistrationArgs']]:
        return pulumi.get(self, "provider_registration")

    @provider_registration.setter
    def provider_registration(self, value: Optional[pulumi.Input['DefaultRolloutSpecificationProviderRegistrationArgs']]):
        pulumi.set(self, "provider_registration", value)

    @property
    @pulumi.getter(name="resourceTypeRegistrations")
    def resource_type_registrations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeRegistrationArgs']]]]:
        return pulumi.get(self, "resource_type_registrations")

    @resource_type_registrations.setter
    def resource_type_registrations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeRegistrationArgs']]]]):
        pulumi.set(self, "resource_type_registrations", value)

    @property
    @pulumi.getter(name="restOfTheWorldGroupOne")
    def rest_of_the_world_group_one(self) -> Optional[pulumi.Input['DefaultRolloutSpecificationRestOfTheWorldGroupOneArgs']]:
        return pulumi.get(self, "rest_of_the_world_group_one")

    @rest_of_the_world_group_one.setter
    def rest_of_the_world_group_one(self, value: Optional[pulumi.Input['DefaultRolloutSpecificationRestOfTheWorldGroupOneArgs']]):
        pulumi.set(self, "rest_of_the_world_group_one", value)

    @property
    @pulumi.getter(name="restOfTheWorldGroupTwo")
    def rest_of_the_world_group_two(self) -> Optional[pulumi.Input['DefaultRolloutSpecificationRestOfTheWorldGroupTwoArgs']]:
        return pulumi.get(self, "rest_of_the_world_group_two")

    @rest_of_the_world_group_two.setter
    def rest_of_the_world_group_two(self, value: Optional[pulumi.Input['DefaultRolloutSpecificationRestOfTheWorldGroupTwoArgs']]):
        pulumi.set(self, "rest_of_the_world_group_two", value)


@pulumi.input_type
class DefaultRolloutPropertiesStatusArgs:
    def __init__(__self__, *,
                 completed_regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 failed_or_skipped_regions: Optional[pulumi.Input[Mapping[str, pulumi.Input['ExtendedErrorInfoArgs']]]] = None,
                 next_traffic_region: Optional[pulumi.Input[Union[str, 'TrafficRegionCategory']]] = None,
                 next_traffic_region_scheduled_time: Optional[pulumi.Input[str]] = None,
                 subscription_reregistration_result: Optional[pulumi.Input[Union[str, 'SubscriptionReregistrationResult']]] = None):
        if completed_regions is not None:
            pulumi.set(__self__, "completed_regions", completed_regions)
        if failed_or_skipped_regions is not None:
            pulumi.set(__self__, "failed_or_skipped_regions", failed_or_skipped_regions)
        if next_traffic_region is not None:
            pulumi.set(__self__, "next_traffic_region", next_traffic_region)
        if next_traffic_region_scheduled_time is not None:
            pulumi.set(__self__, "next_traffic_region_scheduled_time", next_traffic_region_scheduled_time)
        if subscription_reregistration_result is not None:
            pulumi.set(__self__, "subscription_reregistration_result", subscription_reregistration_result)

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

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

    @property
    @pulumi.getter(name="failedOrSkippedRegions")
    def failed_or_skipped_regions(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input['ExtendedErrorInfoArgs']]]]:
        return pulumi.get(self, "failed_or_skipped_regions")

    @failed_or_skipped_regions.setter
    def failed_or_skipped_regions(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['ExtendedErrorInfoArgs']]]]):
        pulumi.set(self, "failed_or_skipped_regions", value)

    @property
    @pulumi.getter(name="nextTrafficRegion")
    def next_traffic_region(self) -> Optional[pulumi.Input[Union[str, 'TrafficRegionCategory']]]:
        return pulumi.get(self, "next_traffic_region")

    @next_traffic_region.setter
    def next_traffic_region(self, value: Optional[pulumi.Input[Union[str, 'TrafficRegionCategory']]]):
        pulumi.set(self, "next_traffic_region", value)

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

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

    @property
    @pulumi.getter(name="subscriptionReregistrationResult")
    def subscription_reregistration_result(self) -> Optional[pulumi.Input[Union[str, 'SubscriptionReregistrationResult']]]:
        return pulumi.get(self, "subscription_reregistration_result")

    @subscription_reregistration_result.setter
    def subscription_reregistration_result(self, value: Optional[pulumi.Input[Union[str, 'SubscriptionReregistrationResult']]]):
        pulumi.set(self, "subscription_reregistration_result", value)


@pulumi.input_type
class DefaultRolloutPropertiesArgs:
    def __init__(__self__, *,
                 provisioning_state: Optional[pulumi.Input[Union[str, 'ProvisioningState']]] = None,
                 specification: Optional[pulumi.Input['DefaultRolloutPropertiesSpecificationArgs']] = None,
                 status: Optional[pulumi.Input['DefaultRolloutPropertiesStatusArgs']] = None):
        """
        Properties of the rollout.
        :param pulumi.Input[Union[str, 'ProvisioningState']] provisioning_state: The provisioned state of the resource.
        """
        if provisioning_state is not None:
            pulumi.set(__self__, "provisioning_state", provisioning_state)
        if specification is not None:
            pulumi.set(__self__, "specification", specification)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="provisioningState")
    def provisioning_state(self) -> Optional[pulumi.Input[Union[str, 'ProvisioningState']]]:
        """
        The provisioned state of the resource.
        """
        return pulumi.get(self, "provisioning_state")

    @provisioning_state.setter
    def provisioning_state(self, value: Optional[pulumi.Input[Union[str, 'ProvisioningState']]]):
        pulumi.set(self, "provisioning_state", value)

    @property
    @pulumi.getter
    def specification(self) -> Optional[pulumi.Input['DefaultRolloutPropertiesSpecificationArgs']]:
        return pulumi.get(self, "specification")

    @specification.setter
    def specification(self, value: Optional[pulumi.Input['DefaultRolloutPropertiesSpecificationArgs']]):
        pulumi.set(self, "specification", value)

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input['DefaultRolloutPropertiesStatusArgs']]:
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: Optional[pulumi.Input['DefaultRolloutPropertiesStatusArgs']]):
        pulumi.set(self, "status", value)


@pulumi.input_type
class DefaultRolloutSpecificationCanaryArgs:
    def __init__(__self__, *,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 skip_regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if skip_regions is not None:
            pulumi.set(__self__, "skip_regions", skip_regions)

    @property
    @pulumi.getter
    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "regions")

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

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

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


@pulumi.input_type
class DefaultRolloutSpecificationExpeditedRolloutArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Indicates whether expedited rollout is enabled/disabled
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether expedited rollout is enabled/disabled
        """
        return pulumi.get(self, "enabled")

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


@pulumi.input_type
class DefaultRolloutSpecificationHighTrafficArgs:
    def __init__(__self__, *,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 wait_duration: Optional[pulumi.Input[str]] = None):
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if wait_duration is not None:
            pulumi.set(__self__, "wait_duration", wait_duration)

    @property
    @pulumi.getter
    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "regions")

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

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

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


@pulumi.input_type
class DefaultRolloutSpecificationLowTrafficArgs:
    def __init__(__self__, *,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 wait_duration: Optional[pulumi.Input[str]] = None):
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if wait_duration is not None:
            pulumi.set(__self__, "wait_duration", wait_duration)

    @property
    @pulumi.getter
    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "regions")

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

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

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


@pulumi.input_type
class DefaultRolloutSpecificationMediumTrafficArgs:
    def __init__(__self__, *,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 wait_duration: Optional[pulumi.Input[str]] = None):
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if wait_duration is not None:
            pulumi.set(__self__, "wait_duration", wait_duration)

    @property
    @pulumi.getter
    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "regions")

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

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

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


@pulumi.input_type
class DefaultRolloutSpecificationProviderRegistrationArgs:
    def __init__(__self__, *,
                 properties: Optional[pulumi.Input['ProviderRegistrationPropertiesArgs']] = None):
        if properties is not None:
            pulumi.set(__self__, "properties", properties)

    @property
    @pulumi.getter
    def properties(self) -> Optional[pulumi.Input['ProviderRegistrationPropertiesArgs']]:
        return pulumi.get(self, "properties")

    @properties.setter
    def properties(self, value: Optional[pulumi.Input['ProviderRegistrationPropertiesArgs']]):
        pulumi.set(self, "properties", value)


@pulumi.input_type
class DefaultRolloutSpecificationRestOfTheWorldGroupOneArgs:
    def __init__(__self__, *,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 wait_duration: Optional[pulumi.Input[str]] = None):
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if wait_duration is not None:
            pulumi.set(__self__, "wait_duration", wait_duration)

    @property
    @pulumi.getter
    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "regions")

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

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

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


@pulumi.input_type
class DefaultRolloutSpecificationRestOfTheWorldGroupTwoArgs:
    def __init__(__self__, *,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 wait_duration: Optional[pulumi.Input[str]] = None):
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if wait_duration is not None:
            pulumi.set(__self__, "wait_duration", wait_duration)

    @property
    @pulumi.getter
    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "regions")

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

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

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


@pulumi.input_type
class ExtendedErrorInfoArgs:
    def __init__(__self__, *,
                 additional_info: Optional[pulumi.Input[Sequence[pulumi.Input['TypedErrorInfoArgs']]]] = None,
                 code: Optional[pulumi.Input[str]] = None,
                 details: Optional[pulumi.Input[Sequence[pulumi.Input['ExtendedErrorInfoArgs']]]] = None,
                 message: Optional[pulumi.Input[str]] = None,
                 target: Optional[pulumi.Input[str]] = None):
        if additional_info is not None:
            pulumi.set(__self__, "additional_info", additional_info)
        if code is not None:
            pulumi.set(__self__, "code", code)
        if details is not None:
            pulumi.set(__self__, "details", details)
        if message is not None:
            pulumi.set(__self__, "message", message)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter(name="additionalInfo")
    def additional_info(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TypedErrorInfoArgs']]]]:
        return pulumi.get(self, "additional_info")

    @additional_info.setter
    def additional_info(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TypedErrorInfoArgs']]]]):
        pulumi.set(self, "additional_info", value)

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

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

    @property
    @pulumi.getter
    def details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ExtendedErrorInfoArgs']]]]:
        return pulumi.get(self, "details")

    @details.setter
    def details(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ExtendedErrorInfoArgs']]]]):
        pulumi.set(self, "details", value)

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

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

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

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


@pulumi.input_type
class ExtendedLocationOptionsArgs:
    def __init__(__self__, *,
                 supported_policy: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        if supported_policy is not None:
            pulumi.set(__self__, "supported_policy", supported_policy)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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


@pulumi.input_type
class LightHouseAuthorizationArgs:
    def __init__(__self__, *,
                 principal_id: pulumi.Input[str],
                 role_definition_id: pulumi.Input[str]):
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "role_definition_id", role_definition_id)

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

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

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

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


@pulumi.input_type
class LinkedAccessCheckArgs:
    def __init__(__self__, *,
                 action_name: Optional[pulumi.Input[str]] = None,
                 linked_action: Optional[pulumi.Input[str]] = None,
                 linked_action_verb: Optional[pulumi.Input[str]] = None,
                 linked_property: Optional[pulumi.Input[str]] = None,
                 linked_type: Optional[pulumi.Input[str]] = None):
        if action_name is not None:
            pulumi.set(__self__, "action_name", action_name)
        if linked_action is not None:
            pulumi.set(__self__, "linked_action", linked_action)
        if linked_action_verb is not None:
            pulumi.set(__self__, "linked_action_verb", linked_action_verb)
        if linked_property is not None:
            pulumi.set(__self__, "linked_property", linked_property)
        if linked_type is not None:
            pulumi.set(__self__, "linked_type", linked_type)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class LoggingRuleHiddenPropertyPathsArgs:
    def __init__(__self__, *,
                 hidden_paths_on_request: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 hidden_paths_on_response: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if hidden_paths_on_request is not None:
            pulumi.set(__self__, "hidden_paths_on_request", hidden_paths_on_request)
        if hidden_paths_on_response is not None:
            pulumi.set(__self__, "hidden_paths_on_response", hidden_paths_on_response)

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

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

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

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


@pulumi.input_type
class LoggingRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str],
                 detail_level: pulumi.Input[Union[str, 'LoggingDetails']],
                 direction: pulumi.Input[Union[str, 'LoggingDirections']],
                 hidden_property_paths: Optional[pulumi.Input['LoggingRuleHiddenPropertyPathsArgs']] = None):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "detail_level", detail_level)
        pulumi.set(__self__, "direction", direction)
        if hidden_property_paths is not None:
            pulumi.set(__self__, "hidden_property_paths", hidden_property_paths)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[str]:
        return pulumi.get(self, "action")

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

    @property
    @pulumi.getter(name="detailLevel")
    def detail_level(self) -> pulumi.Input[Union[str, 'LoggingDetails']]:
        return pulumi.get(self, "detail_level")

    @detail_level.setter
    def detail_level(self, value: pulumi.Input[Union[str, 'LoggingDetails']]):
        pulumi.set(self, "detail_level", value)

    @property
    @pulumi.getter
    def direction(self) -> pulumi.Input[Union[str, 'LoggingDirections']]:
        return pulumi.get(self, "direction")

    @direction.setter
    def direction(self, value: pulumi.Input[Union[str, 'LoggingDirections']]):
        pulumi.set(self, "direction", value)

    @property
    @pulumi.getter(name="hiddenPropertyPaths")
    def hidden_property_paths(self) -> Optional[pulumi.Input['LoggingRuleHiddenPropertyPathsArgs']]:
        return pulumi.get(self, "hidden_property_paths")

    @hidden_property_paths.setter
    def hidden_property_paths(self, value: Optional[pulumi.Input['LoggingRuleHiddenPropertyPathsArgs']]):
        pulumi.set(self, "hidden_property_paths", value)


@pulumi.input_type
class NotificationEndpointArgs:
    def __init__(__self__, *,
                 locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 notification_destination: Optional[pulumi.Input[str]] = None):
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if notification_destination is not None:
            pulumi.set(__self__, "notification_destination", notification_destination)

    @property
    @pulumi.getter
    def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "locations")

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

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

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


@pulumi.input_type
class NotificationRegistrationPropertiesArgs:
    def __init__(__self__, *,
                 included_events: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 message_scope: Optional[pulumi.Input[Union[str, 'MessageScope']]] = None,
                 notification_endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationEndpointArgs']]]] = None,
                 notification_mode: Optional[pulumi.Input[Union[str, 'NotificationMode']]] = None,
                 provisioning_state: Optional[pulumi.Input[Union[str, 'ProvisioningState']]] = None):
        """
        :param pulumi.Input[Union[str, 'ProvisioningState']] provisioning_state: The provisioned state of the resource.
        """
        if included_events is not None:
            pulumi.set(__self__, "included_events", included_events)
        if message_scope is not None:
            pulumi.set(__self__, "message_scope", message_scope)
        if notification_endpoints is not None:
            pulumi.set(__self__, "notification_endpoints", notification_endpoints)
        if notification_mode is not None:
            pulumi.set(__self__, "notification_mode", notification_mode)
        if provisioning_state is not None:
            pulumi.set(__self__, "provisioning_state", provisioning_state)

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

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

    @property
    @pulumi.getter(name="messageScope")
    def message_scope(self) -> Optional[pulumi.Input[Union[str, 'MessageScope']]]:
        return pulumi.get(self, "message_scope")

    @message_scope.setter
    def message_scope(self, value: Optional[pulumi.Input[Union[str, 'MessageScope']]]):
        pulumi.set(self, "message_scope", value)

    @property
    @pulumi.getter(name="notificationEndpoints")
    def notification_endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationEndpointArgs']]]]:
        return pulumi.get(self, "notification_endpoints")

    @notification_endpoints.setter
    def notification_endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationEndpointArgs']]]]):
        pulumi.set(self, "notification_endpoints", value)

    @property
    @pulumi.getter(name="notificationMode")
    def notification_mode(self) -> Optional[pulumi.Input[Union[str, 'NotificationMode']]]:
        return pulumi.get(self, "notification_mode")

    @notification_mode.setter
    def notification_mode(self, value: Optional[pulumi.Input[Union[str, 'NotificationMode']]]):
        pulumi.set(self, "notification_mode", value)

    @property
    @pulumi.getter(name="provisioningState")
    def provisioning_state(self) -> Optional[pulumi.Input[Union[str, 'ProvisioningState']]]:
        """
        The provisioned state of the resource.
        """
        return pulumi.get(self, "provisioning_state")

    @provisioning_state.setter
    def provisioning_state(self, value: Optional[pulumi.Input[Union[str, 'ProvisioningState']]]):
        pulumi.set(self, "provisioning_state", value)


@pulumi.input_type
class OpenApiConfigurationArgs:
    def __init__(__self__, *,
                 validation: Optional[pulumi.Input['OpenApiValidationArgs']] = None):
        if validation is not None:
            pulumi.set(__self__, "validation", validation)

    @property
    @pulumi.getter
    def validation(self) -> Optional[pulumi.Input['OpenApiValidationArgs']]:
        return pulumi.get(self, "validation")

    @validation.setter
    def validation(self, value: Optional[pulumi.Input['OpenApiValidationArgs']]):
        pulumi.set(self, "validation", value)


@pulumi.input_type
class OpenApiValidationArgs:
    def __init__(__self__, *,
                 allow_noncompliant_collection_response: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] allow_noncompliant_collection_response: Indicates whether a non compliance response is allowed for a LIST call
        """
        if allow_noncompliant_collection_response is not None:
            pulumi.set(__self__, "allow_noncompliant_collection_response", allow_noncompliant_collection_response)

    @property
    @pulumi.getter(name="allowNoncompliantCollectionResponse")
    def allow_noncompliant_collection_response(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether a non compliance response is allowed for a LIST call
        """
        return pulumi.get(self, "allow_noncompliant_collection_response")

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


@pulumi.input_type
class ProviderHubMetadataProviderAuthenticationArgs:
    def __init__(__self__, *,
                 allowed_audiences: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "allowed_audiences", allowed_audiences)

    @property
    @pulumi.getter(name="allowedAudiences")
    def allowed_audiences(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "allowed_audiences")

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


@pulumi.input_type
class ProviderHubMetadataThirdPartyProviderAuthorizationArgs:
    def __init__(__self__, *,
                 authorizations: Optional[pulumi.Input[Sequence[pulumi.Input['LightHouseAuthorizationArgs']]]] = None,
                 managed_by_tenant_id: Optional[pulumi.Input[str]] = None):
        if authorizations is not None:
            pulumi.set(__self__, "authorizations", authorizations)
        if managed_by_tenant_id is not None:
            pulumi.set(__self__, "managed_by_tenant_id", managed_by_tenant_id)

    @property
    @pulumi.getter
    def authorizations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LightHouseAuthorizationArgs']]]]:
        return pulumi.get(self, "authorizations")

    @authorizations.setter
    def authorizations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LightHouseAuthorizationArgs']]]]):
        pulumi.set(self, "authorizations", value)

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

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


@pulumi.input_type
class ProviderRegistrationPropertiesProviderHubMetadataArgs:
    def __init__(__self__, *,
                 provider_authentication: Optional[pulumi.Input['ProviderHubMetadataProviderAuthenticationArgs']] = None,
                 provider_authorizations: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderAuthorizationArgs']]]] = None,
                 third_party_provider_authorization: Optional[pulumi.Input['ProviderHubMetadataThirdPartyProviderAuthorizationArgs']] = None):
        if provider_authentication is not None:
            pulumi.set(__self__, "provider_authentication", provider_authentication)
        if provider_authorizations is not None:
            pulumi.set(__self__, "provider_authorizations", provider_authorizations)
        if third_party_provider_authorization is not None:
            pulumi.set(__self__, "third_party_provider_authorization", third_party_provider_authorization)

    @property
    @pulumi.getter(name="providerAuthentication")
    def provider_authentication(self) -> Optional[pulumi.Input['ProviderHubMetadataProviderAuthenticationArgs']]:
        return pulumi.get(self, "provider_authentication")

    @provider_authentication.setter
    def provider_authentication(self, value: Optional[pulumi.Input['ProviderHubMetadataProviderAuthenticationArgs']]):
        pulumi.set(self, "provider_authentication", value)

    @property
    @pulumi.getter(name="providerAuthorizations")
    def provider_authorizations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderAuthorizationArgs']]]]:
        return pulumi.get(self, "provider_authorizations")

    @provider_authorizations.setter
    def provider_authorizations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderAuthorizationArgs']]]]):
        pulumi.set(self, "provider_authorizations", value)

    @property
    @pulumi.getter(name="thirdPartyProviderAuthorization")
    def third_party_provider_authorization(self) -> Optional[pulumi.Input['ProviderHubMetadataThirdPartyProviderAuthorizationArgs']]:
        return pulumi.get(self, "third_party_provider_authorization")

    @third_party_provider_authorization.setter
    def third_party_provider_authorization(self, value: Optional[pulumi.Input['ProviderHubMetadataThirdPartyProviderAuthorizationArgs']]):
        pulumi.set(self, "third_party_provider_authorization", value)


@pulumi.input_type
class ProviderRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs:
    def __init__(__self__, *,
                 soft_delete_ttl: Optional[pulumi.Input[str]] = None,
                 subscription_state_override_actions: Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateOverrideActionArgs']]]] = None):
        if soft_delete_ttl is not None:
            pulumi.set(__self__, "soft_delete_ttl", soft_delete_ttl)
        if subscription_state_override_actions is not None:
            pulumi.set(__self__, "subscription_state_override_actions", subscription_state_override_actions)

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

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

    @property
    @pulumi.getter(name="subscriptionStateOverrideActions")
    def subscription_state_override_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateOverrideActionArgs']]]]:
        return pulumi.get(self, "subscription_state_override_actions")

    @subscription_state_override_actions.setter
    def subscription_state_override_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateOverrideActionArgs']]]]):
        pulumi.set(self, "subscription_state_override_actions", value)


@pulumi.input_type
class ProviderRegistrationPropertiesArgs:
    def __init__(__self__, *,
                 capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderCapabilitiesArgs']]]] = None,
                 features_rule: Optional[pulumi.Input['ResourceProviderManifestPropertiesFeaturesRuleArgs']] = None,
                 management: Optional[pulumi.Input['ResourceProviderManifestPropertiesManagementArgs']] = None,
                 metadata: Optional[Any] = None,
                 namespace: Optional[pulumi.Input[str]] = None,
                 provider_authentication: Optional[pulumi.Input['ResourceProviderManifestPropertiesProviderAuthenticationArgs']] = None,
                 provider_authorizations: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderAuthorizationArgs']]]] = None,
                 provider_hub_metadata: Optional[pulumi.Input['ProviderRegistrationPropertiesProviderHubMetadataArgs']] = None,
                 provider_type: Optional[pulumi.Input[Union[str, 'ResourceProviderType']]] = None,
                 provider_version: Optional[pulumi.Input[str]] = None,
                 provisioning_state: Optional[pulumi.Input[Union[str, 'ProvisioningState']]] = None,
                 request_header_options: Optional[pulumi.Input['ResourceProviderManifestPropertiesRequestHeaderOptionsArgs']] = None,
                 required_features: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 subscription_lifecycle_notification_specifications: Optional[pulumi.Input['ProviderRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs']] = None,
                 template_deployment_options: Optional[pulumi.Input['ResourceProviderManifestPropertiesTemplateDeploymentOptionsArgs']] = None):
        """
        :param pulumi.Input[Union[str, 'ProvisioningState']] provisioning_state: The provisioned state of the resource.
        """
        if capabilities is not None:
            pulumi.set(__self__, "capabilities", capabilities)
        if features_rule is not None:
            pulumi.set(__self__, "features_rule", features_rule)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if provider_authentication is not None:
            pulumi.set(__self__, "provider_authentication", provider_authentication)
        if provider_authorizations is not None:
            pulumi.set(__self__, "provider_authorizations", provider_authorizations)
        if provider_hub_metadata is not None:
            pulumi.set(__self__, "provider_hub_metadata", provider_hub_metadata)
        if provider_type is not None:
            pulumi.set(__self__, "provider_type", provider_type)
        if provider_version is not None:
            pulumi.set(__self__, "provider_version", provider_version)
        if provisioning_state is not None:
            pulumi.set(__self__, "provisioning_state", provisioning_state)
        if request_header_options is not None:
            pulumi.set(__self__, "request_header_options", request_header_options)
        if required_features is not None:
            pulumi.set(__self__, "required_features", required_features)
        if subscription_lifecycle_notification_specifications is not None:
            pulumi.set(__self__, "subscription_lifecycle_notification_specifications", subscription_lifecycle_notification_specifications)
        if template_deployment_options is not None:
            pulumi.set(__self__, "template_deployment_options", template_deployment_options)

    @property
    @pulumi.getter
    def capabilities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderCapabilitiesArgs']]]]:
        return pulumi.get(self, "capabilities")

    @capabilities.setter
    def capabilities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderCapabilitiesArgs']]]]):
        pulumi.set(self, "capabilities", value)

    @property
    @pulumi.getter(name="featuresRule")
    def features_rule(self) -> Optional[pulumi.Input['ResourceProviderManifestPropertiesFeaturesRuleArgs']]:
        return pulumi.get(self, "features_rule")

    @features_rule.setter
    def features_rule(self, value: Optional[pulumi.Input['ResourceProviderManifestPropertiesFeaturesRuleArgs']]):
        pulumi.set(self, "features_rule", value)

    @property
    @pulumi.getter
    def management(self) -> Optional[pulumi.Input['ResourceProviderManifestPropertiesManagementArgs']]:
        return pulumi.get(self, "management")

    @management.setter
    def management(self, value: Optional[pulumi.Input['ResourceProviderManifestPropertiesManagementArgs']]):
        pulumi.set(self, "management", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[Any]:
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[Any]):
        pulumi.set(self, "metadata", value)

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

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

    @property
    @pulumi.getter(name="providerAuthentication")
    def provider_authentication(self) -> Optional[pulumi.Input['ResourceProviderManifestPropertiesProviderAuthenticationArgs']]:
        return pulumi.get(self, "provider_authentication")

    @provider_authentication.setter
    def provider_authentication(self, value: Optional[pulumi.Input['ResourceProviderManifestPropertiesProviderAuthenticationArgs']]):
        pulumi.set(self, "provider_authentication", value)

    @property
    @pulumi.getter(name="providerAuthorizations")
    def provider_authorizations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderAuthorizationArgs']]]]:
        return pulumi.get(self, "provider_authorizations")

    @provider_authorizations.setter
    def provider_authorizations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceProviderAuthorizationArgs']]]]):
        pulumi.set(self, "provider_authorizations", value)

    @property
    @pulumi.getter(name="providerHubMetadata")
    def provider_hub_metadata(self) -> Optional[pulumi.Input['ProviderRegistrationPropertiesProviderHubMetadataArgs']]:
        return pulumi.get(self, "provider_hub_metadata")

    @provider_hub_metadata.setter
    def provider_hub_metadata(self, value: Optional[pulumi.Input['ProviderRegistrationPropertiesProviderHubMetadataArgs']]):
        pulumi.set(self, "provider_hub_metadata", value)

    @property
    @pulumi.getter(name="providerType")
    def provider_type(self) -> Optional[pulumi.Input[Union[str, 'ResourceProviderType']]]:
        return pulumi.get(self, "provider_type")

    @provider_type.setter
    def provider_type(self, value: Optional[pulumi.Input[Union[str, 'ResourceProviderType']]]):
        pulumi.set(self, "provider_type", value)

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

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

    @property
    @pulumi.getter(name="provisioningState")
    def provisioning_state(self) -> Optional[pulumi.Input[Union[str, 'ProvisioningState']]]:
        """
        The provisioned state of the resource.
        """
        return pulumi.get(self, "provisioning_state")

    @provisioning_state.setter
    def provisioning_state(self, value: Optional[pulumi.Input[Union[str, 'ProvisioningState']]]):
        pulumi.set(self, "provisioning_state", value)

    @property
    @pulumi.getter(name="requestHeaderOptions")
    def request_header_options(self) -> Optional[pulumi.Input['ResourceProviderManifestPropertiesRequestHeaderOptionsArgs']]:
        return pulumi.get(self, "request_header_options")

    @request_header_options.setter
    def request_header_options(self, value: Optional[pulumi.Input['ResourceProviderManifestPropertiesRequestHeaderOptionsArgs']]):
        pulumi.set(self, "request_header_options", value)

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

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

    @property
    @pulumi.getter(name="subscriptionLifecycleNotificationSpecifications")
    def subscription_lifecycle_notification_specifications(self) -> Optional[pulumi.Input['ProviderRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs']]:
        return pulumi.get(self, "subscription_lifecycle_notification_specifications")

    @subscription_lifecycle_notification_specifications.setter
    def subscription_lifecycle_notification_specifications(self, value: Optional[pulumi.Input['ProviderRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs']]):
        pulumi.set(self, "subscription_lifecycle_notification_specifications", value)

    @property
    @pulumi.getter(name="templateDeploymentOptions")
    def template_deployment_options(self) -> Optional[pulumi.Input['ResourceProviderManifestPropertiesTemplateDeploymentOptionsArgs']]:
        return pulumi.get(self, "template_deployment_options")

    @template_deployment_options.setter
    def template_deployment_options(self, value: Optional[pulumi.Input['ResourceProviderManifestPropertiesTemplateDeploymentOptionsArgs']]):
        pulumi.set(self, "template_deployment_options", value)


@pulumi.input_type
class ResourceConcurrencyControlOptionArgs:
    def __init__(__self__, *,
                 policy: Optional[pulumi.Input[Union[str, 'Policy']]] = None):
        if policy is not None:
            pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter
    def policy(self) -> Optional[pulumi.Input[Union[str, 'Policy']]]:
        return pulumi.get(self, "policy")

    @policy.setter
    def policy(self, value: Optional[pulumi.Input[Union[str, 'Policy']]]):
        pulumi.set(self, "policy", value)


@pulumi.input_type
class ResourceProviderAuthorizationArgs:
    def __init__(__self__, *,
                 application_id: Optional[pulumi.Input[str]] = None,
                 managed_by_role_definition_id: Optional[pulumi.Input[str]] = None,
                 role_definition_id: Optional[pulumi.Input[str]] = None):
        if application_id is not None:
            pulumi.set(__self__, "application_id", application_id)
        if managed_by_role_definition_id is not None:
            pulumi.set(__self__, "managed_by_role_definition_id", managed_by_role_definition_id)
        if role_definition_id is not None:
            pulumi.set(__self__, "role_definition_id", role_definition_id)

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

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

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

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

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

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


@pulumi.input_type
class ResourceProviderCapabilitiesArgs:
    def __init__(__self__, *,
                 effect: pulumi.Input[Union[str, 'ResourceProviderCapabilitiesEffect']],
                 quota_id: pulumi.Input[str],
                 required_features: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "quota_id", quota_id)
        if required_features is not None:
            pulumi.set(__self__, "required_features", required_features)

    @property
    @pulumi.getter
    def effect(self) -> pulumi.Input[Union[str, 'ResourceProviderCapabilitiesEffect']]:
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: pulumi.Input[Union[str, 'ResourceProviderCapabilitiesEffect']]):
        pulumi.set(self, "effect", value)

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

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

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

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


@pulumi.input_type
class ResourceProviderManifestPropertiesFeaturesRuleArgs:
    def __init__(__self__, *,
                 required_features_policy: pulumi.Input[Union[str, 'FeaturesPolicy']]):
        pulumi.set(__self__, "required_features_policy", required_features_policy)

    @property
    @pulumi.getter(name="requiredFeaturesPolicy")
    def required_features_policy(self) -> pulumi.Input[Union[str, 'FeaturesPolicy']]:
        return pulumi.get(self, "required_features_policy")

    @required_features_policy.setter
    def required_features_policy(self, value: pulumi.Input[Union[str, 'FeaturesPolicy']]):
        pulumi.set(self, "required_features_policy", value)


@pulumi.input_type
class ResourceProviderManifestPropertiesManagementArgs:
    def __init__(__self__, *,
                 incident_contact_email: Optional[pulumi.Input[str]] = None,
                 incident_routing_service: Optional[pulumi.Input[str]] = None,
                 incident_routing_team: Optional[pulumi.Input[str]] = None,
                 manifest_owners: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 resource_access_policy: Optional[pulumi.Input[str]] = None,
                 resource_access_roles: Optional[pulumi.Input[Sequence[Any]]] = None,
                 schema_owners: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 service_tree_infos: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]] = None):
        if incident_contact_email is not None:
            pulumi.set(__self__, "incident_contact_email", incident_contact_email)
        if incident_routing_service is not None:
            pulumi.set(__self__, "incident_routing_service", incident_routing_service)
        if incident_routing_team is not None:
            pulumi.set(__self__, "incident_routing_team", incident_routing_team)
        if manifest_owners is not None:
            pulumi.set(__self__, "manifest_owners", manifest_owners)
        if resource_access_policy is not None:
            pulumi.set(__self__, "resource_access_policy", resource_access_policy)
        if resource_access_roles is not None:
            pulumi.set(__self__, "resource_access_roles", resource_access_roles)
        if schema_owners is not None:
            pulumi.set(__self__, "schema_owners", schema_owners)
        if service_tree_infos is not None:
            pulumi.set(__self__, "service_tree_infos", service_tree_infos)

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="resourceAccessRoles")
    def resource_access_roles(self) -> Optional[pulumi.Input[Sequence[Any]]]:
        return pulumi.get(self, "resource_access_roles")

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

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

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

    @property
    @pulumi.getter(name="serviceTreeInfos")
    def service_tree_infos(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]]:
        return pulumi.get(self, "service_tree_infos")

    @service_tree_infos.setter
    def service_tree_infos(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]]):
        pulumi.set(self, "service_tree_infos", value)


@pulumi.input_type
class ResourceProviderManifestPropertiesProviderAuthenticationArgs:
    def __init__(__self__, *,
                 allowed_audiences: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "allowed_audiences", allowed_audiences)

    @property
    @pulumi.getter(name="allowedAudiences")
    def allowed_audiences(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "allowed_audiences")

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


@pulumi.input_type
class ResourceProviderManifestPropertiesRequestHeaderOptionsArgs:
    def __init__(__self__, *,
                 opt_in_headers: Optional[pulumi.Input[Union[str, 'OptInHeaderType']]] = None):
        if opt_in_headers is not None:
            pulumi.set(__self__, "opt_in_headers", opt_in_headers)

    @property
    @pulumi.getter(name="optInHeaders")
    def opt_in_headers(self) -> Optional[pulumi.Input[Union[str, 'OptInHeaderType']]]:
        return pulumi.get(self, "opt_in_headers")

    @opt_in_headers.setter
    def opt_in_headers(self, value: Optional[pulumi.Input[Union[str, 'OptInHeaderType']]]):
        pulumi.set(self, "opt_in_headers", value)


@pulumi.input_type
class ResourceProviderManifestPropertiesTemplateDeploymentOptionsArgs:
    def __init__(__self__, *,
                 preflight_options: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'PreflightOption']]]]] = None,
                 preflight_supported: Optional[pulumi.Input[bool]] = None):
        if preflight_options is not None:
            pulumi.set(__self__, "preflight_options", preflight_options)
        if preflight_supported is not None:
            pulumi.set(__self__, "preflight_supported", preflight_supported)

    @property
    @pulumi.getter(name="preflightOptions")
    def preflight_options(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'PreflightOption']]]]]:
        return pulumi.get(self, "preflight_options")

    @preflight_options.setter
    def preflight_options(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'PreflightOption']]]]]):
        pulumi.set(self, "preflight_options", value)

    @property
    @pulumi.getter(name="preflightSupported")
    def preflight_supported(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "preflight_supported")

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


@pulumi.input_type
class ResourceTypeEndpointFeaturesRuleArgs:
    def __init__(__self__, *,
                 required_features_policy: pulumi.Input[Union[str, 'FeaturesPolicy']]):
        pulumi.set(__self__, "required_features_policy", required_features_policy)

    @property
    @pulumi.getter(name="requiredFeaturesPolicy")
    def required_features_policy(self) -> pulumi.Input[Union[str, 'FeaturesPolicy']]:
        return pulumi.get(self, "required_features_policy")

    @required_features_policy.setter
    def required_features_policy(self, value: pulumi.Input[Union[str, 'FeaturesPolicy']]):
        pulumi.set(self, "required_features_policy", value)


@pulumi.input_type
class ResourceTypeEndpointArgs:
    def __init__(__self__, *,
                 api_versions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 endpoint_type: Optional[pulumi.Input[Union[str, 'EndpointType']]] = None,
                 extensions: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeExtensionArgs']]]] = None,
                 features_rule: Optional[pulumi.Input['ResourceTypeEndpointFeaturesRuleArgs']] = None,
                 locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 required_features: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 timeout: Optional[pulumi.Input[str]] = None):
        if api_versions is not None:
            pulumi.set(__self__, "api_versions", api_versions)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)
        if extensions is not None:
            pulumi.set(__self__, "extensions", extensions)
        if features_rule is not None:
            pulumi.set(__self__, "features_rule", features_rule)
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if required_features is not None:
            pulumi.set(__self__, "required_features", required_features)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> Optional[pulumi.Input[Union[str, 'EndpointType']]]:
        return pulumi.get(self, "endpoint_type")

    @endpoint_type.setter
    def endpoint_type(self, value: Optional[pulumi.Input[Union[str, 'EndpointType']]]):
        pulumi.set(self, "endpoint_type", value)

    @property
    @pulumi.getter
    def extensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeExtensionArgs']]]]:
        return pulumi.get(self, "extensions")

    @extensions.setter
    def extensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeExtensionArgs']]]]):
        pulumi.set(self, "extensions", value)

    @property
    @pulumi.getter(name="featuresRule")
    def features_rule(self) -> Optional[pulumi.Input['ResourceTypeEndpointFeaturesRuleArgs']]:
        return pulumi.get(self, "features_rule")

    @features_rule.setter
    def features_rule(self, value: Optional[pulumi.Input['ResourceTypeEndpointFeaturesRuleArgs']]):
        pulumi.set(self, "features_rule", value)

    @property
    @pulumi.getter
    def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "locations")

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

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

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

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

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


@pulumi.input_type
class ResourceTypeExtensionOptionsResourceCreationBeginArgs:
    def __init__(__self__, *,
                 request: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionOptionType']]]]] = None,
                 response: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionOptionType']]]]] = None):
        if request is not None:
            pulumi.set(__self__, "request", request)
        if response is not None:
            pulumi.set(__self__, "response", response)

    @property
    @pulumi.getter
    def request(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionOptionType']]]]]:
        return pulumi.get(self, "request")

    @request.setter
    def request(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionOptionType']]]]]):
        pulumi.set(self, "request", value)

    @property
    @pulumi.getter
    def response(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionOptionType']]]]]:
        return pulumi.get(self, "response")

    @response.setter
    def response(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionOptionType']]]]]):
        pulumi.set(self, "response", value)


@pulumi.input_type
class ResourceTypeExtensionArgs:
    def __init__(__self__, *,
                 endpoint_uri: Optional[pulumi.Input[str]] = None,
                 extension_categories: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionCategory']]]]] = None,
                 timeout: Optional[pulumi.Input[str]] = None):
        if endpoint_uri is not None:
            pulumi.set(__self__, "endpoint_uri", endpoint_uri)
        if extension_categories is not None:
            pulumi.set(__self__, "extension_categories", extension_categories)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

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

    @property
    @pulumi.getter(name="extensionCategories")
    def extension_categories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionCategory']]]]]:
        return pulumi.get(self, "extension_categories")

    @extension_categories.setter
    def extension_categories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExtensionCategory']]]]]):
        pulumi.set(self, "extension_categories", value)

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

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


@pulumi.input_type
class ResourceTypeRegistrationPropertiesCheckNameAvailabilitySpecificationsArgs:
    def __init__(__self__, *,
                 enable_default_validation: Optional[pulumi.Input[bool]] = None,
                 resource_types_with_custom_validation: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if enable_default_validation is not None:
            pulumi.set(__self__, "enable_default_validation", enable_default_validation)
        if resource_types_with_custom_validation is not None:
            pulumi.set(__self__, "resource_types_with_custom_validation", resource_types_with_custom_validation)

    @property
    @pulumi.getter(name="enableDefaultValidation")
    def enable_default_validation(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_default_validation")

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

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

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


@pulumi.input_type
class ResourceTypeRegistrationPropertiesExtensionOptionsArgs:
    def __init__(__self__, *,
                 resource_creation_begin: Optional[pulumi.Input['ResourceTypeExtensionOptionsResourceCreationBeginArgs']] = None):
        if resource_creation_begin is not None:
            pulumi.set(__self__, "resource_creation_begin", resource_creation_begin)

    @property
    @pulumi.getter(name="resourceCreationBegin")
    def resource_creation_begin(self) -> Optional[pulumi.Input['ResourceTypeExtensionOptionsResourceCreationBeginArgs']]:
        return pulumi.get(self, "resource_creation_begin")

    @resource_creation_begin.setter
    def resource_creation_begin(self, value: Optional[pulumi.Input['ResourceTypeExtensionOptionsResourceCreationBeginArgs']]):
        pulumi.set(self, "resource_creation_begin", value)


@pulumi.input_type
class ResourceTypeRegistrationPropertiesFeaturesRuleArgs:
    def __init__(__self__, *,
                 required_features_policy: pulumi.Input[Union[str, 'FeaturesPolicy']]):
        pulumi.set(__self__, "required_features_policy", required_features_policy)

    @property
    @pulumi.getter(name="requiredFeaturesPolicy")
    def required_features_policy(self) -> pulumi.Input[Union[str, 'FeaturesPolicy']]:
        return pulumi.get(self, "required_features_policy")

    @required_features_policy.setter
    def required_features_policy(self, value: pulumi.Input[Union[str, 'FeaturesPolicy']]):
        pulumi.set(self, "required_features_policy", value)


@pulumi.input_type
class ResourceTypeRegistrationPropertiesIdentityManagementArgs:
    def __init__(__self__, *,
                 application_id: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[Union[str, 'IdentityManagementTypes']]] = None):
        if application_id is not None:
            pulumi.set(__self__, "application_id", application_id)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[Union[str, 'IdentityManagementTypes']]]:
        return pulumi.get(self, "type")

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


@pulumi.input_type
class ResourceTypeRegistrationPropertiesManagementArgs:
    def __init__(__self__, *,
                 incident_contact_email: Optional[pulumi.Input[str]] = None,
                 incident_routing_service: Optional[pulumi.Input[str]] = None,
                 incident_routing_team: Optional[pulumi.Input[str]] = None,
                 manifest_owners: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 resource_access_policy: Optional[pulumi.Input[str]] = None,
                 resource_access_roles: Optional[pulumi.Input[Sequence[Any]]] = None,
                 schema_owners: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 service_tree_infos: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]] = None):
        if incident_contact_email is not None:
            pulumi.set(__self__, "incident_contact_email", incident_contact_email)
        if incident_routing_service is not None:
            pulumi.set(__self__, "incident_routing_service", incident_routing_service)
        if incident_routing_team is not None:
            pulumi.set(__self__, "incident_routing_team", incident_routing_team)
        if manifest_owners is not None:
            pulumi.set(__self__, "manifest_owners", manifest_owners)
        if resource_access_policy is not None:
            pulumi.set(__self__, "resource_access_policy", resource_access_policy)
        if resource_access_roles is not None:
            pulumi.set(__self__, "resource_access_roles", resource_access_roles)
        if schema_owners is not None:
            pulumi.set(__self__, "schema_owners", schema_owners)
        if service_tree_infos is not None:
            pulumi.set(__self__, "service_tree_infos", service_tree_infos)

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="resourceAccessRoles")
    def resource_access_roles(self) -> Optional[pulumi.Input[Sequence[Any]]]:
        return pulumi.get(self, "resource_access_roles")

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

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

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

    @property
    @pulumi.getter(name="serviceTreeInfos")
    def service_tree_infos(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]]:
        return pulumi.get(self, "service_tree_infos")

    @service_tree_infos.setter
    def service_tree_infos(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]]):
        pulumi.set(self, "service_tree_infos", value)


@pulumi.input_type
class ResourceTypeRegistrationPropertiesRequestHeaderOptionsArgs:
    def __init__(__self__, *,
                 opt_in_headers: Optional[pulumi.Input[Union[str, 'OptInHeaderType']]] = None):
        if opt_in_headers is not None:
            pulumi.set(__self__, "opt_in_headers", opt_in_headers)

    @property
    @pulumi.getter(name="optInHeaders")
    def opt_in_headers(self) -> Optional[pulumi.Input[Union[str, 'OptInHeaderType']]]:
        return pulumi.get(self, "opt_in_headers")

    @opt_in_headers.setter
    def opt_in_headers(self, value: Optional[pulumi.Input[Union[str, 'OptInHeaderType']]]):
        pulumi.set(self, "opt_in_headers", value)


@pulumi.input_type
class ResourceTypeRegistrationPropertiesResourceGraphConfigurationArgs:
    def __init__(__self__, *,
                 api_version: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        if api_version is not None:
            pulumi.set(__self__, "api_version", api_version)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enabled")

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


@pulumi.input_type
class ResourceTypeRegistrationPropertiesResourceMovePolicyArgs:
    def __init__(__self__, *,
                 cross_resource_group_move_enabled: Optional[pulumi.Input[bool]] = None,
                 cross_subscription_move_enabled: Optional[pulumi.Input[bool]] = None,
                 validation_required: Optional[pulumi.Input[bool]] = None):
        if cross_resource_group_move_enabled is not None:
            pulumi.set(__self__, "cross_resource_group_move_enabled", cross_resource_group_move_enabled)
        if cross_subscription_move_enabled is not None:
            pulumi.set(__self__, "cross_subscription_move_enabled", cross_subscription_move_enabled)
        if validation_required is not None:
            pulumi.set(__self__, "validation_required", validation_required)

    @property
    @pulumi.getter(name="crossResourceGroupMoveEnabled")
    def cross_resource_group_move_enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "cross_resource_group_move_enabled")

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

    @property
    @pulumi.getter(name="crossSubscriptionMoveEnabled")
    def cross_subscription_move_enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "cross_subscription_move_enabled")

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

    @property
    @pulumi.getter(name="validationRequired")
    def validation_required(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "validation_required")

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


@pulumi.input_type
class ResourceTypeRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs:
    def __init__(__self__, *,
                 soft_delete_ttl: Optional[pulumi.Input[str]] = None,
                 subscription_state_override_actions: Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateOverrideActionArgs']]]] = None):
        if soft_delete_ttl is not None:
            pulumi.set(__self__, "soft_delete_ttl", soft_delete_ttl)
        if subscription_state_override_actions is not None:
            pulumi.set(__self__, "subscription_state_override_actions", subscription_state_override_actions)

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

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

    @property
    @pulumi.getter(name="subscriptionStateOverrideActions")
    def subscription_state_override_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateOverrideActionArgs']]]]:
        return pulumi.get(self, "subscription_state_override_actions")

    @subscription_state_override_actions.setter
    def subscription_state_override_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateOverrideActionArgs']]]]):
        pulumi.set(self, "subscription_state_override_actions", value)


@pulumi.input_type
class ResourceTypeRegistrationPropertiesTemplateDeploymentOptionsArgs:
    def __init__(__self__, *,
                 preflight_options: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'PreflightOption']]]]] = None,
                 preflight_supported: Optional[pulumi.Input[bool]] = None):
        if preflight_options is not None:
            pulumi.set(__self__, "preflight_options", preflight_options)
        if preflight_supported is not None:
            pulumi.set(__self__, "preflight_supported", preflight_supported)

    @property
    @pulumi.getter(name="preflightOptions")
    def preflight_options(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'PreflightOption']]]]]:
        return pulumi.get(self, "preflight_options")

    @preflight_options.setter
    def preflight_options(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'PreflightOption']]]]]):
        pulumi.set(self, "preflight_options", value)

    @property
    @pulumi.getter(name="preflightSupported")
    def preflight_supported(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "preflight_supported")

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


@pulumi.input_type
class ResourceTypeRegistrationPropertiesArgs:
    def __init__(__self__, *,
                 allowed_unauthorized_actions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 authorization_action_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationActionMappingArgs']]]] = None,
                 check_name_availability_specifications: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesCheckNameAvailabilitySpecificationsArgs']] = None,
                 default_api_version: Optional[pulumi.Input[str]] = None,
                 disallowed_action_verbs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 enable_async_operation: Optional[pulumi.Input[bool]] = None,
                 enable_third_party_s2_s: Optional[pulumi.Input[bool]] = None,
                 endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeEndpointArgs']]]] = None,
                 extended_locations: Optional[pulumi.Input[Sequence[pulumi.Input['ExtendedLocationOptionsArgs']]]] = None,
                 extension_options: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesExtensionOptionsArgs']] = None,
                 features_rule: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesFeaturesRuleArgs']] = None,
                 identity_management: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesIdentityManagementArgs']] = None,
                 is_pure_proxy: Optional[pulumi.Input[bool]] = None,
                 linked_access_checks: Optional[pulumi.Input[Sequence[pulumi.Input['LinkedAccessCheckArgs']]]] = None,
                 logging_rules: Optional[pulumi.Input[Sequence[pulumi.Input['LoggingRuleArgs']]]] = None,
                 management: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesManagementArgs']] = None,
                 marketplace_type: Optional[pulumi.Input[str]] = None,
                 open_api_configuration: Optional[pulumi.Input['OpenApiConfigurationArgs']] = None,
                 provisioning_state: Optional[pulumi.Input[Union[str, 'ProvisioningState']]] = None,
                 regionality: Optional[pulumi.Input[Union[str, 'Regionality']]] = None,
                 request_header_options: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesRequestHeaderOptionsArgs']] = None,
                 required_features: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 resource_concurrency_control_options: Optional[pulumi.Input[Mapping[str, pulumi.Input['ResourceConcurrencyControlOptionArgs']]]] = None,
                 resource_deletion_policy: Optional[pulumi.Input[Union[str, 'ResourceDeletionPolicy']]] = None,
                 resource_graph_configuration: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesResourceGraphConfigurationArgs']] = None,
                 resource_move_policy: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesResourceMovePolicyArgs']] = None,
                 routing_type: Optional[pulumi.Input[Union[str, 'RoutingType']]] = None,
                 service_tree_infos: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]] = None,
                 subscription_lifecycle_notification_specifications: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs']] = None,
                 subscription_state_rules: Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateRuleArgs']]]] = None,
                 swagger_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['SwaggerSpecificationArgs']]]] = None,
                 template_deployment_options: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesTemplateDeploymentOptionsArgs']] = None,
                 throttling_rules: Optional[pulumi.Input[Sequence[pulumi.Input['ThrottlingRuleArgs']]]] = None):
        """
        :param pulumi.Input[Union[str, 'ProvisioningState']] provisioning_state: The provisioned state of the resource.
        """
        if allowed_unauthorized_actions is not None:
            pulumi.set(__self__, "allowed_unauthorized_actions", allowed_unauthorized_actions)
        if authorization_action_mappings is not None:
            pulumi.set(__self__, "authorization_action_mappings", authorization_action_mappings)
        if check_name_availability_specifications is not None:
            pulumi.set(__self__, "check_name_availability_specifications", check_name_availability_specifications)
        if default_api_version is not None:
            pulumi.set(__self__, "default_api_version", default_api_version)
        if disallowed_action_verbs is not None:
            pulumi.set(__self__, "disallowed_action_verbs", disallowed_action_verbs)
        if enable_async_operation is not None:
            pulumi.set(__self__, "enable_async_operation", enable_async_operation)
        if enable_third_party_s2_s is not None:
            pulumi.set(__self__, "enable_third_party_s2_s", enable_third_party_s2_s)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if extended_locations is not None:
            pulumi.set(__self__, "extended_locations", extended_locations)
        if extension_options is not None:
            pulumi.set(__self__, "extension_options", extension_options)
        if features_rule is not None:
            pulumi.set(__self__, "features_rule", features_rule)
        if identity_management is not None:
            pulumi.set(__self__, "identity_management", identity_management)
        if is_pure_proxy is not None:
            pulumi.set(__self__, "is_pure_proxy", is_pure_proxy)
        if linked_access_checks is not None:
            pulumi.set(__self__, "linked_access_checks", linked_access_checks)
        if logging_rules is not None:
            pulumi.set(__self__, "logging_rules", logging_rules)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if marketplace_type is not None:
            pulumi.set(__self__, "marketplace_type", marketplace_type)
        if open_api_configuration is not None:
            pulumi.set(__self__, "open_api_configuration", open_api_configuration)
        if provisioning_state is not None:
            pulumi.set(__self__, "provisioning_state", provisioning_state)
        if regionality is not None:
            pulumi.set(__self__, "regionality", regionality)
        if request_header_options is not None:
            pulumi.set(__self__, "request_header_options", request_header_options)
        if required_features is not None:
            pulumi.set(__self__, "required_features", required_features)
        if resource_concurrency_control_options is not None:
            pulumi.set(__self__, "resource_concurrency_control_options", resource_concurrency_control_options)
        if resource_deletion_policy is not None:
            pulumi.set(__self__, "resource_deletion_policy", resource_deletion_policy)
        if resource_graph_configuration is not None:
            pulumi.set(__self__, "resource_graph_configuration", resource_graph_configuration)
        if resource_move_policy is not None:
            pulumi.set(__self__, "resource_move_policy", resource_move_policy)
        if routing_type is not None:
            pulumi.set(__self__, "routing_type", routing_type)
        if service_tree_infos is not None:
            pulumi.set(__self__, "service_tree_infos", service_tree_infos)
        if subscription_lifecycle_notification_specifications is not None:
            pulumi.set(__self__, "subscription_lifecycle_notification_specifications", subscription_lifecycle_notification_specifications)
        if subscription_state_rules is not None:
            pulumi.set(__self__, "subscription_state_rules", subscription_state_rules)
        if swagger_specifications is not None:
            pulumi.set(__self__, "swagger_specifications", swagger_specifications)
        if template_deployment_options is not None:
            pulumi.set(__self__, "template_deployment_options", template_deployment_options)
        if throttling_rules is not None:
            pulumi.set(__self__, "throttling_rules", throttling_rules)

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

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

    @property
    @pulumi.getter(name="authorizationActionMappings")
    def authorization_action_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationActionMappingArgs']]]]:
        return pulumi.get(self, "authorization_action_mappings")

    @authorization_action_mappings.setter
    def authorization_action_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationActionMappingArgs']]]]):
        pulumi.set(self, "authorization_action_mappings", value)

    @property
    @pulumi.getter(name="checkNameAvailabilitySpecifications")
    def check_name_availability_specifications(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesCheckNameAvailabilitySpecificationsArgs']]:
        return pulumi.get(self, "check_name_availability_specifications")

    @check_name_availability_specifications.setter
    def check_name_availability_specifications(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesCheckNameAvailabilitySpecificationsArgs']]):
        pulumi.set(self, "check_name_availability_specifications", value)

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

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

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

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

    @property
    @pulumi.getter(name="enableAsyncOperation")
    def enable_async_operation(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_async_operation")

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

    @property
    @pulumi.getter(name="enableThirdPartyS2S")
    def enable_third_party_s2_s(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_third_party_s2_s")

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

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeEndpointArgs']]]]:
        return pulumi.get(self, "endpoints")

    @endpoints.setter
    def endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceTypeEndpointArgs']]]]):
        pulumi.set(self, "endpoints", value)

    @property
    @pulumi.getter(name="extendedLocations")
    def extended_locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ExtendedLocationOptionsArgs']]]]:
        return pulumi.get(self, "extended_locations")

    @extended_locations.setter
    def extended_locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ExtendedLocationOptionsArgs']]]]):
        pulumi.set(self, "extended_locations", value)

    @property
    @pulumi.getter(name="extensionOptions")
    def extension_options(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesExtensionOptionsArgs']]:
        return pulumi.get(self, "extension_options")

    @extension_options.setter
    def extension_options(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesExtensionOptionsArgs']]):
        pulumi.set(self, "extension_options", value)

    @property
    @pulumi.getter(name="featuresRule")
    def features_rule(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesFeaturesRuleArgs']]:
        return pulumi.get(self, "features_rule")

    @features_rule.setter
    def features_rule(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesFeaturesRuleArgs']]):
        pulumi.set(self, "features_rule", value)

    @property
    @pulumi.getter(name="identityManagement")
    def identity_management(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesIdentityManagementArgs']]:
        return pulumi.get(self, "identity_management")

    @identity_management.setter
    def identity_management(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesIdentityManagementArgs']]):
        pulumi.set(self, "identity_management", value)

    @property
    @pulumi.getter(name="isPureProxy")
    def is_pure_proxy(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "is_pure_proxy")

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

    @property
    @pulumi.getter(name="linkedAccessChecks")
    def linked_access_checks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LinkedAccessCheckArgs']]]]:
        return pulumi.get(self, "linked_access_checks")

    @linked_access_checks.setter
    def linked_access_checks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LinkedAccessCheckArgs']]]]):
        pulumi.set(self, "linked_access_checks", value)

    @property
    @pulumi.getter(name="loggingRules")
    def logging_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoggingRuleArgs']]]]:
        return pulumi.get(self, "logging_rules")

    @logging_rules.setter
    def logging_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoggingRuleArgs']]]]):
        pulumi.set(self, "logging_rules", value)

    @property
    @pulumi.getter
    def management(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesManagementArgs']]:
        return pulumi.get(self, "management")

    @management.setter
    def management(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesManagementArgs']]):
        pulumi.set(self, "management", value)

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

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

    @property
    @pulumi.getter(name="openApiConfiguration")
    def open_api_configuration(self) -> Optional[pulumi.Input['OpenApiConfigurationArgs']]:
        return pulumi.get(self, "open_api_configuration")

    @open_api_configuration.setter
    def open_api_configuration(self, value: Optional[pulumi.Input['OpenApiConfigurationArgs']]):
        pulumi.set(self, "open_api_configuration", value)

    @property
    @pulumi.getter(name="provisioningState")
    def provisioning_state(self) -> Optional[pulumi.Input[Union[str, 'ProvisioningState']]]:
        """
        The provisioned state of the resource.
        """
        return pulumi.get(self, "provisioning_state")

    @provisioning_state.setter
    def provisioning_state(self, value: Optional[pulumi.Input[Union[str, 'ProvisioningState']]]):
        pulumi.set(self, "provisioning_state", value)

    @property
    @pulumi.getter
    def regionality(self) -> Optional[pulumi.Input[Union[str, 'Regionality']]]:
        return pulumi.get(self, "regionality")

    @regionality.setter
    def regionality(self, value: Optional[pulumi.Input[Union[str, 'Regionality']]]):
        pulumi.set(self, "regionality", value)

    @property
    @pulumi.getter(name="requestHeaderOptions")
    def request_header_options(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesRequestHeaderOptionsArgs']]:
        return pulumi.get(self, "request_header_options")

    @request_header_options.setter
    def request_header_options(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesRequestHeaderOptionsArgs']]):
        pulumi.set(self, "request_header_options", value)

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

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

    @property
    @pulumi.getter(name="resourceConcurrencyControlOptions")
    def resource_concurrency_control_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input['ResourceConcurrencyControlOptionArgs']]]]:
        return pulumi.get(self, "resource_concurrency_control_options")

    @resource_concurrency_control_options.setter
    def resource_concurrency_control_options(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['ResourceConcurrencyControlOptionArgs']]]]):
        pulumi.set(self, "resource_concurrency_control_options", value)

    @property
    @pulumi.getter(name="resourceDeletionPolicy")
    def resource_deletion_policy(self) -> Optional[pulumi.Input[Union[str, 'ResourceDeletionPolicy']]]:
        return pulumi.get(self, "resource_deletion_policy")

    @resource_deletion_policy.setter
    def resource_deletion_policy(self, value: Optional[pulumi.Input[Union[str, 'ResourceDeletionPolicy']]]):
        pulumi.set(self, "resource_deletion_policy", value)

    @property
    @pulumi.getter(name="resourceGraphConfiguration")
    def resource_graph_configuration(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesResourceGraphConfigurationArgs']]:
        return pulumi.get(self, "resource_graph_configuration")

    @resource_graph_configuration.setter
    def resource_graph_configuration(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesResourceGraphConfigurationArgs']]):
        pulumi.set(self, "resource_graph_configuration", value)

    @property
    @pulumi.getter(name="resourceMovePolicy")
    def resource_move_policy(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesResourceMovePolicyArgs']]:
        return pulumi.get(self, "resource_move_policy")

    @resource_move_policy.setter
    def resource_move_policy(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesResourceMovePolicyArgs']]):
        pulumi.set(self, "resource_move_policy", value)

    @property
    @pulumi.getter(name="routingType")
    def routing_type(self) -> Optional[pulumi.Input[Union[str, 'RoutingType']]]:
        return pulumi.get(self, "routing_type")

    @routing_type.setter
    def routing_type(self, value: Optional[pulumi.Input[Union[str, 'RoutingType']]]):
        pulumi.set(self, "routing_type", value)

    @property
    @pulumi.getter(name="serviceTreeInfos")
    def service_tree_infos(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]]:
        return pulumi.get(self, "service_tree_infos")

    @service_tree_infos.setter
    def service_tree_infos(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTreeInfoArgs']]]]):
        pulumi.set(self, "service_tree_infos", value)

    @property
    @pulumi.getter(name="subscriptionLifecycleNotificationSpecifications")
    def subscription_lifecycle_notification_specifications(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs']]:
        return pulumi.get(self, "subscription_lifecycle_notification_specifications")

    @subscription_lifecycle_notification_specifications.setter
    def subscription_lifecycle_notification_specifications(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesSubscriptionLifecycleNotificationSpecificationsArgs']]):
        pulumi.set(self, "subscription_lifecycle_notification_specifications", value)

    @property
    @pulumi.getter(name="subscriptionStateRules")
    def subscription_state_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateRuleArgs']]]]:
        return pulumi.get(self, "subscription_state_rules")

    @subscription_state_rules.setter
    def subscription_state_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubscriptionStateRuleArgs']]]]):
        pulumi.set(self, "subscription_state_rules", value)

    @property
    @pulumi.getter(name="swaggerSpecifications")
    def swagger_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SwaggerSpecificationArgs']]]]:
        return pulumi.get(self, "swagger_specifications")

    @swagger_specifications.setter
    def swagger_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SwaggerSpecificationArgs']]]]):
        pulumi.set(self, "swagger_specifications", value)

    @property
    @pulumi.getter(name="templateDeploymentOptions")
    def template_deployment_options(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesTemplateDeploymentOptionsArgs']]:
        return pulumi.get(self, "template_deployment_options")

    @template_deployment_options.setter
    def template_deployment_options(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesTemplateDeploymentOptionsArgs']]):
        pulumi.set(self, "template_deployment_options", value)

    @property
    @pulumi.getter(name="throttlingRules")
    def throttling_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ThrottlingRuleArgs']]]]:
        return pulumi.get(self, "throttling_rules")

    @throttling_rules.setter
    def throttling_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ThrottlingRuleArgs']]]]):
        pulumi.set(self, "throttling_rules", value)


@pulumi.input_type
class ResourceTypeRegistrationArgs:
    def __init__(__self__, *,
                 properties: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesArgs']] = None):
        if properties is not None:
            pulumi.set(__self__, "properties", properties)

    @property
    @pulumi.getter
    def properties(self) -> Optional[pulumi.Input['ResourceTypeRegistrationPropertiesArgs']]:
        return pulumi.get(self, "properties")

    @properties.setter
    def properties(self, value: Optional[pulumi.Input['ResourceTypeRegistrationPropertiesArgs']]):
        pulumi.set(self, "properties", value)


@pulumi.input_type
class ServiceTreeInfoArgs:
    def __init__(__self__, *,
                 component_id: Optional[pulumi.Input[str]] = None,
                 service_id: Optional[pulumi.Input[str]] = None):
        if component_id is not None:
            pulumi.set(__self__, "component_id", component_id)
        if service_id is not None:
            pulumi.set(__self__, "service_id", service_id)

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

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

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

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


@pulumi.input_type
class SkuCapabilityArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        return pulumi.get(self, "value")

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


@pulumi.input_type
class SkuCostArgs:
    def __init__(__self__, *,
                 meter_id: pulumi.Input[str],
                 extended_unit: Optional[pulumi.Input[str]] = None,
                 quantity: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "meter_id", meter_id)
        if extended_unit is not None:
            pulumi.set(__self__, "extended_unit", extended_unit)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)

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

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

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

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

    @property
    @pulumi.getter
    def quantity(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "quantity")

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


@pulumi.input_type
class SkuLocationInfoArgs:
    def __init__(__self__, *,
                 location: pulumi.Input[str],
                 extended_locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 zone_details: Optional[pulumi.Input[Sequence[pulumi.Input['SkuZoneDetailArgs']]]] = None,
                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "location", location)
        if extended_locations is not None:
            pulumi.set(__self__, "extended_locations", extended_locations)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if zone_details is not None:
            pulumi.set(__self__, "zone_details", zone_details)
        if zones is not None:
            pulumi.set(__self__, "zones", zones)

    @property
    @pulumi.getter
    def location(self) -> pulumi.Input[str]:
        return pulumi.get(self, "location")

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

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

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

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

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

    @property
    @pulumi.getter(name="zoneDetails")
    def zone_details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkuZoneDetailArgs']]]]:
        return pulumi.get(self, "zone_details")

    @zone_details.setter
    def zone_details(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkuZoneDetailArgs']]]]):
        pulumi.set(self, "zone_details", value)

    @property
    @pulumi.getter
    def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "zones")

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


@pulumi.input_type
class SkuSettingCapacityArgs:
    def __init__(__self__, *,
                 minimum: pulumi.Input[int],
                 default: Optional[pulumi.Input[int]] = None,
                 maximum: Optional[pulumi.Input[int]] = None,
                 scale_type: Optional[pulumi.Input[Union[str, 'SkuScaleType']]] = None):
        pulumi.set(__self__, "minimum", minimum)
        if default is not None:
            pulumi.set(__self__, "default", default)
        if maximum is not None:
            pulumi.set(__self__, "maximum", maximum)
        if scale_type is not None:
            pulumi.set(__self__, "scale_type", scale_type)

    @property
    @pulumi.getter
    def minimum(self) -> pulumi.Input[int]:
        return pulumi.get(self, "minimum")

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

    @property
    @pulumi.getter
    def default(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "default")

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

    @property
    @pulumi.getter
    def maximum(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "maximum")

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

    @property
    @pulumi.getter(name="scaleType")
    def scale_type(self) -> Optional[pulumi.Input[Union[str, 'SkuScaleType']]]:
        return pulumi.get(self, "scale_type")

    @scale_type.setter
    def scale_type(self, value: Optional[pulumi.Input[Union[str, 'SkuScaleType']]]):
        pulumi.set(self, "scale_type", value)


@pulumi.input_type
class SkuSettingArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['SkuCapabilityArgs']]]] = None,
                 capacity: Optional[pulumi.Input['SkuSettingCapacityArgs']] = None,
                 costs: Optional[pulumi.Input[Sequence[pulumi.Input['SkuCostArgs']]]] = None,
                 family: Optional[pulumi.Input[str]] = None,
                 kind: Optional[pulumi.Input[str]] = None,
                 location_info: Optional[pulumi.Input[Sequence[pulumi.Input['SkuLocationInfoArgs']]]] = None,
                 locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 required_features: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 required_quota_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 size: Optional[pulumi.Input[str]] = None,
                 tier: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "name", name)
        if capabilities is not None:
            pulumi.set(__self__, "capabilities", capabilities)
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if costs is not None:
            pulumi.set(__self__, "costs", costs)
        if family is not None:
            pulumi.set(__self__, "family", family)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)
        if location_info is not None:
            pulumi.set(__self__, "location_info", location_info)
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if required_features is not None:
            pulumi.set(__self__, "required_features", required_features)
        if required_quota_ids is not None:
            pulumi.set(__self__, "required_quota_ids", required_quota_ids)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if tier is not None:
            pulumi.set(__self__, "tier", tier)

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

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

    @property
    @pulumi.getter
    def capabilities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkuCapabilityArgs']]]]:
        return pulumi.get(self, "capabilities")

    @capabilities.setter
    def capabilities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkuCapabilityArgs']]]]):
        pulumi.set(self, "capabilities", value)

    @property
    @pulumi.getter
    def capacity(self) -> Optional[pulumi.Input['SkuSettingCapacityArgs']]:
        return pulumi.get(self, "capacity")

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

    @property
    @pulumi.getter
    def costs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkuCostArgs']]]]:
        return pulumi.get(self, "costs")

    @costs.setter
    def costs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkuCostArgs']]]]):
        pulumi.set(self, "costs", value)

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

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

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

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

    @property
    @pulumi.getter(name="locationInfo")
    def location_info(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkuLocationInfoArgs']]]]:
        return pulumi.get(self, "location_info")

    @location_info.setter
    def location_info(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkuLocationInfoArgs']]]]):
        pulumi.set(self, "location_info", value)

    @property
    @pulumi.getter
    def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "locations")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class SkuZoneDetailArgs:
    def __init__(__self__, *,
                 capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['SkuCapabilityArgs']]]] = None,
                 name: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if capabilities is not None:
            pulumi.set(__self__, "capabilities", capabilities)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def capabilities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkuCapabilityArgs']]]]:
        return pulumi.get(self, "capabilities")

    @capabilities.setter
    def capabilities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkuCapabilityArgs']]]]):
        pulumi.set(self, "capabilities", value)

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

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


@pulumi.input_type
class SubscriptionStateOverrideActionArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[Union[str, 'SubscriptionNotificationOperation']],
                 state: pulumi.Input[Union[str, 'SubscriptionTransitioningState']]):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[Union[str, 'SubscriptionNotificationOperation']]:
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input[Union[str, 'SubscriptionNotificationOperation']]):
        pulumi.set(self, "action", value)

    @property
    @pulumi.getter
    def state(self) -> pulumi.Input[Union[str, 'SubscriptionTransitioningState']]:
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: pulumi.Input[Union[str, 'SubscriptionTransitioningState']]):
        pulumi.set(self, "state", value)


@pulumi.input_type
class SubscriptionStateRuleArgs:
    def __init__(__self__, *,
                 allowed_actions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 state: Optional[pulumi.Input[Union[str, 'SubscriptionState']]] = None):
        if allowed_actions is not None:
            pulumi.set(__self__, "allowed_actions", allowed_actions)
        if state is not None:
            pulumi.set(__self__, "state", state)

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

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

    @property
    @pulumi.getter
    def state(self) -> Optional[pulumi.Input[Union[str, 'SubscriptionState']]]:
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: Optional[pulumi.Input[Union[str, 'SubscriptionState']]]):
        pulumi.set(self, "state", value)


@pulumi.input_type
class SwaggerSpecificationArgs:
    def __init__(__self__, *,
                 api_versions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 swagger_spec_folder_uri: Optional[pulumi.Input[str]] = None):
        if api_versions is not None:
            pulumi.set(__self__, "api_versions", api_versions)
        if swagger_spec_folder_uri is not None:
            pulumi.set(__self__, "swagger_spec_folder_uri", swagger_spec_folder_uri)

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

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

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

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


@pulumi.input_type
class ThrottlingMetricArgs:
    def __init__(__self__, *,
                 limit: pulumi.Input[float],
                 type: pulumi.Input[Union[str, 'ThrottlingMetricType']],
                 interval: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "limit", limit)
        pulumi.set(__self__, "type", type)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)

    @property
    @pulumi.getter
    def limit(self) -> pulumi.Input[float]:
        return pulumi.get(self, "limit")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[Union[str, 'ThrottlingMetricType']]:
        return pulumi.get(self, "type")

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

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

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


@pulumi.input_type
class ThrottlingRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str],
                 metrics: pulumi.Input[Sequence[pulumi.Input['ThrottlingMetricArgs']]],
                 required_features: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "metrics", metrics)
        if required_features is not None:
            pulumi.set(__self__, "required_features", required_features)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[str]:
        return pulumi.get(self, "action")

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

    @property
    @pulumi.getter
    def metrics(self) -> pulumi.Input[Sequence[pulumi.Input['ThrottlingMetricArgs']]]:
        return pulumi.get(self, "metrics")

    @metrics.setter
    def metrics(self, value: pulumi.Input[Sequence[pulumi.Input['ThrottlingMetricArgs']]]):
        pulumi.set(self, "metrics", value)

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

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


@pulumi.input_type
class TypedErrorInfoArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str]):
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "type")

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


