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

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

__all__ = [
    'ApiDiagnosticBackendRequestArgs',
    'ApiDiagnosticBackendRequestDataMaskingArgs',
    'ApiDiagnosticBackendRequestDataMaskingHeaderArgs',
    'ApiDiagnosticBackendRequestDataMaskingQueryParamArgs',
    'ApiDiagnosticBackendResponseArgs',
    'ApiDiagnosticBackendResponseDataMaskingArgs',
    'ApiDiagnosticBackendResponseDataMaskingHeaderArgs',
    'ApiDiagnosticBackendResponseDataMaskingQueryParamArgs',
    'ApiDiagnosticFrontendRequestArgs',
    'ApiDiagnosticFrontendRequestDataMaskingArgs',
    'ApiDiagnosticFrontendRequestDataMaskingHeaderArgs',
    'ApiDiagnosticFrontendRequestDataMaskingQueryParamArgs',
    'ApiDiagnosticFrontendResponseArgs',
    'ApiDiagnosticFrontendResponseDataMaskingArgs',
    'ApiDiagnosticFrontendResponseDataMaskingHeaderArgs',
    'ApiDiagnosticFrontendResponseDataMaskingQueryParamArgs',
    'ApiImportArgs',
    'ApiImportWsdlSelectorArgs',
    'ApiOauth2AuthorizationArgs',
    'ApiOpenidAuthenticationArgs',
    'ApiOperationRequestArgs',
    'ApiOperationRequestHeaderArgs',
    'ApiOperationRequestQueryParameterArgs',
    'ApiOperationRequestRepresentationArgs',
    'ApiOperationRequestRepresentationExampleArgs',
    'ApiOperationRequestRepresentationFormParameterArgs',
    'ApiOperationResponseArgs',
    'ApiOperationResponseHeaderArgs',
    'ApiOperationResponseRepresentationArgs',
    'ApiOperationResponseRepresentationExampleArgs',
    'ApiOperationResponseRepresentationFormParameterArgs',
    'ApiOperationTemplateParameterArgs',
    'ApiSubscriptionKeyParameterNamesArgs',
    'AuthorizationServerTokenBodyParameterArgs',
    'BackendCredentialsArgs',
    'BackendCredentialsAuthorizationArgs',
    'BackendProxyArgs',
    'BackendServiceFabricClusterArgs',
    'BackendServiceFabricClusterServerX509NameArgs',
    'BackendTlsArgs',
    'CustomDomainDeveloperPortalArgs',
    'CustomDomainGatewayArgs',
    'CustomDomainManagementArgs',
    'CustomDomainPortalArgs',
    'CustomDomainScmArgs',
    'DiagnosticBackendRequestArgs',
    'DiagnosticBackendRequestDataMaskingArgs',
    'DiagnosticBackendRequestDataMaskingHeaderArgs',
    'DiagnosticBackendRequestDataMaskingQueryParamArgs',
    'DiagnosticBackendResponseArgs',
    'DiagnosticBackendResponseDataMaskingArgs',
    'DiagnosticBackendResponseDataMaskingHeaderArgs',
    'DiagnosticBackendResponseDataMaskingQueryParamArgs',
    'DiagnosticFrontendRequestArgs',
    'DiagnosticFrontendRequestDataMaskingArgs',
    'DiagnosticFrontendRequestDataMaskingHeaderArgs',
    'DiagnosticFrontendRequestDataMaskingQueryParamArgs',
    'DiagnosticFrontendResponseArgs',
    'DiagnosticFrontendResponseDataMaskingArgs',
    'DiagnosticFrontendResponseDataMaskingHeaderArgs',
    'DiagnosticFrontendResponseDataMaskingQueryParamArgs',
    'GatewayLocationDataArgs',
    'LoggerApplicationInsightsArgs',
    'LoggerEventhubArgs',
    'NamedValueValueFromKeyVaultArgs',
    'ServiceAdditionalLocationArgs',
    'ServiceAdditionalLocationVirtualNetworkConfigurationArgs',
    'ServiceCertificateArgs',
    'ServiceHostnameConfigurationArgs',
    'ServiceHostnameConfigurationDeveloperPortalArgs',
    'ServiceHostnameConfigurationManagementArgs',
    'ServiceHostnameConfigurationPortalArgs',
    'ServiceHostnameConfigurationProxyArgs',
    'ServiceHostnameConfigurationScmArgs',
    'ServiceIdentityArgs',
    'ServicePolicyArgs',
    'ServiceProtocolsArgs',
    'ServiceSecurityArgs',
    'ServiceSignInArgs',
    'ServiceSignUpArgs',
    'ServiceSignUpTermsOfServiceArgs',
    'ServiceTenantAccessArgs',
    'ServiceVirtualNetworkConfigurationArgs',
]

@pulumi.input_type
class ApiDiagnosticBackendRequestArgs:
    def __init__(__self__, *,
                 body_bytes: Optional[pulumi.Input[int]] = None,
                 data_masking: Optional[pulumi.Input['ApiDiagnosticBackendRequestDataMaskingArgs']] = None,
                 headers_to_logs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] body_bytes: Number of payload bytes to log (up to 8192).
        :param pulumi.Input['ApiDiagnosticBackendRequestDataMaskingArgs'] data_masking: A `data_masking` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] headers_to_logs: Specifies a list of headers to log.
        """
        if body_bytes is not None:
            pulumi.set(__self__, "body_bytes", body_bytes)
        if data_masking is not None:
            pulumi.set(__self__, "data_masking", data_masking)
        if headers_to_logs is not None:
            pulumi.set(__self__, "headers_to_logs", headers_to_logs)

    @property
    @pulumi.getter(name="bodyBytes")
    def body_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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

    @property
    @pulumi.getter(name="dataMasking")
    def data_masking(self) -> Optional[pulumi.Input['ApiDiagnosticBackendRequestDataMaskingArgs']]:
        """
        A `data_masking` block as defined below.
        """
        return pulumi.get(self, "data_masking")

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

    @property
    @pulumi.getter(name="headersToLogs")
    def headers_to_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of headers to log.
        """
        return pulumi.get(self, "headers_to_logs")

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


@pulumi.input_type
class ApiDiagnosticBackendRequestDataMaskingArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendRequestDataMaskingHeaderArgs']]]] = None,
                 query_params: Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendRequestDataMaskingQueryParamArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendRequestDataMaskingHeaderArgs']]] headers: A `headers` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendRequestDataMaskingQueryParamArgs']]] query_params: A `query_params` block as defined below.
        """
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_params is not None:
            pulumi.set(__self__, "query_params", query_params)

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendRequestDataMaskingHeaderArgs']]]]:
        """
        A `headers` block as defined below.
        """
        return pulumi.get(self, "headers")

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

    @property
    @pulumi.getter(name="queryParams")
    def query_params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendRequestDataMaskingQueryParamArgs']]]]:
        """
        A `query_params` block as defined below.
        """
        return pulumi.get(self, "query_params")

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


@pulumi.input_type
class ApiDiagnosticBackendRequestDataMaskingHeaderArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        :param pulumi.Input[str] value: The name of the header or the query parameter to mask.
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The name of the header or the query parameter to mask.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiDiagnosticBackendRequestDataMaskingQueryParamArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        :param pulumi.Input[str] value: The name of the header or the query parameter to mask.
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The name of the header or the query parameter to mask.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiDiagnosticBackendResponseArgs:
    def __init__(__self__, *,
                 body_bytes: Optional[pulumi.Input[int]] = None,
                 data_masking: Optional[pulumi.Input['ApiDiagnosticBackendResponseDataMaskingArgs']] = None,
                 headers_to_logs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] body_bytes: Number of payload bytes to log (up to 8192).
        :param pulumi.Input['ApiDiagnosticBackendResponseDataMaskingArgs'] data_masking: A `data_masking` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] headers_to_logs: Specifies a list of headers to log.
        """
        if body_bytes is not None:
            pulumi.set(__self__, "body_bytes", body_bytes)
        if data_masking is not None:
            pulumi.set(__self__, "data_masking", data_masking)
        if headers_to_logs is not None:
            pulumi.set(__self__, "headers_to_logs", headers_to_logs)

    @property
    @pulumi.getter(name="bodyBytes")
    def body_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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

    @property
    @pulumi.getter(name="dataMasking")
    def data_masking(self) -> Optional[pulumi.Input['ApiDiagnosticBackendResponseDataMaskingArgs']]:
        """
        A `data_masking` block as defined below.
        """
        return pulumi.get(self, "data_masking")

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

    @property
    @pulumi.getter(name="headersToLogs")
    def headers_to_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of headers to log.
        """
        return pulumi.get(self, "headers_to_logs")

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


@pulumi.input_type
class ApiDiagnosticBackendResponseDataMaskingArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendResponseDataMaskingHeaderArgs']]]] = None,
                 query_params: Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendResponseDataMaskingQueryParamArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendResponseDataMaskingHeaderArgs']]] headers: A `headers` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendResponseDataMaskingQueryParamArgs']]] query_params: A `query_params` block as defined below.
        """
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_params is not None:
            pulumi.set(__self__, "query_params", query_params)

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendResponseDataMaskingHeaderArgs']]]]:
        """
        A `headers` block as defined below.
        """
        return pulumi.get(self, "headers")

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

    @property
    @pulumi.getter(name="queryParams")
    def query_params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticBackendResponseDataMaskingQueryParamArgs']]]]:
        """
        A `query_params` block as defined below.
        """
        return pulumi.get(self, "query_params")

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


@pulumi.input_type
class ApiDiagnosticBackendResponseDataMaskingHeaderArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        :param pulumi.Input[str] value: The name of the header or the query parameter to mask.
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The name of the header or the query parameter to mask.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiDiagnosticBackendResponseDataMaskingQueryParamArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        :param pulumi.Input[str] value: The name of the header or the query parameter to mask.
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The name of the header or the query parameter to mask.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiDiagnosticFrontendRequestArgs:
    def __init__(__self__, *,
                 body_bytes: Optional[pulumi.Input[int]] = None,
                 data_masking: Optional[pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingArgs']] = None,
                 headers_to_logs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] body_bytes: Number of payload bytes to log (up to 8192).
        :param pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingArgs'] data_masking: A `data_masking` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] headers_to_logs: Specifies a list of headers to log.
        """
        if body_bytes is not None:
            pulumi.set(__self__, "body_bytes", body_bytes)
        if data_masking is not None:
            pulumi.set(__self__, "data_masking", data_masking)
        if headers_to_logs is not None:
            pulumi.set(__self__, "headers_to_logs", headers_to_logs)

    @property
    @pulumi.getter(name="bodyBytes")
    def body_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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

    @property
    @pulumi.getter(name="dataMasking")
    def data_masking(self) -> Optional[pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingArgs']]:
        """
        A `data_masking` block as defined below.
        """
        return pulumi.get(self, "data_masking")

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

    @property
    @pulumi.getter(name="headersToLogs")
    def headers_to_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of headers to log.
        """
        return pulumi.get(self, "headers_to_logs")

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


@pulumi.input_type
class ApiDiagnosticFrontendRequestDataMaskingArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingHeaderArgs']]]] = None,
                 query_params: Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingQueryParamArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingHeaderArgs']]] headers: A `headers` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingQueryParamArgs']]] query_params: A `query_params` block as defined below.
        """
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_params is not None:
            pulumi.set(__self__, "query_params", query_params)

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingHeaderArgs']]]]:
        """
        A `headers` block as defined below.
        """
        return pulumi.get(self, "headers")

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

    @property
    @pulumi.getter(name="queryParams")
    def query_params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendRequestDataMaskingQueryParamArgs']]]]:
        """
        A `query_params` block as defined below.
        """
        return pulumi.get(self, "query_params")

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


@pulumi.input_type
class ApiDiagnosticFrontendRequestDataMaskingHeaderArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        :param pulumi.Input[str] value: The name of the header or the query parameter to mask.
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The name of the header or the query parameter to mask.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiDiagnosticFrontendRequestDataMaskingQueryParamArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        :param pulumi.Input[str] value: The name of the header or the query parameter to mask.
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The name of the header or the query parameter to mask.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiDiagnosticFrontendResponseArgs:
    def __init__(__self__, *,
                 body_bytes: Optional[pulumi.Input[int]] = None,
                 data_masking: Optional[pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingArgs']] = None,
                 headers_to_logs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] body_bytes: Number of payload bytes to log (up to 8192).
        :param pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingArgs'] data_masking: A `data_masking` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] headers_to_logs: Specifies a list of headers to log.
        """
        if body_bytes is not None:
            pulumi.set(__self__, "body_bytes", body_bytes)
        if data_masking is not None:
            pulumi.set(__self__, "data_masking", data_masking)
        if headers_to_logs is not None:
            pulumi.set(__self__, "headers_to_logs", headers_to_logs)

    @property
    @pulumi.getter(name="bodyBytes")
    def body_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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

    @property
    @pulumi.getter(name="dataMasking")
    def data_masking(self) -> Optional[pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingArgs']]:
        """
        A `data_masking` block as defined below.
        """
        return pulumi.get(self, "data_masking")

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

    @property
    @pulumi.getter(name="headersToLogs")
    def headers_to_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of headers to log.
        """
        return pulumi.get(self, "headers_to_logs")

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


@pulumi.input_type
class ApiDiagnosticFrontendResponseDataMaskingArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingHeaderArgs']]]] = None,
                 query_params: Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingQueryParamArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingHeaderArgs']]] headers: A `headers` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingQueryParamArgs']]] query_params: A `query_params` block as defined below.
        """
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_params is not None:
            pulumi.set(__self__, "query_params", query_params)

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingHeaderArgs']]]]:
        """
        A `headers` block as defined below.
        """
        return pulumi.get(self, "headers")

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

    @property
    @pulumi.getter(name="queryParams")
    def query_params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiDiagnosticFrontendResponseDataMaskingQueryParamArgs']]]]:
        """
        A `query_params` block as defined below.
        """
        return pulumi.get(self, "query_params")

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


@pulumi.input_type
class ApiDiagnosticFrontendResponseDataMaskingHeaderArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        :param pulumi.Input[str] value: The name of the header or the query parameter to mask.
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The name of the header or the query parameter to mask.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiDiagnosticFrontendResponseDataMaskingQueryParamArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] mode: The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        :param pulumi.Input[str] value: The name of the header or the query parameter to mask.
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The data masking mode. Possible values are `Mask` and `Hide` for `query_params`. The only possible value is `Mask` for `headers`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The name of the header or the query parameter to mask.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiImportArgs:
    def __init__(__self__, *,
                 content_format: pulumi.Input[str],
                 content_value: pulumi.Input[str],
                 wsdl_selector: Optional[pulumi.Input['ApiImportWsdlSelectorArgs']] = None):
        """
        :param pulumi.Input[str] content_format: The format of the content from which the API Definition should be imported. Possible values are: `openapi`, `openapi+json`, `openapi+json-link`, `openapi-link`, `swagger-json`, `swagger-link-json`, `wadl-link-json`, `wadl-xml`, `wsdl` and `wsdl-link`.
        :param pulumi.Input[str] content_value: The Content from which the API Definition should be imported. When a `content_format` of `*-link-*` is specified this must be a URL, otherwise this must be defined inline.
        :param pulumi.Input['ApiImportWsdlSelectorArgs'] wsdl_selector: A `wsdl_selector` block as defined below, which allows you to limit the import of a WSDL to only a subset of the document. This can only be specified when `content_format` is `wsdl` or `wsdl-link`.
        """
        pulumi.set(__self__, "content_format", content_format)
        pulumi.set(__self__, "content_value", content_value)
        if wsdl_selector is not None:
            pulumi.set(__self__, "wsdl_selector", wsdl_selector)

    @property
    @pulumi.getter(name="contentFormat")
    def content_format(self) -> pulumi.Input[str]:
        """
        The format of the content from which the API Definition should be imported. Possible values are: `openapi`, `openapi+json`, `openapi+json-link`, `openapi-link`, `swagger-json`, `swagger-link-json`, `wadl-link-json`, `wadl-xml`, `wsdl` and `wsdl-link`.
        """
        return pulumi.get(self, "content_format")

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

    @property
    @pulumi.getter(name="contentValue")
    def content_value(self) -> pulumi.Input[str]:
        """
        The Content from which the API Definition should be imported. When a `content_format` of `*-link-*` is specified this must be a URL, otherwise this must be defined inline.
        """
        return pulumi.get(self, "content_value")

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

    @property
    @pulumi.getter(name="wsdlSelector")
    def wsdl_selector(self) -> Optional[pulumi.Input['ApiImportWsdlSelectorArgs']]:
        """
        A `wsdl_selector` block as defined below, which allows you to limit the import of a WSDL to only a subset of the document. This can only be specified when `content_format` is `wsdl` or `wsdl-link`.
        """
        return pulumi.get(self, "wsdl_selector")

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


@pulumi.input_type
class ApiImportWsdlSelectorArgs:
    def __init__(__self__, *,
                 endpoint_name: pulumi.Input[str],
                 service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] endpoint_name: The name of endpoint (port) to import from WSDL.
        :param pulumi.Input[str] service_name: The name of service to import from WSDL.
        """
        pulumi.set(__self__, "endpoint_name", endpoint_name)
        pulumi.set(__self__, "service_name", service_name)

    @property
    @pulumi.getter(name="endpointName")
    def endpoint_name(self) -> pulumi.Input[str]:
        """
        The name of endpoint (port) to import from WSDL.
        """
        return pulumi.get(self, "endpoint_name")

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

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> pulumi.Input[str]:
        """
        The name of service to import from WSDL.
        """
        return pulumi.get(self, "service_name")

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


@pulumi.input_type
class ApiOauth2AuthorizationArgs:
    def __init__(__self__, *,
                 authorization_server_name: pulumi.Input[str],
                 scope: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] authorization_server_name: OAuth authorization server identifier. The name of an OAuth2 Authorization Server.
        :param pulumi.Input[str] scope: Operations scope.
        """
        pulumi.set(__self__, "authorization_server_name", authorization_server_name)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter(name="authorizationServerName")
    def authorization_server_name(self) -> pulumi.Input[str]:
        """
        OAuth authorization server identifier. The name of an OAuth2 Authorization Server.
        """
        return pulumi.get(self, "authorization_server_name")

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

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

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


@pulumi.input_type
class ApiOpenidAuthenticationArgs:
    def __init__(__self__, *,
                 openid_provider_name: pulumi.Input[str],
                 bearer_token_sending_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] openid_provider_name: OpenID Connect provider identifier. The name of an OpenID Connect Provider.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] bearer_token_sending_methods: How to send token to the server. A list of zero or more methods. Valid values are `authorizationHeader` and `query`.
        """
        pulumi.set(__self__, "openid_provider_name", openid_provider_name)
        if bearer_token_sending_methods is not None:
            pulumi.set(__self__, "bearer_token_sending_methods", bearer_token_sending_methods)

    @property
    @pulumi.getter(name="openidProviderName")
    def openid_provider_name(self) -> pulumi.Input[str]:
        """
        OpenID Connect provider identifier. The name of an OpenID Connect Provider.
        """
        return pulumi.get(self, "openid_provider_name")

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

    @property
    @pulumi.getter(name="bearerTokenSendingMethods")
    def bearer_token_sending_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        How to send token to the server. A list of zero or more methods. Valid values are `authorizationHeader` and `query`.
        """
        return pulumi.get(self, "bearer_token_sending_methods")

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


@pulumi.input_type
class ApiOperationRequestArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[str]] = None,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestHeaderArgs']]]] = None,
                 query_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestQueryParameterArgs']]]] = None,
                 representations: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationArgs']]]] = None):
        """
        :param pulumi.Input[str] description: A description of the HTTP Request, which may include HTML tags.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestHeaderArgs']]] headers: One or more `header` blocks as defined above.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestQueryParameterArgs']]] query_parameters: One or more `query_parameter` blocks as defined above.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationArgs']]] representations: One or more `representation` blocks as defined below.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_parameters is not None:
            pulumi.set(__self__, "query_parameters", query_parameters)
        if representations is not None:
            pulumi.set(__self__, "representations", representations)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of the HTTP Request, which may include HTML tags.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestHeaderArgs']]]]:
        """
        One or more `header` blocks as defined above.
        """
        return pulumi.get(self, "headers")

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

    @property
    @pulumi.getter(name="queryParameters")
    def query_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestQueryParameterArgs']]]]:
        """
        One or more `query_parameter` blocks as defined above.
        """
        return pulumi.get(self, "query_parameters")

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

    @property
    @pulumi.getter
    def representations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationArgs']]]]:
        """
        One or more `representation` blocks as defined below.
        """
        return pulumi.get(self, "representations")

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


@pulumi.input_type
class ApiOperationRequestHeaderArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 required: pulumi.Input[bool],
                 type: pulumi.Input[str],
                 default_value: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] name: The Name of this Header.
        :param pulumi.Input[bool] required: Is this Header Required?
        :param pulumi.Input[str] type: The Type of this Header, such as a `string`.
        :param pulumi.Input[str] default_value: The default value for this Header.
        :param pulumi.Input[str] description: A description of this Header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: One or more acceptable values for this Header.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "required", required)
        pulumi.set(__self__, "type", type)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if values is not None:
            pulumi.set(__self__, "values", values)

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

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

    @property
    @pulumi.getter
    def required(self) -> pulumi.Input[bool]:
        """
        Is this Header Required?
        """
        return pulumi.get(self, "required")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The Type of this Header, such as a `string`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[pulumi.Input[str]]:
        """
        The default value for this Header.
        """
        return pulumi.get(self, "default_value")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of this Header.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        One or more acceptable values for this Header.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class ApiOperationRequestQueryParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 required: pulumi.Input[bool],
                 type: pulumi.Input[str],
                 default_value: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] name: The Name of this Query Parameter.
        :param pulumi.Input[bool] required: Is this Query Parameter Required?
        :param pulumi.Input[str] type: The Type of this Query Parameter, such as a `string`.
        :param pulumi.Input[str] default_value: The default value for this Query Parameter.
        :param pulumi.Input[str] description: A description of this Query Parameter.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: One or more acceptable values for this Query Parameter.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "required", required)
        pulumi.set(__self__, "type", type)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The Name of this Query Parameter.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def required(self) -> pulumi.Input[bool]:
        """
        Is this Query Parameter Required?
        """
        return pulumi.get(self, "required")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The Type of this Query Parameter, such as a `string`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[pulumi.Input[str]]:
        """
        The default value for this Query Parameter.
        """
        return pulumi.get(self, "default_value")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of this Query Parameter.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        One or more acceptable values for this Query Parameter.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class ApiOperationRequestRepresentationArgs:
    def __init__(__self__, *,
                 content_type: pulumi.Input[str],
                 examples: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationExampleArgs']]]] = None,
                 form_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationFormParameterArgs']]]] = None,
                 schema_id: Optional[pulumi.Input[str]] = None,
                 type_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] content_type: The Content Type of this representation, such as `application/json`.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationExampleArgs']]] examples: One or more `example` blocks as defined above.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationFormParameterArgs']]] form_parameters: One or more `form_parameter` block as defined above.
        :param pulumi.Input[str] schema_id: The ID of an API Management Schema which represents this Response.
        :param pulumi.Input[str] type_name: The Type Name defined by the Schema.
        """
        pulumi.set(__self__, "content_type", content_type)
        if examples is not None:
            pulumi.set(__self__, "examples", examples)
        if form_parameters is not None:
            pulumi.set(__self__, "form_parameters", form_parameters)
        if schema_id is not None:
            pulumi.set(__self__, "schema_id", schema_id)
        if type_name is not None:
            pulumi.set(__self__, "type_name", type_name)

    @property
    @pulumi.getter(name="contentType")
    def content_type(self) -> pulumi.Input[str]:
        """
        The Content Type of this representation, such as `application/json`.
        """
        return pulumi.get(self, "content_type")

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

    @property
    @pulumi.getter
    def examples(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationExampleArgs']]]]:
        """
        One or more `example` blocks as defined above.
        """
        return pulumi.get(self, "examples")

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

    @property
    @pulumi.getter(name="formParameters")
    def form_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationRequestRepresentationFormParameterArgs']]]]:
        """
        One or more `form_parameter` block as defined above.
        """
        return pulumi.get(self, "form_parameters")

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

    @property
    @pulumi.getter(name="schemaId")
    def schema_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of an API Management Schema which represents this Response.
        """
        return pulumi.get(self, "schema_id")

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

    @property
    @pulumi.getter(name="typeName")
    def type_name(self) -> Optional[pulumi.Input[str]]:
        """
        The Type Name defined by the Schema.
        """
        return pulumi.get(self, "type_name")

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


@pulumi.input_type
class ApiOperationRequestRepresentationExampleArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None,
                 external_value: Optional[pulumi.Input[str]] = None,
                 summary: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of this example.
        :param pulumi.Input[str] description: A long description for this example.
        :param pulumi.Input[str] external_value: A URL that points to the literal example.
        :param pulumi.Input[str] summary: A short description for this example.
        :param pulumi.Input[str] value: The example of the representation.
        """
        pulumi.set(__self__, "name", name)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if external_value is not None:
            pulumi.set(__self__, "external_value", external_value)
        if summary is not None:
            pulumi.set(__self__, "summary", summary)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A long description for this example.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="externalValue")
    def external_value(self) -> Optional[pulumi.Input[str]]:
        """
        A URL that points to the literal example.
        """
        return pulumi.get(self, "external_value")

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

    @property
    @pulumi.getter
    def summary(self) -> Optional[pulumi.Input[str]]:
        """
        A short description for this example.
        """
        return pulumi.get(self, "summary")

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        The example of the representation.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiOperationRequestRepresentationFormParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 required: pulumi.Input[bool],
                 type: pulumi.Input[str],
                 default_value: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] name: The Name of this Form Parameter.
        :param pulumi.Input[bool] required: Is this Form Parameter Required?
        :param pulumi.Input[str] type: The Type of this Form Parameter, such as a `string`.
        :param pulumi.Input[str] default_value: The default value for this Form Parameter.
        :param pulumi.Input[str] description: A description of this Form Parameter.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: One or more acceptable values for this Form Parameter.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "required", required)
        pulumi.set(__self__, "type", type)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The Name of this Form Parameter.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def required(self) -> pulumi.Input[bool]:
        """
        Is this Form Parameter Required?
        """
        return pulumi.get(self, "required")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The Type of this Form Parameter, such as a `string`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[pulumi.Input[str]]:
        """
        The default value for this Form Parameter.
        """
        return pulumi.get(self, "default_value")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of this Form Parameter.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        One or more acceptable values for this Form Parameter.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class ApiOperationResponseArgs:
    def __init__(__self__, *,
                 status_code: pulumi.Input[int],
                 description: Optional[pulumi.Input[str]] = None,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseHeaderArgs']]]] = None,
                 representations: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationArgs']]]] = None):
        """
        :param pulumi.Input[int] status_code: The HTTP Status Code.
        :param pulumi.Input[str] description: A description of the HTTP Response, which may include HTML tags.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseHeaderArgs']]] headers: One or more `header` blocks as defined above.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationArgs']]] representations: One or more `representation` blocks as defined below.
        """
        pulumi.set(__self__, "status_code", status_code)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if representations is not None:
            pulumi.set(__self__, "representations", representations)

    @property
    @pulumi.getter(name="statusCode")
    def status_code(self) -> pulumi.Input[int]:
        """
        The HTTP Status Code.
        """
        return pulumi.get(self, "status_code")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of the HTTP Response, which may include HTML tags.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseHeaderArgs']]]]:
        """
        One or more `header` blocks as defined above.
        """
        return pulumi.get(self, "headers")

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

    @property
    @pulumi.getter
    def representations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationArgs']]]]:
        """
        One or more `representation` blocks as defined below.
        """
        return pulumi.get(self, "representations")

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


@pulumi.input_type
class ApiOperationResponseHeaderArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 required: pulumi.Input[bool],
                 type: pulumi.Input[str],
                 default_value: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] name: The Name of this Header.
        :param pulumi.Input[bool] required: Is this Header Required?
        :param pulumi.Input[str] type: The Type of this Header, such as a `string`.
        :param pulumi.Input[str] default_value: The default value for this Header.
        :param pulumi.Input[str] description: A description of this Header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: One or more acceptable values for this Header.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "required", required)
        pulumi.set(__self__, "type", type)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if values is not None:
            pulumi.set(__self__, "values", values)

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

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

    @property
    @pulumi.getter
    def required(self) -> pulumi.Input[bool]:
        """
        Is this Header Required?
        """
        return pulumi.get(self, "required")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The Type of this Header, such as a `string`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[pulumi.Input[str]]:
        """
        The default value for this Header.
        """
        return pulumi.get(self, "default_value")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of this Header.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        One or more acceptable values for this Header.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class ApiOperationResponseRepresentationArgs:
    def __init__(__self__, *,
                 content_type: pulumi.Input[str],
                 examples: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationExampleArgs']]]] = None,
                 form_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationFormParameterArgs']]]] = None,
                 schema_id: Optional[pulumi.Input[str]] = None,
                 type_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] content_type: The Content Type of this representation, such as `application/json`.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationExampleArgs']]] examples: One or more `example` blocks as defined above.
        :param pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationFormParameterArgs']]] form_parameters: One or more `form_parameter` block as defined above.
        :param pulumi.Input[str] schema_id: The ID of an API Management Schema which represents this Response.
        :param pulumi.Input[str] type_name: The Type Name defined by the Schema.
        """
        pulumi.set(__self__, "content_type", content_type)
        if examples is not None:
            pulumi.set(__self__, "examples", examples)
        if form_parameters is not None:
            pulumi.set(__self__, "form_parameters", form_parameters)
        if schema_id is not None:
            pulumi.set(__self__, "schema_id", schema_id)
        if type_name is not None:
            pulumi.set(__self__, "type_name", type_name)

    @property
    @pulumi.getter(name="contentType")
    def content_type(self) -> pulumi.Input[str]:
        """
        The Content Type of this representation, such as `application/json`.
        """
        return pulumi.get(self, "content_type")

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

    @property
    @pulumi.getter
    def examples(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationExampleArgs']]]]:
        """
        One or more `example` blocks as defined above.
        """
        return pulumi.get(self, "examples")

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

    @property
    @pulumi.getter(name="formParameters")
    def form_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApiOperationResponseRepresentationFormParameterArgs']]]]:
        """
        One or more `form_parameter` block as defined above.
        """
        return pulumi.get(self, "form_parameters")

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

    @property
    @pulumi.getter(name="schemaId")
    def schema_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of an API Management Schema which represents this Response.
        """
        return pulumi.get(self, "schema_id")

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

    @property
    @pulumi.getter(name="typeName")
    def type_name(self) -> Optional[pulumi.Input[str]]:
        """
        The Type Name defined by the Schema.
        """
        return pulumi.get(self, "type_name")

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


@pulumi.input_type
class ApiOperationResponseRepresentationExampleArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None,
                 external_value: Optional[pulumi.Input[str]] = None,
                 summary: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of this example.
        :param pulumi.Input[str] description: A long description for this example.
        :param pulumi.Input[str] external_value: A URL that points to the literal example.
        :param pulumi.Input[str] summary: A short description for this example.
        :param pulumi.Input[str] value: The example of the representation.
        """
        pulumi.set(__self__, "name", name)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if external_value is not None:
            pulumi.set(__self__, "external_value", external_value)
        if summary is not None:
            pulumi.set(__self__, "summary", summary)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A long description for this example.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="externalValue")
    def external_value(self) -> Optional[pulumi.Input[str]]:
        """
        A URL that points to the literal example.
        """
        return pulumi.get(self, "external_value")

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

    @property
    @pulumi.getter
    def summary(self) -> Optional[pulumi.Input[str]]:
        """
        A short description for this example.
        """
        return pulumi.get(self, "summary")

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        The example of the representation.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ApiOperationResponseRepresentationFormParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 required: pulumi.Input[bool],
                 type: pulumi.Input[str],
                 default_value: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] name: The Name of this Form Parameter.
        :param pulumi.Input[bool] required: Is this Form Parameter Required?
        :param pulumi.Input[str] type: The Type of this Form Parameter, such as a `string`.
        :param pulumi.Input[str] default_value: The default value for this Form Parameter.
        :param pulumi.Input[str] description: A description of this Form Parameter.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: One or more acceptable values for this Form Parameter.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "required", required)
        pulumi.set(__self__, "type", type)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The Name of this Form Parameter.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def required(self) -> pulumi.Input[bool]:
        """
        Is this Form Parameter Required?
        """
        return pulumi.get(self, "required")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The Type of this Form Parameter, such as a `string`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[pulumi.Input[str]]:
        """
        The default value for this Form Parameter.
        """
        return pulumi.get(self, "default_value")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of this Form Parameter.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        One or more acceptable values for this Form Parameter.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class ApiOperationTemplateParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 required: pulumi.Input[bool],
                 type: pulumi.Input[str],
                 default_value: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] name: The Name of this Template Parameter.
        :param pulumi.Input[bool] required: Is this Template Parameter Required?
        :param pulumi.Input[str] type: The Type of this Template Parameter, such as a `string`.
        :param pulumi.Input[str] default_value: The default value for this Template Parameter.
        :param pulumi.Input[str] description: A description of this Template Parameter.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: One or more acceptable values for this Template Parameter.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "required", required)
        pulumi.set(__self__, "type", type)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The Name of this Template Parameter.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def required(self) -> pulumi.Input[bool]:
        """
        Is this Template Parameter Required?
        """
        return pulumi.get(self, "required")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The Type of this Template Parameter, such as a `string`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[pulumi.Input[str]]:
        """
        The default value for this Template Parameter.
        """
        return pulumi.get(self, "default_value")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A description of this Template Parameter.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        One or more acceptable values for this Template Parameter.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class ApiSubscriptionKeyParameterNamesArgs:
    def __init__(__self__, *,
                 header: pulumi.Input[str],
                 query: pulumi.Input[str]):
        """
        :param pulumi.Input[str] header: The name of the HTTP Header which should be used for the Subscription Key.
        :param pulumi.Input[str] query: The name of the QueryString parameter which should be used for the Subscription Key.
        """
        pulumi.set(__self__, "header", header)
        pulumi.set(__self__, "query", query)

    @property
    @pulumi.getter
    def header(self) -> pulumi.Input[str]:
        """
        The name of the HTTP Header which should be used for the Subscription Key.
        """
        return pulumi.get(self, "header")

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

    @property
    @pulumi.getter
    def query(self) -> pulumi.Input[str]:
        """
        The name of the QueryString parameter which should be used for the Subscription Key.
        """
        return pulumi.get(self, "query")

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


@pulumi.input_type
class AuthorizationServerTokenBodyParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: The Name of the Parameter.
        :param pulumi.Input[str] value: The Value of the Parameter.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The Name of the Parameter.
        """
        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]:
        """
        The Value of the Parameter.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class BackendCredentialsArgs:
    def __init__(__self__, *,
                 authorization: Optional[pulumi.Input['BackendCredentialsAuthorizationArgs']] = None,
                 certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 header: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 query: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input['BackendCredentialsAuthorizationArgs'] authorization: An `authorization` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] certificates: A list of client certificate thumbprints to present to the backend host. The certificates must exist within the API Management Service.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] header: A mapping of header parameters to pass to the backend host. The keys are the header names and the values are a comma separated string of header values. This is converted to a list before being passed to the API.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] query: A mapping of query parameters to pass to the backend host. The keys are the query names and the values are a comma separated string of query values. This is converted to a list before being passed to the API.
        """
        if authorization is not None:
            pulumi.set(__self__, "authorization", authorization)
        if certificates is not None:
            pulumi.set(__self__, "certificates", certificates)
        if header is not None:
            pulumi.set(__self__, "header", header)
        if query is not None:
            pulumi.set(__self__, "query", query)

    @property
    @pulumi.getter
    def authorization(self) -> Optional[pulumi.Input['BackendCredentialsAuthorizationArgs']]:
        """
        An `authorization` block as defined below.
        """
        return pulumi.get(self, "authorization")

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

    @property
    @pulumi.getter
    def certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of client certificate thumbprints to present to the backend host. The certificates must exist within the API Management Service.
        """
        return pulumi.get(self, "certificates")

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

    @property
    @pulumi.getter
    def header(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        A mapping of header parameters to pass to the backend host. The keys are the header names and the values are a comma separated string of header values. This is converted to a list before being passed to the API.
        """
        return pulumi.get(self, "header")

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

    @property
    @pulumi.getter
    def query(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        A mapping of query parameters to pass to the backend host. The keys are the query names and the values are a comma separated string of query values. This is converted to a list before being passed to the API.
        """
        return pulumi.get(self, "query")

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


@pulumi.input_type
class BackendCredentialsAuthorizationArgs:
    def __init__(__self__, *,
                 parameter: Optional[pulumi.Input[str]] = None,
                 scheme: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] parameter: The authentication Parameter value.
        :param pulumi.Input[str] scheme: The authentication Scheme name.
        """
        if parameter is not None:
            pulumi.set(__self__, "parameter", parameter)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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

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


@pulumi.input_type
class BackendProxyArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 username: pulumi.Input[str],
                 password: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] url: The URL of the proxy server.
        :param pulumi.Input[str] username: The username to connect to the proxy server.
        :param pulumi.Input[str] password: The password to connect to the proxy server.
        """
        pulumi.set(__self__, "url", url)
        pulumi.set(__self__, "username", username)
        if password is not None:
            pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        The URL of the proxy server.
        """
        return pulumi.get(self, "url")

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

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        """
        The username to connect to the proxy server.
        """
        return pulumi.get(self, "username")

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

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        The password to connect to the proxy server.
        """
        return pulumi.get(self, "password")

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


@pulumi.input_type
class BackendServiceFabricClusterArgs:
    def __init__(__self__, *,
                 management_endpoints: pulumi.Input[Sequence[pulumi.Input[str]]],
                 max_partition_resolution_retries: pulumi.Input[int],
                 client_certificate_id: Optional[pulumi.Input[str]] = None,
                 client_certificate_thumbprint: Optional[pulumi.Input[str]] = None,
                 server_certificate_thumbprints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 server_x509_names: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceFabricClusterServerX509NameArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] management_endpoints: A list of cluster management endpoints.
        :param pulumi.Input[int] max_partition_resolution_retries: The maximum number of retries when attempting resolve the partition.
        :param pulumi.Input[str] client_certificate_id: The client certificate resource id for the management endpoint.
        :param pulumi.Input[str] client_certificate_thumbprint: The client certificate thumbprint for the management endpoint.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] server_certificate_thumbprints: A list of thumbprints of the server certificates of the Service Fabric cluster.
        :param pulumi.Input[Sequence[pulumi.Input['BackendServiceFabricClusterServerX509NameArgs']]] server_x509_names: One or more `server_x509_name` blocks as documented below.
        """
        pulumi.set(__self__, "management_endpoints", management_endpoints)
        pulumi.set(__self__, "max_partition_resolution_retries", max_partition_resolution_retries)
        if client_certificate_id is not None:
            pulumi.set(__self__, "client_certificate_id", client_certificate_id)
        if client_certificate_thumbprint is not None:
            pulumi.set(__self__, "client_certificate_thumbprint", client_certificate_thumbprint)
        if server_certificate_thumbprints is not None:
            pulumi.set(__self__, "server_certificate_thumbprints", server_certificate_thumbprints)
        if server_x509_names is not None:
            pulumi.set(__self__, "server_x509_names", server_x509_names)

    @property
    @pulumi.getter(name="managementEndpoints")
    def management_endpoints(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of cluster management endpoints.
        """
        return pulumi.get(self, "management_endpoints")

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

    @property
    @pulumi.getter(name="maxPartitionResolutionRetries")
    def max_partition_resolution_retries(self) -> pulumi.Input[int]:
        """
        The maximum number of retries when attempting resolve the partition.
        """
        return pulumi.get(self, "max_partition_resolution_retries")

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

    @property
    @pulumi.getter(name="clientCertificateId")
    def client_certificate_id(self) -> Optional[pulumi.Input[str]]:
        """
        The client certificate resource id for the management endpoint.
        """
        return pulumi.get(self, "client_certificate_id")

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

    @property
    @pulumi.getter(name="clientCertificateThumbprint")
    def client_certificate_thumbprint(self) -> Optional[pulumi.Input[str]]:
        """
        The client certificate thumbprint for the management endpoint.
        """
        return pulumi.get(self, "client_certificate_thumbprint")

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

    @property
    @pulumi.getter(name="serverCertificateThumbprints")
    def server_certificate_thumbprints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of thumbprints of the server certificates of the Service Fabric cluster.
        """
        return pulumi.get(self, "server_certificate_thumbprints")

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

    @property
    @pulumi.getter(name="serverX509Names")
    def server_x509_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceFabricClusterServerX509NameArgs']]]]:
        """
        One or more `server_x509_name` blocks as documented below.
        """
        return pulumi.get(self, "server_x509_names")

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


@pulumi.input_type
class BackendServiceFabricClusterServerX509NameArgs:
    def __init__(__self__, *,
                 issuer_certificate_thumbprint: pulumi.Input[str],
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] issuer_certificate_thumbprint: The thumbprint for the issuer of the certificate.
        :param pulumi.Input[str] name: The name of the API Management backend. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "issuer_certificate_thumbprint", issuer_certificate_thumbprint)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="issuerCertificateThumbprint")
    def issuer_certificate_thumbprint(self) -> pulumi.Input[str]:
        """
        The thumbprint for the issuer of the certificate.
        """
        return pulumi.get(self, "issuer_certificate_thumbprint")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the API Management backend. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

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


@pulumi.input_type
class BackendTlsArgs:
    def __init__(__self__, *,
                 validate_certificate_chain: Optional[pulumi.Input[bool]] = None,
                 validate_certificate_name: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] validate_certificate_chain: Flag indicating whether SSL certificate chain validation should be done when using self-signed certificates for the backend host.
        :param pulumi.Input[bool] validate_certificate_name: Flag indicating whether SSL certificate name validation should be done when using self-signed certificates for the backend host.
        """
        if validate_certificate_chain is not None:
            pulumi.set(__self__, "validate_certificate_chain", validate_certificate_chain)
        if validate_certificate_name is not None:
            pulumi.set(__self__, "validate_certificate_name", validate_certificate_name)

    @property
    @pulumi.getter(name="validateCertificateChain")
    def validate_certificate_chain(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether SSL certificate chain validation should be done when using self-signed certificates for the backend host.
        """
        return pulumi.get(self, "validate_certificate_chain")

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

    @property
    @pulumi.getter(name="validateCertificateName")
    def validate_certificate_name(self) -> Optional[pulumi.Input[bool]]:
        """
        Flag indicating whether SSL certificate name validation should be done when using self-signed certificates for the backend host.
        """
        return pulumi.get(self, "validate_certificate_name")

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


@pulumi.input_type
class CustomDomainDeveloperPortalArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the corresponding endpoint.
        :param pulumi.Input[str] certificate: The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        :param pulumi.Input[str] certificate_password: The password associated with the certificate provided above.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the corresponding endpoint.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password associated with the certificate provided above.
        """
        return pulumi.get(self, "certificate_password")

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

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

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

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

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

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

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


@pulumi.input_type
class CustomDomainGatewayArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 default_ssl_binding: Optional[pulumi.Input[bool]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the API Proxy Endpoint.
        :param pulumi.Input[str] certificate: The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        :param pulumi.Input[str] certificate_password: The password associated with the certificate provided above.
        :param pulumi.Input[bool] default_ssl_binding: Is the certificate associated with this Hostname the Default SSL Certificate? This is used when an SNI header isn't specified by a client. Defaults to false.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if default_ssl_binding is not None:
            pulumi.set(__self__, "default_ssl_binding", default_ssl_binding)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the API Proxy Endpoint.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password associated with the certificate provided above.
        """
        return pulumi.get(self, "certificate_password")

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

    @property
    @pulumi.getter(name="defaultSslBinding")
    def default_ssl_binding(self) -> Optional[pulumi.Input[bool]]:
        """
        Is the certificate associated with this Hostname the Default SSL Certificate? This is used when an SNI header isn't specified by a client. Defaults to false.
        """
        return pulumi.get(self, "default_ssl_binding")

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

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

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

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

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

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

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


@pulumi.input_type
class CustomDomainManagementArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the corresponding endpoint.
        :param pulumi.Input[str] certificate: The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        :param pulumi.Input[str] certificate_password: The password associated with the certificate provided above.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the corresponding endpoint.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password associated with the certificate provided above.
        """
        return pulumi.get(self, "certificate_password")

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

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

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

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

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

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

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


@pulumi.input_type
class CustomDomainPortalArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the corresponding endpoint.
        :param pulumi.Input[str] certificate: The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        :param pulumi.Input[str] certificate_password: The password associated with the certificate provided above.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the corresponding endpoint.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password associated with the certificate provided above.
        """
        return pulumi.get(self, "certificate_password")

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

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

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

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

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

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

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


@pulumi.input_type
class CustomDomainScmArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the corresponding endpoint.
        :param pulumi.Input[str] certificate: The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        :param pulumi.Input[str] certificate_password: The password associated with the certificate provided above.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the corresponding endpoint.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The Base64 Encoded Certificate. (Mutually exclusive with `key_vault_id`.)
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password associated with the certificate provided above.
        """
        return pulumi.get(self, "certificate_password")

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type application/x-pkcs12.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to false.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

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

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

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

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

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

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


@pulumi.input_type
class DiagnosticBackendRequestArgs:
    def __init__(__self__, *,
                 body_bytes: Optional[pulumi.Input[int]] = None,
                 data_masking: Optional[pulumi.Input['DiagnosticBackendRequestDataMaskingArgs']] = None,
                 headers_to_logs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] body_bytes: Number of payload bytes to log (up to 8192).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] headers_to_logs: Specifies a list of headers to log.
        """
        if body_bytes is not None:
            pulumi.set(__self__, "body_bytes", body_bytes)
        if data_masking is not None:
            pulumi.set(__self__, "data_masking", data_masking)
        if headers_to_logs is not None:
            pulumi.set(__self__, "headers_to_logs", headers_to_logs)

    @property
    @pulumi.getter(name="bodyBytes")
    def body_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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

    @property
    @pulumi.getter(name="dataMasking")
    def data_masking(self) -> Optional[pulumi.Input['DiagnosticBackendRequestDataMaskingArgs']]:
        return pulumi.get(self, "data_masking")

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

    @property
    @pulumi.getter(name="headersToLogs")
    def headers_to_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of headers to log.
        """
        return pulumi.get(self, "headers_to_logs")

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


@pulumi.input_type
class DiagnosticBackendRequestDataMaskingArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['DiagnosticBackendRequestDataMaskingHeaderArgs']]]] = None,
                 query_params: Optional[pulumi.Input[Sequence[pulumi.Input['DiagnosticBackendRequestDataMaskingQueryParamArgs']]]] = None):
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_params is not None:
            pulumi.set(__self__, "query_params", query_params)

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

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

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

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


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

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

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", 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 DiagnosticBackendRequestDataMaskingQueryParamArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

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

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", 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 DiagnosticBackendResponseArgs:
    def __init__(__self__, *,
                 body_bytes: Optional[pulumi.Input[int]] = None,
                 data_masking: Optional[pulumi.Input['DiagnosticBackendResponseDataMaskingArgs']] = None,
                 headers_to_logs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] body_bytes: Number of payload bytes to log (up to 8192).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] headers_to_logs: Specifies a list of headers to log.
        """
        if body_bytes is not None:
            pulumi.set(__self__, "body_bytes", body_bytes)
        if data_masking is not None:
            pulumi.set(__self__, "data_masking", data_masking)
        if headers_to_logs is not None:
            pulumi.set(__self__, "headers_to_logs", headers_to_logs)

    @property
    @pulumi.getter(name="bodyBytes")
    def body_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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

    @property
    @pulumi.getter(name="dataMasking")
    def data_masking(self) -> Optional[pulumi.Input['DiagnosticBackendResponseDataMaskingArgs']]:
        return pulumi.get(self, "data_masking")

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

    @property
    @pulumi.getter(name="headersToLogs")
    def headers_to_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of headers to log.
        """
        return pulumi.get(self, "headers_to_logs")

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


@pulumi.input_type
class DiagnosticBackendResponseDataMaskingArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['DiagnosticBackendResponseDataMaskingHeaderArgs']]]] = None,
                 query_params: Optional[pulumi.Input[Sequence[pulumi.Input['DiagnosticBackendResponseDataMaskingQueryParamArgs']]]] = None):
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_params is not None:
            pulumi.set(__self__, "query_params", query_params)

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

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

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

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


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

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

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", 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 DiagnosticBackendResponseDataMaskingQueryParamArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

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

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", 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 DiagnosticFrontendRequestArgs:
    def __init__(__self__, *,
                 body_bytes: Optional[pulumi.Input[int]] = None,
                 data_masking: Optional[pulumi.Input['DiagnosticFrontendRequestDataMaskingArgs']] = None,
                 headers_to_logs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] body_bytes: Number of payload bytes to log (up to 8192).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] headers_to_logs: Specifies a list of headers to log.
        """
        if body_bytes is not None:
            pulumi.set(__self__, "body_bytes", body_bytes)
        if data_masking is not None:
            pulumi.set(__self__, "data_masking", data_masking)
        if headers_to_logs is not None:
            pulumi.set(__self__, "headers_to_logs", headers_to_logs)

    @property
    @pulumi.getter(name="bodyBytes")
    def body_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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

    @property
    @pulumi.getter(name="dataMasking")
    def data_masking(self) -> Optional[pulumi.Input['DiagnosticFrontendRequestDataMaskingArgs']]:
        return pulumi.get(self, "data_masking")

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

    @property
    @pulumi.getter(name="headersToLogs")
    def headers_to_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of headers to log.
        """
        return pulumi.get(self, "headers_to_logs")

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


@pulumi.input_type
class DiagnosticFrontendRequestDataMaskingArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['DiagnosticFrontendRequestDataMaskingHeaderArgs']]]] = None,
                 query_params: Optional[pulumi.Input[Sequence[pulumi.Input['DiagnosticFrontendRequestDataMaskingQueryParamArgs']]]] = None):
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_params is not None:
            pulumi.set(__self__, "query_params", query_params)

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

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

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

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


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

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

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", 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 DiagnosticFrontendRequestDataMaskingQueryParamArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

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

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", 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 DiagnosticFrontendResponseArgs:
    def __init__(__self__, *,
                 body_bytes: Optional[pulumi.Input[int]] = None,
                 data_masking: Optional[pulumi.Input['DiagnosticFrontendResponseDataMaskingArgs']] = None,
                 headers_to_logs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] body_bytes: Number of payload bytes to log (up to 8192).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] headers_to_logs: Specifies a list of headers to log.
        """
        if body_bytes is not None:
            pulumi.set(__self__, "body_bytes", body_bytes)
        if data_masking is not None:
            pulumi.set(__self__, "data_masking", data_masking)
        if headers_to_logs is not None:
            pulumi.set(__self__, "headers_to_logs", headers_to_logs)

    @property
    @pulumi.getter(name="bodyBytes")
    def body_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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

    @property
    @pulumi.getter(name="dataMasking")
    def data_masking(self) -> Optional[pulumi.Input['DiagnosticFrontendResponseDataMaskingArgs']]:
        return pulumi.get(self, "data_masking")

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

    @property
    @pulumi.getter(name="headersToLogs")
    def headers_to_logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of headers to log.
        """
        return pulumi.get(self, "headers_to_logs")

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


@pulumi.input_type
class DiagnosticFrontendResponseDataMaskingArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['DiagnosticFrontendResponseDataMaskingHeaderArgs']]]] = None,
                 query_params: Optional[pulumi.Input[Sequence[pulumi.Input['DiagnosticFrontendResponseDataMaskingQueryParamArgs']]]] = None):
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if query_params is not None:
            pulumi.set(__self__, "query_params", query_params)

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

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

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

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


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

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

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", 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 DiagnosticFrontendResponseDataMaskingQueryParamArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "value", value)

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

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", 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 GatewayLocationDataArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 city: Optional[pulumi.Input[str]] = None,
                 district: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: A canonical name for the geographic or physical location.
        :param pulumi.Input[str] city: The city or locality where the resource is located.
        :param pulumi.Input[str] district: The district, state, or province where the resource is located.
        :param pulumi.Input[str] region: The country or region where the resource is located.
        """
        pulumi.set(__self__, "name", name)
        if city is not None:
            pulumi.set(__self__, "city", city)
        if district is not None:
            pulumi.set(__self__, "district", district)
        if region is not None:
            pulumi.set(__self__, "region", region)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        A canonical name for the geographic or physical location.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def city(self) -> Optional[pulumi.Input[str]]:
        """
        The city or locality where the resource is located.
        """
        return pulumi.get(self, "city")

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

    @property
    @pulumi.getter
    def district(self) -> Optional[pulumi.Input[str]]:
        """
        The district, state, or province where the resource is located.
        """
        return pulumi.get(self, "district")

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

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        The country or region where the resource is located.
        """
        return pulumi.get(self, "region")

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


@pulumi.input_type
class LoggerApplicationInsightsArgs:
    def __init__(__self__, *,
                 instrumentation_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] instrumentation_key: The instrumentation key used to push data to Application Insights.
        """
        pulumi.set(__self__, "instrumentation_key", instrumentation_key)

    @property
    @pulumi.getter(name="instrumentationKey")
    def instrumentation_key(self) -> pulumi.Input[str]:
        """
        The instrumentation key used to push data to Application Insights.
        """
        return pulumi.get(self, "instrumentation_key")

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


@pulumi.input_type
class LoggerEventhubArgs:
    def __init__(__self__, *,
                 connection_string: pulumi.Input[str],
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] connection_string: The connection string of an EventHub Namespace.
        :param pulumi.Input[str] name: The name of an EventHub.
        """
        pulumi.set(__self__, "connection_string", connection_string)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="connectionString")
    def connection_string(self) -> pulumi.Input[str]:
        """
        The connection string of an EventHub Namespace.
        """
        return pulumi.get(self, "connection_string")

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

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

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


@pulumi.input_type
class NamedValueValueFromKeyVaultArgs:
    def __init__(__self__, *,
                 secret_id: pulumi.Input[str],
                 identity_client_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] secret_id: The resource ID of the Key Vault Secret.
        :param pulumi.Input[str] identity_client_id: The client ID of User Assigned Identity, for the API Management Service, which will be used to access the key vault secret. The System Assigned Identity will be used in absence.
        """
        pulumi.set(__self__, "secret_id", secret_id)
        if identity_client_id is not None:
            pulumi.set(__self__, "identity_client_id", identity_client_id)

    @property
    @pulumi.getter(name="secretId")
    def secret_id(self) -> pulumi.Input[str]:
        """
        The resource ID of the Key Vault Secret.
        """
        return pulumi.get(self, "secret_id")

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

    @property
    @pulumi.getter(name="identityClientId")
    def identity_client_id(self) -> Optional[pulumi.Input[str]]:
        """
        The client ID of User Assigned Identity, for the API Management Service, which will be used to access the key vault secret. The System Assigned Identity will be used in absence.
        """
        return pulumi.get(self, "identity_client_id")

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


@pulumi.input_type
class ServiceAdditionalLocationArgs:
    def __init__(__self__, *,
                 location: pulumi.Input[str],
                 capacity: Optional[pulumi.Input[int]] = None,
                 gateway_regional_url: Optional[pulumi.Input[str]] = None,
                 private_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 public_ip_address_id: Optional[pulumi.Input[str]] = None,
                 public_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 virtual_network_configuration: Optional[pulumi.Input['ServiceAdditionalLocationVirtualNetworkConfigurationArgs']] = None,
                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] location: The name of the Azure Region in which the API Management Service should be expanded to.
        :param pulumi.Input[int] capacity: The number of compute units in this region. Defaults to the capacity of the main region.
        :param pulumi.Input[str] gateway_regional_url: The URL of the Regional Gateway for the API Management Service in the specified region.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] private_ip_addresses: The Private IP addresses of the API Management Service.  Available only when the API Manager instance is using Virtual Network mode.
        :param pulumi.Input[str] public_ip_address_id: ID of a standard SKU IPv4 Public IP.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] public_ip_addresses: Public Static Load Balanced IP addresses of the API Management service in the additional location. Available only for Basic, Standard and Premium SKU.
        :param pulumi.Input['ServiceAdditionalLocationVirtualNetworkConfigurationArgs'] virtual_network_configuration: A `virtual_network_configuration` block as defined below.  Required when `virtual_network_type` is `External` or `Internal`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] zones: A list of availability zones.
        """
        pulumi.set(__self__, "location", location)
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if gateway_regional_url is not None:
            pulumi.set(__self__, "gateway_regional_url", gateway_regional_url)
        if private_ip_addresses is not None:
            pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        if public_ip_address_id is not None:
            pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        if public_ip_addresses is not None:
            pulumi.set(__self__, "public_ip_addresses", public_ip_addresses)
        if virtual_network_configuration is not None:
            pulumi.set(__self__, "virtual_network_configuration", virtual_network_configuration)
        if zones is not None:
            pulumi.set(__self__, "zones", zones)

    @property
    @pulumi.getter
    def location(self) -> pulumi.Input[str]:
        """
        The name of the Azure Region in which the API Management Service should be expanded to.
        """
        return pulumi.get(self, "location")

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

    @property
    @pulumi.getter
    def capacity(self) -> Optional[pulumi.Input[int]]:
        """
        The number of compute units in this region. Defaults to the capacity of the main region.
        """
        return pulumi.get(self, "capacity")

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

    @property
    @pulumi.getter(name="gatewayRegionalUrl")
    def gateway_regional_url(self) -> Optional[pulumi.Input[str]]:
        """
        The URL of the Regional Gateway for the API Management Service in the specified region.
        """
        return pulumi.get(self, "gateway_regional_url")

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

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The Private IP addresses of the API Management Service.  Available only when the API Manager instance is using Virtual Network mode.
        """
        return pulumi.get(self, "private_ip_addresses")

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

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> Optional[pulumi.Input[str]]:
        """
        ID of a standard SKU IPv4 Public IP.
        """
        return pulumi.get(self, "public_ip_address_id")

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

    @property
    @pulumi.getter(name="publicIpAddresses")
    def public_ip_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Public Static Load Balanced IP addresses of the API Management service in the additional location. Available only for Basic, Standard and Premium SKU.
        """
        return pulumi.get(self, "public_ip_addresses")

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

    @property
    @pulumi.getter(name="virtualNetworkConfiguration")
    def virtual_network_configuration(self) -> Optional[pulumi.Input['ServiceAdditionalLocationVirtualNetworkConfigurationArgs']]:
        """
        A `virtual_network_configuration` block as defined below.  Required when `virtual_network_type` is `External` or `Internal`.
        """
        return pulumi.get(self, "virtual_network_configuration")

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

    @property
    @pulumi.getter
    def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of availability zones.
        """
        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 ServiceAdditionalLocationVirtualNetworkConfigurationArgs:
    def __init__(__self__, *,
                 subnet_id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] subnet_id: The id of the subnet that will be used for the API Management.
        """
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> pulumi.Input[str]:
        """
        The id of the subnet that will be used for the API Management.
        """
        return pulumi.get(self, "subnet_id")

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


@pulumi.input_type
class ServiceCertificateArgs:
    def __init__(__self__, *,
                 encoded_certificate: pulumi.Input[str],
                 store_name: pulumi.Input[str],
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] encoded_certificate: The Base64 Encoded PFX or Base64 Encoded X.509 Certificate.
        :param pulumi.Input[str] store_name: The name of the Certificate Store where this certificate should be stored. Possible values are `CertificateAuthority` and `Root`.
        :param pulumi.Input[str] certificate_password: The password for the certificate.
        :param pulumi.Input[str] expiry: The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        :param pulumi.Input[str] subject: The subject of the certificate.
        :param pulumi.Input[str] thumbprint: The thumbprint of the certificate.
        """
        pulumi.set(__self__, "encoded_certificate", encoded_certificate)
        pulumi.set(__self__, "store_name", store_name)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="encodedCertificate")
    def encoded_certificate(self) -> pulumi.Input[str]:
        """
        The Base64 Encoded PFX or Base64 Encoded X.509 Certificate.
        """
        return pulumi.get(self, "encoded_certificate")

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

    @property
    @pulumi.getter(name="storeName")
    def store_name(self) -> pulumi.Input[str]:
        """
        The name of the Certificate Store where this certificate should be stored. Possible values are `CertificateAuthority` and `Root`.
        """
        return pulumi.get(self, "store_name")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password for the certificate.
        """
        return pulumi.get(self, "certificate_password")

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

    @property
    @pulumi.getter
    def expiry(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        """
        return pulumi.get(self, "expiry")

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

    @property
    @pulumi.getter
    def subject(self) -> Optional[pulumi.Input[str]]:
        """
        The subject of the certificate.
        """
        return pulumi.get(self, "subject")

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

    @property
    @pulumi.getter
    def thumbprint(self) -> Optional[pulumi.Input[str]]:
        """
        The thumbprint of the certificate.
        """
        return pulumi.get(self, "thumbprint")

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


@pulumi.input_type
class ServiceHostnameConfigurationArgs:
    def __init__(__self__, *,
                 developer_portals: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationDeveloperPortalArgs']]]] = None,
                 managements: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationManagementArgs']]]] = None,
                 portals: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationPortalArgs']]]] = None,
                 proxies: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationProxyArgs']]]] = None,
                 scms: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationScmArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationDeveloperPortalArgs']]] developer_portals: One or more `developer_portal` blocks as documented below.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationManagementArgs']]] managements: One or more `management` blocks as documented below.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationPortalArgs']]] portals: One or more `portal` blocks as documented below.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationProxyArgs']]] proxies: One or more `proxy` blocks as documented below.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationScmArgs']]] scms: One or more `scm` blocks as documented below.
        """
        if developer_portals is not None:
            pulumi.set(__self__, "developer_portals", developer_portals)
        if managements is not None:
            pulumi.set(__self__, "managements", managements)
        if portals is not None:
            pulumi.set(__self__, "portals", portals)
        if proxies is not None:
            pulumi.set(__self__, "proxies", proxies)
        if scms is not None:
            pulumi.set(__self__, "scms", scms)

    @property
    @pulumi.getter(name="developerPortals")
    def developer_portals(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationDeveloperPortalArgs']]]]:
        """
        One or more `developer_portal` blocks as documented below.
        """
        return pulumi.get(self, "developer_portals")

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

    @property
    @pulumi.getter
    def managements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationManagementArgs']]]]:
        """
        One or more `management` blocks as documented below.
        """
        return pulumi.get(self, "managements")

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

    @property
    @pulumi.getter
    def portals(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationPortalArgs']]]]:
        """
        One or more `portal` blocks as documented below.
        """
        return pulumi.get(self, "portals")

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

    @property
    @pulumi.getter
    def proxies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationProxyArgs']]]]:
        """
        One or more `proxy` blocks as documented below.
        """
        return pulumi.get(self, "proxies")

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

    @property
    @pulumi.getter
    def scms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceHostnameConfigurationScmArgs']]]]:
        """
        One or more `scm` blocks as documented below.
        """
        return pulumi.get(self, "scms")

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


@pulumi.input_type
class ServiceHostnameConfigurationDeveloperPortalArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the Management API.
        :param pulumi.Input[str] certificate: One or more (up to 10) `certificate` blocks as defined below.
        :param pulumi.Input[str] certificate_password: The password for the certificate.
        :param pulumi.Input[str] expiry: The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        :param pulumi.Input[str] ssl_keyvault_identity_client_id: The client id of the System or User Assigned Managed identity generated by Azure AD, which has `GET` access to the keyVault containing the SSL certificate.
        :param pulumi.Input[str] subject: The subject of the certificate.
        :param pulumi.Input[str] thumbprint: The thumbprint of the certificate.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the Management API.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        One or more (up to 10) `certificate` blocks as defined below.
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password for the certificate.
        """
        return pulumi.get(self, "certificate_password")

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

    @property
    @pulumi.getter
    def expiry(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        """
        return pulumi.get(self, "expiry")

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

    @property
    @pulumi.getter(name="sslKeyvaultIdentityClientId")
    def ssl_keyvault_identity_client_id(self) -> Optional[pulumi.Input[str]]:
        """
        The client id of the System or User Assigned Managed identity generated by Azure AD, which has `GET` access to the keyVault containing the SSL certificate.
        """
        return pulumi.get(self, "ssl_keyvault_identity_client_id")

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

    @property
    @pulumi.getter
    def subject(self) -> Optional[pulumi.Input[str]]:
        """
        The subject of the certificate.
        """
        return pulumi.get(self, "subject")

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

    @property
    @pulumi.getter
    def thumbprint(self) -> Optional[pulumi.Input[str]]:
        """
        The thumbprint of the certificate.
        """
        return pulumi.get(self, "thumbprint")

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


@pulumi.input_type
class ServiceHostnameConfigurationManagementArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the Management API.
        :param pulumi.Input[str] certificate: The Base64 Encoded Certificate.
        :param pulumi.Input[str] certificate_password: The password associated with the certificate provided above.
        :param pulumi.Input[str] expiry: The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        :param pulumi.Input[str] ssl_keyvault_identity_client_id: The client id of the System or User Assigned Managed identity generated by Azure AD, which has `GET` access to the keyVault containing the SSL certificate.
        :param pulumi.Input[str] subject: The subject of the certificate.
        :param pulumi.Input[str] thumbprint: The thumbprint of the certificate.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the Management API.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The Base64 Encoded Certificate.
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password associated with the certificate provided above.
        """
        return pulumi.get(self, "certificate_password")

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

    @property
    @pulumi.getter
    def expiry(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        """
        return pulumi.get(self, "expiry")

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

    @property
    @pulumi.getter(name="sslKeyvaultIdentityClientId")
    def ssl_keyvault_identity_client_id(self) -> Optional[pulumi.Input[str]]:
        """
        The client id of the System or User Assigned Managed identity generated by Azure AD, which has `GET` access to the keyVault containing the SSL certificate.
        """
        return pulumi.get(self, "ssl_keyvault_identity_client_id")

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

    @property
    @pulumi.getter
    def subject(self) -> Optional[pulumi.Input[str]]:
        """
        The subject of the certificate.
        """
        return pulumi.get(self, "subject")

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

    @property
    @pulumi.getter
    def thumbprint(self) -> Optional[pulumi.Input[str]]:
        """
        The thumbprint of the certificate.
        """
        return pulumi.get(self, "thumbprint")

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


@pulumi.input_type
class ServiceHostnameConfigurationPortalArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the Management API.
        :param pulumi.Input[str] certificate: One or more (up to 10) `certificate` blocks as defined below.
        :param pulumi.Input[str] certificate_password: The password for the certificate.
        :param pulumi.Input[str] expiry: The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        :param pulumi.Input[str] ssl_keyvault_identity_client_id: The client id of the System or User Assigned Managed identity generated by Azure AD, which has `GET` access to the keyVault containing the SSL certificate.
        :param pulumi.Input[str] subject: The subject of the certificate.
        :param pulumi.Input[str] thumbprint: The thumbprint of the certificate.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the Management API.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        One or more (up to 10) `certificate` blocks as defined below.
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password for the certificate.
        """
        return pulumi.get(self, "certificate_password")

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

    @property
    @pulumi.getter
    def expiry(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        """
        return pulumi.get(self, "expiry")

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

    @property
    @pulumi.getter(name="sslKeyvaultIdentityClientId")
    def ssl_keyvault_identity_client_id(self) -> Optional[pulumi.Input[str]]:
        """
        The client id of the System or User Assigned Managed identity generated by Azure AD, which has `GET` access to the keyVault containing the SSL certificate.
        """
        return pulumi.get(self, "ssl_keyvault_identity_client_id")

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

    @property
    @pulumi.getter
    def subject(self) -> Optional[pulumi.Input[str]]:
        """
        The subject of the certificate.
        """
        return pulumi.get(self, "subject")

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

    @property
    @pulumi.getter
    def thumbprint(self) -> Optional[pulumi.Input[str]]:
        """
        The thumbprint of the certificate.
        """
        return pulumi.get(self, "thumbprint")

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


@pulumi.input_type
class ServiceHostnameConfigurationProxyArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 default_ssl_binding: Optional[pulumi.Input[bool]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the Management API.
        :param pulumi.Input[str] certificate: The Base64 Encoded Certificate.
        :param pulumi.Input[str] certificate_password: The password associated with the certificate provided above.
        :param pulumi.Input[bool] default_ssl_binding: Is the certificate associated with this Hostname the Default SSL Certificate? This is used when an SNI header isn't specified by a client. Defaults to `false`.
        :param pulumi.Input[str] expiry: The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        :param pulumi.Input[str] ssl_keyvault_identity_client_id: The Managed Identity Client ID to use to access the Key Vault. This Identity must be specified in the `identity` block to be used.
        :param pulumi.Input[str] subject: The subject of the certificate.
        :param pulumi.Input[str] thumbprint: The thumbprint of the certificate.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if default_ssl_binding is not None:
            pulumi.set(__self__, "default_ssl_binding", default_ssl_binding)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the Management API.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The Base64 Encoded Certificate.
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password associated with the certificate provided above.
        """
        return pulumi.get(self, "certificate_password")

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

    @property
    @pulumi.getter(name="defaultSslBinding")
    def default_ssl_binding(self) -> Optional[pulumi.Input[bool]]:
        """
        Is the certificate associated with this Hostname the Default SSL Certificate? This is used when an SNI header isn't specified by a client. Defaults to `false`.
        """
        return pulumi.get(self, "default_ssl_binding")

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

    @property
    @pulumi.getter
    def expiry(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        """
        return pulumi.get(self, "expiry")

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

    @property
    @pulumi.getter(name="sslKeyvaultIdentityClientId")
    def ssl_keyvault_identity_client_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Managed Identity Client ID to use to access the Key Vault. This Identity must be specified in the `identity` block to be used.
        """
        return pulumi.get(self, "ssl_keyvault_identity_client_id")

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

    @property
    @pulumi.getter
    def subject(self) -> Optional[pulumi.Input[str]]:
        """
        The subject of the certificate.
        """
        return pulumi.get(self, "subject")

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

    @property
    @pulumi.getter
    def thumbprint(self) -> Optional[pulumi.Input[str]]:
        """
        The thumbprint of the certificate.
        """
        return pulumi.get(self, "thumbprint")

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


@pulumi.input_type
class ServiceHostnameConfigurationScmArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_password: Optional[pulumi.Input[str]] = None,
                 expiry: Optional[pulumi.Input[str]] = None,
                 key_vault_id: Optional[pulumi.Input[str]] = None,
                 negotiate_client_certificate: Optional[pulumi.Input[bool]] = None,
                 ssl_keyvault_identity_client_id: Optional[pulumi.Input[str]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 thumbprint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: The Hostname to use for the Management API.
        :param pulumi.Input[str] certificate: One or more (up to 10) `certificate` blocks as defined below.
        :param pulumi.Input[str] certificate_password: The password for the certificate.
        :param pulumi.Input[str] expiry: The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        :param pulumi.Input[str] key_vault_id: The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        :param pulumi.Input[bool] negotiate_client_certificate: Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        :param pulumi.Input[str] ssl_keyvault_identity_client_id: The client id of the System or User Assigned Managed identity generated by Azure AD, which has `GET` access to the keyVault containing the SSL certificate.
        :param pulumi.Input[str] subject: The subject of the certificate.
        :param pulumi.Input[str] thumbprint: The thumbprint of the certificate.
        """
        pulumi.set(__self__, "host_name", host_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_password is not None:
            pulumi.set(__self__, "certificate_password", certificate_password)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if key_vault_id is not None:
            pulumi.set(__self__, "key_vault_id", key_vault_id)
        if negotiate_client_certificate is not None:
            pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)
        if ssl_keyvault_identity_client_id is not None:
            pulumi.set(__self__, "ssl_keyvault_identity_client_id", ssl_keyvault_identity_client_id)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if thumbprint is not None:
            pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        The Hostname to use for the Management API.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        One or more (up to 10) `certificate` blocks as defined below.
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="certificatePassword")
    def certificate_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password for the certificate.
        """
        return pulumi.get(self, "certificate_password")

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

    @property
    @pulumi.getter
    def expiry(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration date of the certificate in RFC3339 format: `2000-01-02T03:04:05Z`.
        """
        return pulumi.get(self, "expiry")

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault Secret containing the SSL Certificate, which must be should be of the type `application/x-pkcs12`.
        """
        return pulumi.get(self, "key_vault_id")

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

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Should Client Certificate Negotiation be enabled for this Hostname? Defaults to `false`.
        """
        return pulumi.get(self, "negotiate_client_certificate")

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

    @property
    @pulumi.getter(name="sslKeyvaultIdentityClientId")
    def ssl_keyvault_identity_client_id(self) -> Optional[pulumi.Input[str]]:
        """
        The client id of the System or User Assigned Managed identity generated by Azure AD, which has `GET` access to the keyVault containing the SSL certificate.
        """
        return pulumi.get(self, "ssl_keyvault_identity_client_id")

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

    @property
    @pulumi.getter
    def subject(self) -> Optional[pulumi.Input[str]]:
        """
        The subject of the certificate.
        """
        return pulumi.get(self, "subject")

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

    @property
    @pulumi.getter
    def thumbprint(self) -> Optional[pulumi.Input[str]]:
        """
        The thumbprint of the certificate.
        """
        return pulumi.get(self, "thumbprint")

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


@pulumi.input_type
class ServiceIdentityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 identity_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 principal_id: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Specifies the type of Managed Service Identity that should be configured on this API Management Service. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] identity_ids: A list of User Assigned Managed Identity IDs to be assigned to this API Management Service.
        :param pulumi.Input[str] principal_id: The Principal ID associated with this Managed Service Identity.
        :param pulumi.Input[str] tenant_id: The identifier for the tenant access information contract.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

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

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

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of User Assigned Managed Identity IDs to be assigned to this API Management Service.
        """
        return pulumi.get(self, "identity_ids")

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

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Principal ID associated with this Managed Service Identity.
        """
        return pulumi.get(self, "principal_id")

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

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        The identifier for the tenant access information contract.
        """
        return pulumi.get(self, "tenant_id")

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


@pulumi.input_type
class ServicePolicyArgs:
    def __init__(__self__, *,
                 xml_content: Optional[pulumi.Input[str]] = None,
                 xml_link: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] xml_content: The XML Content for this Policy.
        :param pulumi.Input[str] xml_link: A link to an API Management Policy XML Document, which must be publicly available.
        """
        if xml_content is not None:
            pulumi.set(__self__, "xml_content", xml_content)
        if xml_link is not None:
            pulumi.set(__self__, "xml_link", xml_link)

    @property
    @pulumi.getter(name="xmlContent")
    def xml_content(self) -> Optional[pulumi.Input[str]]:
        """
        The XML Content for this Policy.
        """
        return pulumi.get(self, "xml_content")

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

    @property
    @pulumi.getter(name="xmlLink")
    def xml_link(self) -> Optional[pulumi.Input[str]]:
        """
        A link to an API Management Policy XML Document, which must be publicly available.
        """
        return pulumi.get(self, "xml_link")

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


@pulumi.input_type
class ServiceProtocolsArgs:
    def __init__(__self__, *,
                 enable_http2: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enable_http2: Should HTTP/2 be supported by the API Management Service? Defaults to `false`.
        """
        if enable_http2 is not None:
            pulumi.set(__self__, "enable_http2", enable_http2)

    @property
    @pulumi.getter(name="enableHttp2")
    def enable_http2(self) -> Optional[pulumi.Input[bool]]:
        """
        Should HTTP/2 be supported by the API Management Service? Defaults to `false`.
        """
        return pulumi.get(self, "enable_http2")

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


@pulumi.input_type
class ServiceSecurityArgs:
    def __init__(__self__, *,
                 enable_backend_ssl30: Optional[pulumi.Input[bool]] = None,
                 enable_backend_tls10: Optional[pulumi.Input[bool]] = None,
                 enable_backend_tls11: Optional[pulumi.Input[bool]] = None,
                 enable_frontend_ssl30: Optional[pulumi.Input[bool]] = None,
                 enable_frontend_tls10: Optional[pulumi.Input[bool]] = None,
                 enable_frontend_tls11: Optional[pulumi.Input[bool]] = None,
                 tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 tls_ecdhe_rsa_with_aes128_cbc_sha_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 tls_ecdhe_rsa_with_aes256_cbc_sha_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 tls_rsa_with_aes128_cbc_sha256_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 tls_rsa_with_aes128_cbc_sha_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 tls_rsa_with_aes128_gcm_sha256_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 tls_rsa_with_aes256_cbc_sha256_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 tls_rsa_with_aes256_cbc_sha_ciphers_enabled: Optional[pulumi.Input[bool]] = None,
                 triple_des_ciphers_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enable_backend_ssl30: Should SSL 3.0 be enabled on the backend of the gateway? Defaults to `false`.
        :param pulumi.Input[bool] enable_backend_tls10: Should TLS 1.0 be enabled on the backend of the gateway? Defaults to `false`.
        :param pulumi.Input[bool] enable_backend_tls11: Should TLS 1.1 be enabled on the backend of the gateway? Defaults to `false`.
        :param pulumi.Input[bool] enable_frontend_ssl30: Should SSL 3.0 be enabled on the frontend of the gateway? Defaults to `false`.
        :param pulumi.Input[bool] enable_frontend_tls10: Should TLS 1.0 be enabled on the frontend of the gateway? Defaults to `false`.
        :param pulumi.Input[bool] enable_frontend_tls11: Should TLS 1.1 be enabled on the frontend of the gateway? Defaults to `false`.
        :param pulumi.Input[bool] tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled: Should the `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA` cipher be enabled? Defaults to `false`.
        :param pulumi.Input[bool] tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled: Should the `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA` cipher be enabled? Defaults to `false`.
        :param pulumi.Input[bool] tls_rsa_with_aes128_cbc_sha256_ciphers_enabled: Should the `TLS_RSA_WITH_AES_128_CBC_SHA256` cipher be enabled? Defaults to `false`.
        :param pulumi.Input[bool] tls_rsa_with_aes128_cbc_sha_ciphers_enabled: Should the `TLS_RSA_WITH_AES_128_CBC_SHA` cipher be enabled? Defaults to `false`.
        :param pulumi.Input[bool] tls_rsa_with_aes128_gcm_sha256_ciphers_enabled: Should the `TLS_RSA_WITH_AES_128_GCM_SHA256` cipher be enabled? Defaults to `false`.
        :param pulumi.Input[bool] tls_rsa_with_aes256_cbc_sha256_ciphers_enabled: Should the `TLS_RSA_WITH_AES_256_CBC_SHA256` cipher be enabled? Defaults to `false`.
        :param pulumi.Input[bool] tls_rsa_with_aes256_cbc_sha_ciphers_enabled: Should the `TLS_RSA_WITH_AES_256_CBC_SHA` cipher be enabled? Defaults to `false`.
        :param pulumi.Input[bool] triple_des_ciphers_enabled: Should the `TLS_RSA_WITH_3DES_EDE_CBC_SHA` cipher be enabled for alL TLS versions (1.0, 1.1 and 1.2)? Defaults to `false`.
        """
        if enable_backend_ssl30 is not None:
            pulumi.set(__self__, "enable_backend_ssl30", enable_backend_ssl30)
        if enable_backend_tls10 is not None:
            pulumi.set(__self__, "enable_backend_tls10", enable_backend_tls10)
        if enable_backend_tls11 is not None:
            pulumi.set(__self__, "enable_backend_tls11", enable_backend_tls11)
        if enable_frontend_ssl30 is not None:
            pulumi.set(__self__, "enable_frontend_ssl30", enable_frontend_ssl30)
        if enable_frontend_tls10 is not None:
            pulumi.set(__self__, "enable_frontend_tls10", enable_frontend_tls10)
        if enable_frontend_tls11 is not None:
            pulumi.set(__self__, "enable_frontend_tls11", enable_frontend_tls11)
        if tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled", tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled)
        if tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled", tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled)
        if tls_ecdhe_rsa_with_aes128_cbc_sha_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_ecdhe_rsa_with_aes128_cbc_sha_ciphers_enabled", tls_ecdhe_rsa_with_aes128_cbc_sha_ciphers_enabled)
        if tls_ecdhe_rsa_with_aes256_cbc_sha_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_ecdhe_rsa_with_aes256_cbc_sha_ciphers_enabled", tls_ecdhe_rsa_with_aes256_cbc_sha_ciphers_enabled)
        if tls_rsa_with_aes128_cbc_sha256_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_rsa_with_aes128_cbc_sha256_ciphers_enabled", tls_rsa_with_aes128_cbc_sha256_ciphers_enabled)
        if tls_rsa_with_aes128_cbc_sha_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_rsa_with_aes128_cbc_sha_ciphers_enabled", tls_rsa_with_aes128_cbc_sha_ciphers_enabled)
        if tls_rsa_with_aes128_gcm_sha256_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_rsa_with_aes128_gcm_sha256_ciphers_enabled", tls_rsa_with_aes128_gcm_sha256_ciphers_enabled)
        if tls_rsa_with_aes256_cbc_sha256_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_rsa_with_aes256_cbc_sha256_ciphers_enabled", tls_rsa_with_aes256_cbc_sha256_ciphers_enabled)
        if tls_rsa_with_aes256_cbc_sha_ciphers_enabled is not None:
            pulumi.set(__self__, "tls_rsa_with_aes256_cbc_sha_ciphers_enabled", tls_rsa_with_aes256_cbc_sha_ciphers_enabled)
        if triple_des_ciphers_enabled is not None:
            pulumi.set(__self__, "triple_des_ciphers_enabled", triple_des_ciphers_enabled)

    @property
    @pulumi.getter(name="enableBackendSsl30")
    def enable_backend_ssl30(self) -> Optional[pulumi.Input[bool]]:
        """
        Should SSL 3.0 be enabled on the backend of the gateway? Defaults to `false`.
        """
        return pulumi.get(self, "enable_backend_ssl30")

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

    @property
    @pulumi.getter(name="enableBackendTls10")
    def enable_backend_tls10(self) -> Optional[pulumi.Input[bool]]:
        """
        Should TLS 1.0 be enabled on the backend of the gateway? Defaults to `false`.
        """
        return pulumi.get(self, "enable_backend_tls10")

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

    @property
    @pulumi.getter(name="enableBackendTls11")
    def enable_backend_tls11(self) -> Optional[pulumi.Input[bool]]:
        """
        Should TLS 1.1 be enabled on the backend of the gateway? Defaults to `false`.
        """
        return pulumi.get(self, "enable_backend_tls11")

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

    @property
    @pulumi.getter(name="enableFrontendSsl30")
    def enable_frontend_ssl30(self) -> Optional[pulumi.Input[bool]]:
        """
        Should SSL 3.0 be enabled on the frontend of the gateway? Defaults to `false`.
        """
        return pulumi.get(self, "enable_frontend_ssl30")

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

    @property
    @pulumi.getter(name="enableFrontendTls10")
    def enable_frontend_tls10(self) -> Optional[pulumi.Input[bool]]:
        """
        Should TLS 1.0 be enabled on the frontend of the gateway? Defaults to `false`.
        """
        return pulumi.get(self, "enable_frontend_tls10")

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

    @property
    @pulumi.getter(name="enableFrontendTls11")
    def enable_frontend_tls11(self) -> Optional[pulumi.Input[bool]]:
        """
        Should TLS 1.1 be enabled on the frontend of the gateway? Defaults to `false`.
        """
        return pulumi.get(self, "enable_frontend_tls11")

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

    @property
    @pulumi.getter(name="tlsEcdheEcdsaWithAes128CbcShaCiphersEnabled")
    def tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA` cipher be enabled? Defaults to `false`.
        """
        return pulumi.get(self, "tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled")

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

    @property
    @pulumi.getter(name="tlsEcdheEcdsaWithAes256CbcShaCiphersEnabled")
    def tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA` cipher be enabled? Defaults to `false`.
        """
        return pulumi.get(self, "tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled")

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

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

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

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

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

    @property
    @pulumi.getter(name="tlsRsaWithAes128CbcSha256CiphersEnabled")
    def tls_rsa_with_aes128_cbc_sha256_ciphers_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the `TLS_RSA_WITH_AES_128_CBC_SHA256` cipher be enabled? Defaults to `false`.
        """
        return pulumi.get(self, "tls_rsa_with_aes128_cbc_sha256_ciphers_enabled")

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

    @property
    @pulumi.getter(name="tlsRsaWithAes128CbcShaCiphersEnabled")
    def tls_rsa_with_aes128_cbc_sha_ciphers_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the `TLS_RSA_WITH_AES_128_CBC_SHA` cipher be enabled? Defaults to `false`.
        """
        return pulumi.get(self, "tls_rsa_with_aes128_cbc_sha_ciphers_enabled")

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

    @property
    @pulumi.getter(name="tlsRsaWithAes128GcmSha256CiphersEnabled")
    def tls_rsa_with_aes128_gcm_sha256_ciphers_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the `TLS_RSA_WITH_AES_128_GCM_SHA256` cipher be enabled? Defaults to `false`.
        """
        return pulumi.get(self, "tls_rsa_with_aes128_gcm_sha256_ciphers_enabled")

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

    @property
    @pulumi.getter(name="tlsRsaWithAes256CbcSha256CiphersEnabled")
    def tls_rsa_with_aes256_cbc_sha256_ciphers_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the `TLS_RSA_WITH_AES_256_CBC_SHA256` cipher be enabled? Defaults to `false`.
        """
        return pulumi.get(self, "tls_rsa_with_aes256_cbc_sha256_ciphers_enabled")

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

    @property
    @pulumi.getter(name="tlsRsaWithAes256CbcShaCiphersEnabled")
    def tls_rsa_with_aes256_cbc_sha_ciphers_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the `TLS_RSA_WITH_AES_256_CBC_SHA` cipher be enabled? Defaults to `false`.
        """
        return pulumi.get(self, "tls_rsa_with_aes256_cbc_sha_ciphers_enabled")

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

    @property
    @pulumi.getter(name="tripleDesCiphersEnabled")
    def triple_des_ciphers_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the `TLS_RSA_WITH_3DES_EDE_CBC_SHA` cipher be enabled for alL TLS versions (1.0, 1.1 and 1.2)? Defaults to `false`.
        """
        return pulumi.get(self, "triple_des_ciphers_enabled")

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


@pulumi.input_type
class ServiceSignInArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool]):
        """
        :param pulumi.Input[bool] enabled: Should anonymous users be redirected to the sign in page?
        """
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        """
        Should anonymous users be redirected to the sign in page?
        """
        return pulumi.get(self, "enabled")

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


@pulumi.input_type
class ServiceSignUpArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 terms_of_service: pulumi.Input['ServiceSignUpTermsOfServiceArgs']):
        """
        :param pulumi.Input[bool] enabled: Can users sign up on the development portal?
        :param pulumi.Input['ServiceSignUpTermsOfServiceArgs'] terms_of_service: A `terms_of_service` block as defined below.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "terms_of_service", terms_of_service)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        """
        Can users sign up on the development portal?
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="termsOfService")
    def terms_of_service(self) -> pulumi.Input['ServiceSignUpTermsOfServiceArgs']:
        """
        A `terms_of_service` block as defined below.
        """
        return pulumi.get(self, "terms_of_service")

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


@pulumi.input_type
class ServiceSignUpTermsOfServiceArgs:
    def __init__(__self__, *,
                 consent_required: pulumi.Input[bool],
                 enabled: pulumi.Input[bool],
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] consent_required: Should the user be asked for consent during sign up?
        :param pulumi.Input[bool] enabled: Should Terms of Service be displayed during sign up?.
        :param pulumi.Input[str] text: The Terms of Service which users are required to agree to in order to sign up.
        """
        pulumi.set(__self__, "consent_required", consent_required)
        pulumi.set(__self__, "enabled", enabled)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter(name="consentRequired")
    def consent_required(self) -> pulumi.Input[bool]:
        """
        Should the user be asked for consent during sign up?
        """
        return pulumi.get(self, "consent_required")

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

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        """
        Should Terms of Service be displayed during sign up?.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def text(self) -> Optional[pulumi.Input[str]]:
        """
        The Terms of Service which users are required to agree to in order to sign up.
        """
        return pulumi.get(self, "text")

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


@pulumi.input_type
class ServiceTenantAccessArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 primary_key: Optional[pulumi.Input[str]] = None,
                 secondary_key: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enabled: Should the access to the management API be enabled?
        :param pulumi.Input[str] primary_key: Primary access key for the tenant access information contract.
        :param pulumi.Input[str] secondary_key: Secondary access key for the tenant access information contract.
        :param pulumi.Input[str] tenant_id: The identifier for the tenant access information contract.
        """
        pulumi.set(__self__, "enabled", enabled)
        if primary_key is not None:
            pulumi.set(__self__, "primary_key", primary_key)
        if secondary_key is not None:
            pulumi.set(__self__, "secondary_key", secondary_key)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        """
        Should the access to the management API be enabled?
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="primaryKey")
    def primary_key(self) -> Optional[pulumi.Input[str]]:
        """
        Primary access key for the tenant access information contract.
        """
        return pulumi.get(self, "primary_key")

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

    @property
    @pulumi.getter(name="secondaryKey")
    def secondary_key(self) -> Optional[pulumi.Input[str]]:
        """
        Secondary access key for the tenant access information contract.
        """
        return pulumi.get(self, "secondary_key")

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

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        The identifier for the tenant access information contract.
        """
        return pulumi.get(self, "tenant_id")

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


@pulumi.input_type
class ServiceVirtualNetworkConfigurationArgs:
    def __init__(__self__, *,
                 subnet_id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] subnet_id: The id of the subnet that will be used for the API Management.
        """
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> pulumi.Input[str]:
        """
        The id of the subnet that will be used for the API Management.
        """
        return pulumi.get(self, "subnet_id")

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


