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

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

__all__ = [
    'ClientAddonsArgs',
    'ClientAddonsSamlpArgs',
    'ClientAddonsSamlpLogoutArgs',
    'ClientJwtConfigurationArgs',
    'ClientMobileArgs',
    'ClientMobileAndroidArgs',
    'ClientMobileIosArgs',
    'ClientRefreshTokenArgs',
    'ConnectionOptionsArgs',
    'ConnectionOptionsIdpInitiatedArgs',
    'ConnectionOptionsMfaArgs',
    'ConnectionOptionsPasswordComplexityOptionsArgs',
    'ConnectionOptionsPasswordDictionaryArgs',
    'ConnectionOptionsPasswordHistoryArgs',
    'ConnectionOptionsPasswordNoPersonalInfoArgs',
    'ConnectionOptionsTotpArgs',
    'ConnectionOptionsValidationArgs',
    'ConnectionOptionsValidationUsernameArgs',
    'CustomDomainVerificationArgs',
    'EmailCredentialsArgs',
    'GlobalClientAddonsArgs',
    'GlobalClientAddonsSamlpArgs',
    'GlobalClientAddonsSamlpLogoutArgs',
    'GlobalClientJwtConfigurationArgs',
    'GlobalClientMobileArgs',
    'GlobalClientMobileAndroidArgs',
    'GlobalClientMobileIosArgs',
    'GlobalClientRefreshTokenArgs',
    'GuardianPhoneArgs',
    'GuardianPhoneOptionsArgs',
    'LogStreamSinkArgs',
    'ResourceServerScopeArgs',
    'RolePermissionArgs',
    'TenantChangePasswordArgs',
    'TenantErrorPageArgs',
    'TenantFlagsArgs',
    'TenantGuardianMfaPageArgs',
    'TenantUniversalLoginArgs',
    'TenantUniversalLoginColorsArgs',
]

@pulumi.input_type
class ClientAddonsArgs:
    def __init__(__self__, *,
                 aws: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 azure_blob: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 azure_sb: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 box: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 cloudbees: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 concur: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 dropbox: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 echosign: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 egnyte: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 firebase: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 layer: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 mscrm: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 newrelic: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 office365: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 rms: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 salesforce: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 salesforce_api: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 salesforce_sandbox_api: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 samlp: Optional[pulumi.Input['ClientAddonsSamlpArgs']] = None,
                 sap_api: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 sentry: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 sharepoint: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 slack: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 springcm: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 wams: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 wsfed: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 zendesk: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 zoom: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] aws: String
        :param pulumi.Input[Mapping[str, Any]] azure_blob: String
        :param pulumi.Input[Mapping[str, Any]] azure_sb: String
        :param pulumi.Input[Mapping[str, Any]] box: String
        :param pulumi.Input[Mapping[str, Any]] cloudbees: String
        :param pulumi.Input[Mapping[str, Any]] concur: String
        :param pulumi.Input[Mapping[str, Any]] dropbox: String
        :param pulumi.Input[Mapping[str, Any]] echosign: String
        :param pulumi.Input[Mapping[str, Any]] egnyte: String
        :param pulumi.Input[Mapping[str, Any]] firebase: String
        :param pulumi.Input[Mapping[str, Any]] layer: String
        :param pulumi.Input[Mapping[str, Any]] mscrm: String
        :param pulumi.Input[Mapping[str, Any]] newrelic: String
        :param pulumi.Input[Mapping[str, Any]] office365: String
        :param pulumi.Input[Mapping[str, Any]] rms: String
        :param pulumi.Input[Mapping[str, Any]] salesforce: String
        :param pulumi.Input[Mapping[str, Any]] salesforce_api: String
        :param pulumi.Input[Mapping[str, Any]] salesforce_sandbox_api: String
        :param pulumi.Input['ClientAddonsSamlpArgs'] samlp: List(Resource). Configuration settings for a SAML add-on. For details, see SAML.
        :param pulumi.Input[Mapping[str, Any]] sap_api: String
        :param pulumi.Input[Mapping[str, Any]] sentry: String
        :param pulumi.Input[Mapping[str, Any]] sharepoint: String
        :param pulumi.Input[Mapping[str, Any]] slack: String
        :param pulumi.Input[Mapping[str, Any]] springcm: String
        :param pulumi.Input[Mapping[str, Any]] wams: String
        :param pulumi.Input[Mapping[str, Any]] wsfed: String
        :param pulumi.Input[Mapping[str, Any]] zendesk: String
        :param pulumi.Input[Mapping[str, Any]] zoom: String
        """
        if aws is not None:
            pulumi.set(__self__, "aws", aws)
        if azure_blob is not None:
            pulumi.set(__self__, "azure_blob", azure_blob)
        if azure_sb is not None:
            pulumi.set(__self__, "azure_sb", azure_sb)
        if box is not None:
            pulumi.set(__self__, "box", box)
        if cloudbees is not None:
            pulumi.set(__self__, "cloudbees", cloudbees)
        if concur is not None:
            pulumi.set(__self__, "concur", concur)
        if dropbox is not None:
            pulumi.set(__self__, "dropbox", dropbox)
        if echosign is not None:
            pulumi.set(__self__, "echosign", echosign)
        if egnyte is not None:
            pulumi.set(__self__, "egnyte", egnyte)
        if firebase is not None:
            pulumi.set(__self__, "firebase", firebase)
        if layer is not None:
            pulumi.set(__self__, "layer", layer)
        if mscrm is not None:
            pulumi.set(__self__, "mscrm", mscrm)
        if newrelic is not None:
            pulumi.set(__self__, "newrelic", newrelic)
        if office365 is not None:
            pulumi.set(__self__, "office365", office365)
        if rms is not None:
            pulumi.set(__self__, "rms", rms)
        if salesforce is not None:
            pulumi.set(__self__, "salesforce", salesforce)
        if salesforce_api is not None:
            pulumi.set(__self__, "salesforce_api", salesforce_api)
        if salesforce_sandbox_api is not None:
            pulumi.set(__self__, "salesforce_sandbox_api", salesforce_sandbox_api)
        if samlp is not None:
            pulumi.set(__self__, "samlp", samlp)
        if sap_api is not None:
            pulumi.set(__self__, "sap_api", sap_api)
        if sentry is not None:
            pulumi.set(__self__, "sentry", sentry)
        if sharepoint is not None:
            pulumi.set(__self__, "sharepoint", sharepoint)
        if slack is not None:
            pulumi.set(__self__, "slack", slack)
        if springcm is not None:
            pulumi.set(__self__, "springcm", springcm)
        if wams is not None:
            pulumi.set(__self__, "wams", wams)
        if wsfed is not None:
            pulumi.set(__self__, "wsfed", wsfed)
        if zendesk is not None:
            pulumi.set(__self__, "zendesk", zendesk)
        if zoom is not None:
            pulumi.set(__self__, "zoom", zoom)

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

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

    @property
    @pulumi.getter(name="azureBlob")
    def azure_blob(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        String
        """
        return pulumi.get(self, "azure_blob")

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

    @property
    @pulumi.getter(name="azureSb")
    def azure_sb(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        String
        """
        return pulumi.get(self, "azure_sb")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="salesforceApi")
    def salesforce_api(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        String
        """
        return pulumi.get(self, "salesforce_api")

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

    @property
    @pulumi.getter(name="salesforceSandboxApi")
    def salesforce_sandbox_api(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        String
        """
        return pulumi.get(self, "salesforce_sandbox_api")

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

    @property
    @pulumi.getter
    def samlp(self) -> Optional[pulumi.Input['ClientAddonsSamlpArgs']]:
        """
        List(Resource). Configuration settings for a SAML add-on. For details, see SAML.
        """
        return pulumi.get(self, "samlp")

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

    @property
    @pulumi.getter(name="sapApi")
    def sap_api(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        String
        """
        return pulumi.get(self, "sap_api")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClientAddonsSamlpArgs:
    def __init__(__self__, *,
                 audience: Optional[pulumi.Input[str]] = None,
                 authn_context_class_ref: Optional[pulumi.Input[str]] = None,
                 binding: Optional[pulumi.Input[str]] = None,
                 create_upn_claim: Optional[pulumi.Input[bool]] = None,
                 destination: Optional[pulumi.Input[str]] = None,
                 digest_algorithm: Optional[pulumi.Input[str]] = None,
                 include_attribute_name_format: Optional[pulumi.Input[bool]] = None,
                 lifetime_in_seconds: Optional[pulumi.Input[int]] = None,
                 logout: Optional[pulumi.Input['ClientAddonsSamlpLogoutArgs']] = None,
                 map_identities: Optional[pulumi.Input[bool]] = None,
                 map_unknown_claims_as_is: Optional[pulumi.Input[bool]] = None,
                 mappings: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 name_identifier_format: Optional[pulumi.Input[str]] = None,
                 name_identifier_probes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 passthrough_claims_with_no_mapping: Optional[pulumi.Input[bool]] = None,
                 recipient: Optional[pulumi.Input[str]] = None,
                 sign_response: Optional[pulumi.Input[bool]] = None,
                 signature_algorithm: Optional[pulumi.Input[str]] = None,
                 typed_attributes: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] audience: String. Audience of the SAML Assertion. Default will be the Issuer on SAMLRequest.
        :param pulumi.Input[str] authn_context_class_ref: String. Class reference of the authentication context.
        :param pulumi.Input[str] binding: String. Protocol binding used for SAML logout responses.
        :param pulumi.Input[bool] create_upn_claim: Boolean, (Default=true) Indicates whether or not a UPN claim should be created.
        :param pulumi.Input[str] destination: String. Destination of the SAML Response. If not specified, it will be AssertionConsumerUrlof SAMLRequest or Callback URL if there was no SAMLRequest.
        :param pulumi.Input[str] digest_algorithm: String, (Default=`sha1`). Algorithm used to calculate the digest of the SAML Assertion or response. Options include `defaultsha1` and `sha256`.
        :param pulumi.Input[bool] include_attribute_name_format: Boolean,(Default=true). Indicates whether or not we should infer the NameFormat based on the attribute name. If set to false, the attribute NameFormat is not set in the assertion.
        :param pulumi.Input[int] lifetime_in_seconds: Integer, (Default=3600). Number of seconds during which the token is valid.
        :param pulumi.Input['ClientAddonsSamlpLogoutArgs'] logout: Map(Resource). Configuration settings for logout. For details, see Logout.
        :param pulumi.Input[bool] map_identities: Boolean, (Default=true). Indicates whether or not to add additional identity information in the token, such as the provider used and the access_token, if available.
        :param pulumi.Input[bool] map_unknown_claims_as_is: Boolean, (Default=false). Indicates whether or not to add a prefix of `http://schema.auth0.com` to any claims that are not mapped to the common profile when passed through in the output assertion.
        :param pulumi.Input[Mapping[str, Any]] mappings: Map(String). Mappings between the Auth0 user profile property name (`name`) and the output attributes on the SAML attribute in the assertion (`value`).
        :param pulumi.Input[str] name_identifier_format: String, (Default=`urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`). Format of the name identifier.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] name_identifier_probes: List(String). Attributes that can be used for Subject/NameID. Auth0 will try each of the attributes of this array in order and use the first value it finds.
        :param pulumi.Input[bool] passthrough_claims_with_no_mapping: Boolean, (Default=true). Indicates whether or not to passthrough claims that are not mapped to the common profile in the output assertion.
        :param pulumi.Input[str] recipient: String. Recipient of the SAML Assertion (SubjectConfirmationData). Default is AssertionConsumerUrl on SAMLRequest or Callback URL if no SAMLRequest was sent.
        :param pulumi.Input[bool] sign_response: Boolean. Indicates whether or not the SAML Response should be signed instead of the SAML Assertion.
        :param pulumi.Input[str] signature_algorithm: String, (Default=`rsa-sha1`). Algorithm used to sign the SAML Assertion or response. Options include `rsa-sha1` and `rsa-sha256`.
        :param pulumi.Input[bool] typed_attributes: Boolean, (Default=true). Indicates whether or not we should infer the `xs:type` of the element. Types include `xs:string`, `xs:boolean`, `xs:double`, and `xs:anyType`. When set to false, all `xs:type` are `xs:anyType`.
        """
        if audience is not None:
            pulumi.set(__self__, "audience", audience)
        if authn_context_class_ref is not None:
            pulumi.set(__self__, "authn_context_class_ref", authn_context_class_ref)
        if binding is not None:
            pulumi.set(__self__, "binding", binding)
        if create_upn_claim is not None:
            pulumi.set(__self__, "create_upn_claim", create_upn_claim)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if digest_algorithm is not None:
            pulumi.set(__self__, "digest_algorithm", digest_algorithm)
        if include_attribute_name_format is not None:
            pulumi.set(__self__, "include_attribute_name_format", include_attribute_name_format)
        if lifetime_in_seconds is not None:
            pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        if logout is not None:
            pulumi.set(__self__, "logout", logout)
        if map_identities is not None:
            pulumi.set(__self__, "map_identities", map_identities)
        if map_unknown_claims_as_is is not None:
            pulumi.set(__self__, "map_unknown_claims_as_is", map_unknown_claims_as_is)
        if mappings is not None:
            pulumi.set(__self__, "mappings", mappings)
        if name_identifier_format is not None:
            pulumi.set(__self__, "name_identifier_format", name_identifier_format)
        if name_identifier_probes is not None:
            pulumi.set(__self__, "name_identifier_probes", name_identifier_probes)
        if passthrough_claims_with_no_mapping is not None:
            pulumi.set(__self__, "passthrough_claims_with_no_mapping", passthrough_claims_with_no_mapping)
        if recipient is not None:
            pulumi.set(__self__, "recipient", recipient)
        if sign_response is not None:
            pulumi.set(__self__, "sign_response", sign_response)
        if signature_algorithm is not None:
            pulumi.set(__self__, "signature_algorithm", signature_algorithm)
        if typed_attributes is not None:
            pulumi.set(__self__, "typed_attributes", typed_attributes)

    @property
    @pulumi.getter
    def audience(self) -> Optional[pulumi.Input[str]]:
        """
        String. Audience of the SAML Assertion. Default will be the Issuer on SAMLRequest.
        """
        return pulumi.get(self, "audience")

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

    @property
    @pulumi.getter(name="authnContextClassRef")
    def authn_context_class_ref(self) -> Optional[pulumi.Input[str]]:
        """
        String. Class reference of the authentication context.
        """
        return pulumi.get(self, "authn_context_class_ref")

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

    @property
    @pulumi.getter
    def binding(self) -> Optional[pulumi.Input[str]]:
        """
        String. Protocol binding used for SAML logout responses.
        """
        return pulumi.get(self, "binding")

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

    @property
    @pulumi.getter(name="createUpnClaim")
    def create_upn_claim(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean, (Default=true) Indicates whether or not a UPN claim should be created.
        """
        return pulumi.get(self, "create_upn_claim")

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

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input[str]]:
        """
        String. Destination of the SAML Response. If not specified, it will be AssertionConsumerUrlof SAMLRequest or Callback URL if there was no SAMLRequest.
        """
        return pulumi.get(self, "destination")

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

    @property
    @pulumi.getter(name="digestAlgorithm")
    def digest_algorithm(self) -> Optional[pulumi.Input[str]]:
        """
        String, (Default=`sha1`). Algorithm used to calculate the digest of the SAML Assertion or response. Options include `defaultsha1` and `sha256`.
        """
        return pulumi.get(self, "digest_algorithm")

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

    @property
    @pulumi.getter(name="includeAttributeNameFormat")
    def include_attribute_name_format(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean,(Default=true). Indicates whether or not we should infer the NameFormat based on the attribute name. If set to false, the attribute NameFormat is not set in the assertion.
        """
        return pulumi.get(self, "include_attribute_name_format")

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

    @property
    @pulumi.getter(name="lifetimeInSeconds")
    def lifetime_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Integer, (Default=3600). Number of seconds during which the token is valid.
        """
        return pulumi.get(self, "lifetime_in_seconds")

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

    @property
    @pulumi.getter
    def logout(self) -> Optional[pulumi.Input['ClientAddonsSamlpLogoutArgs']]:
        """
        Map(Resource). Configuration settings for logout. For details, see Logout.
        """
        return pulumi.get(self, "logout")

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

    @property
    @pulumi.getter(name="mapIdentities")
    def map_identities(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean, (Default=true). Indicates whether or not to add additional identity information in the token, such as the provider used and the access_token, if available.
        """
        return pulumi.get(self, "map_identities")

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

    @property
    @pulumi.getter(name="mapUnknownClaimsAsIs")
    def map_unknown_claims_as_is(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean, (Default=false). Indicates whether or not to add a prefix of `http://schema.auth0.com` to any claims that are not mapped to the common profile when passed through in the output assertion.
        """
        return pulumi.get(self, "map_unknown_claims_as_is")

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

    @property
    @pulumi.getter
    def mappings(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Map(String). Mappings between the Auth0 user profile property name (`name`) and the output attributes on the SAML attribute in the assertion (`value`).
        """
        return pulumi.get(self, "mappings")

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

    @property
    @pulumi.getter(name="nameIdentifierFormat")
    def name_identifier_format(self) -> Optional[pulumi.Input[str]]:
        """
        String, (Default=`urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`). Format of the name identifier.
        """
        return pulumi.get(self, "name_identifier_format")

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

    @property
    @pulumi.getter(name="nameIdentifierProbes")
    def name_identifier_probes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List(String). Attributes that can be used for Subject/NameID. Auth0 will try each of the attributes of this array in order and use the first value it finds.
        """
        return pulumi.get(self, "name_identifier_probes")

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

    @property
    @pulumi.getter(name="passthroughClaimsWithNoMapping")
    def passthrough_claims_with_no_mapping(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean, (Default=true). Indicates whether or not to passthrough claims that are not mapped to the common profile in the output assertion.
        """
        return pulumi.get(self, "passthrough_claims_with_no_mapping")

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

    @property
    @pulumi.getter
    def recipient(self) -> Optional[pulumi.Input[str]]:
        """
        String. Recipient of the SAML Assertion (SubjectConfirmationData). Default is AssertionConsumerUrl on SAMLRequest or Callback URL if no SAMLRequest was sent.
        """
        return pulumi.get(self, "recipient")

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

    @property
    @pulumi.getter(name="signResponse")
    def sign_response(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not the SAML Response should be signed instead of the SAML Assertion.
        """
        return pulumi.get(self, "sign_response")

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

    @property
    @pulumi.getter(name="signatureAlgorithm")
    def signature_algorithm(self) -> Optional[pulumi.Input[str]]:
        """
        String, (Default=`rsa-sha1`). Algorithm used to sign the SAML Assertion or response. Options include `rsa-sha1` and `rsa-sha256`.
        """
        return pulumi.get(self, "signature_algorithm")

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

    @property
    @pulumi.getter(name="typedAttributes")
    def typed_attributes(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean, (Default=true). Indicates whether or not we should infer the `xs:type` of the element. Types include `xs:string`, `xs:boolean`, `xs:double`, and `xs:anyType`. When set to false, all `xs:type` are `xs:anyType`.
        """
        return pulumi.get(self, "typed_attributes")

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


@pulumi.input_type
class ClientAddonsSamlpLogoutArgs:
    def __init__(__self__, *,
                 callback: Optional[pulumi.Input[str]] = None,
                 slo_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] callback: String. Service provider's Single Logout Service URL, to which Auth0 will send logout requests and responses.
        :param pulumi.Input[bool] slo_enabled: Boolean. Indicates whether or not Auth0 should notify service providers of session termination.
        """
        if callback is not None:
            pulumi.set(__self__, "callback", callback)
        if slo_enabled is not None:
            pulumi.set(__self__, "slo_enabled", slo_enabled)

    @property
    @pulumi.getter
    def callback(self) -> Optional[pulumi.Input[str]]:
        """
        String. Service provider's Single Logout Service URL, to which Auth0 will send logout requests and responses.
        """
        return pulumi.get(self, "callback")

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

    @property
    @pulumi.getter(name="sloEnabled")
    def slo_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not Auth0 should notify service providers of session termination.
        """
        return pulumi.get(self, "slo_enabled")

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


@pulumi.input_type
class ClientJwtConfigurationArgs:
    def __init__(__self__, *,
                 alg: Optional[pulumi.Input[str]] = None,
                 lifetime_in_seconds: Optional[pulumi.Input[int]] = None,
                 scopes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 secret_encoded: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] alg: String. Algorithm used to sign JWTs.
        :param pulumi.Input[int] lifetime_in_seconds: Integer. Number of seconds during which the JWT will be valid.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] scopes: Map(String). Permissions (scopes) included in JWTs.
        :param pulumi.Input[bool] secret_encoded: Boolean. Indicates whether or not the client secret is base64 encoded.
        """
        if alg is not None:
            pulumi.set(__self__, "alg", alg)
        if lifetime_in_seconds is not None:
            pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        if scopes is not None:
            pulumi.set(__self__, "scopes", scopes)
        if secret_encoded is not None:
            pulumi.set(__self__, "secret_encoded", secret_encoded)

    @property
    @pulumi.getter
    def alg(self) -> Optional[pulumi.Input[str]]:
        """
        String. Algorithm used to sign JWTs.
        """
        return pulumi.get(self, "alg")

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

    @property
    @pulumi.getter(name="lifetimeInSeconds")
    def lifetime_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Integer. Number of seconds during which the JWT will be valid.
        """
        return pulumi.get(self, "lifetime_in_seconds")

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

    @property
    @pulumi.getter
    def scopes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Map(String). Permissions (scopes) included in JWTs.
        """
        return pulumi.get(self, "scopes")

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

    @property
    @pulumi.getter(name="secretEncoded")
    def secret_encoded(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not the client secret is base64 encoded.
        """
        return pulumi.get(self, "secret_encoded")

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


@pulumi.input_type
class ClientMobileArgs:
    def __init__(__self__, *,
                 android: Optional[pulumi.Input['ClientMobileAndroidArgs']] = None,
                 ios: Optional[pulumi.Input['ClientMobileIosArgs']] = None):
        """
        :param pulumi.Input['ClientMobileAndroidArgs'] android: List(Resource). Configuration settings for Android native apps. For details, see Android.
        :param pulumi.Input['ClientMobileIosArgs'] ios: List(Resource). Configuration settings for i0S native apps. For details, see iOS.
        """
        if android is not None:
            pulumi.set(__self__, "android", android)
        if ios is not None:
            pulumi.set(__self__, "ios", ios)

    @property
    @pulumi.getter
    def android(self) -> Optional[pulumi.Input['ClientMobileAndroidArgs']]:
        """
        List(Resource). Configuration settings for Android native apps. For details, see Android.
        """
        return pulumi.get(self, "android")

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

    @property
    @pulumi.getter
    def ios(self) -> Optional[pulumi.Input['ClientMobileIosArgs']]:
        """
        List(Resource). Configuration settings for i0S native apps. For details, see iOS.
        """
        return pulumi.get(self, "ios")

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


@pulumi.input_type
class ClientMobileAndroidArgs:
    def __init__(__self__, *,
                 app_package_name: Optional[pulumi.Input[str]] = None,
                 sha256_cert_fingerprints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] app_package_name: String
        :param pulumi.Input[Sequence[pulumi.Input[str]]] sha256_cert_fingerprints: List(String)
        """
        if app_package_name is not None:
            pulumi.set(__self__, "app_package_name", app_package_name)
        if sha256_cert_fingerprints is not None:
            pulumi.set(__self__, "sha256_cert_fingerprints", sha256_cert_fingerprints)

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

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

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

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


@pulumi.input_type
class ClientMobileIosArgs:
    def __init__(__self__, *,
                 app_bundle_identifier: Optional[pulumi.Input[str]] = None,
                 team_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] app_bundle_identifier: String
        :param pulumi.Input[str] team_id: String
        """
        if app_bundle_identifier is not None:
            pulumi.set(__self__, "app_bundle_identifier", app_bundle_identifier)
        if team_id is not None:
            pulumi.set(__self__, "team_id", team_id)

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

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

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

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


@pulumi.input_type
class ClientRefreshTokenArgs:
    def __init__(__self__, *,
                 expiration_type: pulumi.Input[str],
                 rotation_type: pulumi.Input[str],
                 idle_token_lifetime: Optional[pulumi.Input[int]] = None,
                 infinite_idle_token_lifetime: Optional[pulumi.Input[bool]] = None,
                 infinite_token_lifetime: Optional[pulumi.Input[bool]] = None,
                 leeway: Optional[pulumi.Input[int]] = None,
                 token_lifetime: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] expiration_type: String. Options include `expiring`, `non-expiring`. Whether a refresh token will expire based on an absolute lifetime, after which the token can no longer be used. If rotation is `rotating`, this must be set to `expiring`.
        :param pulumi.Input[str] rotation_type: String. Options include `rotating`, `non-rotating`. When `rotating`, exchanging a refresh token will cause a new refresh token to be issued and the existing token will be invalidated. This allows for automatic detection of token reuse if the token is leaked.
        :param pulumi.Input[int] idle_token_lifetime: Integer. The time in seconds after which inactive refresh tokens will expire.
        :param pulumi.Input[bool] infinite_idle_token_lifetime: Boolean, (Default=false) Whether or not inactive refresh tokens should be remain valid indefinitely.
        :param pulumi.Input[bool] infinite_token_lifetime: Boolean, (Default=false) Whether or not refresh tokens should remain valid indefinitely. If false, `token_lifetime` should also be set
        :param pulumi.Input[int] leeway: Integer. The amount of time in seconds in which a refresh token may be reused without trigging reuse detection.
        :param pulumi.Input[int] token_lifetime: Integer. The absolute lifetime of a refresh token in seconds.
        """
        pulumi.set(__self__, "expiration_type", expiration_type)
        pulumi.set(__self__, "rotation_type", rotation_type)
        if idle_token_lifetime is not None:
            pulumi.set(__self__, "idle_token_lifetime", idle_token_lifetime)
        if infinite_idle_token_lifetime is not None:
            pulumi.set(__self__, "infinite_idle_token_lifetime", infinite_idle_token_lifetime)
        if infinite_token_lifetime is not None:
            pulumi.set(__self__, "infinite_token_lifetime", infinite_token_lifetime)
        if leeway is not None:
            pulumi.set(__self__, "leeway", leeway)
        if token_lifetime is not None:
            pulumi.set(__self__, "token_lifetime", token_lifetime)

    @property
    @pulumi.getter(name="expirationType")
    def expiration_type(self) -> pulumi.Input[str]:
        """
        String. Options include `expiring`, `non-expiring`. Whether a refresh token will expire based on an absolute lifetime, after which the token can no longer be used. If rotation is `rotating`, this must be set to `expiring`.
        """
        return pulumi.get(self, "expiration_type")

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

    @property
    @pulumi.getter(name="rotationType")
    def rotation_type(self) -> pulumi.Input[str]:
        """
        String. Options include `rotating`, `non-rotating`. When `rotating`, exchanging a refresh token will cause a new refresh token to be issued and the existing token will be invalidated. This allows for automatic detection of token reuse if the token is leaked.
        """
        return pulumi.get(self, "rotation_type")

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

    @property
    @pulumi.getter(name="idleTokenLifetime")
    def idle_token_lifetime(self) -> Optional[pulumi.Input[int]]:
        """
        Integer. The time in seconds after which inactive refresh tokens will expire.
        """
        return pulumi.get(self, "idle_token_lifetime")

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

    @property
    @pulumi.getter(name="infiniteIdleTokenLifetime")
    def infinite_idle_token_lifetime(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean, (Default=false) Whether or not inactive refresh tokens should be remain valid indefinitely.
        """
        return pulumi.get(self, "infinite_idle_token_lifetime")

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

    @property
    @pulumi.getter(name="infiniteTokenLifetime")
    def infinite_token_lifetime(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean, (Default=false) Whether or not refresh tokens should remain valid indefinitely. If false, `token_lifetime` should also be set
        """
        return pulumi.get(self, "infinite_token_lifetime")

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

    @property
    @pulumi.getter
    def leeway(self) -> Optional[pulumi.Input[int]]:
        """
        Integer. The amount of time in seconds in which a refresh token may be reused without trigging reuse detection.
        """
        return pulumi.get(self, "leeway")

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

    @property
    @pulumi.getter(name="tokenLifetime")
    def token_lifetime(self) -> Optional[pulumi.Input[int]]:
        """
        Integer. The absolute lifetime of a refresh token in seconds.
        """
        return pulumi.get(self, "token_lifetime")

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


@pulumi.input_type
class ConnectionOptionsArgs:
    def __init__(__self__, *,
                 adfs_server: Optional[pulumi.Input[str]] = None,
                 allowed_audiences: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 api_enable_users: Optional[pulumi.Input[bool]] = None,
                 app_domain: Optional[pulumi.Input[str]] = None,
                 app_id: Optional[pulumi.Input[str]] = None,
                 authorization_endpoint: Optional[pulumi.Input[str]] = None,
                 brute_force_protection: Optional[pulumi.Input[bool]] = None,
                 client_id: Optional[pulumi.Input[str]] = None,
                 client_secret: Optional[pulumi.Input[str]] = None,
                 community_base_url: Optional[pulumi.Input[str]] = None,
                 configuration: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 custom_scripts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 debug: Optional[pulumi.Input[bool]] = None,
                 digest_algorithm: Optional[pulumi.Input[str]] = None,
                 disable_cache: Optional[pulumi.Input[bool]] = None,
                 disable_signup: Optional[pulumi.Input[bool]] = None,
                 discovery_url: Optional[pulumi.Input[str]] = None,
                 domain: Optional[pulumi.Input[str]] = None,
                 domain_aliases: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 enabled_database_customization: Optional[pulumi.Input[bool]] = None,
                 fields_map: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 from_: Optional[pulumi.Input[str]] = None,
                 icon_url: Optional[pulumi.Input[str]] = None,
                 identity_api: Optional[pulumi.Input[str]] = None,
                 idp_initiated: Optional[pulumi.Input['ConnectionOptionsIdpInitiatedArgs']] = None,
                 import_mode: Optional[pulumi.Input[bool]] = None,
                 ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 issuer: Optional[pulumi.Input[str]] = None,
                 jwks_uri: Optional[pulumi.Input[str]] = None,
                 key_id: Optional[pulumi.Input[str]] = None,
                 max_groups_to_retrieve: Optional[pulumi.Input[str]] = None,
                 messaging_service_sid: Optional[pulumi.Input[str]] = None,
                 mfa: Optional[pulumi.Input['ConnectionOptionsMfaArgs']] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 non_persistent_attrs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 password_complexity_options: Optional[pulumi.Input['ConnectionOptionsPasswordComplexityOptionsArgs']] = None,
                 password_dictionary: Optional[pulumi.Input['ConnectionOptionsPasswordDictionaryArgs']] = None,
                 password_histories: Optional[pulumi.Input[Sequence[pulumi.Input['ConnectionOptionsPasswordHistoryArgs']]]] = None,
                 password_no_personal_info: Optional[pulumi.Input['ConnectionOptionsPasswordNoPersonalInfoArgs']] = None,
                 password_policy: Optional[pulumi.Input[str]] = None,
                 protocol_binding: Optional[pulumi.Input[str]] = None,
                 request_template: Optional[pulumi.Input[str]] = None,
                 requires_username: Optional[pulumi.Input[bool]] = None,
                 scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 scripts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 set_user_root_attributes: Optional[pulumi.Input[str]] = None,
                 should_trust_email_verified_connection: Optional[pulumi.Input[str]] = None,
                 sign_in_endpoint: Optional[pulumi.Input[str]] = None,
                 sign_out_endpoint: Optional[pulumi.Input[str]] = None,
                 sign_saml_request: Optional[pulumi.Input[bool]] = None,
                 signature_algorithm: Optional[pulumi.Input[str]] = None,
                 signing_cert: Optional[pulumi.Input[str]] = None,
                 strategy_version: Optional[pulumi.Input[int]] = None,
                 subject: Optional[pulumi.Input[str]] = None,
                 syntax: Optional[pulumi.Input[str]] = None,
                 team_id: Optional[pulumi.Input[str]] = None,
                 template: Optional[pulumi.Input[str]] = None,
                 tenant_domain: Optional[pulumi.Input[str]] = None,
                 token_endpoint: Optional[pulumi.Input[str]] = None,
                 totp: Optional[pulumi.Input['ConnectionOptionsTotpArgs']] = None,
                 twilio_sid: Optional[pulumi.Input[str]] = None,
                 twilio_token: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 use_cert_auth: Optional[pulumi.Input[bool]] = None,
                 use_kerberos: Optional[pulumi.Input[bool]] = None,
                 use_wsfed: Optional[pulumi.Input[bool]] = None,
                 user_id_attribute: Optional[pulumi.Input[str]] = None,
                 userinfo_endpoint: Optional[pulumi.Input[str]] = None,
                 validation: Optional[pulumi.Input['ConnectionOptionsValidationArgs']] = None,
                 waad_common_endpoint: Optional[pulumi.Input[bool]] = None,
                 waad_protocol: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] adfs_server: ADFS Metadata source.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_audiences: List of allowed audiences.
        :param pulumi.Input[str] app_domain: Azure AD domain name.
        :param pulumi.Input[str] app_id: Azure AD app ID.
        :param pulumi.Input[bool] brute_force_protection: Indicates whether or not to enable brute force protection, which will limit the number of signups and failed logins from a suspicious IP address.
        :param pulumi.Input[str] client_id: OIDC provider client ID.
        :param pulumi.Input[str] client_secret: OIDC provider client secret.
        :param pulumi.Input[str] community_base_url: String.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] configuration: A case-sensitive map of key value pairs used as configuration variables for the `custom_script`.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_scripts: Custom database action scripts. For more information, read [Custom Database Action Script Templates](https://auth0.com/docs/connections/database/custom-db/templates).
        :param pulumi.Input[bool] debug: (Boolean) When enabled additional debugging information will be generated.
        :param pulumi.Input[str] digest_algorithm: Sign Request Algorithm Digest
        :param pulumi.Input[bool] disable_signup: Boolean. Indicates whether or not to allow user sign-ups to your application.
        :param pulumi.Input[str] discovery_url: OpenID discovery URL. E.g. `https://auth.example.com/.well-known/openid-configuration`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] domain_aliases: List of the domains that can be authenticated using the Identity Provider. Only needed for Identifier First authentication flows.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] fields_map: SAML Attributes mapping. If you're configuring a SAML enterprise connection for a non-standard PingFederate Server, you must update the attribute mappings.
        :param pulumi.Input[str] from_: SMS number for the sender. Used when SMS Source is From.
        :param pulumi.Input[bool] import_mode: Indicates whether or not you have a legacy user store and want to gradually migrate those users to the Auth0 user store. [Learn more](https://auth0.com/docs/users/guides/configure-automatic-migration).
        :param pulumi.Input[str] issuer: Issuer URL. E.g. `https://auth.example.com`
        :param pulumi.Input[str] key_id: Key ID.
        :param pulumi.Input[str] max_groups_to_retrieve: Maximum number of groups to retrieve.
        :param pulumi.Input[str] messaging_service_sid: SID for Copilot. Used when SMS Source is Copilot.
        :param pulumi.Input['ConnectionOptionsMfaArgs'] mfa: Configuration settings Options for multifactor authentication. For details, see MFA Options.
        :param pulumi.Input[str] name: Name of the connection.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] non_persistent_attrs: If there are user fields that should not be stored in Auth0 databases due to privacy reasons, you can add them to the denylist. See [here](https://auth0.com/docs/security/denylist-user-attributes) for more info.
        :param pulumi.Input['ConnectionOptionsPasswordComplexityOptionsArgs'] password_complexity_options: Configuration settings for password complexity. For details, see Password Complexity Options.
        :param pulumi.Input['ConnectionOptionsPasswordDictionaryArgs'] password_dictionary: Configuration settings for the password dictionary check, which does not allow passwords that are part of the password dictionary. For details, see Password Dictionary.
        :param pulumi.Input[Sequence[pulumi.Input['ConnectionOptionsPasswordHistoryArgs']]] password_histories: Configuration settings for the password history that is maintained for each user to prevent the reuse of passwords. For details, see Password History.
        :param pulumi.Input['ConnectionOptionsPasswordNoPersonalInfoArgs'] password_no_personal_info: Configuration settings for the password personal info check, which does not allow passwords that contain any part of the user's personal data, including user's name, username, nickname, user_metadata.name, user_metadata.first, user_metadata.last, user's email, or first part of the user's email. For details, see Password No Personal Info.
        :param pulumi.Input[str] password_policy: Indicates level of password strength to enforce during authentication. A strong password policy will make it difficult, if not improbable, for someone to guess a password through either manual or automated means. Options include `none`, `low`, `fair`, `good`, `excellent`.
        :param pulumi.Input[str] protocol_binding: The SAML Response Binding - how the SAML token is received by Auth0 from IdP. Two possible values are `urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect` (default) and `urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST`
        :param pulumi.Input[str] request_template: Template that formats the SAML request
        :param pulumi.Input[bool] requires_username: Indicates whether or not the user is required to provide a username in addition to an email address.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] scopes: Scopes required by the connection. The value must be a list, for example `["openid", "profile", "email"]`.
        :param pulumi.Input[str] set_user_root_attributes: Determines whether the 'name', 'given_name', 'family_name', 'nickname', and 'picture' attributes can be independently updated when using the external IdP. Default is `on_each_login` and can be set to `on_first_login`.
        :param pulumi.Input[str] should_trust_email_verified_connection: Determines how Auth0 sets the email_verified field in the user profile. Can either be set to `never_set_emails_as_verified` or `always_set_emails_as_verified`.
        :param pulumi.Input[str] sign_in_endpoint: SAML single login URL for the connection.
        :param pulumi.Input[str] sign_out_endpoint: SAML single logout URL for the connection.
        :param pulumi.Input[bool] sign_saml_request: (Boolean) When enabled, the SAML authentication request will be signed.
        :param pulumi.Input[str] signature_algorithm: Sign Request Algorithm
        :param pulumi.Input[str] signing_cert: The X.509 signing certificate (encoded in PEM or CER) you retrieved from the IdP, Base64-encoded
        :param pulumi.Input[int] strategy_version: Version 1 is deprecated, use version 2.
        :param pulumi.Input[str] syntax: Syntax of the SMS. Options include `markdown` and `liquid`.
        :param pulumi.Input[str] team_id: Team ID.
        :param pulumi.Input[str] template: Template for the SMS. You can use `@@password@@` as a placeholder for the password value.
        :param pulumi.Input['ConnectionOptionsTotpArgs'] totp: Configuration options for one-time passwords. For details, see TOTP.
        :param pulumi.Input[str] twilio_sid: SID for your Twilio account.
        :param pulumi.Input[str] twilio_token: AuthToken for your Twilio account.
        :param pulumi.Input[str] type: Value can be `back_channel` or `front_channel`.
        :param pulumi.Input[str] user_id_attribute: Attribute in the SAML token that will be mapped to the user_id property in Auth0.
        :param pulumi.Input['ConnectionOptionsValidationArgs'] validation: Validation of the minimum and maximum values allowed for a user to have as username. For details, see Validation.
        :param pulumi.Input[bool] waad_common_endpoint: Indicates whether or not to use the common endpoint rather than the default endpoint. Typically enabled if you're using this for a multi-tenant application in Azure AD.
        """
        if adfs_server is not None:
            pulumi.set(__self__, "adfs_server", adfs_server)
        if allowed_audiences is not None:
            pulumi.set(__self__, "allowed_audiences", allowed_audiences)
        if api_enable_users is not None:
            pulumi.set(__self__, "api_enable_users", api_enable_users)
        if app_domain is not None:
            warnings.warn("""use domain instead""", DeprecationWarning)
            pulumi.log.warn("""app_domain is deprecated: use domain instead""")
        if app_domain is not None:
            pulumi.set(__self__, "app_domain", app_domain)
        if app_id is not None:
            pulumi.set(__self__, "app_id", app_id)
        if authorization_endpoint is not None:
            pulumi.set(__self__, "authorization_endpoint", authorization_endpoint)
        if brute_force_protection is not None:
            pulumi.set(__self__, "brute_force_protection", brute_force_protection)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if community_base_url is not None:
            pulumi.set(__self__, "community_base_url", community_base_url)
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if custom_scripts is not None:
            pulumi.set(__self__, "custom_scripts", custom_scripts)
        if debug is not None:
            pulumi.set(__self__, "debug", debug)
        if digest_algorithm is not None:
            pulumi.set(__self__, "digest_algorithm", digest_algorithm)
        if disable_cache is not None:
            pulumi.set(__self__, "disable_cache", disable_cache)
        if disable_signup is not None:
            pulumi.set(__self__, "disable_signup", disable_signup)
        if discovery_url is not None:
            pulumi.set(__self__, "discovery_url", discovery_url)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if domain_aliases is not None:
            pulumi.set(__self__, "domain_aliases", domain_aliases)
        if enabled_database_customization is not None:
            pulumi.set(__self__, "enabled_database_customization", enabled_database_customization)
        if fields_map is not None:
            pulumi.set(__self__, "fields_map", fields_map)
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if icon_url is not None:
            pulumi.set(__self__, "icon_url", icon_url)
        if identity_api is not None:
            pulumi.set(__self__, "identity_api", identity_api)
        if idp_initiated is not None:
            pulumi.set(__self__, "idp_initiated", idp_initiated)
        if import_mode is not None:
            pulumi.set(__self__, "import_mode", import_mode)
        if ips is not None:
            pulumi.set(__self__, "ips", ips)
        if issuer is not None:
            pulumi.set(__self__, "issuer", issuer)
        if jwks_uri is not None:
            pulumi.set(__self__, "jwks_uri", jwks_uri)
        if key_id is not None:
            pulumi.set(__self__, "key_id", key_id)
        if max_groups_to_retrieve is not None:
            pulumi.set(__self__, "max_groups_to_retrieve", max_groups_to_retrieve)
        if messaging_service_sid is not None:
            pulumi.set(__self__, "messaging_service_sid", messaging_service_sid)
        if mfa is not None:
            pulumi.set(__self__, "mfa", mfa)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if non_persistent_attrs is not None:
            pulumi.set(__self__, "non_persistent_attrs", non_persistent_attrs)
        if password_complexity_options is not None:
            pulumi.set(__self__, "password_complexity_options", password_complexity_options)
        if password_dictionary is not None:
            pulumi.set(__self__, "password_dictionary", password_dictionary)
        if password_histories is not None:
            pulumi.set(__self__, "password_histories", password_histories)
        if password_no_personal_info is not None:
            pulumi.set(__self__, "password_no_personal_info", password_no_personal_info)
        if password_policy is not None:
            pulumi.set(__self__, "password_policy", password_policy)
        if protocol_binding is not None:
            pulumi.set(__self__, "protocol_binding", protocol_binding)
        if request_template is not None:
            pulumi.set(__self__, "request_template", request_template)
        if requires_username is not None:
            pulumi.set(__self__, "requires_username", requires_username)
        if scopes is not None:
            pulumi.set(__self__, "scopes", scopes)
        if scripts is not None:
            pulumi.set(__self__, "scripts", scripts)
        if set_user_root_attributes is not None:
            pulumi.set(__self__, "set_user_root_attributes", set_user_root_attributes)
        if should_trust_email_verified_connection is not None:
            pulumi.set(__self__, "should_trust_email_verified_connection", should_trust_email_verified_connection)
        if sign_in_endpoint is not None:
            pulumi.set(__self__, "sign_in_endpoint", sign_in_endpoint)
        if sign_out_endpoint is not None:
            pulumi.set(__self__, "sign_out_endpoint", sign_out_endpoint)
        if sign_saml_request is not None:
            pulumi.set(__self__, "sign_saml_request", sign_saml_request)
        if signature_algorithm is not None:
            pulumi.set(__self__, "signature_algorithm", signature_algorithm)
        if signing_cert is not None:
            pulumi.set(__self__, "signing_cert", signing_cert)
        if strategy_version is not None:
            pulumi.set(__self__, "strategy_version", strategy_version)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)
        if syntax is not None:
            pulumi.set(__self__, "syntax", syntax)
        if team_id is not None:
            pulumi.set(__self__, "team_id", team_id)
        if template is not None:
            pulumi.set(__self__, "template", template)
        if tenant_domain is not None:
            pulumi.set(__self__, "tenant_domain", tenant_domain)
        if token_endpoint is not None:
            pulumi.set(__self__, "token_endpoint", token_endpoint)
        if totp is not None:
            pulumi.set(__self__, "totp", totp)
        if twilio_sid is not None:
            pulumi.set(__self__, "twilio_sid", twilio_sid)
        if twilio_token is not None:
            pulumi.set(__self__, "twilio_token", twilio_token)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if use_cert_auth is not None:
            pulumi.set(__self__, "use_cert_auth", use_cert_auth)
        if use_kerberos is not None:
            pulumi.set(__self__, "use_kerberos", use_kerberos)
        if use_wsfed is not None:
            pulumi.set(__self__, "use_wsfed", use_wsfed)
        if user_id_attribute is not None:
            pulumi.set(__self__, "user_id_attribute", user_id_attribute)
        if userinfo_endpoint is not None:
            pulumi.set(__self__, "userinfo_endpoint", userinfo_endpoint)
        if validation is not None:
            pulumi.set(__self__, "validation", validation)
        if waad_common_endpoint is not None:
            pulumi.set(__self__, "waad_common_endpoint", waad_common_endpoint)
        if waad_protocol is not None:
            pulumi.set(__self__, "waad_protocol", waad_protocol)

    @property
    @pulumi.getter(name="adfsServer")
    def adfs_server(self) -> Optional[pulumi.Input[str]]:
        """
        ADFS Metadata source.
        """
        return pulumi.get(self, "adfs_server")

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

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

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

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

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

    @property
    @pulumi.getter(name="appDomain")
    def app_domain(self) -> Optional[pulumi.Input[str]]:
        """
        Azure AD domain name.
        """
        return pulumi.get(self, "app_domain")

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

    @property
    @pulumi.getter(name="appId")
    def app_id(self) -> Optional[pulumi.Input[str]]:
        """
        Azure AD app ID.
        """
        return pulumi.get(self, "app_id")

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

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

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

    @property
    @pulumi.getter(name="bruteForceProtection")
    def brute_force_protection(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether or not to enable brute force protection, which will limit the number of signups and failed logins from a suspicious IP address.
        """
        return pulumi.get(self, "brute_force_protection")

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

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[pulumi.Input[str]]:
        """
        OIDC provider client ID.
        """
        return pulumi.get(self, "client_id")

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

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> Optional[pulumi.Input[str]]:
        """
        OIDC provider client secret.
        """
        return pulumi.get(self, "client_secret")

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

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

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

    @property
    @pulumi.getter
    def configuration(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        A case-sensitive map of key value pairs used as configuration variables for the `custom_script`.
        """
        return pulumi.get(self, "configuration")

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

    @property
    @pulumi.getter(name="customScripts")
    def custom_scripts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Custom database action scripts. For more information, read [Custom Database Action Script Templates](https://auth0.com/docs/connections/database/custom-db/templates).
        """
        return pulumi.get(self, "custom_scripts")

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

    @property
    @pulumi.getter
    def debug(self) -> Optional[pulumi.Input[bool]]:
        """
        (Boolean) When enabled additional debugging information will be generated.
        """
        return pulumi.get(self, "debug")

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

    @property
    @pulumi.getter(name="digestAlgorithm")
    def digest_algorithm(self) -> Optional[pulumi.Input[str]]:
        """
        Sign Request Algorithm Digest
        """
        return pulumi.get(self, "digest_algorithm")

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

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

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

    @property
    @pulumi.getter(name="disableSignup")
    def disable_signup(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not to allow user sign-ups to your application.
        """
        return pulumi.get(self, "disable_signup")

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

    @property
    @pulumi.getter(name="discoveryUrl")
    def discovery_url(self) -> Optional[pulumi.Input[str]]:
        """
        OpenID discovery URL. E.g. `https://auth.example.com/.well-known/openid-configuration`.
        """
        return pulumi.get(self, "discovery_url")

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

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

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

    @property
    @pulumi.getter(name="domainAliases")
    def domain_aliases(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of the domains that can be authenticated using the Identity Provider. Only needed for Identifier First authentication flows.
        """
        return pulumi.get(self, "domain_aliases")

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

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

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

    @property
    @pulumi.getter(name="fieldsMap")
    def fields_map(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        SAML Attributes mapping. If you're configuring a SAML enterprise connection for a non-standard PingFederate Server, you must update the attribute mappings.
        """
        return pulumi.get(self, "fields_map")

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

    @property
    @pulumi.getter(name="from")
    def from_(self) -> Optional[pulumi.Input[str]]:
        """
        SMS number for the sender. Used when SMS Source is From.
        """
        return pulumi.get(self, "from_")

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

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

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

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

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

    @property
    @pulumi.getter(name="idpInitiated")
    def idp_initiated(self) -> Optional[pulumi.Input['ConnectionOptionsIdpInitiatedArgs']]:
        return pulumi.get(self, "idp_initiated")

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

    @property
    @pulumi.getter(name="importMode")
    def import_mode(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether or not you have a legacy user store and want to gradually migrate those users to the Auth0 user store. [Learn more](https://auth0.com/docs/users/guides/configure-automatic-migration).
        """
        return pulumi.get(self, "import_mode")

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

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

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

    @property
    @pulumi.getter
    def issuer(self) -> Optional[pulumi.Input[str]]:
        """
        Issuer URL. E.g. `https://auth.example.com`
        """
        return pulumi.get(self, "issuer")

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

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

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

    @property
    @pulumi.getter(name="keyId")
    def key_id(self) -> Optional[pulumi.Input[str]]:
        """
        Key ID.
        """
        return pulumi.get(self, "key_id")

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

    @property
    @pulumi.getter(name="maxGroupsToRetrieve")
    def max_groups_to_retrieve(self) -> Optional[pulumi.Input[str]]:
        """
        Maximum number of groups to retrieve.
        """
        return pulumi.get(self, "max_groups_to_retrieve")

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

    @property
    @pulumi.getter(name="messagingServiceSid")
    def messaging_service_sid(self) -> Optional[pulumi.Input[str]]:
        """
        SID for Copilot. Used when SMS Source is Copilot.
        """
        return pulumi.get(self, "messaging_service_sid")

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

    @property
    @pulumi.getter
    def mfa(self) -> Optional[pulumi.Input['ConnectionOptionsMfaArgs']]:
        """
        Configuration settings Options for multifactor authentication. For details, see MFA Options.
        """
        return pulumi.get(self, "mfa")

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

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

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

    @property
    @pulumi.getter(name="nonPersistentAttrs")
    def non_persistent_attrs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        If there are user fields that should not be stored in Auth0 databases due to privacy reasons, you can add them to the denylist. See [here](https://auth0.com/docs/security/denylist-user-attributes) for more info.
        """
        return pulumi.get(self, "non_persistent_attrs")

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

    @property
    @pulumi.getter(name="passwordComplexityOptions")
    def password_complexity_options(self) -> Optional[pulumi.Input['ConnectionOptionsPasswordComplexityOptionsArgs']]:
        """
        Configuration settings for password complexity. For details, see Password Complexity Options.
        """
        return pulumi.get(self, "password_complexity_options")

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

    @property
    @pulumi.getter(name="passwordDictionary")
    def password_dictionary(self) -> Optional[pulumi.Input['ConnectionOptionsPasswordDictionaryArgs']]:
        """
        Configuration settings for the password dictionary check, which does not allow passwords that are part of the password dictionary. For details, see Password Dictionary.
        """
        return pulumi.get(self, "password_dictionary")

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

    @property
    @pulumi.getter(name="passwordHistories")
    def password_histories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConnectionOptionsPasswordHistoryArgs']]]]:
        """
        Configuration settings for the password history that is maintained for each user to prevent the reuse of passwords. For details, see Password History.
        """
        return pulumi.get(self, "password_histories")

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

    @property
    @pulumi.getter(name="passwordNoPersonalInfo")
    def password_no_personal_info(self) -> Optional[pulumi.Input['ConnectionOptionsPasswordNoPersonalInfoArgs']]:
        """
        Configuration settings for the password personal info check, which does not allow passwords that contain any part of the user's personal data, including user's name, username, nickname, user_metadata.name, user_metadata.first, user_metadata.last, user's email, or first part of the user's email. For details, see Password No Personal Info.
        """
        return pulumi.get(self, "password_no_personal_info")

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

    @property
    @pulumi.getter(name="passwordPolicy")
    def password_policy(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates level of password strength to enforce during authentication. A strong password policy will make it difficult, if not improbable, for someone to guess a password through either manual or automated means. Options include `none`, `low`, `fair`, `good`, `excellent`.
        """
        return pulumi.get(self, "password_policy")

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

    @property
    @pulumi.getter(name="protocolBinding")
    def protocol_binding(self) -> Optional[pulumi.Input[str]]:
        """
        The SAML Response Binding - how the SAML token is received by Auth0 from IdP. Two possible values are `urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect` (default) and `urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST`
        """
        return pulumi.get(self, "protocol_binding")

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

    @property
    @pulumi.getter(name="requestTemplate")
    def request_template(self) -> Optional[pulumi.Input[str]]:
        """
        Template that formats the SAML request
        """
        return pulumi.get(self, "request_template")

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

    @property
    @pulumi.getter(name="requiresUsername")
    def requires_username(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether or not the user is required to provide a username in addition to an email address.
        """
        return pulumi.get(self, "requires_username")

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

    @property
    @pulumi.getter
    def scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Scopes required by the connection. The value must be a list, for example `["openid", "profile", "email"]`.
        """
        return pulumi.get(self, "scopes")

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

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

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

    @property
    @pulumi.getter(name="setUserRootAttributes")
    def set_user_root_attributes(self) -> Optional[pulumi.Input[str]]:
        """
        Determines whether the 'name', 'given_name', 'family_name', 'nickname', and 'picture' attributes can be independently updated when using the external IdP. Default is `on_each_login` and can be set to `on_first_login`.
        """
        return pulumi.get(self, "set_user_root_attributes")

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

    @property
    @pulumi.getter(name="shouldTrustEmailVerifiedConnection")
    def should_trust_email_verified_connection(self) -> Optional[pulumi.Input[str]]:
        """
        Determines how Auth0 sets the email_verified field in the user profile. Can either be set to `never_set_emails_as_verified` or `always_set_emails_as_verified`.
        """
        return pulumi.get(self, "should_trust_email_verified_connection")

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

    @property
    @pulumi.getter(name="signInEndpoint")
    def sign_in_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        SAML single login URL for the connection.
        """
        return pulumi.get(self, "sign_in_endpoint")

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

    @property
    @pulumi.getter(name="signOutEndpoint")
    def sign_out_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        SAML single logout URL for the connection.
        """
        return pulumi.get(self, "sign_out_endpoint")

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

    @property
    @pulumi.getter(name="signSamlRequest")
    def sign_saml_request(self) -> Optional[pulumi.Input[bool]]:
        """
        (Boolean) When enabled, the SAML authentication request will be signed.
        """
        return pulumi.get(self, "sign_saml_request")

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

    @property
    @pulumi.getter(name="signatureAlgorithm")
    def signature_algorithm(self) -> Optional[pulumi.Input[str]]:
        """
        Sign Request Algorithm
        """
        return pulumi.get(self, "signature_algorithm")

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

    @property
    @pulumi.getter(name="signingCert")
    def signing_cert(self) -> Optional[pulumi.Input[str]]:
        """
        The X.509 signing certificate (encoded in PEM or CER) you retrieved from the IdP, Base64-encoded
        """
        return pulumi.get(self, "signing_cert")

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

    @property
    @pulumi.getter(name="strategyVersion")
    def strategy_version(self) -> Optional[pulumi.Input[int]]:
        """
        Version 1 is deprecated, use version 2.
        """
        return pulumi.get(self, "strategy_version")

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

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

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

    @property
    @pulumi.getter
    def syntax(self) -> Optional[pulumi.Input[str]]:
        """
        Syntax of the SMS. Options include `markdown` and `liquid`.
        """
        return pulumi.get(self, "syntax")

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

    @property
    @pulumi.getter(name="teamId")
    def team_id(self) -> Optional[pulumi.Input[str]]:
        """
        Team ID.
        """
        return pulumi.get(self, "team_id")

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

    @property
    @pulumi.getter
    def template(self) -> Optional[pulumi.Input[str]]:
        """
        Template for the SMS. You can use `@@password@@` as a placeholder for the password value.
        """
        return pulumi.get(self, "template")

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

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

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

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

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

    @property
    @pulumi.getter
    def totp(self) -> Optional[pulumi.Input['ConnectionOptionsTotpArgs']]:
        """
        Configuration options for one-time passwords. For details, see TOTP.
        """
        return pulumi.get(self, "totp")

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

    @property
    @pulumi.getter(name="twilioSid")
    def twilio_sid(self) -> Optional[pulumi.Input[str]]:
        """
        SID for your Twilio account.
        """
        return pulumi.get(self, "twilio_sid")

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

    @property
    @pulumi.getter(name="twilioToken")
    def twilio_token(self) -> Optional[pulumi.Input[str]]:
        """
        AuthToken for your Twilio account.
        """
        return pulumi.get(self, "twilio_token")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Value can be `back_channel` or `front_channel`.
        """
        return pulumi.get(self, "type")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="userIdAttribute")
    def user_id_attribute(self) -> Optional[pulumi.Input[str]]:
        """
        Attribute in the SAML token that will be mapped to the user_id property in Auth0.
        """
        return pulumi.get(self, "user_id_attribute")

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

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

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

    @property
    @pulumi.getter
    def validation(self) -> Optional[pulumi.Input['ConnectionOptionsValidationArgs']]:
        """
        Validation of the minimum and maximum values allowed for a user to have as username. For details, see Validation.
        """
        return pulumi.get(self, "validation")

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

    @property
    @pulumi.getter(name="waadCommonEndpoint")
    def waad_common_endpoint(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether or not to use the common endpoint rather than the default endpoint. Typically enabled if you're using this for a multi-tenant application in Azure AD.
        """
        return pulumi.get(self, "waad_common_endpoint")

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

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

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


@pulumi.input_type
class ConnectionOptionsIdpInitiatedArgs:
    def __init__(__self__, *,
                 client_authorize_query: Optional[pulumi.Input[str]] = None,
                 client_id: Optional[pulumi.Input[str]] = None,
                 client_protocol: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] client_id: Google client ID.
        """
        if client_authorize_query is not None:
            pulumi.set(__self__, "client_authorize_query", client_authorize_query)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if client_protocol is not None:
            pulumi.set(__self__, "client_protocol", client_protocol)

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

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

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[pulumi.Input[str]]:
        """
        Google client ID.
        """
        return pulumi.get(self, "client_id")

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

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

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


@pulumi.input_type
class ConnectionOptionsMfaArgs:
    def __init__(__self__, *,
                 active: Optional[pulumi.Input[bool]] = None,
                 return_enroll_settings: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] active: Indicates whether multifactor authentication is enabled for this connection.
        :param pulumi.Input[bool] return_enroll_settings: Indicates whether multifactor authentication enrollment settings will be returned.
        """
        if active is not None:
            pulumi.set(__self__, "active", active)
        if return_enroll_settings is not None:
            pulumi.set(__self__, "return_enroll_settings", return_enroll_settings)

    @property
    @pulumi.getter
    def active(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether multifactor authentication is enabled for this connection.
        """
        return pulumi.get(self, "active")

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

    @property
    @pulumi.getter(name="returnEnrollSettings")
    def return_enroll_settings(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether multifactor authentication enrollment settings will be returned.
        """
        return pulumi.get(self, "return_enroll_settings")

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


@pulumi.input_type
class ConnectionOptionsPasswordComplexityOptionsArgs:
    def __init__(__self__, *,
                 min_length: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] min_length: Minimum number of characters allowed in passwords.
        """
        if min_length is not None:
            pulumi.set(__self__, "min_length", min_length)

    @property
    @pulumi.getter(name="minLength")
    def min_length(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum number of characters allowed in passwords.
        """
        return pulumi.get(self, "min_length")

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


@pulumi.input_type
class ConnectionOptionsPasswordDictionaryArgs:
    def __init__(__self__, *,
                 dictionaries: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 enable: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] dictionaries: Customized contents of the password dictionary. By default, the password dictionary contains a list of the [10,000 most common passwords](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/10k-most-common.txt); your customized content is used in addition to the default password dictionary. Matching is not case-sensitive.
        :param pulumi.Input[bool] enable: Indicates whether password history is enabled for the connection. When enabled, any existing users in this connection will be unaffected; the system will maintain their password history going forward.
        """
        if dictionaries is not None:
            pulumi.set(__self__, "dictionaries", dictionaries)
        if enable is not None:
            pulumi.set(__self__, "enable", enable)

    @property
    @pulumi.getter
    def dictionaries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Customized contents of the password dictionary. By default, the password dictionary contains a list of the [10,000 most common passwords](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/10k-most-common.txt); your customized content is used in addition to the default password dictionary. Matching is not case-sensitive.
        """
        return pulumi.get(self, "dictionaries")

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

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether password history is enabled for the connection. When enabled, any existing users in this connection will be unaffected; the system will maintain their password history going forward.
        """
        return pulumi.get(self, "enable")

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


@pulumi.input_type
class ConnectionOptionsPasswordHistoryArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[bool]] = None,
                 size: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] enable: Indicates whether password history is enabled for the connection. When enabled, any existing users in this connection will be unaffected; the system will maintain their password history going forward.
        :param pulumi.Input[int] size: Indicates the number of passwords to keep in history with a maximum of 24.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether password history is enabled for the connection. When enabled, any existing users in this connection will be unaffected; the system will maintain their password history going forward.
        """
        return pulumi.get(self, "enable")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[int]]:
        """
        Indicates the number of passwords to keep in history with a maximum of 24.
        """
        return pulumi.get(self, "size")

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


@pulumi.input_type
class ConnectionOptionsPasswordNoPersonalInfoArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enable: Indicates whether the password personal info check is enabled for this connection.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the password personal info check is enabled for this connection.
        """
        return pulumi.get(self, "enable")

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


@pulumi.input_type
class ConnectionOptionsTotpArgs:
    def __init__(__self__, *,
                 length: Optional[pulumi.Input[int]] = None,
                 time_step: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] length: Integer. Length of the one-time password.
        :param pulumi.Input[int] time_step: Integer. Seconds between allowed generation of new passwords.
        """
        if length is not None:
            pulumi.set(__self__, "length", length)
        if time_step is not None:
            pulumi.set(__self__, "time_step", time_step)

    @property
    @pulumi.getter
    def length(self) -> Optional[pulumi.Input[int]]:
        """
        Integer. Length of the one-time password.
        """
        return pulumi.get(self, "length")

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

    @property
    @pulumi.getter(name="timeStep")
    def time_step(self) -> Optional[pulumi.Input[int]]:
        """
        Integer. Seconds between allowed generation of new passwords.
        """
        return pulumi.get(self, "time_step")

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


@pulumi.input_type
class ConnectionOptionsValidationArgs:
    def __init__(__self__, *,
                 username: Optional[pulumi.Input['ConnectionOptionsValidationUsernameArgs']] = None):
        """
        :param pulumi.Input['ConnectionOptionsValidationUsernameArgs'] username: Specifies the `min` and `max` values of username length. `min` and `max` are integers.
        """
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input['ConnectionOptionsValidationUsernameArgs']]:
        """
        Specifies the `min` and `max` values of username length. `min` and `max` are integers.
        """
        return pulumi.get(self, "username")

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


@pulumi.input_type
class ConnectionOptionsValidationUsernameArgs:
    def __init__(__self__, *,
                 max: Optional[pulumi.Input[int]] = None,
                 min: Optional[pulumi.Input[int]] = None):
        if max is not None:
            pulumi.set(__self__, "max", max)
        if min is not None:
            pulumi.set(__self__, "min", min)

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

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

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

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


@pulumi.input_type
class CustomDomainVerificationArgs:
    def __init__(__self__, *,
                 methods: Optional[pulumi.Input[Sequence[Any]]] = None):
        """
        :param pulumi.Input[Sequence[Any]] methods: List(Map). Verification methods for the domain.
        """
        if methods is not None:
            pulumi.set(__self__, "methods", methods)

    @property
    @pulumi.getter
    def methods(self) -> Optional[pulumi.Input[Sequence[Any]]]:
        """
        List(Map). Verification methods for the domain.
        """
        return pulumi.get(self, "methods")

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


@pulumi.input_type
class EmailCredentialsArgs:
    def __init__(__self__, *,
                 access_key_id: Optional[pulumi.Input[str]] = None,
                 api_key: Optional[pulumi.Input[str]] = None,
                 api_user: Optional[pulumi.Input[str]] = None,
                 domain: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 secret_access_key: Optional[pulumi.Input[str]] = None,
                 smtp_host: Optional[pulumi.Input[str]] = None,
                 smtp_pass: Optional[pulumi.Input[str]] = None,
                 smtp_port: Optional[pulumi.Input[int]] = None,
                 smtp_user: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_key_id: String, Case-sensitive. AWS Access Key ID. Used only for AWS.
        :param pulumi.Input[str] api_key: String, Case-sensitive. API Key for your email service. Will always be encrypted in our database.
        :param pulumi.Input[str] api_user: String. API User for your email service.
        :param pulumi.Input[str] region: String. Default region. Used only for AWS, Mailgun, and SparkPost.
        :param pulumi.Input[str] secret_access_key: String, Case-sensitive. AWS Secret Key. Will always be encrypted in our database. Used only for AWS.
        :param pulumi.Input[str] smtp_host: String. Hostname or IP address of your SMTP server. Used only for SMTP.
        :param pulumi.Input[str] smtp_pass: String, Case-sensitive. SMTP password. Used only for SMTP.
        :param pulumi.Input[int] smtp_port: Integer. Port used by your SMTP server. Please avoid using port 25 if possible because many providers have limitations on this port. Used only for SMTP.
        :param pulumi.Input[str] smtp_user: String. SMTP username. Used only for SMTP.
        """
        if access_key_id is not None:
            pulumi.set(__self__, "access_key_id", access_key_id)
        if api_key is not None:
            pulumi.set(__self__, "api_key", api_key)
        if api_user is not None:
            pulumi.set(__self__, "api_user", api_user)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_access_key is not None:
            pulumi.set(__self__, "secret_access_key", secret_access_key)
        if smtp_host is not None:
            pulumi.set(__self__, "smtp_host", smtp_host)
        if smtp_pass is not None:
            pulumi.set(__self__, "smtp_pass", smtp_pass)
        if smtp_port is not None:
            pulumi.set(__self__, "smtp_port", smtp_port)
        if smtp_user is not None:
            pulumi.set(__self__, "smtp_user", smtp_user)

    @property
    @pulumi.getter(name="accessKeyId")
    def access_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        String, Case-sensitive. AWS Access Key ID. Used only for AWS.
        """
        return pulumi.get(self, "access_key_id")

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

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> Optional[pulumi.Input[str]]:
        """
        String, Case-sensitive. API Key for your email service. Will always be encrypted in our database.
        """
        return pulumi.get(self, "api_key")

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

    @property
    @pulumi.getter(name="apiUser")
    def api_user(self) -> Optional[pulumi.Input[str]]:
        """
        String. API User for your email service.
        """
        return pulumi.get(self, "api_user")

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

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

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

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        String. Default region. Used only for AWS, Mailgun, and SparkPost.
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> Optional[pulumi.Input[str]]:
        """
        String, Case-sensitive. AWS Secret Key. Will always be encrypted in our database. Used only for AWS.
        """
        return pulumi.get(self, "secret_access_key")

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

    @property
    @pulumi.getter(name="smtpHost")
    def smtp_host(self) -> Optional[pulumi.Input[str]]:
        """
        String. Hostname or IP address of your SMTP server. Used only for SMTP.
        """
        return pulumi.get(self, "smtp_host")

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

    @property
    @pulumi.getter(name="smtpPass")
    def smtp_pass(self) -> Optional[pulumi.Input[str]]:
        """
        String, Case-sensitive. SMTP password. Used only for SMTP.
        """
        return pulumi.get(self, "smtp_pass")

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

    @property
    @pulumi.getter(name="smtpPort")
    def smtp_port(self) -> Optional[pulumi.Input[int]]:
        """
        Integer. Port used by your SMTP server. Please avoid using port 25 if possible because many providers have limitations on this port. Used only for SMTP.
        """
        return pulumi.get(self, "smtp_port")

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

    @property
    @pulumi.getter(name="smtpUser")
    def smtp_user(self) -> Optional[pulumi.Input[str]]:
        """
        String. SMTP username. Used only for SMTP.
        """
        return pulumi.get(self, "smtp_user")

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


@pulumi.input_type
class GlobalClientAddonsArgs:
    def __init__(__self__, *,
                 aws: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 azure_blob: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 azure_sb: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 box: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 cloudbees: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 concur: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 dropbox: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 echosign: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 egnyte: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 firebase: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 layer: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 mscrm: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 newrelic: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 office365: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 rms: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 salesforce: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 salesforce_api: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 salesforce_sandbox_api: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 samlp: Optional[pulumi.Input['GlobalClientAddonsSamlpArgs']] = None,
                 sap_api: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 sentry: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 sharepoint: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 slack: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 springcm: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 wams: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 wsfed: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 zendesk: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 zoom: Optional[pulumi.Input[Mapping[str, Any]]] = None):
        if aws is not None:
            pulumi.set(__self__, "aws", aws)
        if azure_blob is not None:
            pulumi.set(__self__, "azure_blob", azure_blob)
        if azure_sb is not None:
            pulumi.set(__self__, "azure_sb", azure_sb)
        if box is not None:
            pulumi.set(__self__, "box", box)
        if cloudbees is not None:
            pulumi.set(__self__, "cloudbees", cloudbees)
        if concur is not None:
            pulumi.set(__self__, "concur", concur)
        if dropbox is not None:
            pulumi.set(__self__, "dropbox", dropbox)
        if echosign is not None:
            pulumi.set(__self__, "echosign", echosign)
        if egnyte is not None:
            pulumi.set(__self__, "egnyte", egnyte)
        if firebase is not None:
            pulumi.set(__self__, "firebase", firebase)
        if layer is not None:
            pulumi.set(__self__, "layer", layer)
        if mscrm is not None:
            pulumi.set(__self__, "mscrm", mscrm)
        if newrelic is not None:
            pulumi.set(__self__, "newrelic", newrelic)
        if office365 is not None:
            pulumi.set(__self__, "office365", office365)
        if rms is not None:
            pulumi.set(__self__, "rms", rms)
        if salesforce is not None:
            pulumi.set(__self__, "salesforce", salesforce)
        if salesforce_api is not None:
            pulumi.set(__self__, "salesforce_api", salesforce_api)
        if salesforce_sandbox_api is not None:
            pulumi.set(__self__, "salesforce_sandbox_api", salesforce_sandbox_api)
        if samlp is not None:
            pulumi.set(__self__, "samlp", samlp)
        if sap_api is not None:
            pulumi.set(__self__, "sap_api", sap_api)
        if sentry is not None:
            pulumi.set(__self__, "sentry", sentry)
        if sharepoint is not None:
            pulumi.set(__self__, "sharepoint", sharepoint)
        if slack is not None:
            pulumi.set(__self__, "slack", slack)
        if springcm is not None:
            pulumi.set(__self__, "springcm", springcm)
        if wams is not None:
            pulumi.set(__self__, "wams", wams)
        if wsfed is not None:
            pulumi.set(__self__, "wsfed", wsfed)
        if zendesk is not None:
            pulumi.set(__self__, "zendesk", zendesk)
        if zoom is not None:
            pulumi.set(__self__, "zoom", zoom)

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

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

    @property
    @pulumi.getter(name="azureBlob")
    def azure_blob(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "azure_blob")

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

    @property
    @pulumi.getter(name="azureSb")
    def azure_sb(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "azure_sb")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="salesforceApi")
    def salesforce_api(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "salesforce_api")

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

    @property
    @pulumi.getter(name="salesforceSandboxApi")
    def salesforce_sandbox_api(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "salesforce_sandbox_api")

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

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

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

    @property
    @pulumi.getter(name="sapApi")
    def sap_api(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        return pulumi.get(self, "sap_api")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class GlobalClientAddonsSamlpArgs:
    def __init__(__self__, *,
                 audience: Optional[pulumi.Input[str]] = None,
                 authn_context_class_ref: Optional[pulumi.Input[str]] = None,
                 binding: Optional[pulumi.Input[str]] = None,
                 create_upn_claim: Optional[pulumi.Input[bool]] = None,
                 destination: Optional[pulumi.Input[str]] = None,
                 digest_algorithm: Optional[pulumi.Input[str]] = None,
                 include_attribute_name_format: Optional[pulumi.Input[bool]] = None,
                 lifetime_in_seconds: Optional[pulumi.Input[int]] = None,
                 logout: Optional[pulumi.Input['GlobalClientAddonsSamlpLogoutArgs']] = None,
                 map_identities: Optional[pulumi.Input[bool]] = None,
                 map_unknown_claims_as_is: Optional[pulumi.Input[bool]] = None,
                 mappings: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 name_identifier_format: Optional[pulumi.Input[str]] = None,
                 name_identifier_probes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 passthrough_claims_with_no_mapping: Optional[pulumi.Input[bool]] = None,
                 recipient: Optional[pulumi.Input[str]] = None,
                 sign_response: Optional[pulumi.Input[bool]] = None,
                 signature_algorithm: Optional[pulumi.Input[str]] = None,
                 typed_attributes: Optional[pulumi.Input[bool]] = None):
        if audience is not None:
            pulumi.set(__self__, "audience", audience)
        if authn_context_class_ref is not None:
            pulumi.set(__self__, "authn_context_class_ref", authn_context_class_ref)
        if binding is not None:
            pulumi.set(__self__, "binding", binding)
        if create_upn_claim is not None:
            pulumi.set(__self__, "create_upn_claim", create_upn_claim)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if digest_algorithm is not None:
            pulumi.set(__self__, "digest_algorithm", digest_algorithm)
        if include_attribute_name_format is not None:
            pulumi.set(__self__, "include_attribute_name_format", include_attribute_name_format)
        if lifetime_in_seconds is not None:
            pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        if logout is not None:
            pulumi.set(__self__, "logout", logout)
        if map_identities is not None:
            pulumi.set(__self__, "map_identities", map_identities)
        if map_unknown_claims_as_is is not None:
            pulumi.set(__self__, "map_unknown_claims_as_is", map_unknown_claims_as_is)
        if mappings is not None:
            pulumi.set(__self__, "mappings", mappings)
        if name_identifier_format is not None:
            pulumi.set(__self__, "name_identifier_format", name_identifier_format)
        if name_identifier_probes is not None:
            pulumi.set(__self__, "name_identifier_probes", name_identifier_probes)
        if passthrough_claims_with_no_mapping is not None:
            pulumi.set(__self__, "passthrough_claims_with_no_mapping", passthrough_claims_with_no_mapping)
        if recipient is not None:
            pulumi.set(__self__, "recipient", recipient)
        if sign_response is not None:
            pulumi.set(__self__, "sign_response", sign_response)
        if signature_algorithm is not None:
            pulumi.set(__self__, "signature_algorithm", signature_algorithm)
        if typed_attributes is not None:
            pulumi.set(__self__, "typed_attributes", typed_attributes)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class GlobalClientJwtConfigurationArgs:
    def __init__(__self__, *,
                 alg: Optional[pulumi.Input[str]] = None,
                 lifetime_in_seconds: Optional[pulumi.Input[int]] = None,
                 scopes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 secret_encoded: Optional[pulumi.Input[bool]] = None):
        if alg is not None:
            pulumi.set(__self__, "alg", alg)
        if lifetime_in_seconds is not None:
            pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        if scopes is not None:
            pulumi.set(__self__, "scopes", scopes)
        if secret_encoded is not None:
            pulumi.set(__self__, "secret_encoded", secret_encoded)

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

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

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

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

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

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

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

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


@pulumi.input_type
class GlobalClientMobileArgs:
    def __init__(__self__, *,
                 android: Optional[pulumi.Input['GlobalClientMobileAndroidArgs']] = None,
                 ios: Optional[pulumi.Input['GlobalClientMobileIosArgs']] = None):
        if android is not None:
            pulumi.set(__self__, "android", android)
        if ios is not None:
            pulumi.set(__self__, "ios", ios)

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

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

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

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


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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class GlobalClientRefreshTokenArgs:
    def __init__(__self__, *,
                 expiration_type: pulumi.Input[str],
                 rotation_type: pulumi.Input[str],
                 idle_token_lifetime: Optional[pulumi.Input[int]] = None,
                 infinite_idle_token_lifetime: Optional[pulumi.Input[bool]] = None,
                 infinite_token_lifetime: Optional[pulumi.Input[bool]] = None,
                 leeway: Optional[pulumi.Input[int]] = None,
                 token_lifetime: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "expiration_type", expiration_type)
        pulumi.set(__self__, "rotation_type", rotation_type)
        if idle_token_lifetime is not None:
            pulumi.set(__self__, "idle_token_lifetime", idle_token_lifetime)
        if infinite_idle_token_lifetime is not None:
            pulumi.set(__self__, "infinite_idle_token_lifetime", infinite_idle_token_lifetime)
        if infinite_token_lifetime is not None:
            pulumi.set(__self__, "infinite_token_lifetime", infinite_token_lifetime)
        if leeway is not None:
            pulumi.set(__self__, "leeway", leeway)
        if token_lifetime is not None:
            pulumi.set(__self__, "token_lifetime", token_lifetime)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class GuardianPhoneArgs:
    def __init__(__self__, *,
                 message_types: pulumi.Input[Sequence[pulumi.Input[str]]],
                 provider: pulumi.Input[str],
                 options: Optional[pulumi.Input['GuardianPhoneOptionsArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] message_types: List(String). Message types to use, array of `phone` and or `voice`. Adding both to array should enable the user to choose.
        :param pulumi.Input[str] provider: String, Case-sensitive. Provider to use, one of `auth0`, `twilio` or `phone-message-hook`.
        :param pulumi.Input['GuardianPhoneOptionsArgs'] options: List(Resource). Options for the various providers. See Options.
        """
        pulumi.set(__self__, "message_types", message_types)
        pulumi.set(__self__, "provider", provider)
        if options is not None:
            pulumi.set(__self__, "options", options)

    @property
    @pulumi.getter(name="messageTypes")
    def message_types(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        List(String). Message types to use, array of `phone` and or `voice`. Adding both to array should enable the user to choose.
        """
        return pulumi.get(self, "message_types")

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

    @property
    @pulumi.getter
    def provider(self) -> pulumi.Input[str]:
        """
        String, Case-sensitive. Provider to use, one of `auth0`, `twilio` or `phone-message-hook`.
        """
        return pulumi.get(self, "provider")

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

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input['GuardianPhoneOptionsArgs']]:
        """
        List(Resource). Options for the various providers. See Options.
        """
        return pulumi.get(self, "options")

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


@pulumi.input_type
class GuardianPhoneOptionsArgs:
    def __init__(__self__, *,
                 auth_token: Optional[pulumi.Input[str]] = None,
                 enrollment_message: Optional[pulumi.Input[str]] = None,
                 from_: Optional[pulumi.Input[str]] = None,
                 messaging_service_sid: Optional[pulumi.Input[str]] = None,
                 sid: Optional[pulumi.Input[str]] = None,
                 verification_message: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] auth_token: String.
        :param pulumi.Input[str] enrollment_message: String. This message will be sent whenever a user enrolls a new device for the first time using MFA. Supports liquid syntax, see [Auth0 docs](https://auth0.com/docs/mfa/customize-sms-or-voice-messages).
        :param pulumi.Input[str] from_: String.
        :param pulumi.Input[str] messaging_service_sid: String.
        :param pulumi.Input[str] sid: String.
        :param pulumi.Input[str] verification_message: String. This message will be sent whenever a user logs in after the enrollment. Supports liquid syntax, see [Auth0 docs](https://auth0.com/docs/mfa/customize-sms-or-voice-messages).
        """
        if auth_token is not None:
            pulumi.set(__self__, "auth_token", auth_token)
        if enrollment_message is not None:
            pulumi.set(__self__, "enrollment_message", enrollment_message)
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if messaging_service_sid is not None:
            pulumi.set(__self__, "messaging_service_sid", messaging_service_sid)
        if sid is not None:
            pulumi.set(__self__, "sid", sid)
        if verification_message is not None:
            pulumi.set(__self__, "verification_message", verification_message)

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

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

    @property
    @pulumi.getter(name="enrollmentMessage")
    def enrollment_message(self) -> Optional[pulumi.Input[str]]:
        """
        String. This message will be sent whenever a user enrolls a new device for the first time using MFA. Supports liquid syntax, see [Auth0 docs](https://auth0.com/docs/mfa/customize-sms-or-voice-messages).
        """
        return pulumi.get(self, "enrollment_message")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="verificationMessage")
    def verification_message(self) -> Optional[pulumi.Input[str]]:
        """
        String. This message will be sent whenever a user logs in after the enrollment. Supports liquid syntax, see [Auth0 docs](https://auth0.com/docs/mfa/customize-sms-or-voice-messages).
        """
        return pulumi.get(self, "verification_message")

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


@pulumi.input_type
class LogStreamSinkArgs:
    def __init__(__self__, *,
                 aws_account_id: Optional[pulumi.Input[str]] = None,
                 aws_partner_event_source: Optional[pulumi.Input[str]] = None,
                 aws_region: Optional[pulumi.Input[str]] = None,
                 azure_partner_topic: Optional[pulumi.Input[str]] = None,
                 azure_region: Optional[pulumi.Input[str]] = None,
                 azure_resource_group: Optional[pulumi.Input[str]] = None,
                 azure_subscription_id: Optional[pulumi.Input[str]] = None,
                 datadog_api_key: Optional[pulumi.Input[str]] = None,
                 datadog_region: Optional[pulumi.Input[str]] = None,
                 http_authorization: Optional[pulumi.Input[str]] = None,
                 http_content_format: Optional[pulumi.Input[str]] = None,
                 http_content_type: Optional[pulumi.Input[str]] = None,
                 http_custom_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 http_endpoint: Optional[pulumi.Input[str]] = None,
                 splunk_domain: Optional[pulumi.Input[str]] = None,
                 splunk_port: Optional[pulumi.Input[str]] = None,
                 splunk_secure: Optional[pulumi.Input[bool]] = None,
                 splunk_token: Optional[pulumi.Input[str]] = None,
                 sumo_source_address: Optional[pulumi.Input[str]] = None):
        if aws_account_id is not None:
            pulumi.set(__self__, "aws_account_id", aws_account_id)
        if aws_partner_event_source is not None:
            pulumi.set(__self__, "aws_partner_event_source", aws_partner_event_source)
        if aws_region is not None:
            pulumi.set(__self__, "aws_region", aws_region)
        if azure_partner_topic is not None:
            pulumi.set(__self__, "azure_partner_topic", azure_partner_topic)
        if azure_region is not None:
            pulumi.set(__self__, "azure_region", azure_region)
        if azure_resource_group is not None:
            pulumi.set(__self__, "azure_resource_group", azure_resource_group)
        if azure_subscription_id is not None:
            pulumi.set(__self__, "azure_subscription_id", azure_subscription_id)
        if datadog_api_key is not None:
            pulumi.set(__self__, "datadog_api_key", datadog_api_key)
        if datadog_region is not None:
            pulumi.set(__self__, "datadog_region", datadog_region)
        if http_authorization is not None:
            pulumi.set(__self__, "http_authorization", http_authorization)
        if http_content_format is not None:
            pulumi.set(__self__, "http_content_format", http_content_format)
        if http_content_type is not None:
            pulumi.set(__self__, "http_content_type", http_content_type)
        if http_custom_headers is not None:
            pulumi.set(__self__, "http_custom_headers", http_custom_headers)
        if http_endpoint is not None:
            pulumi.set(__self__, "http_endpoint", http_endpoint)
        if splunk_domain is not None:
            pulumi.set(__self__, "splunk_domain", splunk_domain)
        if splunk_port is not None:
            pulumi.set(__self__, "splunk_port", splunk_port)
        if splunk_secure is not None:
            pulumi.set(__self__, "splunk_secure", splunk_secure)
        if splunk_token is not None:
            pulumi.set(__self__, "splunk_token", splunk_token)
        if sumo_source_address is not None:
            pulumi.set(__self__, "sumo_source_address", sumo_source_address)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ResourceServerScopeArgs:
    def __init__(__self__, *,
                 value: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] value: String. Name of the permission (scope). Examples include `read:appointments` or `delete:appointments`.
        :param pulumi.Input[str] description: String. Description of the permission (scope).
        """
        pulumi.set(__self__, "value", value)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        String. Name of the permission (scope). Examples include `read:appointments` or `delete:appointments`.
        """
        return pulumi.get(self, "value")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        String. Description of the permission (scope).
        """
        return pulumi.get(self, "description")

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


@pulumi.input_type
class RolePermissionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 resource_server_identifier: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: String. Name of the permission (scope).
        :param pulumi.Input[str] resource_server_identifier: String. Unique identifier for the resource server.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_server_identifier", resource_server_identifier)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        String. Name of the permission (scope).
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="resourceServerIdentifier")
    def resource_server_identifier(self) -> pulumi.Input[str]:
        """
        String. Unique identifier for the resource server.
        """
        return pulumi.get(self, "resource_server_identifier")

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


@pulumi.input_type
class TenantChangePasswordArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 html: pulumi.Input[str]):
        """
        :param pulumi.Input[bool] enabled: Boolean. Indicates whether or not to use the custom change password page.
        :param pulumi.Input[str] html: String, HTML format with supported Liquid syntax. Customized content of the change password page.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "html", html)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        """
        Boolean. Indicates whether or not to use the custom change password page.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def html(self) -> pulumi.Input[str]:
        """
        String, HTML format with supported Liquid syntax. Customized content of the change password page.
        """
        return pulumi.get(self, "html")

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


@pulumi.input_type
class TenantErrorPageArgs:
    def __init__(__self__, *,
                 html: pulumi.Input[str],
                 show_log_link: pulumi.Input[bool],
                 url: pulumi.Input[str]):
        """
        :param pulumi.Input[str] html: String, HTML format with supported Liquid syntax. Customized content of the error page.
        :param pulumi.Input[bool] show_log_link: Boolean. Indicates whether or not to show the link to logs as part of the default error page.
        :param pulumi.Input[str] url: String. URL to redirect to when an error occurs rather than showing the default error page.
        """
        pulumi.set(__self__, "html", html)
        pulumi.set(__self__, "show_log_link", show_log_link)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def html(self) -> pulumi.Input[str]:
        """
        String, HTML format with supported Liquid syntax. Customized content of the error page.
        """
        return pulumi.get(self, "html")

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

    @property
    @pulumi.getter(name="showLogLink")
    def show_log_link(self) -> pulumi.Input[bool]:
        """
        Boolean. Indicates whether or not to show the link to logs as part of the default error page.
        """
        return pulumi.get(self, "show_log_link")

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

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        String. URL to redirect to when an error occurs rather than showing the default error page.
        """
        return pulumi.get(self, "url")

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


@pulumi.input_type
class TenantFlagsArgs:
    def __init__(__self__, *,
                 change_pwd_flow_v1: Optional[pulumi.Input[bool]] = None,
                 disable_clickjack_protection_headers: Optional[pulumi.Input[bool]] = None,
                 enable_apis_section: Optional[pulumi.Input[bool]] = None,
                 enable_client_connections: Optional[pulumi.Input[bool]] = None,
                 enable_custom_domain_in_emails: Optional[pulumi.Input[bool]] = None,
                 enable_dynamic_client_registration: Optional[pulumi.Input[bool]] = None,
                 enable_legacy_logs_search_v2: Optional[pulumi.Input[bool]] = None,
                 enable_pipeline2: Optional[pulumi.Input[bool]] = None,
                 enable_public_signup_user_exists_error: Optional[pulumi.Input[bool]] = None,
                 universal_login: Optional[pulumi.Input[bool]] = None,
                 use_scope_descriptions_for_consent: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] change_pwd_flow_v1: Boolean. Indicates whether or not to use the older v1 change password flow. Not recommended except for backward compatibility.
        :param pulumi.Input[bool] disable_clickjack_protection_headers: Boolean. Indicated whether or not classic Universal Login prompts include additional security headers to prevent clickjacking.
        :param pulumi.Input[bool] enable_apis_section: Boolean. Indicates whether or not the APIs section is enabled for the tenant.
        :param pulumi.Input[bool] enable_client_connections: Boolean. Indicates whether or not all current connections should be enabled when a new client is created.
        :param pulumi.Input[bool] enable_custom_domain_in_emails: Boolean. Indicates whether or not the tenant allows custom domains in emails.
        :param pulumi.Input[bool] enable_dynamic_client_registration: Boolean. Indicates whether or not the tenant allows dynamic client registration.
        :param pulumi.Input[bool] enable_legacy_logs_search_v2: Boolean. Indicates whether or not to use the older v2 legacy logs search.
        :param pulumi.Input[bool] enable_pipeline2: Boolean. Indicates whether or not advanced API Authorization scenarios are enabled.
        :param pulumi.Input[bool] enable_public_signup_user_exists_error: Boolean. Indicates whether or not the public sign up process shows a user_exists error if the user already exists.
        :param pulumi.Input[bool] universal_login: Boolean. Indicates whether or not the tenant uses universal login.
        """
        if change_pwd_flow_v1 is not None:
            pulumi.set(__self__, "change_pwd_flow_v1", change_pwd_flow_v1)
        if disable_clickjack_protection_headers is not None:
            pulumi.set(__self__, "disable_clickjack_protection_headers", disable_clickjack_protection_headers)
        if enable_apis_section is not None:
            pulumi.set(__self__, "enable_apis_section", enable_apis_section)
        if enable_client_connections is not None:
            pulumi.set(__self__, "enable_client_connections", enable_client_connections)
        if enable_custom_domain_in_emails is not None:
            pulumi.set(__self__, "enable_custom_domain_in_emails", enable_custom_domain_in_emails)
        if enable_dynamic_client_registration is not None:
            pulumi.set(__self__, "enable_dynamic_client_registration", enable_dynamic_client_registration)
        if enable_legacy_logs_search_v2 is not None:
            pulumi.set(__self__, "enable_legacy_logs_search_v2", enable_legacy_logs_search_v2)
        if enable_pipeline2 is not None:
            pulumi.set(__self__, "enable_pipeline2", enable_pipeline2)
        if enable_public_signup_user_exists_error is not None:
            pulumi.set(__self__, "enable_public_signup_user_exists_error", enable_public_signup_user_exists_error)
        if universal_login is not None:
            pulumi.set(__self__, "universal_login", universal_login)
        if use_scope_descriptions_for_consent is not None:
            pulumi.set(__self__, "use_scope_descriptions_for_consent", use_scope_descriptions_for_consent)

    @property
    @pulumi.getter(name="changePwdFlowV1")
    def change_pwd_flow_v1(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not to use the older v1 change password flow. Not recommended except for backward compatibility.
        """
        return pulumi.get(self, "change_pwd_flow_v1")

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

    @property
    @pulumi.getter(name="disableClickjackProtectionHeaders")
    def disable_clickjack_protection_headers(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicated whether or not classic Universal Login prompts include additional security headers to prevent clickjacking.
        """
        return pulumi.get(self, "disable_clickjack_protection_headers")

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

    @property
    @pulumi.getter(name="enableApisSection")
    def enable_apis_section(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not the APIs section is enabled for the tenant.
        """
        return pulumi.get(self, "enable_apis_section")

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

    @property
    @pulumi.getter(name="enableClientConnections")
    def enable_client_connections(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not all current connections should be enabled when a new client is created.
        """
        return pulumi.get(self, "enable_client_connections")

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

    @property
    @pulumi.getter(name="enableCustomDomainInEmails")
    def enable_custom_domain_in_emails(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not the tenant allows custom domains in emails.
        """
        return pulumi.get(self, "enable_custom_domain_in_emails")

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

    @property
    @pulumi.getter(name="enableDynamicClientRegistration")
    def enable_dynamic_client_registration(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not the tenant allows dynamic client registration.
        """
        return pulumi.get(self, "enable_dynamic_client_registration")

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

    @property
    @pulumi.getter(name="enableLegacyLogsSearchV2")
    def enable_legacy_logs_search_v2(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not to use the older v2 legacy logs search.
        """
        return pulumi.get(self, "enable_legacy_logs_search_v2")

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

    @property
    @pulumi.getter(name="enablePipeline2")
    def enable_pipeline2(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not advanced API Authorization scenarios are enabled.
        """
        return pulumi.get(self, "enable_pipeline2")

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

    @property
    @pulumi.getter(name="enablePublicSignupUserExistsError")
    def enable_public_signup_user_exists_error(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not the public sign up process shows a user_exists error if the user already exists.
        """
        return pulumi.get(self, "enable_public_signup_user_exists_error")

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

    @property
    @pulumi.getter(name="universalLogin")
    def universal_login(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean. Indicates whether or not the tenant uses universal login.
        """
        return pulumi.get(self, "universal_login")

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

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

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


@pulumi.input_type
class TenantGuardianMfaPageArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 html: pulumi.Input[str]):
        """
        :param pulumi.Input[bool] enabled: Boolean. Indicates whether or not to use the custom Guardian page.
        :param pulumi.Input[str] html: String, HTML format with supported Liquid syntax. Customized content of the Guardian page.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "html", html)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        """
        Boolean. Indicates whether or not to use the custom Guardian page.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def html(self) -> pulumi.Input[str]:
        """
        String, HTML format with supported Liquid syntax. Customized content of the Guardian page.
        """
        return pulumi.get(self, "html")

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


@pulumi.input_type
class TenantUniversalLoginArgs:
    def __init__(__self__, *,
                 colors: Optional[pulumi.Input['TenantUniversalLoginColorsArgs']] = None):
        """
        :param pulumi.Input['TenantUniversalLoginColorsArgs'] colors: List(Resource). Configuration settings for Universal Login colors. See Universal Login - Colors.
        """
        if colors is not None:
            pulumi.set(__self__, "colors", colors)

    @property
    @pulumi.getter
    def colors(self) -> Optional[pulumi.Input['TenantUniversalLoginColorsArgs']]:
        """
        List(Resource). Configuration settings for Universal Login colors. See Universal Login - Colors.
        """
        return pulumi.get(self, "colors")

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


@pulumi.input_type
class TenantUniversalLoginColorsArgs:
    def __init__(__self__, *,
                 page_background: Optional[pulumi.Input[str]] = None,
                 primary: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] page_background: String, Hexadecimal. Background color of login pages.
        :param pulumi.Input[str] primary: String, Hexadecimal. Primary button background color.
        """
        if page_background is not None:
            pulumi.set(__self__, "page_background", page_background)
        if primary is not None:
            pulumi.set(__self__, "primary", primary)

    @property
    @pulumi.getter(name="pageBackground")
    def page_background(self) -> Optional[pulumi.Input[str]]:
        """
        String, Hexadecimal. Background color of login pages.
        """
        return pulumi.get(self, "page_background")

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

    @property
    @pulumi.getter
    def primary(self) -> Optional[pulumi.Input[str]]:
        """
        String, Hexadecimal. Primary button background color.
        """
        return pulumi.get(self, "primary")

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


