# 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
from . import outputs

__all__ = [
    'ApiDiagnosticBackendRequest',
    'ApiDiagnosticBackendResponse',
    'ApiDiagnosticFrontendRequest',
    'ApiDiagnosticFrontendResponse',
    'ApiImport',
    'ApiImportWsdlSelector',
    'ApiOauth2Authorization',
    'ApiOpenidAuthentication',
    'ApiOperationRequest',
    'ApiOperationRequestHeader',
    'ApiOperationRequestQueryParameter',
    'ApiOperationRequestRepresentation',
    'ApiOperationRequestRepresentationFormParameter',
    'ApiOperationResponse',
    'ApiOperationResponseHeader',
    'ApiOperationResponseRepresentation',
    'ApiOperationResponseRepresentationFormParameter',
    'ApiOperationTemplateParameter',
    'ApiSubscriptionKeyParameterNames',
    'AuthorizationServerTokenBodyParameter',
    'BackendCredentials',
    'BackendCredentialsAuthorization',
    'BackendProxy',
    'BackendServiceFabricCluster',
    'BackendServiceFabricClusterServerX509Name',
    'BackendTls',
    'CustomDomainDeveloperPortal',
    'CustomDomainManagement',
    'CustomDomainPortal',
    'CustomDomainProxy',
    'CustomDomainScm',
    'DiagnosticBackendRequest',
    'DiagnosticBackendResponse',
    'DiagnosticFrontendRequest',
    'DiagnosticFrontendResponse',
    'LoggerApplicationInsights',
    'LoggerEventhub',
    'ServiceAdditionalLocation',
    'ServiceAdditionalLocationVirtualNetworkConfiguration',
    'ServiceCertificate',
    'ServiceHostnameConfiguration',
    'ServiceHostnameConfigurationDeveloperPortal',
    'ServiceHostnameConfigurationManagement',
    'ServiceHostnameConfigurationPortal',
    'ServiceHostnameConfigurationProxy',
    'ServiceHostnameConfigurationScm',
    'ServiceIdentity',
    'ServicePolicy',
    'ServiceProtocols',
    'ServiceSecurity',
    'ServiceSignIn',
    'ServiceSignUp',
    'ServiceSignUpTermsOfService',
    'ServiceTenantAccess',
    'ServiceVirtualNetworkConfiguration',
    'GetApiSubscriptionKeyParameterNameResult',
    'GetServiceAdditionalLocationResult',
    'GetServiceHostnameConfigurationResult',
    'GetServiceHostnameConfigurationDeveloperPortalResult',
    'GetServiceHostnameConfigurationManagementResult',
    'GetServiceHostnameConfigurationPortalResult',
    'GetServiceHostnameConfigurationProxyResult',
    'GetServiceHostnameConfigurationScmResult',
    'GetServiceIdentityResult',
]

@pulumi.output_type
class ApiDiagnosticBackendRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyBytes":
            suggest = "body_bytes"
        elif key == "headersToLogs":
            suggest = "headers_to_logs"

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

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

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

    def __init__(__self__, *,
                 body_bytes: Optional[int] = None,
                 headers_to_logs: Optional[Sequence[str]] = None):
        """
        :param int body_bytes: Number of payload bytes to log (up to 8192).
        :param Sequence[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 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[int]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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


@pulumi.output_type
class ApiDiagnosticBackendResponse(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyBytes":
            suggest = "body_bytes"
        elif key == "headersToLogs":
            suggest = "headers_to_logs"

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

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

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

    def __init__(__self__, *,
                 body_bytes: Optional[int] = None,
                 headers_to_logs: Optional[Sequence[str]] = None):
        """
        :param int body_bytes: Number of payload bytes to log (up to 8192).
        :param Sequence[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 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[int]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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


@pulumi.output_type
class ApiDiagnosticFrontendRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyBytes":
            suggest = "body_bytes"
        elif key == "headersToLogs":
            suggest = "headers_to_logs"

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

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

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

    def __init__(__self__, *,
                 body_bytes: Optional[int] = None,
                 headers_to_logs: Optional[Sequence[str]] = None):
        """
        :param int body_bytes: Number of payload bytes to log (up to 8192).
        :param Sequence[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 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[int]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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


@pulumi.output_type
class ApiDiagnosticFrontendResponse(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyBytes":
            suggest = "body_bytes"
        elif key == "headersToLogs":
            suggest = "headers_to_logs"

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

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

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

    def __init__(__self__, *,
                 body_bytes: Optional[int] = None,
                 headers_to_logs: Optional[Sequence[str]] = None):
        """
        :param int body_bytes: Number of payload bytes to log (up to 8192).
        :param Sequence[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 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[int]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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


@pulumi.output_type
class ApiImport(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentFormat":
            suggest = "content_format"
        elif key == "contentValue":
            suggest = "content_value"
        elif key == "wsdlSelector":
            suggest = "wsdl_selector"

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

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

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

    def __init__(__self__, *,
                 content_format: str,
                 content_value: str,
                 wsdl_selector: Optional['outputs.ApiImportWsdlSelector'] = None):
        """
        :param 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 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 '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) -> 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")

    @property
    @pulumi.getter(name="contentValue")
    def content_value(self) -> 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")

    @property
    @pulumi.getter(name="wsdlSelector")
    def wsdl_selector(self) -> Optional['outputs.ApiImportWsdlSelector']:
        """
        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")


@pulumi.output_type
class ApiImportWsdlSelector(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endpointName":
            suggest = "endpoint_name"
        elif key == "serviceName":
            suggest = "service_name"

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

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

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

    def __init__(__self__, *,
                 endpoint_name: str,
                 service_name: str):
        """
        :param str endpoint_name: The name of endpoint (port) to import from WSDL.
        :param 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) -> str:
        """
        The name of endpoint (port) to import from WSDL.
        """
        return pulumi.get(self, "endpoint_name")

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


@pulumi.output_type
class ApiOauth2Authorization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authorizationServerName":
            suggest = "authorization_server_name"

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

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

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

    def __init__(__self__, *,
                 authorization_server_name: str,
                 scope: Optional[str] = None):
        """
        :param str authorization_server_name: OAuth authorization server identifier. The name of an OAuth2 Authorization Server.
        :param 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) -> str:
        """
        OAuth authorization server identifier. The name of an OAuth2 Authorization Server.
        """
        return pulumi.get(self, "authorization_server_name")

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


@pulumi.output_type
class ApiOpenidAuthentication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "openidProviderName":
            suggest = "openid_provider_name"
        elif key == "bearerTokenSendingMethods":
            suggest = "bearer_token_sending_methods"

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

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

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

    def __init__(__self__, *,
                 openid_provider_name: str,
                 bearer_token_sending_methods: Optional[Sequence[str]] = None):
        """
        :param str openid_provider_name: OpenID Connect provider identifier. The name of an OpenID Connect Provider.
        :param Sequence[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) -> str:
        """
        OpenID Connect provider identifier. The name of an OpenID Connect Provider.
        """
        return pulumi.get(self, "openid_provider_name")

    @property
    @pulumi.getter(name="bearerTokenSendingMethods")
    def bearer_token_sending_methods(self) -> Optional[Sequence[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")


@pulumi.output_type
class ApiOperationRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "queryParameters":
            suggest = "query_parameters"

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

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

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

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 headers: Optional[Sequence['outputs.ApiOperationRequestHeader']] = None,
                 query_parameters: Optional[Sequence['outputs.ApiOperationRequestQueryParameter']] = None,
                 representations: Optional[Sequence['outputs.ApiOperationRequestRepresentation']] = None):
        """
        :param str description: A description of the HTTP Request, which may include HTML tags.
        :param Sequence['ApiOperationRequestHeaderArgs'] headers: One or more `header` blocks as defined above.
        :param Sequence['ApiOperationRequestQueryParameterArgs'] query_parameters: One or more `query_parameter` blocks as defined above.
        :param Sequence['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[str]:
        """
        A description of the HTTP Request, which may include HTML tags.
        """
        return pulumi.get(self, "description")

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

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

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


@pulumi.output_type
class ApiOperationRequestHeader(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultValue":
            suggest = "default_value"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 required: bool,
                 type: str,
                 default_value: Optional[str] = None,
                 description: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str name: The Name of this Header.
        :param bool required: Is this Header Required?
        :param str type: The Type of this Header, such as a `string`.
        :param str default_value: The default value for this Header.
        :param str description: A description of this Header.
        :param Sequence[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) -> str:
        """
        The Name of this Header.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.output_type
class ApiOperationRequestQueryParameter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultValue":
            suggest = "default_value"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 required: bool,
                 type: str,
                 default_value: Optional[str] = None,
                 description: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str name: The Name of this Query Parameter.
        :param bool required: Is this Query Parameter Required?
        :param str type: The Type of this Query Parameter, such as a `string`.
        :param str default_value: The default value for this Query Parameter.
        :param str description: A description of this Query Parameter.
        :param Sequence[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) -> str:
        """
        The Name of this Query Parameter.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.output_type
class ApiOperationRequestRepresentation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentType":
            suggest = "content_type"
        elif key == "formParameters":
            suggest = "form_parameters"
        elif key == "schemaId":
            suggest = "schema_id"
        elif key == "typeName":
            suggest = "type_name"

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

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

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

    def __init__(__self__, *,
                 content_type: str,
                 form_parameters: Optional[Sequence['outputs.ApiOperationRequestRepresentationFormParameter']] = None,
                 sample: Optional[str] = None,
                 schema_id: Optional[str] = None,
                 type_name: Optional[str] = None):
        """
        :param str content_type: The Content Type of this representation, such as `application/json`.
        :param Sequence['ApiOperationRequestRepresentationFormParameterArgs'] form_parameters: One or more `form_parameter` block as defined above.
        :param str sample: An example of this representation.
        :param str schema_id: The ID of an API Management Schema which represents this Response.
        :param str type_name: The Type Name defined by the Schema.
        """
        pulumi.set(__self__, "content_type", content_type)
        if form_parameters is not None:
            pulumi.set(__self__, "form_parameters", form_parameters)
        if sample is not None:
            pulumi.set(__self__, "sample", sample)
        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) -> str:
        """
        The Content Type of this representation, such as `application/json`.
        """
        return pulumi.get(self, "content_type")

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

    @property
    @pulumi.getter
    def sample(self) -> Optional[str]:
        """
        An example of this representation.
        """
        return pulumi.get(self, "sample")

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

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


@pulumi.output_type
class ApiOperationRequestRepresentationFormParameter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultValue":
            suggest = "default_value"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 required: bool,
                 type: str,
                 default_value: Optional[str] = None,
                 description: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str name: The Name of this Form Parameter.
        :param bool required: Is this Form Parameter Required?
        :param str type: The Type of this Form Parameter, such as a `string`.
        :param str default_value: The default value for this Form Parameter.
        :param str description: A description of this Form Parameter.
        :param Sequence[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) -> str:
        """
        The Name of this Form Parameter.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.output_type
class ApiOperationResponse(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "statusCode":
            suggest = "status_code"

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

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

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

    def __init__(__self__, *,
                 status_code: int,
                 description: Optional[str] = None,
                 headers: Optional[Sequence['outputs.ApiOperationResponseHeader']] = None,
                 representations: Optional[Sequence['outputs.ApiOperationResponseRepresentation']] = None):
        """
        :param int status_code: The HTTP Status Code.
        :param str description: A description of the HTTP Response, which may include HTML tags.
        :param Sequence['ApiOperationResponseHeaderArgs'] headers: One or more `header` blocks as defined above.
        :param Sequence['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) -> int:
        """
        The HTTP Status Code.
        """
        return pulumi.get(self, "status_code")

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

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

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


@pulumi.output_type
class ApiOperationResponseHeader(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultValue":
            suggest = "default_value"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 required: bool,
                 type: str,
                 default_value: Optional[str] = None,
                 description: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str name: The Name of this Header.
        :param bool required: Is this Header Required?
        :param str type: The Type of this Header, such as a `string`.
        :param str default_value: The default value for this Header.
        :param str description: A description of this Header.
        :param Sequence[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) -> str:
        """
        The Name of this Header.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.output_type
class ApiOperationResponseRepresentation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentType":
            suggest = "content_type"
        elif key == "formParameters":
            suggest = "form_parameters"
        elif key == "schemaId":
            suggest = "schema_id"
        elif key == "typeName":
            suggest = "type_name"

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

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

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

    def __init__(__self__, *,
                 content_type: str,
                 form_parameters: Optional[Sequence['outputs.ApiOperationResponseRepresentationFormParameter']] = None,
                 sample: Optional[str] = None,
                 schema_id: Optional[str] = None,
                 type_name: Optional[str] = None):
        """
        :param str content_type: The Content Type of this representation, such as `application/json`.
        :param Sequence['ApiOperationResponseRepresentationFormParameterArgs'] form_parameters: One or more `form_parameter` block as defined above.
        :param str sample: An example of this representation.
        :param str schema_id: The ID of an API Management Schema which represents this Response.
        :param str type_name: The Type Name defined by the Schema.
        """
        pulumi.set(__self__, "content_type", content_type)
        if form_parameters is not None:
            pulumi.set(__self__, "form_parameters", form_parameters)
        if sample is not None:
            pulumi.set(__self__, "sample", sample)
        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) -> str:
        """
        The Content Type of this representation, such as `application/json`.
        """
        return pulumi.get(self, "content_type")

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

    @property
    @pulumi.getter
    def sample(self) -> Optional[str]:
        """
        An example of this representation.
        """
        return pulumi.get(self, "sample")

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

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


@pulumi.output_type
class ApiOperationResponseRepresentationFormParameter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultValue":
            suggest = "default_value"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 required: bool,
                 type: str,
                 default_value: Optional[str] = None,
                 description: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str name: The Name of this Form Parameter.
        :param bool required: Is this Form Parameter Required?
        :param str type: The Type of this Form Parameter, such as a `string`.
        :param str default_value: The default value for this Form Parameter.
        :param str description: A description of this Form Parameter.
        :param Sequence[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) -> str:
        """
        The Name of this Form Parameter.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.output_type
class ApiOperationTemplateParameter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultValue":
            suggest = "default_value"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 required: bool,
                 type: str,
                 default_value: Optional[str] = None,
                 description: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str name: The Name of this Template Parameter.
        :param bool required: Is this Template Parameter Required?
        :param str type: The Type of this Template Parameter, such as a `string`.
        :param str default_value: The default value for this Template Parameter.
        :param str description: A description of this Template Parameter.
        :param Sequence[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) -> str:
        """
        The Name of this Template Parameter.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.output_type
class ApiSubscriptionKeyParameterNames(dict):
    def __init__(__self__, *,
                 header: str,
                 query: str):
        """
        :param str header: The name of the HTTP Header which should be used for the Subscription Key.
        :param 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) -> str:
        """
        The name of the HTTP Header which should be used for the Subscription Key.
        """
        return pulumi.get(self, "header")

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


@pulumi.output_type
class AuthorizationServerTokenBodyParameter(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The Name of the Parameter.
        :param str value: The Value of the Parameter.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class BackendCredentials(dict):
    def __init__(__self__, *,
                 authorization: Optional['outputs.BackendCredentialsAuthorization'] = None,
                 certificates: Optional[Sequence[str]] = None,
                 header: Optional[Mapping[str, str]] = None,
                 query: Optional[Mapping[str, str]] = None):
        """
        :param 'BackendCredentialsAuthorizationArgs' authorization: An `authorization` block as defined below.
        :param Sequence[str] certificates: A list of client certificate thumbprints to present to the backend host. The certificates must exist within the API Management Service.
        :param Mapping[str, 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 Mapping[str, 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['outputs.BackendCredentialsAuthorization']:
        """
        An `authorization` block as defined below.
        """
        return pulumi.get(self, "authorization")

    @property
    @pulumi.getter
    def certificates(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter
    def header(self) -> Optional[Mapping[str, 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")

    @property
    @pulumi.getter
    def query(self) -> Optional[Mapping[str, 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")


@pulumi.output_type
class BackendCredentialsAuthorization(dict):
    def __init__(__self__, *,
                 parameter: Optional[str] = None,
                 scheme: Optional[str] = None):
        """
        :param str parameter: The authentication Parameter value.
        :param 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[str]:
        """
        The authentication Parameter value.
        """
        return pulumi.get(self, "parameter")

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


@pulumi.output_type
class BackendProxy(dict):
    def __init__(__self__, *,
                 url: str,
                 username: str,
                 password: Optional[str] = None):
        """
        :param str url: The URL of the proxy server.
        :param str username: The username to connect to the proxy server.
        :param 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) -> str:
        """
        The URL of the proxy server.
        """
        return pulumi.get(self, "url")

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

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


@pulumi.output_type
class BackendServiceFabricCluster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientCertificateThumbprint":
            suggest = "client_certificate_thumbprint"
        elif key == "managementEndpoints":
            suggest = "management_endpoints"
        elif key == "maxPartitionResolutionRetries":
            suggest = "max_partition_resolution_retries"
        elif key == "serverCertificateThumbprints":
            suggest = "server_certificate_thumbprints"
        elif key == "serverX509Names":
            suggest = "server_x509_names"

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

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

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

    def __init__(__self__, *,
                 client_certificate_thumbprint: str,
                 management_endpoints: Sequence[str],
                 max_partition_resolution_retries: int,
                 server_certificate_thumbprints: Optional[Sequence[str]] = None,
                 server_x509_names: Optional[Sequence['outputs.BackendServiceFabricClusterServerX509Name']] = None):
        """
        :param str client_certificate_thumbprint: The client certificate thumbprint for the management endpoint.
        :param Sequence[str] management_endpoints: A list of cluster management endpoints.
        :param int max_partition_resolution_retries: The maximum number of retries when attempting resolve the partition.
        :param Sequence[str] server_certificate_thumbprints: A list of thumbprints of the server certificates of the Service Fabric cluster.
        :param Sequence['BackendServiceFabricClusterServerX509NameArgs'] server_x509_names: One or more `server_x509_name` blocks as documented below.
        """
        pulumi.set(__self__, "client_certificate_thumbprint", client_certificate_thumbprint)
        pulumi.set(__self__, "management_endpoints", management_endpoints)
        pulumi.set(__self__, "max_partition_resolution_retries", max_partition_resolution_retries)
        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="clientCertificateThumbprint")
    def client_certificate_thumbprint(self) -> str:
        """
        The client certificate thumbprint for the management endpoint.
        """
        return pulumi.get(self, "client_certificate_thumbprint")

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

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

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

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


@pulumi.output_type
class BackendServiceFabricClusterServerX509Name(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "issuerCertificateThumbprint":
            suggest = "issuer_certificate_thumbprint"

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

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

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

    def __init__(__self__, *,
                 issuer_certificate_thumbprint: str,
                 name: str):
        """
        :param str issuer_certificate_thumbprint: The thumbprint for the issuer of the certificate.
        :param 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) -> str:
        """
        The thumbprint for the issuer of the certificate.
        """
        return pulumi.get(self, "issuer_certificate_thumbprint")

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


@pulumi.output_type
class BackendTls(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "validateCertificateChain":
            suggest = "validate_certificate_chain"
        elif key == "validateCertificateName":
            suggest = "validate_certificate_name"

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

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

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

    def __init__(__self__, *,
                 validate_certificate_chain: Optional[bool] = None,
                 validate_certificate_name: Optional[bool] = None):
        """
        :param bool validate_certificate_chain: Flag indicating whether SSL certificate chain validation should be done when using self-signed certificates for the backend host.
        :param 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[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")

    @property
    @pulumi.getter(name="validateCertificateName")
    def validate_certificate_name(self) -> Optional[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")


@pulumi.output_type
class CustomDomainDeveloperPortal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the corresponding endpoint.
        :param str certificate: The Base64 Encoded Certificate. (Mutually exlusive with `key_vault_id`.)
        :param str certificate_password: The password associated with the certificate provided above.
        :param 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class CustomDomainManagement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the corresponding endpoint.
        :param str certificate: The Base64 Encoded Certificate. (Mutually exlusive with `key_vault_id`.)
        :param str certificate_password: The password associated with the certificate provided above.
        :param 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class CustomDomainPortal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the corresponding endpoint.
        :param str certificate: The Base64 Encoded Certificate. (Mutually exlusive with `key_vault_id`.)
        :param str certificate_password: The password associated with the certificate provided above.
        :param 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class CustomDomainProxy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "defaultSslBinding":
            suggest = "default_ssl_binding"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 default_ssl_binding: Optional[bool] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the API Proxy Endpoint.
        :param str certificate: The Base64 Encoded Certificate. (Mutually exlusive with `key_vault_id`.)
        :param str certificate_password: The password associated with the certificate provided above.
        :param 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 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="defaultSslBinding")
    def default_ssl_binding(self) -> Optional[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")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class CustomDomainScm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the corresponding endpoint.
        :param str certificate: The Base64 Encoded Certificate. (Mutually exlusive with `key_vault_id`.)
        :param str certificate_password: The password associated with the certificate provided above.
        :param 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class DiagnosticBackendRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyBytes":
            suggest = "body_bytes"
        elif key == "headersToLogs":
            suggest = "headers_to_logs"

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

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

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

    def __init__(__self__, *,
                 body_bytes: Optional[int] = None,
                 headers_to_logs: Optional[Sequence[str]] = None):
        """
        :param int body_bytes: Number of payload bytes to log (up to 8192).
        :param Sequence[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 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[int]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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


@pulumi.output_type
class DiagnosticBackendResponse(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyBytes":
            suggest = "body_bytes"
        elif key == "headersToLogs":
            suggest = "headers_to_logs"

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

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

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

    def __init__(__self__, *,
                 body_bytes: Optional[int] = None,
                 headers_to_logs: Optional[Sequence[str]] = None):
        """
        :param int body_bytes: Number of payload bytes to log (up to 8192).
        :param Sequence[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 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[int]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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


@pulumi.output_type
class DiagnosticFrontendRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyBytes":
            suggest = "body_bytes"
        elif key == "headersToLogs":
            suggest = "headers_to_logs"

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

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

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

    def __init__(__self__, *,
                 body_bytes: Optional[int] = None,
                 headers_to_logs: Optional[Sequence[str]] = None):
        """
        :param int body_bytes: Number of payload bytes to log (up to 8192).
        :param Sequence[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 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[int]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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


@pulumi.output_type
class DiagnosticFrontendResponse(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyBytes":
            suggest = "body_bytes"
        elif key == "headersToLogs":
            suggest = "headers_to_logs"

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

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

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

    def __init__(__self__, *,
                 body_bytes: Optional[int] = None,
                 headers_to_logs: Optional[Sequence[str]] = None):
        """
        :param int body_bytes: Number of payload bytes to log (up to 8192).
        :param Sequence[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 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[int]:
        """
        Number of payload bytes to log (up to 8192).
        """
        return pulumi.get(self, "body_bytes")

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


@pulumi.output_type
class LoggerApplicationInsights(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instrumentationKey":
            suggest = "instrumentation_key"

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

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

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

    def __init__(__self__, *,
                 instrumentation_key: str):
        """
        :param 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) -> str:
        """
        The instrumentation key used to push data to Application Insights.
        """
        return pulumi.get(self, "instrumentation_key")


@pulumi.output_type
class LoggerEventhub(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionString":
            suggest = "connection_string"

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

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

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

    def __init__(__self__, *,
                 connection_string: str,
                 name: str):
        """
        :param str connection_string: The connection string of an EventHub Namespace.
        :param 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) -> str:
        """
        The connection string of an EventHub Namespace.
        """
        return pulumi.get(self, "connection_string")

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


@pulumi.output_type
class ServiceAdditionalLocation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gatewayRegionalUrl":
            suggest = "gateway_regional_url"
        elif key == "privateIpAddresses":
            suggest = "private_ip_addresses"
        elif key == "publicIpAddresses":
            suggest = "public_ip_addresses"
        elif key == "virtualNetworkConfiguration":
            suggest = "virtual_network_configuration"

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

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

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

    def __init__(__self__, *,
                 location: str,
                 gateway_regional_url: Optional[str] = None,
                 private_ip_addresses: Optional[Sequence[str]] = None,
                 public_ip_addresses: Optional[Sequence[str]] = None,
                 virtual_network_configuration: Optional['outputs.ServiceAdditionalLocationVirtualNetworkConfiguration'] = None):
        """
        :param str location: The name of the Azure Region in which the API Management Service should be expanded to.
        :param str gateway_regional_url: The URL of the Regional Gateway for the API Management Service in the specified region.
        :param Sequence[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 Sequence[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 'ServiceAdditionalLocationVirtualNetworkConfigurationArgs' virtual_network_configuration: A `virtual_network_configuration` block as defined below.  Required when `virtual_network_type` is `External` or `Internal`.
        """
        pulumi.set(__self__, "location", location)
        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_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)

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

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

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="publicIpAddresses")
    def public_ip_addresses(self) -> Optional[Sequence[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")

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


@pulumi.output_type
class ServiceAdditionalLocationVirtualNetworkConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetId":
            suggest = "subnet_id"

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

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

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

    def __init__(__self__, *,
                 subnet_id: str):
        """
        :param 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) -> str:
        """
        The id of the subnet that will be used for the API Management.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class ServiceCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "encodedCertificate":
            suggest = "encoded_certificate"
        elif key == "storeName":
            suggest = "store_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"

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

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

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

    def __init__(__self__, *,
                 encoded_certificate: str,
                 store_name: str,
                 certificate_password: Optional[str] = None):
        """
        :param str encoded_certificate: The Base64 Encoded PFX or Base64 Encoded X.509 Certificate.
        :param str store_name: The name of the Certificate Store where this certificate should be stored. Possible values are `CertificateAuthority` and `Root`.
        :param str certificate_password: The password for 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)

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

    @property
    @pulumi.getter(name="storeName")
    def store_name(self) -> 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")

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


@pulumi.output_type
class ServiceHostnameConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "developerPortals":
            suggest = "developer_portals"

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

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

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

    def __init__(__self__, *,
                 developer_portals: Optional[Sequence['outputs.ServiceHostnameConfigurationDeveloperPortal']] = None,
                 managements: Optional[Sequence['outputs.ServiceHostnameConfigurationManagement']] = None,
                 portals: Optional[Sequence['outputs.ServiceHostnameConfigurationPortal']] = None,
                 proxies: Optional[Sequence['outputs.ServiceHostnameConfigurationProxy']] = None,
                 scms: Optional[Sequence['outputs.ServiceHostnameConfigurationScm']] = None):
        """
        :param Sequence['ServiceHostnameConfigurationDeveloperPortalArgs'] developer_portals: One or more `developer_portal` blocks as documented below.
        :param Sequence['ServiceHostnameConfigurationManagementArgs'] managements: One or more `management` blocks as documented below.
        :param Sequence['ServiceHostnameConfigurationPortalArgs'] portals: One or more `portal` blocks as documented below.
        :param Sequence['ServiceHostnameConfigurationProxyArgs'] proxies: One or more `proxy` blocks as documented below.
        :param Sequence['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[Sequence['outputs.ServiceHostnameConfigurationDeveloperPortal']]:
        """
        One or more `developer_portal` blocks as documented below.
        """
        return pulumi.get(self, "developer_portals")

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

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

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

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


@pulumi.output_type
class ServiceHostnameConfigurationDeveloperPortal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the Management API.
        :param str certificate: One or more (up to 10) `certificate` blocks as defined below.
        :param str certificate_password: The password for the certificate.
        :param 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class ServiceHostnameConfigurationManagement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the Management API.
        :param str certificate: The Base64 Encoded Certificate.
        :param str certificate_password: The password associated with the certificate provided above.
        :param 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class ServiceHostnameConfigurationPortal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the Management API.
        :param str certificate: One or more (up to 10) `certificate` blocks as defined below.
        :param str certificate_password: The password for the certificate.
        :param 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class ServiceHostnameConfigurationProxy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "defaultSslBinding":
            suggest = "default_ssl_binding"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 default_ssl_binding: Optional[bool] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the Management API.
        :param str certificate: The Base64 Encoded Certificate.
        :param str certificate_password: The password associated with the certificate provided above.
        :param 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 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="defaultSslBinding")
    def default_ssl_binding(self) -> Optional[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")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class ServiceHostnameConfigurationScm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostName":
            suggest = "host_name"
        elif key == "certificatePassword":
            suggest = "certificate_password"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "negotiateClientCertificate":
            suggest = "negotiate_client_certificate"

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

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

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

    def __init__(__self__, *,
                 host_name: str,
                 certificate: Optional[str] = None,
                 certificate_password: Optional[str] = None,
                 key_vault_id: Optional[str] = None,
                 negotiate_client_certificate: Optional[bool] = None):
        """
        :param str host_name: The Hostname to use for the Management API.
        :param str certificate: One or more (up to 10) `certificate` blocks as defined below.
        :param str certificate_password: The password for the certificate.
        :param 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 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 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)

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

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

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

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> Optional[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")

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


@pulumi.output_type
class ServiceIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityIds":
            suggest = "identity_ids"
        elif key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"

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

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

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

    def __init__(__self__, *,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param Sequence[str] identity_ids: A list of IDs for User Assigned Managed Identity resources to be assigned.
        :param str principal_id: The Principal ID associated with this Managed Service Identity.
        :param str tenant_id: The identifier for the tenant access information contract.
        :param 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).
        """
        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)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class ServicePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "xmlContent":
            suggest = "xml_content"
        elif key == "xmlLink":
            suggest = "xml_link"

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

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

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

    def __init__(__self__, *,
                 xml_content: Optional[str] = None,
                 xml_link: Optional[str] = None):
        """
        :param str xml_content: The XML Content for this Policy.
        :param 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[str]:
        """
        The XML Content for this Policy.
        """
        return pulumi.get(self, "xml_content")

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


@pulumi.output_type
class ServiceProtocols(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableHttp2":
            suggest = "enable_http2"

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

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

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

    def __init__(__self__, *,
                 enable_http2: Optional[bool] = None):
        """
        :param 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[bool]:
        """
        Should HTTP/2 be supported by the API Management Service? Defaults to `false`.
        """
        return pulumi.get(self, "enable_http2")


@pulumi.output_type
class ServiceSecurity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableBackendSsl30":
            suggest = "enable_backend_ssl30"
        elif key == "enableBackendTls10":
            suggest = "enable_backend_tls10"
        elif key == "enableBackendTls11":
            suggest = "enable_backend_tls11"
        elif key == "enableFrontendSsl30":
            suggest = "enable_frontend_ssl30"
        elif key == "enableFrontendTls10":
            suggest = "enable_frontend_tls10"
        elif key == "enableFrontendTls11":
            suggest = "enable_frontend_tls11"
        elif key == "enableTripleDesCiphers":
            suggest = "enable_triple_des_ciphers"
        elif key == "tlsEcdheEcdsaWithAes128CbcShaCiphersEnabled":
            suggest = "tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled"
        elif key == "tlsEcdheEcdsaWithAes256CbcShaCiphersEnabled":
            suggest = "tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled"
        elif key == "tlsEcdheRsaWithAes128CbcShaCiphersEnabled":
            suggest = "tls_ecdhe_rsa_with_aes128_cbc_sha_ciphers_enabled"
        elif key == "tlsEcdheRsaWithAes256CbcShaCiphersEnabled":
            suggest = "tls_ecdhe_rsa_with_aes256_cbc_sha_ciphers_enabled"
        elif key == "tlsRsaWithAes128CbcSha256CiphersEnabled":
            suggest = "tls_rsa_with_aes128_cbc_sha256_ciphers_enabled"
        elif key == "tlsRsaWithAes128CbcShaCiphersEnabled":
            suggest = "tls_rsa_with_aes128_cbc_sha_ciphers_enabled"
        elif key == "tlsRsaWithAes128GcmSha256CiphersEnabled":
            suggest = "tls_rsa_with_aes128_gcm_sha256_ciphers_enabled"
        elif key == "tlsRsaWithAes256CbcSha256CiphersEnabled":
            suggest = "tls_rsa_with_aes256_cbc_sha256_ciphers_enabled"
        elif key == "tlsRsaWithAes256CbcShaCiphersEnabled":
            suggest = "tls_rsa_with_aes256_cbc_sha_ciphers_enabled"
        elif key == "tripleDesCiphersEnabled":
            suggest = "triple_des_ciphers_enabled"

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

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

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

    def __init__(__self__, *,
                 enable_backend_ssl30: Optional[bool] = None,
                 enable_backend_tls10: Optional[bool] = None,
                 enable_backend_tls11: Optional[bool] = None,
                 enable_frontend_ssl30: Optional[bool] = None,
                 enable_frontend_tls10: Optional[bool] = None,
                 enable_frontend_tls11: Optional[bool] = None,
                 enable_triple_des_ciphers: Optional[bool] = None,
                 tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled: Optional[bool] = None,
                 tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled: Optional[bool] = None,
                 tls_ecdhe_rsa_with_aes128_cbc_sha_ciphers_enabled: Optional[bool] = None,
                 tls_ecdhe_rsa_with_aes256_cbc_sha_ciphers_enabled: Optional[bool] = None,
                 tls_rsa_with_aes128_cbc_sha256_ciphers_enabled: Optional[bool] = None,
                 tls_rsa_with_aes128_cbc_sha_ciphers_enabled: Optional[bool] = None,
                 tls_rsa_with_aes128_gcm_sha256_ciphers_enabled: Optional[bool] = None,
                 tls_rsa_with_aes256_cbc_sha256_ciphers_enabled: Optional[bool] = None,
                 tls_rsa_with_aes256_cbc_sha_ciphers_enabled: Optional[bool] = None,
                 triple_des_ciphers_enabled: Optional[bool] = None):
        """
        :param bool enable_backend_ssl30: Should SSL 3.0 be enabled on the backend of the gateway? Defaults to `false`.
        :param bool enable_backend_tls10: Should TLS 1.0 be enabled on the backend of the gateway? Defaults to `false`.
        :param bool enable_backend_tls11: Should TLS 1.1 be enabled on the backend of the gateway? Defaults to `false`.
        :param bool enable_frontend_ssl30: Should SSL 3.0 be enabled on the frontend of the gateway? Defaults to `false`.
        :param bool enable_frontend_tls10: Should TLS 1.0 be enabled on the frontend of the gateway? Defaults to `false`.
        :param bool enable_frontend_tls11: Should TLS 1.1 be enabled on the frontend of the gateway? Defaults to `false`.
        :param bool enable_triple_des_ciphers: 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`.
        :param 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 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 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 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 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 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 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 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 enable_triple_des_ciphers is not None:
            pulumi.set(__self__, "enable_triple_des_ciphers", enable_triple_des_ciphers)
        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[bool]:
        """
        Should SSL 3.0 be enabled on the backend of the gateway? Defaults to `false`.
        """
        return pulumi.get(self, "enable_backend_ssl30")

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

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

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

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

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

    @property
    @pulumi.getter(name="enableTripleDesCiphers")
    def enable_triple_des_ciphers(self) -> Optional[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, "enable_triple_des_ciphers")

    @property
    @pulumi.getter(name="tlsEcdheEcdsaWithAes128CbcShaCiphersEnabled")
    def tls_ecdhe_ecdsa_with_aes128_cbc_sha_ciphers_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="tlsEcdheEcdsaWithAes256CbcShaCiphersEnabled")
    def tls_ecdhe_ecdsa_with_aes256_cbc_sha_ciphers_enabled(self) -> Optional[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")

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

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

    @property
    @pulumi.getter(name="tlsRsaWithAes128CbcSha256CiphersEnabled")
    def tls_rsa_with_aes128_cbc_sha256_ciphers_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="tlsRsaWithAes128CbcShaCiphersEnabled")
    def tls_rsa_with_aes128_cbc_sha_ciphers_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="tlsRsaWithAes128GcmSha256CiphersEnabled")
    def tls_rsa_with_aes128_gcm_sha256_ciphers_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="tlsRsaWithAes256CbcSha256CiphersEnabled")
    def tls_rsa_with_aes256_cbc_sha256_ciphers_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="tlsRsaWithAes256CbcShaCiphersEnabled")
    def tls_rsa_with_aes256_cbc_sha_ciphers_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="tripleDesCiphersEnabled")
    def triple_des_ciphers_enabled(self) -> Optional[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")


@pulumi.output_type
class ServiceSignIn(dict):
    def __init__(__self__, *,
                 enabled: bool):
        """
        :param bool enabled: Should anonymous users be redirected to the sign in page?
        """
        pulumi.set(__self__, "enabled", enabled)

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


@pulumi.output_type
class ServiceSignUp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "termsOfService":
            suggest = "terms_of_service"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 terms_of_service: 'outputs.ServiceSignUpTermsOfService'):
        """
        :param bool enabled: Can users sign up on the development portal?
        :param '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) -> bool:
        """
        Can users sign up on the development portal?
        """
        return pulumi.get(self, "enabled")

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


@pulumi.output_type
class ServiceSignUpTermsOfService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "consentRequired":
            suggest = "consent_required"

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

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

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

    def __init__(__self__, *,
                 consent_required: bool,
                 enabled: bool,
                 text: Optional[str] = None):
        """
        :param bool consent_required: Should the user be asked for consent during sign up?
        :param bool enabled: Should Terms of Service be displayed during sign up?.
        :param 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) -> bool:
        """
        Should the user be asked for consent during sign up?
        """
        return pulumi.get(self, "consent_required")

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

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


@pulumi.output_type
class ServiceTenantAccess(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "primaryKey":
            suggest = "primary_key"
        elif key == "secondaryKey":
            suggest = "secondary_key"
        elif key == "tenantId":
            suggest = "tenant_id"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 primary_key: Optional[str] = None,
                 secondary_key: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param bool enabled: Should the access to the management api be enabled?
        :param str primary_key: Primary access key for the tenant access information contract.
        :param str secondary_key: Secondary access key for the tenant access information contract.
        :param 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) -> bool:
        """
        Should the access to the management api be enabled?
        """
        return pulumi.get(self, "enabled")

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

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

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


@pulumi.output_type
class ServiceVirtualNetworkConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetId":
            suggest = "subnet_id"

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

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

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

    def __init__(__self__, *,
                 subnet_id: str):
        """
        :param 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) -> str:
        """
        The id of the subnet that will be used for the API Management.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class GetApiSubscriptionKeyParameterNameResult(dict):
    def __init__(__self__, *,
                 header: str,
                 query: str):
        """
        :param str header: The name of the HTTP Header which should be used for the Subscription Key.
        :param 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) -> str:
        """
        The name of the HTTP Header which should be used for the Subscription Key.
        """
        return pulumi.get(self, "header")

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


@pulumi.output_type
class GetServiceAdditionalLocationResult(dict):
    def __init__(__self__, *,
                 gateway_regional_url: str,
                 location: str,
                 private_ip_addresses: Sequence[str],
                 public_ip_addresses: Sequence[str]):
        """
        :param str gateway_regional_url: Gateway URL of the API Management service in the Region.
        :param str location: The location name of the additional region among Azure Data center regions.
        :param Sequence[str] private_ip_addresses: Private IP addresses of the API Management service in the additional location, for instances using virtual network mode.
        :param Sequence[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.
        """
        pulumi.set(__self__, "gateway_regional_url", gateway_regional_url)
        pulumi.set(__self__, "location", location)
        pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        pulumi.set(__self__, "public_ip_addresses", public_ip_addresses)

    @property
    @pulumi.getter(name="gatewayRegionalUrl")
    def gateway_regional_url(self) -> str:
        """
        Gateway URL of the API Management service in the Region.
        """
        return pulumi.get(self, "gateway_regional_url")

    @property
    @pulumi.getter
    def location(self) -> str:
        """
        The location name of the additional region among Azure Data center regions.
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Sequence[str]:
        """
        Private IP addresses of the API Management service in the additional location, for instances using virtual network mode.
        """
        return pulumi.get(self, "private_ip_addresses")

    @property
    @pulumi.getter(name="publicIpAddresses")
    def public_ip_addresses(self) -> Sequence[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")


@pulumi.output_type
class GetServiceHostnameConfigurationResult(dict):
    def __init__(__self__, *,
                 developer_portals: Sequence['outputs.GetServiceHostnameConfigurationDeveloperPortalResult'],
                 managements: Sequence['outputs.GetServiceHostnameConfigurationManagementResult'],
                 portals: Sequence['outputs.GetServiceHostnameConfigurationPortalResult'],
                 proxies: Sequence['outputs.GetServiceHostnameConfigurationProxyResult'],
                 scms: Sequence['outputs.GetServiceHostnameConfigurationScmResult']):
        """
        :param Sequence['GetServiceHostnameConfigurationDeveloperPortalArgs'] developer_portals: One or more `developer_portal` blocks as documented below.
        :param Sequence['GetServiceHostnameConfigurationManagementArgs'] managements: One or more `management` blocks as documented below.
        :param Sequence['GetServiceHostnameConfigurationPortalArgs'] portals: One or more `portal` blocks as documented below.
        :param Sequence['GetServiceHostnameConfigurationProxyArgs'] proxies: One or more `proxy` blocks as documented below.
        :param Sequence['GetServiceHostnameConfigurationScmArgs'] scms: One or more `scm` blocks as documented below.
        """
        pulumi.set(__self__, "developer_portals", developer_portals)
        pulumi.set(__self__, "managements", managements)
        pulumi.set(__self__, "portals", portals)
        pulumi.set(__self__, "proxies", proxies)
        pulumi.set(__self__, "scms", scms)

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

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

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

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

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


@pulumi.output_type
class GetServiceHostnameConfigurationDeveloperPortalResult(dict):
    def __init__(__self__, *,
                 host_name: str,
                 key_vault_id: str,
                 negotiate_client_certificate: bool):
        """
        :param str host_name: The Hostname used for the SCM URL.
        :param str key_vault_id: The ID of the Key Vault Secret which contains the SSL Certificate.
        :param bool negotiate_client_certificate: Is Client Certificate Negotiation enabled?
        """
        pulumi.set(__self__, "host_name", host_name)
        pulumi.set(__self__, "key_vault_id", key_vault_id)
        pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> str:
        """
        The Hostname used for the SCM URL.
        """
        return pulumi.get(self, "host_name")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> str:
        """
        The ID of the Key Vault Secret which contains the SSL Certificate.
        """
        return pulumi.get(self, "key_vault_id")

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> bool:
        """
        Is Client Certificate Negotiation enabled?
        """
        return pulumi.get(self, "negotiate_client_certificate")


@pulumi.output_type
class GetServiceHostnameConfigurationManagementResult(dict):
    def __init__(__self__, *,
                 host_name: str,
                 key_vault_id: str,
                 negotiate_client_certificate: bool):
        """
        :param str host_name: The Hostname used for the SCM URL.
        :param str key_vault_id: The ID of the Key Vault Secret which contains the SSL Certificate.
        :param bool negotiate_client_certificate: Is Client Certificate Negotiation enabled?
        """
        pulumi.set(__self__, "host_name", host_name)
        pulumi.set(__self__, "key_vault_id", key_vault_id)
        pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> str:
        """
        The Hostname used for the SCM URL.
        """
        return pulumi.get(self, "host_name")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> str:
        """
        The ID of the Key Vault Secret which contains the SSL Certificate.
        """
        return pulumi.get(self, "key_vault_id")

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> bool:
        """
        Is Client Certificate Negotiation enabled?
        """
        return pulumi.get(self, "negotiate_client_certificate")


@pulumi.output_type
class GetServiceHostnameConfigurationPortalResult(dict):
    def __init__(__self__, *,
                 host_name: str,
                 key_vault_id: str,
                 negotiate_client_certificate: bool):
        """
        :param str host_name: The Hostname used for the SCM URL.
        :param str key_vault_id: The ID of the Key Vault Secret which contains the SSL Certificate.
        :param bool negotiate_client_certificate: Is Client Certificate Negotiation enabled?
        """
        pulumi.set(__self__, "host_name", host_name)
        pulumi.set(__self__, "key_vault_id", key_vault_id)
        pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> str:
        """
        The Hostname used for the SCM URL.
        """
        return pulumi.get(self, "host_name")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> str:
        """
        The ID of the Key Vault Secret which contains the SSL Certificate.
        """
        return pulumi.get(self, "key_vault_id")

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> bool:
        """
        Is Client Certificate Negotiation enabled?
        """
        return pulumi.get(self, "negotiate_client_certificate")


@pulumi.output_type
class GetServiceHostnameConfigurationProxyResult(dict):
    def __init__(__self__, *,
                 default_ssl_binding: bool,
                 host_name: str,
                 key_vault_id: str,
                 negotiate_client_certificate: bool):
        """
        :param bool default_ssl_binding: Is this the default SSL Binding?
        :param str host_name: The Hostname used for the SCM URL.
        :param str key_vault_id: The ID of the Key Vault Secret which contains the SSL Certificate.
        :param bool negotiate_client_certificate: Is Client Certificate Negotiation enabled?
        """
        pulumi.set(__self__, "default_ssl_binding", default_ssl_binding)
        pulumi.set(__self__, "host_name", host_name)
        pulumi.set(__self__, "key_vault_id", key_vault_id)
        pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)

    @property
    @pulumi.getter(name="defaultSslBinding")
    def default_ssl_binding(self) -> bool:
        """
        Is this the default SSL Binding?
        """
        return pulumi.get(self, "default_ssl_binding")

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> str:
        """
        The Hostname used for the SCM URL.
        """
        return pulumi.get(self, "host_name")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> str:
        """
        The ID of the Key Vault Secret which contains the SSL Certificate.
        """
        return pulumi.get(self, "key_vault_id")

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> bool:
        """
        Is Client Certificate Negotiation enabled?
        """
        return pulumi.get(self, "negotiate_client_certificate")


@pulumi.output_type
class GetServiceHostnameConfigurationScmResult(dict):
    def __init__(__self__, *,
                 host_name: str,
                 key_vault_id: str,
                 negotiate_client_certificate: bool):
        """
        :param str host_name: The Hostname used for the SCM URL.
        :param str key_vault_id: The ID of the Key Vault Secret which contains the SSL Certificate.
        :param bool negotiate_client_certificate: Is Client Certificate Negotiation enabled?
        """
        pulumi.set(__self__, "host_name", host_name)
        pulumi.set(__self__, "key_vault_id", key_vault_id)
        pulumi.set(__self__, "negotiate_client_certificate", negotiate_client_certificate)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> str:
        """
        The Hostname used for the SCM URL.
        """
        return pulumi.get(self, "host_name")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> str:
        """
        The ID of the Key Vault Secret which contains the SSL Certificate.
        """
        return pulumi.get(self, "key_vault_id")

    @property
    @pulumi.getter(name="negotiateClientCertificate")
    def negotiate_client_certificate(self) -> bool:
        """
        Is Client Certificate Negotiation enabled?
        """
        return pulumi.get(self, "negotiate_client_certificate")


@pulumi.output_type
class GetServiceIdentityResult(dict):
    def __init__(__self__, *,
                 identity_ids: Sequence[str],
                 principal_id: str,
                 tenant_id: str,
                 type: str):
        """
        :param Sequence[str] identity_ids: A list of IDs for User Assigned Managed Identity resources to be assigned.
        :param str principal_id: Specifies the Principal ID of the System Assigned Managed Service Identity that is configured on this API Management Service.
        :param str tenant_id: Specifies the Tenant ID of the System Assigned Managed Service Identity that is configured on this API Management Service.
        :param str type: Specifies the type of Managed Service Identity that is configured on this API Management Service.
        """
        pulumi.set(__self__, "identity_ids", identity_ids)
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        Specifies the Principal ID of the System Assigned Managed Service Identity that is configured on this API Management Service.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        Specifies the Tenant ID of the System Assigned Managed Service Identity that is configured on this API Management Service.
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of Managed Service Identity that is configured on this API Management Service.
        """
        return pulumi.get(self, "type")


