text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi SDK Generator. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union, overload
  from ... import _utilities
  from . import outputs
  from ._enums import *
  
  __all__ = [
      'AdditionalLocationResponse',
      'ApiManagementServiceIdentityResponse',
      'ApiManagementServiceSkuPropertiesResponse',
      'ApiVersionSetContractDetailsResponse',
      'AuthenticationSettingsContractResponse',
      'BackendAuthorizationHeaderCredentialsResponse',
      'BackendCredentialsContractResponse',
      'BackendPropertiesResponse',
      'BackendProxyContractResponse',
      'BackendServiceFabricClusterPropertiesResponse',
      'BackendTlsPropertiesResponse',
      'CertificateConfigurationResponse',
      'CertificateInformationResponse',
      'EmailTemplateParametersContractPropertiesResponse',
      'GroupContractPropertiesResponse',
      'HostnameConfigurationResponse',
      'OAuth2AuthenticationSettingsContractResponse',
      'OpenIdAuthenticationSettingsContractResponse',
      'ParameterContractResponse',
      'RepresentationContractResponse',
      'RequestContractResponse',
      'ResponseContractResponse',
      'SubscriptionKeyParameterNamesContractResponse',
      'TokenBodyParameterContractResponse',
      'UserIdentityContractResponse',
      'VirtualNetworkConfigurationResponse',
      'X509CertificateNameResponse',
  ]
  
  @pulumi.output_type
  class AdditionalLocationResponse(dict):
      """
      Description of an additional API Management resource location.
      """
      @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 AdditionalLocationResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          AdditionalLocationResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          AdditionalLocationResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   gateway_regional_url: str,
                   location: str,
                   private_ip_addresses: Sequence[str],
                   public_ip_addresses: Sequence[str],
                   sku: 'outputs.ApiManagementServiceSkuPropertiesResponse',
                   virtual_network_configuration: Optional['outputs.VirtualNetworkConfigurationResponse'] = None):
          """
          Description of an additional API Management resource location.
          :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 Static Load Balanced IP addresses of the API Management service which is deployed in an Internal Virtual Network in a particular additional location. Available only for Basic, Standard and Premium SKU.
          :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 'ApiManagementServiceSkuPropertiesResponse' sku: SKU properties of the API Management service.
          :param 'VirtualNetworkConfigurationResponse' virtual_network_configuration: Virtual network configuration for the location.
          """
          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)
          pulumi.set(__self__, "sku", sku)
          if virtual_network_configuration is not None:
              pulumi.set(__self__, "virtual_network_configuration", virtual_network_configuration)
  
      @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 Static Load Balanced IP addresses of the API Management service which is deployed in an Internal Virtual Network in a particular additional location. Available only for Basic, Standard and Premium SKU.
          """
          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")
  
      @property
      @pulumi.getter
      def sku(self) -> 'outputs.ApiManagementServiceSkuPropertiesResponse':
          """
          SKU properties of the API Management service.
          """
          return pulumi.get(self, "sku")
  
      @property
      @pulumi.getter(name="virtualNetworkConfiguration")
      def virtual_network_configuration(self) -> Optional['outputs.VirtualNetworkConfigurationResponse']:
          """
          Virtual network configuration for the location.
          """
          return pulumi.get(self, "virtual_network_configuration")
  
  
  @pulumi.output_type
  class ApiManagementServiceIdentityResponse(dict):
      """
      Identity properties of the Api Management service resource.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "principalId":
              suggest = "principal_id"
          elif key == "tenantId":
              suggest = "tenant_id"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ApiManagementServiceIdentityResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ApiManagementServiceIdentityResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ApiManagementServiceIdentityResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   principal_id: str,
                   tenant_id: str,
                   type: str):
          """
          Identity properties of the Api Management service resource.
          :param str principal_id: The principal id of the identity.
          :param str tenant_id: The client tenant id of the identity.
          :param str type: The identity type. Currently the only supported type is 'SystemAssigned'.
          """
          pulumi.set(__self__, "principal_id", principal_id)
          pulumi.set(__self__, "tenant_id", tenant_id)
          pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The principal id of the identity.
          """
          return pulumi.get(self, "principal_id")
  
      @property
      @pulumi.getter(name="tenantId")
      def tenant_id(self) -> str:
          """
          The client tenant id of the identity.
          """
          return pulumi.get(self, "tenant_id")
  
      @property
      @pulumi.getter
      def type(self) -> str:
          """
          The identity type. Currently the only supported type is 'SystemAssigned'.
          """
          return pulumi.get(self, "type")
  
  
  @pulumi.output_type
  class ApiManagementServiceSkuPropertiesResponse(dict):
      """
      API Management service resource SKU properties.
      """
      def __init__(__self__, *,
                   name: str,
                   capacity: Optional[int] = None):
          """
          API Management service resource SKU properties.
          :param str name: Name of the Sku.
          :param int capacity: Capacity of the SKU (number of deployed units of the SKU). The default value is 1.
          """
          pulumi.set(__self__, "name", name)
          if capacity is None:
              capacity = 1
          if capacity is not None:
              pulumi.set(__self__, "capacity", capacity)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          Name of the Sku.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def capacity(self) -> Optional[int]:
          """
          Capacity of the SKU (number of deployed units of the SKU). The default value is 1.
          """
          return pulumi.get(self, "capacity")
  
  
  @pulumi.output_type
  class ApiVersionSetContractDetailsResponse(dict):
      """
      An API Version Set contains the common configuration for a set of API Versions relating 
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "versionHeaderName":
              suggest = "version_header_name"
          elif key == "versionQueryName":
              suggest = "version_query_name"
          elif key == "versioningScheme":
              suggest = "versioning_scheme"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ApiVersionSetContractDetailsResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ApiVersionSetContractDetailsResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ApiVersionSetContractDetailsResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   description: Optional[str] = None,
                   id: Optional[str] = None,
                   version_header_name: Optional[str] = None,
                   version_query_name: Optional[str] = None,
                   versioning_scheme: Optional[str] = None):
          """
          An API Version Set contains the common configuration for a set of API Versions relating 
          :param str description: Description of API Version Set.
          :param str id: Identifier for existing API Version Set. Omit this value to create a new Version Set.
          :param str version_header_name: Name of HTTP header parameter that indicates the API Version if versioningScheme is set to `header`.
          :param str version_query_name: Name of query parameter that indicates the API Version if versioningScheme is set to `query`.
          :param str versioning_scheme: An value that determines where the API Version identifier will be located in a HTTP request.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if version_header_name is not None:
              pulumi.set(__self__, "version_header_name", version_header_name)
          if version_query_name is not None:
              pulumi.set(__self__, "version_query_name", version_query_name)
          if versioning_scheme is not None:
              pulumi.set(__self__, "versioning_scheme", versioning_scheme)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[str]:
          """
          Description of API Version Set.
          """
          return pulumi.get(self, "description")
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Identifier for existing API Version Set. Omit this value to create a new Version Set.
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter(name="versionHeaderName")
      def version_header_name(self) -> Optional[str]:
          """
          Name of HTTP header parameter that indicates the API Version if versioningScheme is set to `header`.
          """
          return pulumi.get(self, "version_header_name")
  
      @property
      @pulumi.getter(name="versionQueryName")
      def version_query_name(self) -> Optional[str]:
          """
          Name of query parameter that indicates the API Version if versioningScheme is set to `query`.
          """
          return pulumi.get(self, "version_query_name")
  
      @property
      @pulumi.getter(name="versioningScheme")
      def versioning_scheme(self) -> Optional[str]:
          """
          An value that determines where the API Version identifier will be located in a HTTP request.
          """
          return pulumi.get(self, "versioning_scheme")
  
  
  @pulumi.output_type
  class AuthenticationSettingsContractResponse(dict):
      """
      API Authentication Settings.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "oAuth2":
              suggest = "o_auth2"
          elif key == "subscriptionKeyRequired":
              suggest = "subscription_key_required"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in AuthenticationSettingsContractResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          AuthenticationSettingsContractResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          AuthenticationSettingsContractResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   o_auth2: Optional['outputs.OAuth2AuthenticationSettingsContractResponse'] = None,
                   openid: Optional['outputs.OpenIdAuthenticationSettingsContractResponse'] = None,
                   subscription_key_required: Optional[bool] = None):
          """
          API Authentication Settings.
          :param 'OAuth2AuthenticationSettingsContractResponse' o_auth2: OAuth2 Authentication settings
          :param 'OpenIdAuthenticationSettingsContractResponse' openid: OpenID Connect Authentication Settings
          :param bool subscription_key_required: Specifies whether subscription key is required during call to this API, true - API is included into closed products only, false - API is included into open products alone, null - there is a mix of products.
          """
          if o_auth2 is not None:
              pulumi.set(__self__, "o_auth2", o_auth2)
          if openid is not None:
              pulumi.set(__self__, "openid", openid)
          if subscription_key_required is not None:
              pulumi.set(__self__, "subscription_key_required", subscription_key_required)
  
      @property
      @pulumi.getter(name="oAuth2")
      def o_auth2(self) -> Optional['outputs.OAuth2AuthenticationSettingsContractResponse']:
          """
          OAuth2 Authentication settings
          """
          return pulumi.get(self, "o_auth2")
  
      @property
      @pulumi.getter
      def openid(self) -> Optional['outputs.OpenIdAuthenticationSettingsContractResponse']:
          """
          OpenID Connect Authentication Settings
          """
          return pulumi.get(self, "openid")
  
      @property
      @pulumi.getter(name="subscriptionKeyRequired")
      def subscription_key_required(self) -> Optional[bool]:
          """
          Specifies whether subscription key is required during call to this API, true - API is included into closed products only, false - API is included into open products alone, null - there is a mix of products.
          """
          return pulumi.get(self, "subscription_key_required")
  
  
  @pulumi.output_type
  class BackendAuthorizationHeaderCredentialsResponse(dict):
      """
      Authorization header information.
      """
      def __init__(__self__, *,
                   parameter: str,
                   scheme: str):
          """
          Authorization header information.
          :param str parameter: Authentication Parameter value.
          :param str scheme: Authentication Scheme name.
          """
          pulumi.set(__self__, "parameter", parameter)
          pulumi.set(__self__, "scheme", scheme)
  
      @property
      @pulumi.getter
      def parameter(self) -> str:
          """
          Authentication Parameter value.
          """
          return pulumi.get(self, "parameter")
  
      @property
      @pulumi.getter
      def scheme(self) -> str:
          """
          Authentication Scheme name.
          """
          return pulumi.get(self, "scheme")
  
  
  @pulumi.output_type
  class BackendCredentialsContractResponse(dict):
      """
      Details of the Credentials used to connect to Backend.
      """
      def __init__(__self__, *,
                   authorization: Optional['outputs.BackendAuthorizationHeaderCredentialsResponse'] = None,
                   certificate: Optional[Sequence[str]] = None,
                   header: Optional[Mapping[str, Sequence[str]]] = None,
                   query: Optional[Mapping[str, Sequence[str]]] = None):
          """
          Details of the Credentials used to connect to Backend.
          :param 'BackendAuthorizationHeaderCredentialsResponse' authorization: Authorization header authentication
          :param Sequence[str] certificate: List of Client Certificate Thumbprint.
          :param Mapping[str, Sequence[str]] header: Header Parameter description.
          :param Mapping[str, Sequence[str]] query: Query Parameter description.
          """
          if authorization is not None:
              pulumi.set(__self__, "authorization", authorization)
          if certificate is not None:
              pulumi.set(__self__, "certificate", certificate)
          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.BackendAuthorizationHeaderCredentialsResponse']:
          """
          Authorization header authentication
          """
          return pulumi.get(self, "authorization")
  
      @property
      @pulumi.getter
      def certificate(self) -> Optional[Sequence[str]]:
          """
          List of Client Certificate Thumbprint.
          """
          return pulumi.get(self, "certificate")
  
      @property
      @pulumi.getter
      def header(self) -> Optional[Mapping[str, Sequence[str]]]:
          """
          Header Parameter description.
          """
          return pulumi.get(self, "header")
  
      @property
      @pulumi.getter
      def query(self) -> Optional[Mapping[str, Sequence[str]]]:
          """
          Query Parameter description.
          """
          return pulumi.get(self, "query")
  
  
  @pulumi.output_type
  class BackendPropertiesResponse(dict):
      """
      Properties specific to the Backend Type.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "serviceFabricCluster":
              suggest = "service_fabric_cluster"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in BackendPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          BackendPropertiesResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          BackendPropertiesResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   service_fabric_cluster: Optional['outputs.BackendServiceFabricClusterPropertiesResponse'] = None):
          """
          Properties specific to the Backend Type.
          :param 'BackendServiceFabricClusterPropertiesResponse' service_fabric_cluster: Backend Service Fabric Cluster Properties
          """
          if service_fabric_cluster is not None:
              pulumi.set(__self__, "service_fabric_cluster", service_fabric_cluster)
  
      @property
      @pulumi.getter(name="serviceFabricCluster")
      def service_fabric_cluster(self) -> Optional['outputs.BackendServiceFabricClusterPropertiesResponse']:
          """
          Backend Service Fabric Cluster Properties
          """
          return pulumi.get(self, "service_fabric_cluster")
  
  
  @pulumi.output_type
  class BackendProxyContractResponse(dict):
      """
      Details of the Backend WebProxy Server to use in the Request to Backend.
      """
      def __init__(__self__, *,
                   url: str,
                   password: Optional[str] = None,
                   username: Optional[str] = None):
          """
          Details of the Backend WebProxy Server to use in the Request to Backend.
          :param str url: WebProxy Server AbsoluteUri property which includes the entire URI stored in the Uri instance, including all fragments and query strings.
          :param str password: Password to connect to the WebProxy Server
          :param str username: Username to connect to the WebProxy server
          """
          pulumi.set(__self__, "url", url)
          if password is not None:
              pulumi.set(__self__, "password", password)
          if username is not None:
              pulumi.set(__self__, "username", username)
  
      @property
      @pulumi.getter
      def url(self) -> str:
          """
          WebProxy Server AbsoluteUri property which includes the entire URI stored in the Uri instance, including all fragments and query strings.
          """
          return pulumi.get(self, "url")
  
      @property
      @pulumi.getter
      def password(self) -> Optional[str]:
          """
          Password to connect to the WebProxy Server
          """
          return pulumi.get(self, "password")
  
      @property
      @pulumi.getter
      def username(self) -> Optional[str]:
          """
          Username to connect to the WebProxy server
          """
          return pulumi.get(self, "username")
  
  
  @pulumi.output_type
  class BackendServiceFabricClusterPropertiesResponse(dict):
      """
      Properties of the Service Fabric Type Backend.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "clientCertificatethumbprint":
              suggest = "client_certificatethumbprint"
          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 BackendServiceFabricClusterPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          BackendServiceFabricClusterPropertiesResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          BackendServiceFabricClusterPropertiesResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   client_certificatethumbprint: str,
                   management_endpoints: Sequence[str],
                   max_partition_resolution_retries: Optional[int] = None,
                   server_certificate_thumbprints: Optional[Sequence[str]] = None,
                   server_x509_names: Optional[Sequence['outputs.X509CertificateNameResponse']] = None):
          """
          Properties of the Service Fabric Type Backend.
          :param str client_certificatethumbprint: The client certificate thumbprint for the management endpoint.
          :param Sequence[str] management_endpoints: The cluster management endpoint.
          :param int max_partition_resolution_retries: Maximum number of retries while attempting resolve the partition.
          :param Sequence[str] server_certificate_thumbprints: Thumbprints of certificates cluster management service uses for tls communication
          :param Sequence['X509CertificateNameResponse'] server_x509_names: Server X509 Certificate Names Collection
          """
          pulumi.set(__self__, "client_certificatethumbprint", client_certificatethumbprint)
          pulumi.set(__self__, "management_endpoints", management_endpoints)
          if max_partition_resolution_retries is not None:
              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_certificatethumbprint(self) -> str:
          """
          The client certificate thumbprint for the management endpoint.
          """
          return pulumi.get(self, "client_certificatethumbprint")
  
      @property
      @pulumi.getter(name="managementEndpoints")
      def management_endpoints(self) -> Sequence[str]:
          """
          The cluster management endpoint.
          """
          return pulumi.get(self, "management_endpoints")
  
      @property
      @pulumi.getter(name="maxPartitionResolutionRetries")
      def max_partition_resolution_retries(self) -> Optional[int]:
          """
          Maximum number of retries while 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]]:
          """
          Thumbprints of certificates cluster management service uses for tls communication
          """
          return pulumi.get(self, "server_certificate_thumbprints")
  
      @property
      @pulumi.getter(name="serverX509Names")
      def server_x509_names(self) -> Optional[Sequence['outputs.X509CertificateNameResponse']]:
          """
          Server X509 Certificate Names Collection
          """
          return pulumi.get(self, "server_x509_names")
  
  
  @pulumi.output_type
  class BackendTlsPropertiesResponse(dict):
      """
      Properties controlling TLS Certificate Validation.
      """
      @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 BackendTlsPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          BackendTlsPropertiesResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          BackendTlsPropertiesResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   validate_certificate_chain: Optional[bool] = None,
                   validate_certificate_name: Optional[bool] = None):
          """
          Properties controlling TLS Certificate Validation.
          :param bool validate_certificate_chain: Flag indicating whether SSL certificate chain validation should be done when using self-signed certificates for this backend host.
          :param bool validate_certificate_name: Flag indicating whether SSL certificate name validation should be done when using self-signed certificates for this backend host.
          """
          if validate_certificate_chain is None:
              validate_certificate_chain = True
          if validate_certificate_chain is not None:
              pulumi.set(__self__, "validate_certificate_chain", validate_certificate_chain)
          if validate_certificate_name is None:
              validate_certificate_name = True
          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 this 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 this backend host.
          """
          return pulumi.get(self, "validate_certificate_name")
  
  
  @pulumi.output_type
  class CertificateConfigurationResponse(dict):
      """
      Certificate configuration which consist of non-trusted intermediates and root certificates.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "storeName":
              suggest = "store_name"
          elif key == "certificatePassword":
              suggest = "certificate_password"
          elif key == "encodedCertificate":
              suggest = "encoded_certificate"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in CertificateConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          CertificateConfigurationResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          CertificateConfigurationResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   store_name: str,
                   certificate: Optional['outputs.CertificateInformationResponse'] = None,
                   certificate_password: Optional[str] = None,
                   encoded_certificate: Optional[str] = None):
          """
          Certificate configuration which consist of non-trusted intermediates and root certificates.
          :param str store_name: The System.Security.Cryptography.x509certificates.StoreName certificate store location. Only Root and CertificateAuthority are valid locations.
          :param 'CertificateInformationResponse' certificate: Certificate information.
          :param str certificate_password: Certificate Password.
          :param str encoded_certificate: Base64 Encoded certificate.
          """
          pulumi.set(__self__, "store_name", store_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 encoded_certificate is not None:
              pulumi.set(__self__, "encoded_certificate", encoded_certificate)
  
      @property
      @pulumi.getter(name="storeName")
      def store_name(self) -> str:
          """
          The System.Security.Cryptography.x509certificates.StoreName certificate store location. Only Root and CertificateAuthority are valid locations.
          """
          return pulumi.get(self, "store_name")
  
      @property
      @pulumi.getter
      def certificate(self) -> Optional['outputs.CertificateInformationResponse']:
          """
          Certificate information.
          """
          return pulumi.get(self, "certificate")
  
      @property
      @pulumi.getter(name="certificatePassword")
      def certificate_password(self) -> Optional[str]:
          """
          Certificate Password.
          """
          return pulumi.get(self, "certificate_password")
  
      @property
      @pulumi.getter(name="encodedCertificate")
      def encoded_certificate(self) -> Optional[str]:
          """
          Base64 Encoded certificate.
          """
          return pulumi.get(self, "encoded_certificate")
  
  
  @pulumi.output_type
  class CertificateInformationResponse(dict):
      """
      SSL certificate information.
      """
      def __init__(__self__, *,
                   expiry: str,
                   subject: str,
                   thumbprint: str):
          """
          SSL certificate information.
          :param str expiry: Expiration date of the certificate. The date conforms to the following format: `yyyy-MM-ddTHH:mm:ssZ` as specified by the ISO 8601 standard.
          :param str subject: Subject of the certificate.
          :param str thumbprint: Thumbprint of the certificate.
          """
          pulumi.set(__self__, "expiry", expiry)
          pulumi.set(__self__, "subject", subject)
          pulumi.set(__self__, "thumbprint", thumbprint)
  
      @property
      @pulumi.getter
      def expiry(self) -> str:
          """
          Expiration date of the certificate. The date conforms to the following format: `yyyy-MM-ddTHH:mm:ssZ` as specified by the ISO 8601 standard.
          """
          return pulumi.get(self, "expiry")
  
      @property
      @pulumi.getter
      def subject(self) -> str:
          """
          Subject of the certificate.
          """
          return pulumi.get(self, "subject")
  
      @property
      @pulumi.getter
      def thumbprint(self) -> str:
          """
          Thumbprint of the certificate.
          """
          return pulumi.get(self, "thumbprint")
  
  
  @pulumi.output_type
  class EmailTemplateParametersContractPropertiesResponse(dict):
      """
      Email Template Parameter contract.
      """
      def __init__(__self__, *,
                   description: Optional[str] = None,
                   name: Optional[str] = None,
                   title: Optional[str] = None):
          """
          Email Template Parameter contract.
          :param str description: Template parameter description.
          :param str name: Template parameter name.
          :param str title: Template parameter title.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if title is not None:
              pulumi.set(__self__, "title", title)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[str]:
          """
          Template parameter description.
          """
          return pulumi.get(self, "description")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          Template parameter name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def title(self) -> Optional[str]:
          """
          Template parameter title.
          """
          return pulumi.get(self, "title")
  
  
  @pulumi.output_type
  class GroupContractPropertiesResponse(dict):
      """
      Group contract Properties.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "builtIn":
              suggest = "built_in"
          elif key == "displayName":
              suggest = "display_name"
          elif key == "externalId":
              suggest = "external_id"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in GroupContractPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          GroupContractPropertiesResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          GroupContractPropertiesResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   built_in: bool,
                   display_name: str,
                   description: Optional[str] = None,
                   external_id: Optional[str] = None,
                   type: Optional[str] = None):
          """
          Group contract Properties.
          :param bool built_in: true if the group is one of the three system groups (Administrators, Developers, or Guests); otherwise false.
          :param str display_name: Group name.
          :param str description: Group description. Can contain HTML formatting tags.
          :param str external_id: For external groups, this property contains the id of the group from the external identity provider, e.g. for Azure Active Directory aad://<tenant>.onmicrosoft.com/groups/<group object id>; otherwise the value is null.
          :param str type: Group type.
          """
          pulumi.set(__self__, "built_in", built_in)
          pulumi.set(__self__, "display_name", display_name)
          if description is not None:
              pulumi.set(__self__, "description", description)
          if external_id is not None:
              pulumi.set(__self__, "external_id", external_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="builtIn")
      def built_in(self) -> bool:
          """
          true if the group is one of the three system groups (Administrators, Developers, or Guests); otherwise false.
          """
          return pulumi.get(self, "built_in")
  
      @property
      @pulumi.getter(name="displayName")
      def display_name(self) -> str:
          """
          Group name.
          """
          return pulumi.get(self, "display_name")
  
      @property
      @pulumi.getter
      def description(self) -> Optional[str]:
          """
          Group description. Can contain HTML formatting tags.
          """
          return pulumi.get(self, "description")
  
      @property
      @pulumi.getter(name="externalId")
      def external_id(self) -> Optional[str]:
          """
          For external groups, this property contains the id of the group from the external identity provider, e.g. for Azure Active Directory aad://<tenant>.onmicrosoft.com/groups/<group object id>; otherwise the value is null.
          """
          return pulumi.get(self, "external_id")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          Group type.
          """
          return pulumi.get(self, "type")
  
  
  @pulumi.output_type
  class HostnameConfigurationResponse(dict):
      """
      Custom hostname configuration.
      """
      @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 == "encodedCertificate":
              suggest = "encoded_certificate"
          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 HostnameConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          HostnameConfigurationResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          HostnameConfigurationResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   host_name: str,
                   type: str,
                   certificate: Optional['outputs.CertificateInformationResponse'] = None,
                   certificate_password: Optional[str] = None,
                   default_ssl_binding: Optional[bool] = None,
                   encoded_certificate: Optional[str] = None,
                   key_vault_id: Optional[str] = None,
                   negotiate_client_certificate: Optional[bool] = None):
          """
          Custom hostname configuration.
          :param str host_name: Hostname to configure on the Api Management service.
          :param str type: Hostname type.
          :param 'CertificateInformationResponse' certificate: Certificate information.
          :param str certificate_password: Certificate Password.
          :param bool default_ssl_binding: Specify true to setup the certificate associated with this Hostname as the Default SSL Certificate. If a client does not send the SNI header, then this will be the certificate that will be challenged. The property is useful if a service has multiple custom hostname enabled and it needs to decide on the default ssl certificate. The setting only applied to Proxy Hostname Type.
          :param str encoded_certificate: Base64 Encoded certificate.
          :param str key_vault_id: Url to the KeyVault Secret containing the Ssl Certificate. If absolute Url containing version is provided, auto-update of ssl certificate will not work. This requires Api Management service to be configured with MSI. The secret should be of type *application/x-pkcs12*
          :param bool negotiate_client_certificate: Specify true to always negotiate client certificate on the hostname. Default Value is false.
          """
          pulumi.set(__self__, "host_name", host_name)
          pulumi.set(__self__, "type", type)
          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 None:
              default_ssl_binding = False
          if default_ssl_binding is not None:
              pulumi.set(__self__, "default_ssl_binding", default_ssl_binding)
          if encoded_certificate is not None:
              pulumi.set(__self__, "encoded_certificate", encoded_certificate)
          if key_vault_id is not None:
              pulumi.set(__self__, "key_vault_id", key_vault_id)
          if negotiate_client_certificate is None:
              negotiate_client_certificate = False
          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:
          """
          Hostname to configure on the Api Management service.
          """
          return pulumi.get(self, "host_name")
  
      @property
      @pulumi.getter
      def type(self) -> str:
          """
          Hostname type.
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter
      def certificate(self) -> Optional['outputs.CertificateInformationResponse']:
          """
          Certificate information.
          """
          return pulumi.get(self, "certificate")
  
      @property
      @pulumi.getter(name="certificatePassword")
      def certificate_password(self) -> Optional[str]:
          """
          Certificate Password.
          """
          return pulumi.get(self, "certificate_password")
  
      @property
      @pulumi.getter(name="defaultSslBinding")
      def default_ssl_binding(self) -> Optional[bool]:
          """
          Specify true to setup the certificate associated with this Hostname as the Default SSL Certificate. If a client does not send the SNI header, then this will be the certificate that will be challenged. The property is useful if a service has multiple custom hostname enabled and it needs to decide on the default ssl certificate. The setting only applied to Proxy Hostname Type.
          """
          return pulumi.get(self, "default_ssl_binding")
  
      @property
      @pulumi.getter(name="encodedCertificate")
      def encoded_certificate(self) -> Optional[str]:
          """
          Base64 Encoded certificate.
          """
          return pulumi.get(self, "encoded_certificate")
  
      @property
      @pulumi.getter(name="keyVaultId")
      def key_vault_id(self) -> Optional[str]:
          """
          Url to the KeyVault Secret containing the Ssl Certificate. If absolute Url containing version is provided, auto-update of ssl certificate will not work. This requires Api Management service to be configured with MSI. The secret should be of type *application/x-pkcs12*
          """
          return pulumi.get(self, "key_vault_id")
  
      @property
      @pulumi.getter(name="negotiateClientCertificate")
      def negotiate_client_certificate(self) -> Optional[bool]:
          """
          Specify true to always negotiate client certificate on the hostname. Default Value is false.
          """
          return pulumi.get(self, "negotiate_client_certificate")
  
  
  @pulumi.output_type
  class OAuth2AuthenticationSettingsContractResponse(dict):
      """
      API OAuth2 Authentication settings details.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "authorizationServerId":
              suggest = "authorization_server_id"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in OAuth2AuthenticationSettingsContractResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          OAuth2AuthenticationSettingsContractResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          OAuth2AuthenticationSettingsContractResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   authorization_server_id: Optional[str] = None,
                   scope: Optional[str] = None):
          """
          API OAuth2 Authentication settings details.
          :param str authorization_server_id: OAuth authorization server identifier.
          :param str scope: operations scope.
          """
          if authorization_server_id is not None:
              pulumi.set(__self__, "authorization_server_id", authorization_server_id)
          if scope is not None:
              pulumi.set(__self__, "scope", scope)
  
      @property
      @pulumi.getter(name="authorizationServerId")
      def authorization_server_id(self) -> Optional[str]:
          """
          OAuth authorization server identifier.
          """
          return pulumi.get(self, "authorization_server_id")
  
      @property
      @pulumi.getter
      def scope(self) -> Optional[str]:
          """
          operations scope.
          """
          return pulumi.get(self, "scope")
  
  
  @pulumi.output_type
  class OpenIdAuthenticationSettingsContractResponse(dict):
      """
      API OAuth2 Authentication settings details.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "bearerTokenSendingMethods":
              suggest = "bearer_token_sending_methods"
          elif key == "openidProviderId":
              suggest = "openid_provider_id"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in OpenIdAuthenticationSettingsContractResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          OpenIdAuthenticationSettingsContractResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          OpenIdAuthenticationSettingsContractResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   bearer_token_sending_methods: Optional[Sequence[str]] = None,
                   openid_provider_id: Optional[str] = None):
          """
          API OAuth2 Authentication settings details.
          :param Sequence[str] bearer_token_sending_methods: How to send token to the server.
          :param str openid_provider_id: OAuth authorization server identifier.
          """
          if bearer_token_sending_methods is not None:
              pulumi.set(__self__, "bearer_token_sending_methods", bearer_token_sending_methods)
          if openid_provider_id is not None:
              pulumi.set(__self__, "openid_provider_id", openid_provider_id)
  
      @property
      @pulumi.getter(name="bearerTokenSendingMethods")
      def bearer_token_sending_methods(self) -> Optional[Sequence[str]]:
          """
          How to send token to the server.
          """
          return pulumi.get(self, "bearer_token_sending_methods")
  
      @property
      @pulumi.getter(name="openidProviderId")
      def openid_provider_id(self) -> Optional[str]:
          """
          OAuth authorization server identifier.
          """
          return pulumi.get(self, "openid_provider_id")
  
  
  @pulumi.output_type
  class ParameterContractResponse(dict):
      """
      Operation parameters details.
      """
      @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 ParameterContractResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ParameterContractResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ParameterContractResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   name: str,
                   type: str,
                   default_value: Optional[str] = None,
                   description: Optional[str] = None,
                   required: Optional[bool] = None,
                   values: Optional[Sequence[str]] = None):
          """
          Operation parameters details.
          :param str name: Parameter name.
          :param str type: Parameter type.
          :param str default_value: Default parameter value.
          :param str description: Parameter description.
          :param bool required: whether parameter is required or not.
          :param Sequence[str] values: Parameter values.
          """
          pulumi.set(__self__, "name", name)
          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 required is not None:
              pulumi.set(__self__, "required", required)
          if values is not None:
              pulumi.set(__self__, "values", values)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          Parameter name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def type(self) -> str:
          """
          Parameter type.
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="defaultValue")
      def default_value(self) -> Optional[str]:
          """
          Default parameter value.
          """
          return pulumi.get(self, "default_value")
  
      @property
      @pulumi.getter
      def description(self) -> Optional[str]:
          """
          Parameter description.
          """
          return pulumi.get(self, "description")
  
      @property
      @pulumi.getter
      def required(self) -> Optional[bool]:
          """
          whether parameter is required or not.
          """
          return pulumi.get(self, "required")
  
      @property
      @pulumi.getter
      def values(self) -> Optional[Sequence[str]]:
          """
          Parameter values.
          """
          return pulumi.get(self, "values")
  
  
  @pulumi.output_type
  class RepresentationContractResponse(dict):
      """
      Operation request/response representation details.
      """
      @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 RepresentationContractResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          RepresentationContractResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          RepresentationContractResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   content_type: str,
                   form_parameters: Optional[Sequence['outputs.ParameterContractResponse']] = None,
                   sample: Optional[str] = None,
                   schema_id: Optional[str] = None,
                   type_name: Optional[str] = None):
          """
          Operation request/response representation details.
          :param str content_type: Specifies a registered or custom content type for this representation, e.g. application/xml.
          :param Sequence['ParameterContractResponse'] form_parameters: Collection of form parameters. Required if 'contentType' value is either 'application/x-www-form-urlencoded' or 'multipart/form-data'..
          :param str sample: An example of the representation.
          :param str schema_id: Schema identifier. Applicable only if 'contentType' value is neither 'application/x-www-form-urlencoded' nor 'multipart/form-data'.
          :param str type_name: Type name defined by the schema. Applicable only if 'contentType' value is neither 'application/x-www-form-urlencoded' nor 'multipart/form-data'.
          """
          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:
          """
          Specifies a registered or custom content type for this representation, e.g. application/xml.
          """
          return pulumi.get(self, "content_type")
  
      @property
      @pulumi.getter(name="formParameters")
      def form_parameters(self) -> Optional[Sequence['outputs.ParameterContractResponse']]:
          """
          Collection of form parameters. Required if 'contentType' value is either 'application/x-www-form-urlencoded' or 'multipart/form-data'..
          """
          return pulumi.get(self, "form_parameters")
  
      @property
      @pulumi.getter
      def sample(self) -> Optional[str]:
          """
          An example of the representation.
          """
          return pulumi.get(self, "sample")
  
      @property
      @pulumi.getter(name="schemaId")
      def schema_id(self) -> Optional[str]:
          """
          Schema identifier. Applicable only if 'contentType' value is neither 'application/x-www-form-urlencoded' nor 'multipart/form-data'.
          """
          return pulumi.get(self, "schema_id")
  
      @property
      @pulumi.getter(name="typeName")
      def type_name(self) -> Optional[str]:
          """
          Type name defined by the schema. Applicable only if 'contentType' value is neither 'application/x-www-form-urlencoded' nor 'multipart/form-data'.
          """
          return pulumi.get(self, "type_name")
  
  
  @pulumi.output_type
  class RequestContractResponse(dict):
      """
      Operation request details.
      """
      @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 RequestContractResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          RequestContractResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          RequestContractResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   description: Optional[str] = None,
                   headers: Optional[Sequence['outputs.ParameterContractResponse']] = None,
                   query_parameters: Optional[Sequence['outputs.ParameterContractResponse']] = None,
                   representations: Optional[Sequence['outputs.RepresentationContractResponse']] = None):
          """
          Operation request details.
          :param str description: Operation request description.
          :param Sequence['ParameterContractResponse'] headers: Collection of operation request headers.
          :param Sequence['ParameterContractResponse'] query_parameters: Collection of operation request query parameters.
          :param Sequence['RepresentationContractResponse'] representations: Collection of operation request representations.
          """
          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]:
          """
          Operation request description.
          """
          return pulumi.get(self, "description")
  
      @property
      @pulumi.getter
      def headers(self) -> Optional[Sequence['outputs.ParameterContractResponse']]:
          """
          Collection of operation request headers.
          """
          return pulumi.get(self, "headers")
  
      @property
      @pulumi.getter(name="queryParameters")
      def query_parameters(self) -> Optional[Sequence['outputs.ParameterContractResponse']]:
          """
          Collection of operation request query parameters.
          """
          return pulumi.get(self, "query_parameters")
  
      @property
      @pulumi.getter
      def representations(self) -> Optional[Sequence['outputs.RepresentationContractResponse']]:
          """
          Collection of operation request representations.
          """
          return pulumi.get(self, "representations")
  
  
  @pulumi.output_type
  class ResponseContractResponse(dict):
      """
      Operation response details.
      """
      @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 ResponseContractResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ResponseContractResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ResponseContractResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   status_code: int,
                   description: Optional[str] = None,
                   headers: Optional[Sequence['outputs.ParameterContractResponse']] = None,
                   representations: Optional[Sequence['outputs.RepresentationContractResponse']] = None):
          """
          Operation response details.
          :param int status_code: Operation response HTTP status code.
          :param str description: Operation response description.
          :param Sequence['ParameterContractResponse'] headers: Collection of operation response headers.
          :param Sequence['RepresentationContractResponse'] representations: Collection of operation response representations.
          """
          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:
          """
          Operation response HTTP status code.
          """
          return pulumi.get(self, "status_code")
  
      @property
      @pulumi.getter
      def description(self) -> Optional[str]:
          """
          Operation response description.
          """
          return pulumi.get(self, "description")
  
      @property
      @pulumi.getter
      def headers(self) -> Optional[Sequence['outputs.ParameterContractResponse']]:
          """
          Collection of operation response headers.
          """
          return pulumi.get(self, "headers")
  
      @property
      @pulumi.getter
      def representations(self) -> Optional[Sequence['outputs.RepresentationContractResponse']]:
          """
          Collection of operation response representations.
          """
          return pulumi.get(self, "representations")
  
  
  @pulumi.output_type
  class SubscriptionKeyParameterNamesContractResponse(dict):
      """
      Subscription key parameter names details.
      """
      def __init__(__self__, *,
                   header: Optional[str] = None,
                   query: Optional[str] = None):
          """
          Subscription key parameter names details.
          :param str header: Subscription key header name.
          :param str query: Subscription key query string parameter name.
          """
          if header is not None:
              pulumi.set(__self__, "header", header)
          if query is not None:
              pulumi.set(__self__, "query", query)
  
      @property
      @pulumi.getter
      def header(self) -> Optional[str]:
          """
          Subscription key header name.
          """
          return pulumi.get(self, "header")
  
      @property
      @pulumi.getter
      def query(self) -> Optional[str]:
          """
          Subscription key query string parameter name.
          """
          return pulumi.get(self, "query")
  
  
  @pulumi.output_type
  class TokenBodyParameterContractResponse(dict):
      """
      OAuth acquire token request body parameter (www-url-form-encoded).
      """
      def __init__(__self__, *,
                   name: str,
                   value: str):
          """
          OAuth acquire token request body parameter (www-url-form-encoded).
          :param str name: body parameter name.
          :param str value: body parameter value.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          body parameter name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def value(self) -> str:
          """
          body parameter value.
          """
          return pulumi.get(self, "value")
  
  
  @pulumi.output_type
  class UserIdentityContractResponse(dict):
      """
      User identity details.
      """
      def __init__(__self__, *,
                   id: Optional[str] = None,
                   provider: Optional[str] = None):
          """
          User identity details.
          :param str id: Identifier value within provider.
          :param str provider: Identity provider name.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
          if provider is not None:
              pulumi.set(__self__, "provider", provider)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Identifier value within provider.
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter
      def provider(self) -> Optional[str]:
          """
          Identity provider name.
          """
          return pulumi.get(self, "provider")
  
  
  @pulumi.output_type
  class VirtualNetworkConfigurationResponse(dict):
      """
      Configuration of a virtual network to which API Management service is deployed.
      """
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "subnetResourceId":
              suggest = "subnet_resource_id"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in VirtualNetworkConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          VirtualNetworkConfigurationResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          VirtualNetworkConfigurationResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   subnetname: str,
                   vnetid: str,
                   subnet_resource_id: Optional[str] = None):
          """
          Configuration of a virtual network to which API Management service is deployed.
          :param str subnetname: The name of the subnet.
          :param str vnetid: The virtual network ID. This is typically a GUID. Expect a null GUID by default.
          :param str subnet_resource_id: The full resource ID of a subnet in a virtual network to deploy the API Management service in.
          """
          pulumi.set(__self__, "subnetname", subnetname)
          pulumi.set(__self__, "vnetid", vnetid)
          if subnet_resource_id is not None:
              pulumi.set(__self__, "subnet_resource_id", subnet_resource_id)
  
      @property
      @pulumi.getter
      def subnetname(self) -> str:
          """
          The name of the subnet.
          """
          return pulumi.get(self, "subnetname")
  
      @property
      @pulumi.getter
      def vnetid(self) -> str:
          """
          The virtual network ID. This is typically a GUID. Expect a null GUID by default.
          """
          return pulumi.get(self, "vnetid")
  
      @property
      @pulumi.getter(name="subnetResourceId")
      def subnet_resource_id(self) -> Optional[str]:
          """
          The full resource ID of a subnet in a virtual network to deploy the API Management service in.
          """
          return pulumi.get(self, "subnet_resource_id")
  
  
  @pulumi.output_type
  class X509CertificateNameResponse(dict):
      """
      Properties of server X509Names.
      """
      @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 X509CertificateNameResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          X509CertificateNameResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          X509CertificateNameResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   issuer_certificate_thumbprint: Optional[str] = None,
                   name: Optional[str] = None):
          """
          Properties of server X509Names.
          :param str issuer_certificate_thumbprint: Thumbprint for the Issuer of the Certificate.
          :param str name: Common Name of the Certificate.
          """
          if issuer_certificate_thumbprint is not None:
              pulumi.set(__self__, "issuer_certificate_thumbprint", issuer_certificate_thumbprint)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter(name="issuerCertificateThumbprint")
      def issuer_certificate_thumbprint(self) -> Optional[str]:
          """
          Thumbprint for the Issuer of the Certificate.
          """
          return pulumi.get(self, "issuer_certificate_thumbprint")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          Common Name of the Certificate.
          """
          return pulumi.get(self, "name")
  
  
  