# 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 copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs

__all__ = [
    'ActionDependency',
    'ActionSecret',
    'ActionSupportedTriggers',
    'AttackProtectionBreachedPasswordDetection',
    'AttackProtectionBreachedPasswordDetectionPreUserRegistration',
    'AttackProtectionBruteForceProtection',
    'AttackProtectionSuspiciousIpThrottling',
    'AttackProtectionSuspiciousIpThrottlingPreLogin',
    'AttackProtectionSuspiciousIpThrottlingPreUserRegistration',
    'BrandingColors',
    'BrandingFont',
    'BrandingThemeBorders',
    'BrandingThemeColors',
    'BrandingThemeFonts',
    'BrandingThemeFontsBodyText',
    'BrandingThemeFontsButtonsText',
    'BrandingThemeFontsInputLabels',
    'BrandingThemeFontsLinks',
    'BrandingThemeFontsSubtitle',
    'BrandingThemeFontsTitle',
    'BrandingThemePageBackground',
    'BrandingThemeWidget',
    'BrandingUniversalLogin',
    'ClientAddons',
    'ClientAddonsAws',
    'ClientAddonsAzureBlob',
    'ClientAddonsAzureSb',
    'ClientAddonsBox',
    'ClientAddonsCloudbees',
    'ClientAddonsConcur',
    'ClientAddonsDropbox',
    'ClientAddonsEchosign',
    'ClientAddonsEgnyte',
    'ClientAddonsFirebase',
    'ClientAddonsLayer',
    'ClientAddonsMscrm',
    'ClientAddonsNewrelic',
    'ClientAddonsOffice365',
    'ClientAddonsRms',
    'ClientAddonsSalesforce',
    'ClientAddonsSalesforceApi',
    'ClientAddonsSalesforceSandboxApi',
    'ClientAddonsSamlp',
    'ClientAddonsSamlpLogout',
    'ClientAddonsSapApi',
    'ClientAddonsSentry',
    'ClientAddonsSharepoint',
    'ClientAddonsSlack',
    'ClientAddonsSpringcm',
    'ClientAddonsSsoIntegration',
    'ClientAddonsWams',
    'ClientAddonsWsfed',
    'ClientAddonsZendesk',
    'ClientAddonsZoom',
    'ClientCredentialsPrivateKeyJwt',
    'ClientCredentialsPrivateKeyJwtCredential',
    'ClientJwtConfiguration',
    'ClientMobile',
    'ClientMobileAndroid',
    'ClientMobileIos',
    'ClientNativeSocialLogin',
    'ClientNativeSocialLoginApple',
    'ClientNativeSocialLoginFacebook',
    'ClientRefreshToken',
    'ConnectionOptions',
    'ConnectionOptionsAttributeMap',
    'ConnectionOptionsConnectionSettings',
    'ConnectionOptionsDecryptionKey',
    'ConnectionOptionsGatewayAuthentication',
    'ConnectionOptionsIdpInitiated',
    'ConnectionOptionsMfa',
    'ConnectionOptionsPasswordComplexityOptions',
    'ConnectionOptionsPasswordDictionary',
    'ConnectionOptionsPasswordHistory',
    'ConnectionOptionsPasswordNoPersonalInfo',
    'ConnectionOptionsSigningKey',
    'ConnectionOptionsTotp',
    'ConnectionOptionsValidation',
    'ConnectionOptionsValidationUsername',
    'CustomDomainVerification',
    'EmailProviderCredentials',
    'EmailProviderSettings',
    'EmailProviderSettingsHeaders',
    'EmailProviderSettingsMessage',
    'GuardianDuo',
    'GuardianPhone',
    'GuardianPhoneOptions',
    'GuardianPush',
    'GuardianPushAmazonSns',
    'GuardianPushCustomApp',
    'GuardianPushDirectApns',
    'GuardianPushDirectFcm',
    'GuardianWebauthnPlatform',
    'GuardianWebauthnRoaming',
    'LogStreamSink',
    'OrganizationBranding',
    'OrganizationConnectionsEnabledConnection',
    'PagesChangePassword',
    'PagesError',
    'PagesGuardianMfa',
    'PagesLogin',
    'ResourceServerScopesScope',
    'RolePermissionsPermission',
    'TenantFlags',
    'TenantSessionCookie',
    'TenantSessions',
    'TriggerActionsAction',
    'UserPermissionsPermission',
    'GetAttackProtectionBreachedPasswordDetectionResult',
    'GetAttackProtectionBreachedPasswordDetectionPreUserRegistrationResult',
    'GetAttackProtectionBruteForceProtectionResult',
    'GetAttackProtectionSuspiciousIpThrottlingResult',
    'GetAttackProtectionSuspiciousIpThrottlingPreLoginResult',
    'GetAttackProtectionSuspiciousIpThrottlingPreUserRegistrationResult',
    'GetBrandingColorResult',
    'GetBrandingFontResult',
    'GetBrandingThemeBorderResult',
    'GetBrandingThemeColorResult',
    'GetBrandingThemeFontResult',
    'GetBrandingThemeFontBodyTextResult',
    'GetBrandingThemeFontButtonsTextResult',
    'GetBrandingThemeFontInputLabelResult',
    'GetBrandingThemeFontLinkResult',
    'GetBrandingThemeFontSubtitleResult',
    'GetBrandingThemeFontTitleResult',
    'GetBrandingThemePageBackgroundResult',
    'GetBrandingThemeWidgetResult',
    'GetBrandingUniversalLoginResult',
    'GetClientAddonResult',
    'GetClientAddonAwResult',
    'GetClientAddonAzureBlobResult',
    'GetClientAddonAzureSbResult',
    'GetClientAddonBoxResult',
    'GetClientAddonCloudbeeResult',
    'GetClientAddonConcurResult',
    'GetClientAddonDropboxResult',
    'GetClientAddonEchosignResult',
    'GetClientAddonEgnyteResult',
    'GetClientAddonFirebaseResult',
    'GetClientAddonLayerResult',
    'GetClientAddonMscrmResult',
    'GetClientAddonNewrelicResult',
    'GetClientAddonOffice365Result',
    'GetClientAddonRmResult',
    'GetClientAddonSalesforceResult',
    'GetClientAddonSalesforceApiResult',
    'GetClientAddonSalesforceSandboxApiResult',
    'GetClientAddonSamlpResult',
    'GetClientAddonSamlpLogoutResult',
    'GetClientAddonSapApiResult',
    'GetClientAddonSentryResult',
    'GetClientAddonSharepointResult',
    'GetClientAddonSlackResult',
    'GetClientAddonSpringcmResult',
    'GetClientAddonSsoIntegrationResult',
    'GetClientAddonWamResult',
    'GetClientAddonWsfedResult',
    'GetClientAddonZendeskResult',
    'GetClientAddonZoomResult',
    'GetClientJwtConfigurationResult',
    'GetClientMobileResult',
    'GetClientMobileAndroidResult',
    'GetClientMobileIoResult',
    'GetClientNativeSocialLoginResult',
    'GetClientNativeSocialLoginAppleResult',
    'GetClientNativeSocialLoginFacebookResult',
    'GetClientRefreshTokenResult',
    'GetConnectionOptionResult',
    'GetConnectionOptionAttributeMapResult',
    'GetConnectionOptionConnectionSettingResult',
    'GetConnectionOptionDecryptionKeyResult',
    'GetConnectionOptionGatewayAuthenticationResult',
    'GetConnectionOptionIdpInitiatedResult',
    'GetConnectionOptionMfaResult',
    'GetConnectionOptionPasswordComplexityOptionResult',
    'GetConnectionOptionPasswordDictionaryResult',
    'GetConnectionOptionPasswordHistoryResult',
    'GetConnectionOptionPasswordNoPersonalInfoResult',
    'GetConnectionOptionSigningKeyResult',
    'GetConnectionOptionTotpResult',
    'GetConnectionOptionValidationResult',
    'GetConnectionOptionValidationUsernameResult',
    'GetCustomDomainVerificationResult',
    'GetOrganizationBrandingResult',
    'GetOrganizationConnectionResult',
    'GetPagesChangePasswordResult',
    'GetPagesErrorResult',
    'GetPagesGuardianMfaResult',
    'GetPagesLoginResult',
    'GetResourceServerScopeResult',
    'GetRolePermissionResult',
    'GetSigningKeysSigningKeyResult',
    'GetTenantFlagResult',
    'GetTenantSessionResult',
    'GetTenantSessionCookyResult',
    'GetUserPermissionResult',
]

@pulumi.output_type
class ActionDependency(dict):
    def __init__(__self__, *,
                 name: str,
                 version: str):
        """
        :param str name: Dependency name, e.g. `lodash`.
        :param str version: Dependency version, e.g. `latest` or `4.17.21`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Dependency name, e.g. `lodash`.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        Dependency version, e.g. `latest` or `4.17.21`.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class ActionSecret(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: Secret name.
        :param str value: Secret value.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class ActionSupportedTriggers(dict):
    def __init__(__self__, *,
                 id: str,
                 version: str):
        """
        :param str id: The trigger ID.
        :param str version: The trigger version. This regulates which `runtime` versions are supported.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The trigger ID.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The trigger version. This regulates which `runtime` versions are supported.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class AttackProtectionBreachedPasswordDetection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adminNotificationFrequencies":
            suggest = "admin_notification_frequencies"
        elif key == "preUserRegistration":
            suggest = "pre_user_registration"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 admin_notification_frequencies: Optional[Sequence[str]] = None,
                 method: Optional[str] = None,
                 pre_user_registration: Optional['outputs.AttackProtectionBreachedPasswordDetectionPreUserRegistration'] = None,
                 shields: Optional[Sequence[str]] = None):
        """
        :param bool enabled: Whether breached password detection is active.
        :param Sequence[str] admin_notification_frequencies: When `admin_notification` is enabled within the `shields` property, determines how often email notifications are sent. Possible values: `immediately`, `daily`, `weekly`, `monthly`.
        :param str method: The subscription level for breached password detection methods. Use "enhanced" to enable Credential Guard. Possible values: `standard`, `enhanced`.
        :param 'AttackProtectionBreachedPasswordDetectionPreUserRegistrationArgs' pre_user_registration: Configuration options that apply before every user registration attempt. Only available on public tenants.
        :param Sequence[str] shields: Action to take when a breached password is detected. Options include: `block` (block compromised user accounts), `user_notification` (send an email to user when we detect that they are using compromised credentials) and `admin_notification` (send an email with a summary of the number of accounts logging in with compromised credentials).
        """
        pulumi.set(__self__, "enabled", enabled)
        if admin_notification_frequencies is not None:
            pulumi.set(__self__, "admin_notification_frequencies", admin_notification_frequencies)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if pre_user_registration is not None:
            pulumi.set(__self__, "pre_user_registration", pre_user_registration)
        if shields is not None:
            pulumi.set(__self__, "shields", shields)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether breached password detection is active.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="adminNotificationFrequencies")
    def admin_notification_frequencies(self) -> Optional[Sequence[str]]:
        """
        When `admin_notification` is enabled within the `shields` property, determines how often email notifications are sent. Possible values: `immediately`, `daily`, `weekly`, `monthly`.
        """
        return pulumi.get(self, "admin_notification_frequencies")

    @property
    @pulumi.getter
    def method(self) -> Optional[str]:
        """
        The subscription level for breached password detection methods. Use "enhanced" to enable Credential Guard. Possible values: `standard`, `enhanced`.
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter(name="preUserRegistration")
    def pre_user_registration(self) -> Optional['outputs.AttackProtectionBreachedPasswordDetectionPreUserRegistration']:
        """
        Configuration options that apply before every user registration attempt. Only available on public tenants.
        """
        return pulumi.get(self, "pre_user_registration")

    @property
    @pulumi.getter
    def shields(self) -> Optional[Sequence[str]]:
        """
        Action to take when a breached password is detected. Options include: `block` (block compromised user accounts), `user_notification` (send an email to user when we detect that they are using compromised credentials) and `admin_notification` (send an email with a summary of the number of accounts logging in with compromised credentials).
        """
        return pulumi.get(self, "shields")


@pulumi.output_type
class AttackProtectionBreachedPasswordDetectionPreUserRegistration(dict):
    def __init__(__self__, *,
                 shields: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] shields: Action to take when a breached password is detected during a signup. Possible values: `block` (block compromised credentials for new accounts), `admin_notification` (send an email notification with a summary of compromised credentials in new accounts).
        """
        if shields is not None:
            pulumi.set(__self__, "shields", shields)

    @property
    @pulumi.getter
    def shields(self) -> Optional[Sequence[str]]:
        """
        Action to take when a breached password is detected during a signup. Possible values: `block` (block compromised credentials for new accounts), `admin_notification` (send an email notification with a summary of compromised credentials in new accounts).
        """
        return pulumi.get(self, "shields")


@pulumi.output_type
class AttackProtectionBruteForceProtection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxAttempts":
            suggest = "max_attempts"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 allowlists: Optional[Sequence[str]] = None,
                 max_attempts: Optional[int] = None,
                 mode: Optional[str] = None,
                 shields: Optional[Sequence[str]] = None):
        """
        :param bool enabled: Whether brute force attack protections are active.
        :param Sequence[str] allowlists: List of trusted IP addresses that will not have attack protection enforced against them. This field allows you to specify multiple IP addresses, or ranges. You can use IPv4 or IPv6 addresses and CIDR notation.
        :param int max_attempts: Maximum number of consecutive failed login attempts from a single user before blocking is triggered. Only available on public tenants.
        :param str mode: Determines whether the IP address is used when counting failed attempts. Possible values: `count_per_identifier_and_ip` (lockout an account from a given IP Address) or `count_per_identifier` (lockout an account regardless of IP Address).
        :param Sequence[str] shields: Action to take when a brute force protection threshold is violated. Possible values: `block` (block login attempts for a flagged user account), `user_notification` (send an email to user when their account has been blocked).
        """
        pulumi.set(__self__, "enabled", enabled)
        if allowlists is not None:
            pulumi.set(__self__, "allowlists", allowlists)
        if max_attempts is not None:
            pulumi.set(__self__, "max_attempts", max_attempts)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if shields is not None:
            pulumi.set(__self__, "shields", shields)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether brute force attack protections are active.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def allowlists(self) -> Optional[Sequence[str]]:
        """
        List of trusted IP addresses that will not have attack protection enforced against them. This field allows you to specify multiple IP addresses, or ranges. You can use IPv4 or IPv6 addresses and CIDR notation.
        """
        return pulumi.get(self, "allowlists")

    @property
    @pulumi.getter(name="maxAttempts")
    def max_attempts(self) -> Optional[int]:
        """
        Maximum number of consecutive failed login attempts from a single user before blocking is triggered. Only available on public tenants.
        """
        return pulumi.get(self, "max_attempts")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        Determines whether the IP address is used when counting failed attempts. Possible values: `count_per_identifier_and_ip` (lockout an account from a given IP Address) or `count_per_identifier` (lockout an account regardless of IP Address).
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def shields(self) -> Optional[Sequence[str]]:
        """
        Action to take when a brute force protection threshold is violated. Possible values: `block` (block login attempts for a flagged user account), `user_notification` (send an email to user when their account has been blocked).
        """
        return pulumi.get(self, "shields")


@pulumi.output_type
class AttackProtectionSuspiciousIpThrottling(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "preLogin":
            suggest = "pre_login"
        elif key == "preUserRegistration":
            suggest = "pre_user_registration"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 allowlists: Optional[Sequence[str]] = None,
                 pre_login: Optional['outputs.AttackProtectionSuspiciousIpThrottlingPreLogin'] = None,
                 pre_user_registration: Optional['outputs.AttackProtectionSuspiciousIpThrottlingPreUserRegistration'] = None,
                 shields: Optional[Sequence[str]] = None):
        """
        :param bool enabled: Whether suspicious IP throttling attack protections are active.
        :param Sequence[str] allowlists: List of trusted IP addresses that will not have attack protection enforced against them. This field allows you to specify multiple IP addresses, or ranges. You can use IPv4 or IPv6 addresses and CIDR notation.
        :param 'AttackProtectionSuspiciousIpThrottlingPreLoginArgs' pre_login: Configuration options that apply before every login attempt. Only available on public tenants.
        :param 'AttackProtectionSuspiciousIpThrottlingPreUserRegistrationArgs' pre_user_registration: Configuration options that apply before every user registration attempt. Only available on public tenants.
        :param Sequence[str] shields: Action to take when a suspicious IP throttling threshold is violated. Possible values: `block` (throttle traffic from an IP address when there is a high number of login attempts targeting too many different accounts), `admin_notification` (send an email notification when traffic is throttled on one or more IP addresses due to high-velocity traffic).
        """
        pulumi.set(__self__, "enabled", enabled)
        if allowlists is not None:
            pulumi.set(__self__, "allowlists", allowlists)
        if pre_login is not None:
            pulumi.set(__self__, "pre_login", pre_login)
        if pre_user_registration is not None:
            pulumi.set(__self__, "pre_user_registration", pre_user_registration)
        if shields is not None:
            pulumi.set(__self__, "shields", shields)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether suspicious IP throttling attack protections are active.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def allowlists(self) -> Optional[Sequence[str]]:
        """
        List of trusted IP addresses that will not have attack protection enforced against them. This field allows you to specify multiple IP addresses, or ranges. You can use IPv4 or IPv6 addresses and CIDR notation.
        """
        return pulumi.get(self, "allowlists")

    @property
    @pulumi.getter(name="preLogin")
    def pre_login(self) -> Optional['outputs.AttackProtectionSuspiciousIpThrottlingPreLogin']:
        """
        Configuration options that apply before every login attempt. Only available on public tenants.
        """
        return pulumi.get(self, "pre_login")

    @property
    @pulumi.getter(name="preUserRegistration")
    def pre_user_registration(self) -> Optional['outputs.AttackProtectionSuspiciousIpThrottlingPreUserRegistration']:
        """
        Configuration options that apply before every user registration attempt. Only available on public tenants.
        """
        return pulumi.get(self, "pre_user_registration")

    @property
    @pulumi.getter
    def shields(self) -> Optional[Sequence[str]]:
        """
        Action to take when a suspicious IP throttling threshold is violated. Possible values: `block` (throttle traffic from an IP address when there is a high number of login attempts targeting too many different accounts), `admin_notification` (send an email notification when traffic is throttled on one or more IP addresses due to high-velocity traffic).
        """
        return pulumi.get(self, "shields")


@pulumi.output_type
class AttackProtectionSuspiciousIpThrottlingPreLogin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxAttempts":
            suggest = "max_attempts"

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

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

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

    def __init__(__self__, *,
                 max_attempts: Optional[int] = None,
                 rate: Optional[int] = None):
        """
        :param int max_attempts: The maximum number of failed login attempts allowed from a single IP address.
        :param int rate: Interval of time, given in milliseconds at which new login tokens will become available after they have been used by an IP address. Each login attempt will be added on the defined throttling rate.
        """
        if max_attempts is not None:
            pulumi.set(__self__, "max_attempts", max_attempts)
        if rate is not None:
            pulumi.set(__self__, "rate", rate)

    @property
    @pulumi.getter(name="maxAttempts")
    def max_attempts(self) -> Optional[int]:
        """
        The maximum number of failed login attempts allowed from a single IP address.
        """
        return pulumi.get(self, "max_attempts")

    @property
    @pulumi.getter
    def rate(self) -> Optional[int]:
        """
        Interval of time, given in milliseconds at which new login tokens will become available after they have been used by an IP address. Each login attempt will be added on the defined throttling rate.
        """
        return pulumi.get(self, "rate")


@pulumi.output_type
class AttackProtectionSuspiciousIpThrottlingPreUserRegistration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxAttempts":
            suggest = "max_attempts"

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

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

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

    def __init__(__self__, *,
                 max_attempts: Optional[int] = None,
                 rate: Optional[int] = None):
        """
        :param int max_attempts: The maximum number of sign up attempts allowed from a single IP address.
        :param int rate: Interval of time, given in milliseconds at which new sign up tokens will become available after they have been used by an IP address. Each sign up attempt will be added on the defined throttling rate.
        """
        if max_attempts is not None:
            pulumi.set(__self__, "max_attempts", max_attempts)
        if rate is not None:
            pulumi.set(__self__, "rate", rate)

    @property
    @pulumi.getter(name="maxAttempts")
    def max_attempts(self) -> Optional[int]:
        """
        The maximum number of sign up attempts allowed from a single IP address.
        """
        return pulumi.get(self, "max_attempts")

    @property
    @pulumi.getter
    def rate(self) -> Optional[int]:
        """
        Interval of time, given in milliseconds at which new sign up tokens will become available after they have been used by an IP address. Each sign up attempt will be added on the defined throttling rate.
        """
        return pulumi.get(self, "rate")


@pulumi.output_type
class BrandingColors(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pageBackground":
            suggest = "page_background"

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

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

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

    def __init__(__self__, *,
                 page_background: Optional[str] = None,
                 primary: Optional[str] = None):
        """
        :param str page_background: Background color of login pages in hexadecimal.
        :param str primary: Primary button background color in hexadecimal.
        """
        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[str]:
        """
        Background color of login pages in hexadecimal.
        """
        return pulumi.get(self, "page_background")

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


@pulumi.output_type
class BrandingFont(dict):
    def __init__(__self__, *,
                 url: Optional[str] = None):
        """
        :param str url: URL for the custom font.
        """
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        """
        URL for the custom font.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class BrandingThemeBorders(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buttonBorderRadius":
            suggest = "button_border_radius"
        elif key == "buttonBorderWeight":
            suggest = "button_border_weight"
        elif key == "buttonsStyle":
            suggest = "buttons_style"
        elif key == "inputBorderRadius":
            suggest = "input_border_radius"
        elif key == "inputBorderWeight":
            suggest = "input_border_weight"
        elif key == "inputsStyle":
            suggest = "inputs_style"
        elif key == "showWidgetShadow":
            suggest = "show_widget_shadow"
        elif key == "widgetBorderWeight":
            suggest = "widget_border_weight"
        elif key == "widgetCornerRadius":
            suggest = "widget_corner_radius"

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

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

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

    def __init__(__self__, *,
                 button_border_radius: Optional[float] = None,
                 button_border_weight: Optional[float] = None,
                 buttons_style: Optional[str] = None,
                 input_border_radius: Optional[float] = None,
                 input_border_weight: Optional[float] = None,
                 inputs_style: Optional[str] = None,
                 show_widget_shadow: Optional[bool] = None,
                 widget_border_weight: Optional[float] = None,
                 widget_corner_radius: Optional[float] = None):
        """
        :param float button_border_radius: Button border radius. Value needs to be between `1` and `10`. Defaults to `3.0`.
        :param float button_border_weight: Button border weight. Value needs to be between `0` and `10`. Defaults to `1.0`.
        :param str buttons_style: Buttons style. Available options: `pill`, `rounded`, `sharp`. Defaults to `rounded`.
        :param float input_border_radius: Input border radius. Value needs to be between `0` and `10`. Defaults to `3.0`.
        :param float input_border_weight: Input border weight. Value needs to be between `0` and `3`. Defaults to `1.0`.
        :param str inputs_style: Inputs style. Available options: `pill`, `rounded`, `sharp`. Defaults to `rounded`.
        :param bool show_widget_shadow: Show widget shadow. Defaults to `true`.
        :param float widget_border_weight: Widget border weight. Value needs to be between `0` and `10`. Defaults to `0.0`.
        :param float widget_corner_radius: Widget corner radius. Value needs to be between `0` and `50`. Defaults to `5.0`.
        """
        if button_border_radius is not None:
            pulumi.set(__self__, "button_border_radius", button_border_radius)
        if button_border_weight is not None:
            pulumi.set(__self__, "button_border_weight", button_border_weight)
        if buttons_style is not None:
            pulumi.set(__self__, "buttons_style", buttons_style)
        if input_border_radius is not None:
            pulumi.set(__self__, "input_border_radius", input_border_radius)
        if input_border_weight is not None:
            pulumi.set(__self__, "input_border_weight", input_border_weight)
        if inputs_style is not None:
            pulumi.set(__self__, "inputs_style", inputs_style)
        if show_widget_shadow is not None:
            pulumi.set(__self__, "show_widget_shadow", show_widget_shadow)
        if widget_border_weight is not None:
            pulumi.set(__self__, "widget_border_weight", widget_border_weight)
        if widget_corner_radius is not None:
            pulumi.set(__self__, "widget_corner_radius", widget_corner_radius)

    @property
    @pulumi.getter(name="buttonBorderRadius")
    def button_border_radius(self) -> Optional[float]:
        """
        Button border radius. Value needs to be between `1` and `10`. Defaults to `3.0`.
        """
        return pulumi.get(self, "button_border_radius")

    @property
    @pulumi.getter(name="buttonBorderWeight")
    def button_border_weight(self) -> Optional[float]:
        """
        Button border weight. Value needs to be between `0` and `10`. Defaults to `1.0`.
        """
        return pulumi.get(self, "button_border_weight")

    @property
    @pulumi.getter(name="buttonsStyle")
    def buttons_style(self) -> Optional[str]:
        """
        Buttons style. Available options: `pill`, `rounded`, `sharp`. Defaults to `rounded`.
        """
        return pulumi.get(self, "buttons_style")

    @property
    @pulumi.getter(name="inputBorderRadius")
    def input_border_radius(self) -> Optional[float]:
        """
        Input border radius. Value needs to be between `0` and `10`. Defaults to `3.0`.
        """
        return pulumi.get(self, "input_border_radius")

    @property
    @pulumi.getter(name="inputBorderWeight")
    def input_border_weight(self) -> Optional[float]:
        """
        Input border weight. Value needs to be between `0` and `3`. Defaults to `1.0`.
        """
        return pulumi.get(self, "input_border_weight")

    @property
    @pulumi.getter(name="inputsStyle")
    def inputs_style(self) -> Optional[str]:
        """
        Inputs style. Available options: `pill`, `rounded`, `sharp`. Defaults to `rounded`.
        """
        return pulumi.get(self, "inputs_style")

    @property
    @pulumi.getter(name="showWidgetShadow")
    def show_widget_shadow(self) -> Optional[bool]:
        """
        Show widget shadow. Defaults to `true`.
        """
        return pulumi.get(self, "show_widget_shadow")

    @property
    @pulumi.getter(name="widgetBorderWeight")
    def widget_border_weight(self) -> Optional[float]:
        """
        Widget border weight. Value needs to be between `0` and `10`. Defaults to `0.0`.
        """
        return pulumi.get(self, "widget_border_weight")

    @property
    @pulumi.getter(name="widgetCornerRadius")
    def widget_corner_radius(self) -> Optional[float]:
        """
        Widget corner radius. Value needs to be between `0` and `50`. Defaults to `5.0`.
        """
        return pulumi.get(self, "widget_corner_radius")


@pulumi.output_type
class BrandingThemeColors(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "baseFocusColor":
            suggest = "base_focus_color"
        elif key == "baseHoverColor":
            suggest = "base_hover_color"
        elif key == "bodyText":
            suggest = "body_text"
        elif key == "inputBackground":
            suggest = "input_background"
        elif key == "inputBorder":
            suggest = "input_border"
        elif key == "inputFilledText":
            suggest = "input_filled_text"
        elif key == "inputLabelsPlaceholders":
            suggest = "input_labels_placeholders"
        elif key == "linksFocusedComponents":
            suggest = "links_focused_components"
        elif key == "primaryButton":
            suggest = "primary_button"
        elif key == "primaryButtonLabel":
            suggest = "primary_button_label"
        elif key == "secondaryButtonBorder":
            suggest = "secondary_button_border"
        elif key == "secondaryButtonLabel":
            suggest = "secondary_button_label"
        elif key == "widgetBackground":
            suggest = "widget_background"
        elif key == "widgetBorder":
            suggest = "widget_border"

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

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

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

    def __init__(__self__, *,
                 base_focus_color: Optional[str] = None,
                 base_hover_color: Optional[str] = None,
                 body_text: Optional[str] = None,
                 error: Optional[str] = None,
                 header: Optional[str] = None,
                 icons: Optional[str] = None,
                 input_background: Optional[str] = None,
                 input_border: Optional[str] = None,
                 input_filled_text: Optional[str] = None,
                 input_labels_placeholders: Optional[str] = None,
                 links_focused_components: Optional[str] = None,
                 primary_button: Optional[str] = None,
                 primary_button_label: Optional[str] = None,
                 secondary_button_border: Optional[str] = None,
                 secondary_button_label: Optional[str] = None,
                 success: Optional[str] = None,
                 widget_background: Optional[str] = None,
                 widget_border: Optional[str] = None):
        """
        :param str base_focus_color: Base focus color. Defaults to `#635dff`.
        :param str base_hover_color: Base hover color. Defaults to `#000000`.
        :param str body_text: Body text. Defaults to `#1e212a`.
        :param str error: Error. Defaults to `#d03c38`.
        :param str header: Header. Defaults to `#1e212a`.
        :param str icons: Icons. Defaults to `#65676e`.
        :param str input_background: Input background. Defaults to `#ffffff`.
        :param str input_border: Input border. Defaults to `#c9cace`.
        :param str input_filled_text: Input filled text. Defaults to `#000000`.
        :param str input_labels_placeholders: Input labels & placeholders. Defaults to `#65676e`.
        :param str links_focused_components: Links & focused components. Defaults to `#635dff`.
        :param str primary_button: Primary button. Defaults to `#635dff`.
        :param str primary_button_label: Primary button label. Defaults to `#ffffff`.
        :param str secondary_button_border: Secondary button border. Defaults to `#c9cace`.
        :param str secondary_button_label: Secondary button label. Defaults to `#1e212a`.
        :param str success: Success. Defaults to `#13a688`.
        :param str widget_background: Widget background. Defaults to `#ffffff`.
        :param str widget_border: Widget border. Defaults to `#c9cace`.
        """
        if base_focus_color is not None:
            pulumi.set(__self__, "base_focus_color", base_focus_color)
        if base_hover_color is not None:
            pulumi.set(__self__, "base_hover_color", base_hover_color)
        if body_text is not None:
            pulumi.set(__self__, "body_text", body_text)
        if error is not None:
            pulumi.set(__self__, "error", error)
        if header is not None:
            pulumi.set(__self__, "header", header)
        if icons is not None:
            pulumi.set(__self__, "icons", icons)
        if input_background is not None:
            pulumi.set(__self__, "input_background", input_background)
        if input_border is not None:
            pulumi.set(__self__, "input_border", input_border)
        if input_filled_text is not None:
            pulumi.set(__self__, "input_filled_text", input_filled_text)
        if input_labels_placeholders is not None:
            pulumi.set(__self__, "input_labels_placeholders", input_labels_placeholders)
        if links_focused_components is not None:
            pulumi.set(__self__, "links_focused_components", links_focused_components)
        if primary_button is not None:
            pulumi.set(__self__, "primary_button", primary_button)
        if primary_button_label is not None:
            pulumi.set(__self__, "primary_button_label", primary_button_label)
        if secondary_button_border is not None:
            pulumi.set(__self__, "secondary_button_border", secondary_button_border)
        if secondary_button_label is not None:
            pulumi.set(__self__, "secondary_button_label", secondary_button_label)
        if success is not None:
            pulumi.set(__self__, "success", success)
        if widget_background is not None:
            pulumi.set(__self__, "widget_background", widget_background)
        if widget_border is not None:
            pulumi.set(__self__, "widget_border", widget_border)

    @property
    @pulumi.getter(name="baseFocusColor")
    def base_focus_color(self) -> Optional[str]:
        """
        Base focus color. Defaults to `#635dff`.
        """
        return pulumi.get(self, "base_focus_color")

    @property
    @pulumi.getter(name="baseHoverColor")
    def base_hover_color(self) -> Optional[str]:
        """
        Base hover color. Defaults to `#000000`.
        """
        return pulumi.get(self, "base_hover_color")

    @property
    @pulumi.getter(name="bodyText")
    def body_text(self) -> Optional[str]:
        """
        Body text. Defaults to `#1e212a`.
        """
        return pulumi.get(self, "body_text")

    @property
    @pulumi.getter
    def error(self) -> Optional[str]:
        """
        Error. Defaults to `#d03c38`.
        """
        return pulumi.get(self, "error")

    @property
    @pulumi.getter
    def header(self) -> Optional[str]:
        """
        Header. Defaults to `#1e212a`.
        """
        return pulumi.get(self, "header")

    @property
    @pulumi.getter
    def icons(self) -> Optional[str]:
        """
        Icons. Defaults to `#65676e`.
        """
        return pulumi.get(self, "icons")

    @property
    @pulumi.getter(name="inputBackground")
    def input_background(self) -> Optional[str]:
        """
        Input background. Defaults to `#ffffff`.
        """
        return pulumi.get(self, "input_background")

    @property
    @pulumi.getter(name="inputBorder")
    def input_border(self) -> Optional[str]:
        """
        Input border. Defaults to `#c9cace`.
        """
        return pulumi.get(self, "input_border")

    @property
    @pulumi.getter(name="inputFilledText")
    def input_filled_text(self) -> Optional[str]:
        """
        Input filled text. Defaults to `#000000`.
        """
        return pulumi.get(self, "input_filled_text")

    @property
    @pulumi.getter(name="inputLabelsPlaceholders")
    def input_labels_placeholders(self) -> Optional[str]:
        """
        Input labels & placeholders. Defaults to `#65676e`.
        """
        return pulumi.get(self, "input_labels_placeholders")

    @property
    @pulumi.getter(name="linksFocusedComponents")
    def links_focused_components(self) -> Optional[str]:
        """
        Links & focused components. Defaults to `#635dff`.
        """
        return pulumi.get(self, "links_focused_components")

    @property
    @pulumi.getter(name="primaryButton")
    def primary_button(self) -> Optional[str]:
        """
        Primary button. Defaults to `#635dff`.
        """
        return pulumi.get(self, "primary_button")

    @property
    @pulumi.getter(name="primaryButtonLabel")
    def primary_button_label(self) -> Optional[str]:
        """
        Primary button label. Defaults to `#ffffff`.
        """
        return pulumi.get(self, "primary_button_label")

    @property
    @pulumi.getter(name="secondaryButtonBorder")
    def secondary_button_border(self) -> Optional[str]:
        """
        Secondary button border. Defaults to `#c9cace`.
        """
        return pulumi.get(self, "secondary_button_border")

    @property
    @pulumi.getter(name="secondaryButtonLabel")
    def secondary_button_label(self) -> Optional[str]:
        """
        Secondary button label. Defaults to `#1e212a`.
        """
        return pulumi.get(self, "secondary_button_label")

    @property
    @pulumi.getter
    def success(self) -> Optional[str]:
        """
        Success. Defaults to `#13a688`.
        """
        return pulumi.get(self, "success")

    @property
    @pulumi.getter(name="widgetBackground")
    def widget_background(self) -> Optional[str]:
        """
        Widget background. Defaults to `#ffffff`.
        """
        return pulumi.get(self, "widget_background")

    @property
    @pulumi.getter(name="widgetBorder")
    def widget_border(self) -> Optional[str]:
        """
        Widget border. Defaults to `#c9cace`.
        """
        return pulumi.get(self, "widget_border")


@pulumi.output_type
class BrandingThemeFonts(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bodyText":
            suggest = "body_text"
        elif key == "buttonsText":
            suggest = "buttons_text"
        elif key == "inputLabels":
            suggest = "input_labels"
        elif key == "fontUrl":
            suggest = "font_url"
        elif key == "linksStyle":
            suggest = "links_style"
        elif key == "referenceTextSize":
            suggest = "reference_text_size"

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

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

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

    def __init__(__self__, *,
                 body_text: 'outputs.BrandingThemeFontsBodyText',
                 buttons_text: 'outputs.BrandingThemeFontsButtonsText',
                 input_labels: 'outputs.BrandingThemeFontsInputLabels',
                 links: 'outputs.BrandingThemeFontsLinks',
                 subtitle: 'outputs.BrandingThemeFontsSubtitle',
                 title: 'outputs.BrandingThemeFontsTitle',
                 font_url: Optional[str] = None,
                 links_style: Optional[str] = None,
                 reference_text_size: Optional[float] = None):
        """
        :param 'BrandingThemeFontsBodyTextArgs' body_text: Body text.
        :param 'BrandingThemeFontsButtonsTextArgs' buttons_text: Buttons text.
        :param 'BrandingThemeFontsInputLabelsArgs' input_labels: Input labels.
        :param 'BrandingThemeFontsLinksArgs' links: Links.
        :param 'BrandingThemeFontsSubtitleArgs' subtitle: Subtitle.
        :param 'BrandingThemeFontsTitleArgs' title: Title.
        :param str font_url: Font URL. Defaults to an empty string.
        :param str links_style: Links style. Defaults to `normal`.
        :param float reference_text_size: Reference text size. Value needs to be between `12` and `24`. Defaults to `16.0`.
        """
        pulumi.set(__self__, "body_text", body_text)
        pulumi.set(__self__, "buttons_text", buttons_text)
        pulumi.set(__self__, "input_labels", input_labels)
        pulumi.set(__self__, "links", links)
        pulumi.set(__self__, "subtitle", subtitle)
        pulumi.set(__self__, "title", title)
        if font_url is not None:
            pulumi.set(__self__, "font_url", font_url)
        if links_style is not None:
            pulumi.set(__self__, "links_style", links_style)
        if reference_text_size is not None:
            pulumi.set(__self__, "reference_text_size", reference_text_size)

    @property
    @pulumi.getter(name="bodyText")
    def body_text(self) -> 'outputs.BrandingThemeFontsBodyText':
        """
        Body text.
        """
        return pulumi.get(self, "body_text")

    @property
    @pulumi.getter(name="buttonsText")
    def buttons_text(self) -> 'outputs.BrandingThemeFontsButtonsText':
        """
        Buttons text.
        """
        return pulumi.get(self, "buttons_text")

    @property
    @pulumi.getter(name="inputLabels")
    def input_labels(self) -> 'outputs.BrandingThemeFontsInputLabels':
        """
        Input labels.
        """
        return pulumi.get(self, "input_labels")

    @property
    @pulumi.getter
    def links(self) -> 'outputs.BrandingThemeFontsLinks':
        """
        Links.
        """
        return pulumi.get(self, "links")

    @property
    @pulumi.getter
    def subtitle(self) -> 'outputs.BrandingThemeFontsSubtitle':
        """
        Subtitle.
        """
        return pulumi.get(self, "subtitle")

    @property
    @pulumi.getter
    def title(self) -> 'outputs.BrandingThemeFontsTitle':
        """
        Title.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter(name="fontUrl")
    def font_url(self) -> Optional[str]:
        """
        Font URL. Defaults to an empty string.
        """
        return pulumi.get(self, "font_url")

    @property
    @pulumi.getter(name="linksStyle")
    def links_style(self) -> Optional[str]:
        """
        Links style. Defaults to `normal`.
        """
        return pulumi.get(self, "links_style")

    @property
    @pulumi.getter(name="referenceTextSize")
    def reference_text_size(self) -> Optional[float]:
        """
        Reference text size. Value needs to be between `12` and `24`. Defaults to `16.0`.
        """
        return pulumi.get(self, "reference_text_size")


@pulumi.output_type
class BrandingThemeFontsBodyText(dict):
    def __init__(__self__, *,
                 bold: Optional[bool] = None,
                 size: Optional[float] = None):
        """
        :param bool bold: Body text bold. Defaults to `false`.
        :param float size: Body text size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        if bold is not None:
            pulumi.set(__self__, "bold", bold)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> Optional[bool]:
        """
        Body text bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> Optional[float]:
        """
        Body text size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class BrandingThemeFontsButtonsText(dict):
    def __init__(__self__, *,
                 bold: Optional[bool] = None,
                 size: Optional[float] = None):
        """
        :param bool bold: Buttons text bold. Defaults to `false`.
        :param float size: Buttons text size. Value needs to be between `0` and `150`. Defaults to `100.0`.
        """
        if bold is not None:
            pulumi.set(__self__, "bold", bold)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> Optional[bool]:
        """
        Buttons text bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> Optional[float]:
        """
        Buttons text size. Value needs to be between `0` and `150`. Defaults to `100.0`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class BrandingThemeFontsInputLabels(dict):
    def __init__(__self__, *,
                 bold: Optional[bool] = None,
                 size: Optional[float] = None):
        """
        :param bool bold: Input labels bold. Defaults to `false`.
        :param float size: Input labels size. Value needs to be between `0` and `150`. Defaults to `100.0`.
        """
        if bold is not None:
            pulumi.set(__self__, "bold", bold)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> Optional[bool]:
        """
        Input labels bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> Optional[float]:
        """
        Input labels size. Value needs to be between `0` and `150`. Defaults to `100.0`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class BrandingThemeFontsLinks(dict):
    def __init__(__self__, *,
                 bold: Optional[bool] = None,
                 size: Optional[float] = None):
        """
        :param bool bold: Links bold. Defaults to `true`.
        :param float size: Links size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        if bold is not None:
            pulumi.set(__self__, "bold", bold)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> Optional[bool]:
        """
        Links bold. Defaults to `true`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> Optional[float]:
        """
        Links size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class BrandingThemeFontsSubtitle(dict):
    def __init__(__self__, *,
                 bold: Optional[bool] = None,
                 size: Optional[float] = None):
        """
        :param bool bold: Subtitle bold. Defaults to `false`.
        :param float size: Subtitle size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        if bold is not None:
            pulumi.set(__self__, "bold", bold)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> Optional[bool]:
        """
        Subtitle bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> Optional[float]:
        """
        Subtitle size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class BrandingThemeFontsTitle(dict):
    def __init__(__self__, *,
                 bold: Optional[bool] = None,
                 size: Optional[float] = None):
        """
        :param bool bold: Title bold. Defaults to `false`.
        :param float size: Title size. Value needs to be between `75` and `150`. Defaults to `150.0`.
        """
        if bold is not None:
            pulumi.set(__self__, "bold", bold)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> Optional[bool]:
        """
        Title bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> Optional[float]:
        """
        Title size. Value needs to be between `75` and `150`. Defaults to `150.0`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class BrandingThemePageBackground(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backgroundColor":
            suggest = "background_color"
        elif key == "backgroundImageUrl":
            suggest = "background_image_url"
        elif key == "pageLayout":
            suggest = "page_layout"

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

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

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

    def __init__(__self__, *,
                 background_color: Optional[str] = None,
                 background_image_url: Optional[str] = None,
                 page_layout: Optional[str] = None):
        """
        :param str background_color: Background color. Defaults to `#000000`.
        :param str background_image_url: Background image url. Defaults to an empty string.
        :param str page_layout: Page layout. Available options: `center`, `left`, `right`. Defaults to `center`.
        """
        if background_color is not None:
            pulumi.set(__self__, "background_color", background_color)
        if background_image_url is not None:
            pulumi.set(__self__, "background_image_url", background_image_url)
        if page_layout is not None:
            pulumi.set(__self__, "page_layout", page_layout)

    @property
    @pulumi.getter(name="backgroundColor")
    def background_color(self) -> Optional[str]:
        """
        Background color. Defaults to `#000000`.
        """
        return pulumi.get(self, "background_color")

    @property
    @pulumi.getter(name="backgroundImageUrl")
    def background_image_url(self) -> Optional[str]:
        """
        Background image url. Defaults to an empty string.
        """
        return pulumi.get(self, "background_image_url")

    @property
    @pulumi.getter(name="pageLayout")
    def page_layout(self) -> Optional[str]:
        """
        Page layout. Available options: `center`, `left`, `right`. Defaults to `center`.
        """
        return pulumi.get(self, "page_layout")


@pulumi.output_type
class BrandingThemeWidget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerTextAlignment":
            suggest = "header_text_alignment"
        elif key == "logoHeight":
            suggest = "logo_height"
        elif key == "logoPosition":
            suggest = "logo_position"
        elif key == "logoUrl":
            suggest = "logo_url"
        elif key == "socialButtonsLayout":
            suggest = "social_buttons_layout"

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

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

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

    def __init__(__self__, *,
                 header_text_alignment: Optional[str] = None,
                 logo_height: Optional[float] = None,
                 logo_position: Optional[str] = None,
                 logo_url: Optional[str] = None,
                 social_buttons_layout: Optional[str] = None):
        """
        :param str header_text_alignment: Header text alignment. Available options: `center`, `left`, `right`. Defaults to `center`.
        :param float logo_height: Logo height. Value needs to be between `1` and `100`. Defaults to `52.0`.
        :param str logo_position: Logo position. Available options: `center`, `left`, `right`, `none`. Defaults to `center`.
        :param str logo_url: Logo url. Defaults to an empty string.
        :param str social_buttons_layout: Social buttons layout. Available options: `bottom`, `top`. Defaults to `bottom`.
        """
        if header_text_alignment is not None:
            pulumi.set(__self__, "header_text_alignment", header_text_alignment)
        if logo_height is not None:
            pulumi.set(__self__, "logo_height", logo_height)
        if logo_position is not None:
            pulumi.set(__self__, "logo_position", logo_position)
        if logo_url is not None:
            pulumi.set(__self__, "logo_url", logo_url)
        if social_buttons_layout is not None:
            pulumi.set(__self__, "social_buttons_layout", social_buttons_layout)

    @property
    @pulumi.getter(name="headerTextAlignment")
    def header_text_alignment(self) -> Optional[str]:
        """
        Header text alignment. Available options: `center`, `left`, `right`. Defaults to `center`.
        """
        return pulumi.get(self, "header_text_alignment")

    @property
    @pulumi.getter(name="logoHeight")
    def logo_height(self) -> Optional[float]:
        """
        Logo height. Value needs to be between `1` and `100`. Defaults to `52.0`.
        """
        return pulumi.get(self, "logo_height")

    @property
    @pulumi.getter(name="logoPosition")
    def logo_position(self) -> Optional[str]:
        """
        Logo position. Available options: `center`, `left`, `right`, `none`. Defaults to `center`.
        """
        return pulumi.get(self, "logo_position")

    @property
    @pulumi.getter(name="logoUrl")
    def logo_url(self) -> Optional[str]:
        """
        Logo url. Defaults to an empty string.
        """
        return pulumi.get(self, "logo_url")

    @property
    @pulumi.getter(name="socialButtonsLayout")
    def social_buttons_layout(self) -> Optional[str]:
        """
        Social buttons layout. Available options: `bottom`, `top`. Defaults to `bottom`.
        """
        return pulumi.get(self, "social_buttons_layout")


@pulumi.output_type
class BrandingUniversalLogin(dict):
    def __init__(__self__, *,
                 body: str):
        """
        :param str body: The html template for the New Universal Login Experience.
        """
        pulumi.set(__self__, "body", body)

    @property
    @pulumi.getter
    def body(self) -> str:
        """
        The html template for the New Universal Login Experience.
        """
        return pulumi.get(self, "body")


@pulumi.output_type
class ClientAddons(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "azureBlob":
            suggest = "azure_blob"
        elif key == "azureSb":
            suggest = "azure_sb"
        elif key == "salesforceApi":
            suggest = "salesforce_api"
        elif key == "salesforceSandboxApi":
            suggest = "salesforce_sandbox_api"
        elif key == "sapApi":
            suggest = "sap_api"
        elif key == "ssoIntegration":
            suggest = "sso_integration"

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

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

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

    def __init__(__self__, *,
                 aws: Optional['outputs.ClientAddonsAws'] = None,
                 azure_blob: Optional['outputs.ClientAddonsAzureBlob'] = None,
                 azure_sb: Optional['outputs.ClientAddonsAzureSb'] = None,
                 box: Optional['outputs.ClientAddonsBox'] = None,
                 cloudbees: Optional['outputs.ClientAddonsCloudbees'] = None,
                 concur: Optional['outputs.ClientAddonsConcur'] = None,
                 dropbox: Optional['outputs.ClientAddonsDropbox'] = None,
                 echosign: Optional['outputs.ClientAddonsEchosign'] = None,
                 egnyte: Optional['outputs.ClientAddonsEgnyte'] = None,
                 firebase: Optional['outputs.ClientAddonsFirebase'] = None,
                 layer: Optional['outputs.ClientAddonsLayer'] = None,
                 mscrm: Optional['outputs.ClientAddonsMscrm'] = None,
                 newrelic: Optional['outputs.ClientAddonsNewrelic'] = None,
                 office365: Optional['outputs.ClientAddonsOffice365'] = None,
                 rms: Optional['outputs.ClientAddonsRms'] = None,
                 salesforce: Optional['outputs.ClientAddonsSalesforce'] = None,
                 salesforce_api: Optional['outputs.ClientAddonsSalesforceApi'] = None,
                 salesforce_sandbox_api: Optional['outputs.ClientAddonsSalesforceSandboxApi'] = None,
                 samlp: Optional['outputs.ClientAddonsSamlp'] = None,
                 sap_api: Optional['outputs.ClientAddonsSapApi'] = None,
                 sentry: Optional['outputs.ClientAddonsSentry'] = None,
                 sharepoint: Optional['outputs.ClientAddonsSharepoint'] = None,
                 slack: Optional['outputs.ClientAddonsSlack'] = None,
                 springcm: Optional['outputs.ClientAddonsSpringcm'] = None,
                 sso_integration: Optional['outputs.ClientAddonsSsoIntegration'] = None,
                 wams: Optional['outputs.ClientAddonsWams'] = None,
                 wsfed: Optional['outputs.ClientAddonsWsfed'] = None,
                 zendesk: Optional['outputs.ClientAddonsZendesk'] = None,
                 zoom: Optional['outputs.ClientAddonsZoom'] = None):
        """
        :param 'ClientAddonsAwsArgs' aws: AWS Addon configuration.
        :param 'ClientAddonsAzureBlobArgs' azure_blob: Azure Blob Storage Addon configuration.
        :param 'ClientAddonsAzureSbArgs' azure_sb: Azure Storage Bus Addon configuration.
        :param 'ClientAddonsBoxArgs' box: Box SSO indicator (no configuration settings needed for Box SSO).
        :param 'ClientAddonsCloudbeesArgs' cloudbees: CloudBees SSO indicator (no configuration settings needed for CloudBees SSO).
        :param 'ClientAddonsConcurArgs' concur: Concur SSO indicator (no configuration settings needed for Concur SSO).
        :param 'ClientAddonsDropboxArgs' dropbox: Dropbox SSO indicator (no configuration settings needed for Dropbox SSO).
        :param 'ClientAddonsEchosignArgs' echosign: Adobe EchoSign SSO configuration.
        :param 'ClientAddonsEgnyteArgs' egnyte: Egnyte SSO configuration.
        :param 'ClientAddonsFirebaseArgs' firebase: Google Firebase addon configuration.
        :param 'ClientAddonsLayerArgs' layer: Layer addon configuration.
        :param 'ClientAddonsMscrmArgs' mscrm: Microsoft Dynamics CRM SSO configuration.
        :param 'ClientAddonsNewrelicArgs' newrelic: New Relic SSO configuration.
        :param 'ClientAddonsOffice365Args' office365: Microsoft Office 365 SSO configuration.
        :param 'ClientAddonsRmsArgs' rms: Active Directory Rights Management Service SSO configuration.
        :param 'ClientAddonsSalesforceArgs' salesforce: Salesforce SSO configuration.
        :param 'ClientAddonsSalesforceApiArgs' salesforce_api: Salesforce API addon configuration.
        :param 'ClientAddonsSalesforceSandboxApiArgs' salesforce_sandbox_api: Salesforce Sandbox addon configuration.
        :param 'ClientAddonsSamlpArgs' samlp: Configuration settings for a SAML add-on.
        :param 'ClientAddonsSapApiArgs' sap_api: SAP API addon configuration.
        :param 'ClientAddonsSentryArgs' sentry: Sentry SSO configuration.
        :param 'ClientAddonsSharepointArgs' sharepoint: SharePoint SSO configuration.
        :param 'ClientAddonsSlackArgs' slack: Slack team or workspace name usually first segment in your Slack URL, for example `https://acme-org.slack.com` would be `acme-org`.
        :param 'ClientAddonsSpringcmArgs' springcm: SpringCM SSO configuration.
        :param 'ClientAddonsSsoIntegrationArgs' sso_integration: Generic SSO configuration.
        :param 'ClientAddonsWamsArgs' wams: Windows Azure Mobile Services addon configuration.
        :param 'ClientAddonsWsfedArgs' wsfed: WS-Fed (WIF) addon indicator. Actual configuration is stored in `callback` and `client_aliases` properties on the client.
        :param 'ClientAddonsZendeskArgs' zendesk: Zendesk SSO configuration.
        :param 'ClientAddonsZoomArgs' zoom: Zoom SSO configuration.
        """
        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 sso_integration is not None:
            pulumi.set(__self__, "sso_integration", sso_integration)
        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['outputs.ClientAddonsAws']:
        """
        AWS Addon configuration.
        """
        return pulumi.get(self, "aws")

    @property
    @pulumi.getter(name="azureBlob")
    def azure_blob(self) -> Optional['outputs.ClientAddonsAzureBlob']:
        """
        Azure Blob Storage Addon configuration.
        """
        return pulumi.get(self, "azure_blob")

    @property
    @pulumi.getter(name="azureSb")
    def azure_sb(self) -> Optional['outputs.ClientAddonsAzureSb']:
        """
        Azure Storage Bus Addon configuration.
        """
        return pulumi.get(self, "azure_sb")

    @property
    @pulumi.getter
    def box(self) -> Optional['outputs.ClientAddonsBox']:
        """
        Box SSO indicator (no configuration settings needed for Box SSO).
        """
        return pulumi.get(self, "box")

    @property
    @pulumi.getter
    def cloudbees(self) -> Optional['outputs.ClientAddonsCloudbees']:
        """
        CloudBees SSO indicator (no configuration settings needed for CloudBees SSO).
        """
        return pulumi.get(self, "cloudbees")

    @property
    @pulumi.getter
    def concur(self) -> Optional['outputs.ClientAddonsConcur']:
        """
        Concur SSO indicator (no configuration settings needed for Concur SSO).
        """
        return pulumi.get(self, "concur")

    @property
    @pulumi.getter
    def dropbox(self) -> Optional['outputs.ClientAddonsDropbox']:
        """
        Dropbox SSO indicator (no configuration settings needed for Dropbox SSO).
        """
        return pulumi.get(self, "dropbox")

    @property
    @pulumi.getter
    def echosign(self) -> Optional['outputs.ClientAddonsEchosign']:
        """
        Adobe EchoSign SSO configuration.
        """
        return pulumi.get(self, "echosign")

    @property
    @pulumi.getter
    def egnyte(self) -> Optional['outputs.ClientAddonsEgnyte']:
        """
        Egnyte SSO configuration.
        """
        return pulumi.get(self, "egnyte")

    @property
    @pulumi.getter
    def firebase(self) -> Optional['outputs.ClientAddonsFirebase']:
        """
        Google Firebase addon configuration.
        """
        return pulumi.get(self, "firebase")

    @property
    @pulumi.getter
    def layer(self) -> Optional['outputs.ClientAddonsLayer']:
        """
        Layer addon configuration.
        """
        return pulumi.get(self, "layer")

    @property
    @pulumi.getter
    def mscrm(self) -> Optional['outputs.ClientAddonsMscrm']:
        """
        Microsoft Dynamics CRM SSO configuration.
        """
        return pulumi.get(self, "mscrm")

    @property
    @pulumi.getter
    def newrelic(self) -> Optional['outputs.ClientAddonsNewrelic']:
        """
        New Relic SSO configuration.
        """
        return pulumi.get(self, "newrelic")

    @property
    @pulumi.getter
    def office365(self) -> Optional['outputs.ClientAddonsOffice365']:
        """
        Microsoft Office 365 SSO configuration.
        """
        return pulumi.get(self, "office365")

    @property
    @pulumi.getter
    def rms(self) -> Optional['outputs.ClientAddonsRms']:
        """
        Active Directory Rights Management Service SSO configuration.
        """
        return pulumi.get(self, "rms")

    @property
    @pulumi.getter
    def salesforce(self) -> Optional['outputs.ClientAddonsSalesforce']:
        """
        Salesforce SSO configuration.
        """
        return pulumi.get(self, "salesforce")

    @property
    @pulumi.getter(name="salesforceApi")
    def salesforce_api(self) -> Optional['outputs.ClientAddonsSalesforceApi']:
        """
        Salesforce API addon configuration.
        """
        return pulumi.get(self, "salesforce_api")

    @property
    @pulumi.getter(name="salesforceSandboxApi")
    def salesforce_sandbox_api(self) -> Optional['outputs.ClientAddonsSalesforceSandboxApi']:
        """
        Salesforce Sandbox addon configuration.
        """
        return pulumi.get(self, "salesforce_sandbox_api")

    @property
    @pulumi.getter
    def samlp(self) -> Optional['outputs.ClientAddonsSamlp']:
        """
        Configuration settings for a SAML add-on.
        """
        return pulumi.get(self, "samlp")

    @property
    @pulumi.getter(name="sapApi")
    def sap_api(self) -> Optional['outputs.ClientAddonsSapApi']:
        """
        SAP API addon configuration.
        """
        return pulumi.get(self, "sap_api")

    @property
    @pulumi.getter
    def sentry(self) -> Optional['outputs.ClientAddonsSentry']:
        """
        Sentry SSO configuration.
        """
        return pulumi.get(self, "sentry")

    @property
    @pulumi.getter
    def sharepoint(self) -> Optional['outputs.ClientAddonsSharepoint']:
        """
        SharePoint SSO configuration.
        """
        return pulumi.get(self, "sharepoint")

    @property
    @pulumi.getter
    def slack(self) -> Optional['outputs.ClientAddonsSlack']:
        """
        Slack team or workspace name usually first segment in your Slack URL, for example `https://acme-org.slack.com` would be `acme-org`.
        """
        return pulumi.get(self, "slack")

    @property
    @pulumi.getter
    def springcm(self) -> Optional['outputs.ClientAddonsSpringcm']:
        """
        SpringCM SSO configuration.
        """
        return pulumi.get(self, "springcm")

    @property
    @pulumi.getter(name="ssoIntegration")
    def sso_integration(self) -> Optional['outputs.ClientAddonsSsoIntegration']:
        """
        Generic SSO configuration.
        """
        return pulumi.get(self, "sso_integration")

    @property
    @pulumi.getter
    def wams(self) -> Optional['outputs.ClientAddonsWams']:
        """
        Windows Azure Mobile Services addon configuration.
        """
        return pulumi.get(self, "wams")

    @property
    @pulumi.getter
    def wsfed(self) -> Optional['outputs.ClientAddonsWsfed']:
        """
        WS-Fed (WIF) addon indicator. Actual configuration is stored in `callback` and `client_aliases` properties on the client.
        """
        return pulumi.get(self, "wsfed")

    @property
    @pulumi.getter
    def zendesk(self) -> Optional['outputs.ClientAddonsZendesk']:
        """
        Zendesk SSO configuration.
        """
        return pulumi.get(self, "zendesk")

    @property
    @pulumi.getter
    def zoom(self) -> Optional['outputs.ClientAddonsZoom']:
        """
        Zoom SSO configuration.
        """
        return pulumi.get(self, "zoom")


@pulumi.output_type
class ClientAddonsAws(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lifetimeInSeconds":
            suggest = "lifetime_in_seconds"

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

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

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

    def __init__(__self__, *,
                 lifetime_in_seconds: Optional[int] = None,
                 principal: Optional[str] = None,
                 role: Optional[str] = None):
        """
        :param int lifetime_in_seconds: AWS token lifetime in seconds.
        :param str principal: AWS principal ARN, for example `arn:aws:iam::010616021751:saml-provider/idpname`.
        :param str role: AWS role ARN, for example `arn:aws:iam::010616021751:role/foo`.
        """
        if lifetime_in_seconds is not None:
            pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        if principal is not None:
            pulumi.set(__self__, "principal", principal)
        if role is not None:
            pulumi.set(__self__, "role", role)

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

    @property
    @pulumi.getter
    def principal(self) -> Optional[str]:
        """
        AWS principal ARN, for example `arn:aws:iam::010616021751:saml-provider/idpname`.
        """
        return pulumi.get(self, "principal")

    @property
    @pulumi.getter
    def role(self) -> Optional[str]:
        """
        AWS role ARN, for example `arn:aws:iam::010616021751:role/foo`.
        """
        return pulumi.get(self, "role")


@pulumi.output_type
class ClientAddonsAzureBlob(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountName":
            suggest = "account_name"
        elif key == "blobDelete":
            suggest = "blob_delete"
        elif key == "blobName":
            suggest = "blob_name"
        elif key == "blobRead":
            suggest = "blob_read"
        elif key == "blobWrite":
            suggest = "blob_write"
        elif key == "containerDelete":
            suggest = "container_delete"
        elif key == "containerList":
            suggest = "container_list"
        elif key == "containerName":
            suggest = "container_name"
        elif key == "containerRead":
            suggest = "container_read"
        elif key == "containerWrite":
            suggest = "container_write"
        elif key == "signedIdentifier":
            suggest = "signed_identifier"
        elif key == "storageAccessKey":
            suggest = "storage_access_key"

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

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

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

    def __init__(__self__, *,
                 account_name: Optional[str] = None,
                 blob_delete: Optional[bool] = None,
                 blob_name: Optional[str] = None,
                 blob_read: Optional[bool] = None,
                 blob_write: Optional[bool] = None,
                 container_delete: Optional[bool] = None,
                 container_list: Optional[bool] = None,
                 container_name: Optional[str] = None,
                 container_read: Optional[bool] = None,
                 container_write: Optional[bool] = None,
                 expiration: Optional[int] = None,
                 signed_identifier: Optional[str] = None,
                 storage_access_key: Optional[str] = None):
        """
        :param str account_name: Your Azure storage account name. Usually first segment in your Azure storage URL, for example `https://acme-org.blob.core.windows.net` would be the account name `acme-org`.
        :param bool blob_delete: Indicates if the issued token has permission to delete the blob.
        :param str blob_name: Entity to request a token for, such as `my-blob`. If blank the computed SAS will apply to the entire storage container.
        :param bool blob_read: Indicates if the issued token has permission to read the content, properties, metadata and block list. Use the blob as the source of a copy operation.
        :param bool blob_write: Indicates if the issued token has permission to create or write content, properties, metadata, or block list. Snapshot or lease the blob. Resize the blob (page blob only). Use the blob as the destination of a copy operation within the same account.
        :param bool container_delete: Indicates if issued token has permission to delete any blob in the container.
        :param bool container_list: Indicates if the issued token has permission to list blobs in the container.
        :param str container_name: Container to request a token for, such as `my-container`.
        :param bool container_read: Indicates if the issued token has permission to read the content, properties, metadata or block list of any blob in the container. Use any blob in the container as the source of a copy operation.
        :param bool container_write: Indicates that for any blob in the container if the issued token has permission to create or write content, properties, metadata, or block list. Snapshot or lease the blob. Resize the blob (page blob only). Use the blob as the destination of a copy operation within the same account.
        :param int expiration: Expiration in minutes for the generated token (default of 5 minutes).
        :param str signed_identifier: Shared access policy identifier defined in your storage account resource.
        :param str storage_access_key: Access key associated with this storage account.
        """
        if account_name is not None:
            pulumi.set(__self__, "account_name", account_name)
        if blob_delete is not None:
            pulumi.set(__self__, "blob_delete", blob_delete)
        if blob_name is not None:
            pulumi.set(__self__, "blob_name", blob_name)
        if blob_read is not None:
            pulumi.set(__self__, "blob_read", blob_read)
        if blob_write is not None:
            pulumi.set(__self__, "blob_write", blob_write)
        if container_delete is not None:
            pulumi.set(__self__, "container_delete", container_delete)
        if container_list is not None:
            pulumi.set(__self__, "container_list", container_list)
        if container_name is not None:
            pulumi.set(__self__, "container_name", container_name)
        if container_read is not None:
            pulumi.set(__self__, "container_read", container_read)
        if container_write is not None:
            pulumi.set(__self__, "container_write", container_write)
        if expiration is not None:
            pulumi.set(__self__, "expiration", expiration)
        if signed_identifier is not None:
            pulumi.set(__self__, "signed_identifier", signed_identifier)
        if storage_access_key is not None:
            pulumi.set(__self__, "storage_access_key", storage_access_key)

    @property
    @pulumi.getter(name="accountName")
    def account_name(self) -> Optional[str]:
        """
        Your Azure storage account name. Usually first segment in your Azure storage URL, for example `https://acme-org.blob.core.windows.net` would be the account name `acme-org`.
        """
        return pulumi.get(self, "account_name")

    @property
    @pulumi.getter(name="blobDelete")
    def blob_delete(self) -> Optional[bool]:
        """
        Indicates if the issued token has permission to delete the blob.
        """
        return pulumi.get(self, "blob_delete")

    @property
    @pulumi.getter(name="blobName")
    def blob_name(self) -> Optional[str]:
        """
        Entity to request a token for, such as `my-blob`. If blank the computed SAS will apply to the entire storage container.
        """
        return pulumi.get(self, "blob_name")

    @property
    @pulumi.getter(name="blobRead")
    def blob_read(self) -> Optional[bool]:
        """
        Indicates if the issued token has permission to read the content, properties, metadata and block list. Use the blob as the source of a copy operation.
        """
        return pulumi.get(self, "blob_read")

    @property
    @pulumi.getter(name="blobWrite")
    def blob_write(self) -> Optional[bool]:
        """
        Indicates if the issued token has permission to create or write content, properties, metadata, or block list. Snapshot or lease the blob. Resize the blob (page blob only). Use the blob as the destination of a copy operation within the same account.
        """
        return pulumi.get(self, "blob_write")

    @property
    @pulumi.getter(name="containerDelete")
    def container_delete(self) -> Optional[bool]:
        """
        Indicates if issued token has permission to delete any blob in the container.
        """
        return pulumi.get(self, "container_delete")

    @property
    @pulumi.getter(name="containerList")
    def container_list(self) -> Optional[bool]:
        """
        Indicates if the issued token has permission to list blobs in the container.
        """
        return pulumi.get(self, "container_list")

    @property
    @pulumi.getter(name="containerName")
    def container_name(self) -> Optional[str]:
        """
        Container to request a token for, such as `my-container`.
        """
        return pulumi.get(self, "container_name")

    @property
    @pulumi.getter(name="containerRead")
    def container_read(self) -> Optional[bool]:
        """
        Indicates if the issued token has permission to read the content, properties, metadata or block list of any blob in the container. Use any blob in the container as the source of a copy operation.
        """
        return pulumi.get(self, "container_read")

    @property
    @pulumi.getter(name="containerWrite")
    def container_write(self) -> Optional[bool]:
        """
        Indicates that for any blob in the container if the issued token has permission to create or write content, properties, metadata, or block list. Snapshot or lease the blob. Resize the blob (page blob only). Use the blob as the destination of a copy operation within the same account.
        """
        return pulumi.get(self, "container_write")

    @property
    @pulumi.getter
    def expiration(self) -> Optional[int]:
        """
        Expiration in minutes for the generated token (default of 5 minutes).
        """
        return pulumi.get(self, "expiration")

    @property
    @pulumi.getter(name="signedIdentifier")
    def signed_identifier(self) -> Optional[str]:
        """
        Shared access policy identifier defined in your storage account resource.
        """
        return pulumi.get(self, "signed_identifier")

    @property
    @pulumi.getter(name="storageAccessKey")
    def storage_access_key(self) -> Optional[str]:
        """
        Access key associated with this storage account.
        """
        return pulumi.get(self, "storage_access_key")


@pulumi.output_type
class ClientAddonsAzureSb(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "entityPath":
            suggest = "entity_path"
        elif key == "sasKey":
            suggest = "sas_key"
        elif key == "sasKeyName":
            suggest = "sas_key_name"

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

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

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

    def __init__(__self__, *,
                 entity_path: Optional[str] = None,
                 expiration: Optional[int] = None,
                 namespace: Optional[str] = None,
                 sas_key: Optional[str] = None,
                 sas_key_name: Optional[str] = None):
        """
        :param str entity_path: Entity you want to request a token for, such as `my-queue`.
        :param int expiration: Optional expiration in minutes for the generated token. Defaults to 5 minutes.
        :param str namespace: Your Azure Service Bus namespace. Usually the first segment of your Service Bus URL (for example `https://acme-org.servicebus.windows.net` would be `acme-org`).
        :param str sas_key: Primary Key associated with your shared access policy.
        :param str sas_key_name: Your shared access policy name defined in your Service Bus entity.
        """
        if entity_path is not None:
            pulumi.set(__self__, "entity_path", entity_path)
        if expiration is not None:
            pulumi.set(__self__, "expiration", expiration)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if sas_key is not None:
            pulumi.set(__self__, "sas_key", sas_key)
        if sas_key_name is not None:
            pulumi.set(__self__, "sas_key_name", sas_key_name)

    @property
    @pulumi.getter(name="entityPath")
    def entity_path(self) -> Optional[str]:
        """
        Entity you want to request a token for, such as `my-queue`.
        """
        return pulumi.get(self, "entity_path")

    @property
    @pulumi.getter
    def expiration(self) -> Optional[int]:
        """
        Optional expiration in minutes for the generated token. Defaults to 5 minutes.
        """
        return pulumi.get(self, "expiration")

    @property
    @pulumi.getter
    def namespace(self) -> Optional[str]:
        """
        Your Azure Service Bus namespace. Usually the first segment of your Service Bus URL (for example `https://acme-org.servicebus.windows.net` would be `acme-org`).
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="sasKey")
    def sas_key(self) -> Optional[str]:
        """
        Primary Key associated with your shared access policy.
        """
        return pulumi.get(self, "sas_key")

    @property
    @pulumi.getter(name="sasKeyName")
    def sas_key_name(self) -> Optional[str]:
        """
        Your shared access policy name defined in your Service Bus entity.
        """
        return pulumi.get(self, "sas_key_name")


@pulumi.output_type
class ClientAddonsBox(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class ClientAddonsCloudbees(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class ClientAddonsConcur(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class ClientAddonsDropbox(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class ClientAddonsEchosign(dict):
    def __init__(__self__, *,
                 domain: Optional[str] = None):
        """
        :param str domain: Your custom domain found in your EchoSign URL, for example `https://acme-org.echosign.com` would be `acme-org`.
        """
        if domain is not None:
            pulumi.set(__self__, "domain", domain)

    @property
    @pulumi.getter
    def domain(self) -> Optional[str]:
        """
        Your custom domain found in your EchoSign URL, for example `https://acme-org.echosign.com` would be `acme-org`.
        """
        return pulumi.get(self, "domain")


@pulumi.output_type
class ClientAddonsEgnyte(dict):
    def __init__(__self__, *,
                 domain: Optional[str] = None):
        """
        :param str domain: Your custom domain found in your Egnyte URL, for example `https://acme-org.echosign.com` would be `acme-org`.
        """
        if domain is not None:
            pulumi.set(__self__, "domain", domain)

    @property
    @pulumi.getter
    def domain(self) -> Optional[str]:
        """
        Your custom domain found in your Egnyte URL, for example `https://acme-org.echosign.com` would be `acme-org`.
        """
        return pulumi.get(self, "domain")


@pulumi.output_type
class ClientAddonsFirebase(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientEmail":
            suggest = "client_email"
        elif key == "lifetimeInSeconds":
            suggest = "lifetime_in_seconds"
        elif key == "privateKey":
            suggest = "private_key"
        elif key == "privateKeyId":
            suggest = "private_key_id"

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

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

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

    def __init__(__self__, *,
                 client_email: Optional[str] = None,
                 lifetime_in_seconds: Optional[int] = None,
                 private_key: Optional[str] = None,
                 private_key_id: Optional[str] = None,
                 secret: Optional[str] = None):
        """
        :param str client_email: ID of the Service Account you have created (shown as `client_email` in the generated JSON file, SDK v3+ tokens only).
        :param int lifetime_in_seconds: Optional expiration in seconds for the generated token. Defaults to 3600 seconds (SDK v3+ tokens only).
        :param str private_key: Private Key for signing the token (SDK v3+ tokens only).
        :param str private_key_id: Optional ID of the private key to obtain the `kid` header claim from the issued token (SDK v3+ tokens only).
        :param str secret: Google Firebase Secret. (SDK v2 only).
        """
        if client_email is not None:
            pulumi.set(__self__, "client_email", client_email)
        if lifetime_in_seconds is not None:
            pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        if private_key is not None:
            pulumi.set(__self__, "private_key", private_key)
        if private_key_id is not None:
            pulumi.set(__self__, "private_key_id", private_key_id)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter(name="clientEmail")
    def client_email(self) -> Optional[str]:
        """
        ID of the Service Account you have created (shown as `client_email` in the generated JSON file, SDK v3+ tokens only).
        """
        return pulumi.get(self, "client_email")

    @property
    @pulumi.getter(name="lifetimeInSeconds")
    def lifetime_in_seconds(self) -> Optional[int]:
        """
        Optional expiration in seconds for the generated token. Defaults to 3600 seconds (SDK v3+ tokens only).
        """
        return pulumi.get(self, "lifetime_in_seconds")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> Optional[str]:
        """
        Private Key for signing the token (SDK v3+ tokens only).
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="privateKeyId")
    def private_key_id(self) -> Optional[str]:
        """
        Optional ID of the private key to obtain the `kid` header claim from the issued token (SDK v3+ tokens only).
        """
        return pulumi.get(self, "private_key_id")

    @property
    @pulumi.getter
    def secret(self) -> Optional[str]:
        """
        Google Firebase Secret. (SDK v2 only).
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class ClientAddonsLayer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyId":
            suggest = "key_id"
        elif key == "privateKey":
            suggest = "private_key"
        elif key == "providerId":
            suggest = "provider_id"

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

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

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

    def __init__(__self__, *,
                 key_id: str,
                 private_key: str,
                 provider_id: str,
                 expiration: Optional[int] = None,
                 principal: Optional[str] = None):
        """
        :param str key_id: Authentication Key identifier used to sign the Layer token.
        :param str private_key: Private key for signing the Layer token.
        :param str provider_id: Provider ID of your Layer account.
        :param int expiration: Optional expiration in minutes for the generated token. Defaults to 5 minutes.
        :param str principal: Name of the property used as the unique user ID in Layer. If not specified `user_id` is used.
        """
        pulumi.set(__self__, "key_id", key_id)
        pulumi.set(__self__, "private_key", private_key)
        pulumi.set(__self__, "provider_id", provider_id)
        if expiration is not None:
            pulumi.set(__self__, "expiration", expiration)
        if principal is not None:
            pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter(name="keyId")
    def key_id(self) -> str:
        """
        Authentication Key identifier used to sign the Layer token.
        """
        return pulumi.get(self, "key_id")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        Private key for signing the Layer token.
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="providerId")
    def provider_id(self) -> str:
        """
        Provider ID of your Layer account.
        """
        return pulumi.get(self, "provider_id")

    @property
    @pulumi.getter
    def expiration(self) -> Optional[int]:
        """
        Optional expiration in minutes for the generated token. Defaults to 5 minutes.
        """
        return pulumi.get(self, "expiration")

    @property
    @pulumi.getter
    def principal(self) -> Optional[str]:
        """
        Name of the property used as the unique user ID in Layer. If not specified `user_id` is used.
        """
        return pulumi.get(self, "principal")


@pulumi.output_type
class ClientAddonsMscrm(dict):
    def __init__(__self__, *,
                 url: Optional[str] = None):
        """
        :param str url: Microsoft Dynamics CRM application URL.
        """
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        """
        Microsoft Dynamics CRM application URL.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class ClientAddonsNewrelic(dict):
    def __init__(__self__, *,
                 account: Optional[str] = None):
        """
        :param str account: Your New Relic Account ID found in your New Relic URL after the `/accounts/` path, for example `https://rpm.newrelic.com/accounts/123456/query` would be `123456`.
        """
        if account is not None:
            pulumi.set(__self__, "account", account)

    @property
    @pulumi.getter
    def account(self) -> Optional[str]:
        """
        Your New Relic Account ID found in your New Relic URL after the `/accounts/` path, for example `https://rpm.newrelic.com/accounts/123456/query` would be `123456`.
        """
        return pulumi.get(self, "account")


@pulumi.output_type
class ClientAddonsOffice365(dict):
    def __init__(__self__, *,
                 connection: Optional[str] = None,
                 domain: Optional[str] = None):
        """
        :param str connection: Optional Auth0 database connection for testing an already-configured Office 365 tenant.
        :param str domain: Your Office 365 domain name, for example `acme-org.com`.
        """
        if connection is not None:
            pulumi.set(__self__, "connection", connection)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)

    @property
    @pulumi.getter
    def connection(self) -> Optional[str]:
        """
        Optional Auth0 database connection for testing an already-configured Office 365 tenant.
        """
        return pulumi.get(self, "connection")

    @property
    @pulumi.getter
    def domain(self) -> Optional[str]:
        """
        Your Office 365 domain name, for example `acme-org.com`.
        """
        return pulumi.get(self, "domain")


@pulumi.output_type
class ClientAddonsRms(dict):
    def __init__(__self__, *,
                 url: Optional[str] = None):
        """
        :param str url: URL of your Rights Management Server. It can be internal or external, but users will have to be able to reach it.
        """
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        """
        URL of your Rights Management Server. It can be internal or external, but users will have to be able to reach it.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class ClientAddonsSalesforce(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "entityId":
            suggest = "entity_id"

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

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

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

    def __init__(__self__, *,
                 entity_id: Optional[str] = None):
        """
        :param str entity_id: Arbitrary logical URL that identifies the Saleforce resource, for example `https://acme-org.com`.
        """
        if entity_id is not None:
            pulumi.set(__self__, "entity_id", entity_id)

    @property
    @pulumi.getter(name="entityId")
    def entity_id(self) -> Optional[str]:
        """
        Arbitrary logical URL that identifies the Saleforce resource, for example `https://acme-org.com`.
        """
        return pulumi.get(self, "entity_id")


@pulumi.output_type
class ClientAddonsSalesforceApi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "communityName":
            suggest = "community_name"
        elif key == "communityUrlSection":
            suggest = "community_url_section"

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

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

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

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 community_name: Optional[str] = None,
                 community_url_section: Optional[str] = None,
                 principal: Optional[str] = None):
        """
        :param str client_id: Consumer Key assigned by Salesforce to the Connected App.
        :param str community_name: Community name.
        :param str community_url_section: Community URL section.
        :param str principal: Name of the property in the user object that maps to a Salesforce username, for example `email`.
        """
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if community_name is not None:
            pulumi.set(__self__, "community_name", community_name)
        if community_url_section is not None:
            pulumi.set(__self__, "community_url_section", community_url_section)
        if principal is not None:
            pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        Consumer Key assigned by Salesforce to the Connected App.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="communityName")
    def community_name(self) -> Optional[str]:
        """
        Community name.
        """
        return pulumi.get(self, "community_name")

    @property
    @pulumi.getter(name="communityUrlSection")
    def community_url_section(self) -> Optional[str]:
        """
        Community URL section.
        """
        return pulumi.get(self, "community_url_section")

    @property
    @pulumi.getter
    def principal(self) -> Optional[str]:
        """
        Name of the property in the user object that maps to a Salesforce username, for example `email`.
        """
        return pulumi.get(self, "principal")


@pulumi.output_type
class ClientAddonsSalesforceSandboxApi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "communityName":
            suggest = "community_name"
        elif key == "communityUrlSection":
            suggest = "community_url_section"

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

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

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

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 community_name: Optional[str] = None,
                 community_url_section: Optional[str] = None,
                 principal: Optional[str] = None):
        """
        :param str client_id: Consumer Key assigned by Salesforce to the Connected App.
        :param str community_name: Community name.
        :param str community_url_section: Community URL section.
        :param str principal: Name of the property in the user object that maps to a Salesforce username, for example `email`.
        """
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if community_name is not None:
            pulumi.set(__self__, "community_name", community_name)
        if community_url_section is not None:
            pulumi.set(__self__, "community_url_section", community_url_section)
        if principal is not None:
            pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        Consumer Key assigned by Salesforce to the Connected App.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="communityName")
    def community_name(self) -> Optional[str]:
        """
        Community name.
        """
        return pulumi.get(self, "community_name")

    @property
    @pulumi.getter(name="communityUrlSection")
    def community_url_section(self) -> Optional[str]:
        """
        Community URL section.
        """
        return pulumi.get(self, "community_url_section")

    @property
    @pulumi.getter
    def principal(self) -> Optional[str]:
        """
        Name of the property in the user object that maps to a Salesforce username, for example `email`.
        """
        return pulumi.get(self, "principal")


@pulumi.output_type
class ClientAddonsSamlp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authnContextClassRef":
            suggest = "authn_context_class_ref"
        elif key == "createUpnClaim":
            suggest = "create_upn_claim"
        elif key == "digestAlgorithm":
            suggest = "digest_algorithm"
        elif key == "includeAttributeNameFormat":
            suggest = "include_attribute_name_format"
        elif key == "lifetimeInSeconds":
            suggest = "lifetime_in_seconds"
        elif key == "mapIdentities":
            suggest = "map_identities"
        elif key == "mapUnknownClaimsAsIs":
            suggest = "map_unknown_claims_as_is"
        elif key == "nameIdentifierFormat":
            suggest = "name_identifier_format"
        elif key == "nameIdentifierProbes":
            suggest = "name_identifier_probes"
        elif key == "passthroughClaimsWithNoMapping":
            suggest = "passthrough_claims_with_no_mapping"
        elif key == "signResponse":
            suggest = "sign_response"
        elif key == "signatureAlgorithm":
            suggest = "signature_algorithm"
        elif key == "signingCert":
            suggest = "signing_cert"
        elif key == "typedAttributes":
            suggest = "typed_attributes"

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

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

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

    def __init__(__self__, *,
                 audience: Optional[str] = None,
                 authn_context_class_ref: Optional[str] = None,
                 binding: Optional[str] = None,
                 create_upn_claim: Optional[bool] = None,
                 destination: Optional[str] = None,
                 digest_algorithm: Optional[str] = None,
                 include_attribute_name_format: Optional[bool] = None,
                 issuer: Optional[str] = None,
                 lifetime_in_seconds: Optional[int] = None,
                 logout: Optional['outputs.ClientAddonsSamlpLogout'] = None,
                 map_identities: Optional[bool] = None,
                 map_unknown_claims_as_is: Optional[bool] = None,
                 mappings: Optional[Mapping[str, Any]] = None,
                 name_identifier_format: Optional[str] = None,
                 name_identifier_probes: Optional[Sequence[str]] = None,
                 passthrough_claims_with_no_mapping: Optional[bool] = None,
                 recipient: Optional[str] = None,
                 sign_response: Optional[bool] = None,
                 signature_algorithm: Optional[str] = None,
                 signing_cert: Optional[str] = None,
                 typed_attributes: Optional[bool] = None):
        """
        :param str audience: Audience of the SAML Assertion. Default will be the Issuer on SAMLRequest.
        :param str authn_context_class_ref: Class reference of the authentication context.
        :param str binding: Protocol binding used for SAML logout responses.
        :param bool create_upn_claim: Indicates whether a UPN claim should be created. Defaults to `true`.
        :param str destination: Destination of the SAML Response. If not specified, it will be `AssertionConsumerUrl` of SAMLRequest or callback URL if there was no SAMLRequest.
        :param str digest_algorithm: Algorithm used to calculate the digest of the SAML Assertion or response. Options include `sha1` and `sha256`. Defaults to `sha1`.
        :param bool include_attribute_name_format: 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. Defaults to `true`.
        :param str issuer: Issuer of the SAML Assertion.
        :param int lifetime_in_seconds: Number of seconds during which the token is valid. Defaults to `3600` seconds.
        :param 'ClientAddonsSamlpLogoutArgs' logout: Configuration settings for logout.
        :param bool map_identities: Indicates whether or not to add additional identity information in the token, such as the provider used and the `access_token`, if available. Defaults to `true`.
        :param bool map_unknown_claims_as_is: Indicates whether 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. Defaults to `false`.
        :param Mapping[str, Any] mappings: Mappings between the Auth0 user profile property name (`name`) and the output attributes on the SAML attribute in the assertion (`value`).
        :param str name_identifier_format: Format of the name identifier. Defaults to `urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`.
        :param Sequence[str] name_identifier_probes: 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 bool passthrough_claims_with_no_mapping: Indicates whether or not to passthrough claims that are not mapped to the common profile in the output assertion. Defaults to `true`.
        :param str recipient: Recipient of the SAML Assertion (SubjectConfirmationData). Default is `AssertionConsumerUrl` on SAMLRequest or callback URL if no SAMLRequest was sent.
        :param bool sign_response: Indicates whether or not the SAML Response should be signed instead of the SAML Assertion.
        :param str signature_algorithm: Algorithm used to sign the SAML Assertion or response. Options include `rsa-sha1` and `rsa-sha256`. Defaults to `rsa-sha1`.
        :param str signing_cert: Optionally indicates the public key certificate used to validate SAML requests. If set, SAML requests will be required to be signed. A sample value would be `-----BEGIN PUBLIC KEY-----\\nMIGf...bpP/t3\\n+JGNGIRMj1hF1rnb6QIDAQAB\\n-----END PUBLIC KEY-----\\n`.
        :param bool typed_attributes: 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`. Defaults to `true`.
        """
        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 issuer is not None:
            pulumi.set(__self__, "issuer", issuer)
        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 signing_cert is not None:
            pulumi.set(__self__, "signing_cert", signing_cert)
        if typed_attributes is not None:
            pulumi.set(__self__, "typed_attributes", typed_attributes)

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

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

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

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

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

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

    @property
    @pulumi.getter(name="includeAttributeNameFormat")
    def include_attribute_name_format(self) -> Optional[bool]:
        """
        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. Defaults to `true`.
        """
        return pulumi.get(self, "include_attribute_name_format")

    @property
    @pulumi.getter
    def issuer(self) -> Optional[str]:
        """
        Issuer of the SAML Assertion.
        """
        return pulumi.get(self, "issuer")

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

    @property
    @pulumi.getter
    def logout(self) -> Optional['outputs.ClientAddonsSamlpLogout']:
        """
        Configuration settings for logout.
        """
        return pulumi.get(self, "logout")

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

    @property
    @pulumi.getter(name="mapUnknownClaimsAsIs")
    def map_unknown_claims_as_is(self) -> Optional[bool]:
        """
        Indicates whether 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. Defaults to `false`.
        """
        return pulumi.get(self, "map_unknown_claims_as_is")

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

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

    @property
    @pulumi.getter(name="nameIdentifierProbes")
    def name_identifier_probes(self) -> Optional[Sequence[str]]:
        """
        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")

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

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

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

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

    @property
    @pulumi.getter(name="signingCert")
    def signing_cert(self) -> Optional[str]:
        """
        Optionally indicates the public key certificate used to validate SAML requests. If set, SAML requests will be required to be signed. A sample value would be `-----BEGIN PUBLIC KEY-----\\nMIGf...bpP/t3\\n+JGNGIRMj1hF1rnb6QIDAQAB\\n-----END PUBLIC KEY-----\\n`.
        """
        return pulumi.get(self, "signing_cert")

    @property
    @pulumi.getter(name="typedAttributes")
    def typed_attributes(self) -> Optional[bool]:
        """
        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`. Defaults to `true`.
        """
        return pulumi.get(self, "typed_attributes")


@pulumi.output_type
class ClientAddonsSamlpLogout(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sloEnabled":
            suggest = "slo_enabled"

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

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

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

    def __init__(__self__, *,
                 callback: Optional[str] = None,
                 slo_enabled: Optional[bool] = None):
        """
        :param str callback: The service provider (client application)'s Single Logout Service URL, where Auth0 will send logout requests and responses.
        :param bool slo_enabled: Controls whether 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[str]:
        """
        The service provider (client application)'s Single Logout Service URL, where Auth0 will send logout requests and responses.
        """
        return pulumi.get(self, "callback")

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


@pulumi.output_type
class ClientAddonsSapApi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "nameIdentifierFormat":
            suggest = "name_identifier_format"
        elif key == "servicePassword":
            suggest = "service_password"
        elif key == "tokenEndpointUrl":
            suggest = "token_endpoint_url"
        elif key == "usernameAttribute":
            suggest = "username_attribute"

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

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

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

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 name_identifier_format: Optional[str] = None,
                 scope: Optional[str] = None,
                 service_password: Optional[str] = None,
                 token_endpoint_url: Optional[str] = None,
                 username_attribute: Optional[str] = None):
        """
        :param str client_id: If activated in the OAuth 2.0 client configuration (transaction `SOAUTH2) the SAML attribute`client*id`must be set and equal the`client*id` form parameter of the access token request.
        :param str name_identifier_format: NameID element of the Subject which can be used to express the user's identity. Defaults to `urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`.
        :param str scope: Requested scope for SAP APIs.
        :param str service_password: Service account password to use to authenticate API calls to the token endpoint.
        :param str token_endpoint_url: The OAuth2 token endpoint URL of your SAP OData server.
        :param str username_attribute: Name of the property in the user object that maps to a SAP username, for example `email`.
        """
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if name_identifier_format is not None:
            pulumi.set(__self__, "name_identifier_format", name_identifier_format)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)
        if service_password is not None:
            pulumi.set(__self__, "service_password", service_password)
        if token_endpoint_url is not None:
            pulumi.set(__self__, "token_endpoint_url", token_endpoint_url)
        if username_attribute is not None:
            pulumi.set(__self__, "username_attribute", username_attribute)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        If activated in the OAuth 2.0 client configuration (transaction `SOAUTH2) the SAML attribute`client*id`must be set and equal the`client*id` form parameter of the access token request.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="nameIdentifierFormat")
    def name_identifier_format(self) -> Optional[str]:
        """
        NameID element of the Subject which can be used to express the user's identity. Defaults to `urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`.
        """
        return pulumi.get(self, "name_identifier_format")

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

    @property
    @pulumi.getter(name="servicePassword")
    def service_password(self) -> Optional[str]:
        """
        Service account password to use to authenticate API calls to the token endpoint.
        """
        return pulumi.get(self, "service_password")

    @property
    @pulumi.getter(name="tokenEndpointUrl")
    def token_endpoint_url(self) -> Optional[str]:
        """
        The OAuth2 token endpoint URL of your SAP OData server.
        """
        return pulumi.get(self, "token_endpoint_url")

    @property
    @pulumi.getter(name="usernameAttribute")
    def username_attribute(self) -> Optional[str]:
        """
        Name of the property in the user object that maps to a SAP username, for example `email`.
        """
        return pulumi.get(self, "username_attribute")


@pulumi.output_type
class ClientAddonsSentry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "baseUrl":
            suggest = "base_url"
        elif key == "orgSlug":
            suggest = "org_slug"

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

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

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

    def __init__(__self__, *,
                 base_url: Optional[str] = None,
                 org_slug: Optional[str] = None):
        """
        :param str base_url: URL prefix only if running Sentry Community Edition, otherwise leave empty.
        :param str org_slug: Generated slug for your Sentry organization. Found in your Sentry URL, for example `https://sentry.acme.com/acme-org/` would be `acme-org`.
        """
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if org_slug is not None:
            pulumi.set(__self__, "org_slug", org_slug)

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[str]:
        """
        URL prefix only if running Sentry Community Edition, otherwise leave empty.
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter(name="orgSlug")
    def org_slug(self) -> Optional[str]:
        """
        Generated slug for your Sentry organization. Found in your Sentry URL, for example `https://sentry.acme.com/acme-org/` would be `acme-org`.
        """
        return pulumi.get(self, "org_slug")


@pulumi.output_type
class ClientAddonsSharepoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "externalUrls":
            suggest = "external_urls"

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

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

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

    def __init__(__self__, *,
                 external_urls: Optional[Sequence[str]] = None,
                 url: Optional[str] = None):
        """
        :param Sequence[str] external_urls: External SharePoint application URLs if exposed to the Internet.
        :param str url: Internal SharePoint application URL.
        """
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[Sequence[str]]:
        """
        External SharePoint application URLs if exposed to the Internet.
        """
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        """
        Internal SharePoint application URL.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class ClientAddonsSlack(dict):
    def __init__(__self__, *,
                 team: Optional[str] = None):
        """
        :param str team: Slack team name.
        """
        if team is not None:
            pulumi.set(__self__, "team", team)

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


@pulumi.output_type
class ClientAddonsSpringcm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "acsUrl":
            suggest = "acs_url"

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

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

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

    def __init__(__self__, *,
                 acs_url: Optional[str] = None):
        """
        :param str acs_url: SpringCM ACS URL, for example `https://na11.springcm.com/atlas/sso/SSOEndpoint.ashx`.
        """
        if acs_url is not None:
            pulumi.set(__self__, "acs_url", acs_url)

    @property
    @pulumi.getter(name="acsUrl")
    def acs_url(self) -> Optional[str]:
        """
        SpringCM ACS URL, for example `https://na11.springcm.com/atlas/sso/SSOEndpoint.ashx`.
        """
        return pulumi.get(self, "acs_url")


@pulumi.output_type
class ClientAddonsSsoIntegration(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param str name: SSO integration name.
        :param str version: SSO integration version installed.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        SSO integration version installed.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class ClientAddonsWams(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "masterKey":
            suggest = "master_key"

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

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

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

    def __init__(__self__, *,
                 master_key: Optional[str] = None):
        """
        :param str master_key: Your master key for Windows Azure Mobile Services.
        """
        if master_key is not None:
            pulumi.set(__self__, "master_key", master_key)

    @property
    @pulumi.getter(name="masterKey")
    def master_key(self) -> Optional[str]:
        """
        Your master key for Windows Azure Mobile Services.
        """
        return pulumi.get(self, "master_key")


@pulumi.output_type
class ClientAddonsWsfed(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class ClientAddonsZendesk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountName":
            suggest = "account_name"

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

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

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

    def __init__(__self__, *,
                 account_name: Optional[str] = None):
        """
        :param str account_name: Zendesk account name. Usually the first segment in your Zendesk URL, for example `https://acme-org.zendesk.com` would be `acme-org`.
        """
        if account_name is not None:
            pulumi.set(__self__, "account_name", account_name)

    @property
    @pulumi.getter(name="accountName")
    def account_name(self) -> Optional[str]:
        """
        Zendesk account name. Usually the first segment in your Zendesk URL, for example `https://acme-org.zendesk.com` would be `acme-org`.
        """
        return pulumi.get(self, "account_name")


@pulumi.output_type
class ClientAddonsZoom(dict):
    def __init__(__self__, *,
                 account: Optional[str] = None):
        """
        :param str account: Zoom account name. Usually the first segment of your Zoom URL, for example `https://acme-org.zoom.us` would be `acme-org`.
        """
        if account is not None:
            pulumi.set(__self__, "account", account)

    @property
    @pulumi.getter
    def account(self) -> Optional[str]:
        """
        Zoom account name. Usually the first segment of your Zoom URL, for example `https://acme-org.zoom.us` would be `acme-org`.
        """
        return pulumi.get(self, "account")


@pulumi.output_type
class ClientCredentialsPrivateKeyJwt(dict):
    def __init__(__self__, *,
                 credentials: Sequence['outputs.ClientCredentialsPrivateKeyJwtCredential']):
        """
        :param Sequence['ClientCredentialsPrivateKeyJwtCredentialArgs'] credentials: Client credentials available for use when Private Key JWT is in use as the client authentication method. A maximum of 2 client credentials can be set.
        """
        pulumi.set(__self__, "credentials", credentials)

    @property
    @pulumi.getter
    def credentials(self) -> Sequence['outputs.ClientCredentialsPrivateKeyJwtCredential']:
        """
        Client credentials available for use when Private Key JWT is in use as the client authentication method. A maximum of 2 client credentials can be set.
        """
        return pulumi.get(self, "credentials")


@pulumi.output_type
class ClientCredentialsPrivateKeyJwtCredential(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "credentialType":
            suggest = "credential_type"
        elif key == "createdAt":
            suggest = "created_at"
        elif key == "expiresAt":
            suggest = "expires_at"
        elif key == "keyId":
            suggest = "key_id"
        elif key == "parseExpiryFromCert":
            suggest = "parse_expiry_from_cert"
        elif key == "updatedAt":
            suggest = "updated_at"

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

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

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

    def __init__(__self__, *,
                 credential_type: str,
                 pem: str,
                 algorithm: Optional[str] = None,
                 created_at: Optional[str] = None,
                 expires_at: Optional[str] = None,
                 id: Optional[str] = None,
                 key_id: Optional[str] = None,
                 name: Optional[str] = None,
                 parse_expiry_from_cert: Optional[bool] = None,
                 updated_at: Optional[str] = None):
        """
        :param str credential_type: Credential type. Supported types: `public_key`.
        :param str pem: PEM-formatted public key (SPKI and PKCS1) or X509 certificate. Must be JSON escaped.
        :param str algorithm: Algorithm which will be used with the credential. Can be one of `RS256`, `RS384`, `PS256`. If not specified, `RS256` will be used.
        :param str created_at: The ISO 8601 formatted date the credential was created.
        :param str expires_at: The ISO 8601 formatted date representing the expiration of the credential. It is not possible to set this to never expire after it has been set. Recreate the certificate if needed.
        :param str id: The ID of the client credential.
        :param str key_id: The key identifier of the credential, generated on creation.
        :param str name: Friendly name for a credential.
        :param bool parse_expiry_from_cert: Parse expiry from x509 certificate. If true, attempts to parse the expiry date from the provided PEM. If also the `expires_at` is set the credential expiry will be set to the explicit `expires_at` value.
        :param str updated_at: The ISO 8601 formatted date the credential was updated.
        """
        pulumi.set(__self__, "credential_type", credential_type)
        pulumi.set(__self__, "pem", pem)
        if algorithm is not None:
            pulumi.set(__self__, "algorithm", algorithm)
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if expires_at is not None:
            pulumi.set(__self__, "expires_at", expires_at)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if key_id is not None:
            pulumi.set(__self__, "key_id", key_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if parse_expiry_from_cert is not None:
            pulumi.set(__self__, "parse_expiry_from_cert", parse_expiry_from_cert)
        if updated_at is not None:
            pulumi.set(__self__, "updated_at", updated_at)

    @property
    @pulumi.getter(name="credentialType")
    def credential_type(self) -> str:
        """
        Credential type. Supported types: `public_key`.
        """
        return pulumi.get(self, "credential_type")

    @property
    @pulumi.getter
    def pem(self) -> str:
        """
        PEM-formatted public key (SPKI and PKCS1) or X509 certificate. Must be JSON escaped.
        """
        return pulumi.get(self, "pem")

    @property
    @pulumi.getter
    def algorithm(self) -> Optional[str]:
        """
        Algorithm which will be used with the credential. Can be one of `RS256`, `RS384`, `PS256`. If not specified, `RS256` will be used.
        """
        return pulumi.get(self, "algorithm")

    @property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[str]:
        """
        The ISO 8601 formatted date the credential was created.
        """
        return pulumi.get(self, "created_at")

    @property
    @pulumi.getter(name="expiresAt")
    def expires_at(self) -> Optional[str]:
        """
        The ISO 8601 formatted date representing the expiration of the credential. It is not possible to set this to never expire after it has been set. Recreate the certificate if needed.
        """
        return pulumi.get(self, "expires_at")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        The ID of the client credential.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="keyId")
    def key_id(self) -> Optional[str]:
        """
        The key identifier of the credential, generated on creation.
        """
        return pulumi.get(self, "key_id")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Friendly name for a credential.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="parseExpiryFromCert")
    def parse_expiry_from_cert(self) -> Optional[bool]:
        """
        Parse expiry from x509 certificate. If true, attempts to parse the expiry date from the provided PEM. If also the `expires_at` is set the credential expiry will be set to the explicit `expires_at` value.
        """
        return pulumi.get(self, "parse_expiry_from_cert")

    @property
    @pulumi.getter(name="updatedAt")
    def updated_at(self) -> Optional[str]:
        """
        The ISO 8601 formatted date the credential was updated.
        """
        return pulumi.get(self, "updated_at")


@pulumi.output_type
class ClientJwtConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lifetimeInSeconds":
            suggest = "lifetime_in_seconds"
        elif key == "secretEncoded":
            suggest = "secret_encoded"

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

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

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

    def __init__(__self__, *,
                 alg: Optional[str] = None,
                 lifetime_in_seconds: Optional[int] = None,
                 scopes: Optional[Mapping[str, str]] = None,
                 secret_encoded: Optional[bool] = None):
        """
        :param str alg: Algorithm used to sign JWTs.
        :param int lifetime_in_seconds: Number of seconds during which the JWT will be valid.
        :param Mapping[str, str] scopes: Permissions (scopes) included in JWTs.
        :param bool secret_encoded: Indicates whether 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[str]:
        """
        Algorithm used to sign JWTs.
        """
        return pulumi.get(self, "alg")

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

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

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


@pulumi.output_type
class ClientMobile(dict):
    def __init__(__self__, *,
                 android: Optional['outputs.ClientMobileAndroid'] = None,
                 ios: Optional['outputs.ClientMobileIos'] = None):
        """
        :param 'ClientMobileAndroidArgs' android: Configuration settings for Android native apps.
        :param 'ClientMobileIosArgs' ios: Configuration settings for i0S native apps.
        """
        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['outputs.ClientMobileAndroid']:
        """
        Configuration settings for Android native apps.
        """
        return pulumi.get(self, "android")

    @property
    @pulumi.getter
    def ios(self) -> Optional['outputs.ClientMobileIos']:
        """
        Configuration settings for i0S native apps.
        """
        return pulumi.get(self, "ios")


@pulumi.output_type
class ClientMobileAndroid(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appPackageName":
            suggest = "app_package_name"
        elif key == "sha256CertFingerprints":
            suggest = "sha256_cert_fingerprints"

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

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

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

    def __init__(__self__, *,
                 app_package_name: Optional[str] = None,
                 sha256_cert_fingerprints: Optional[Sequence[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[str]:
        return pulumi.get(self, "app_package_name")

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


@pulumi.output_type
class ClientMobileIos(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appBundleIdentifier":
            suggest = "app_bundle_identifier"
        elif key == "teamId":
            suggest = "team_id"

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

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

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

    def __init__(__self__, *,
                 app_bundle_identifier: Optional[str] = None,
                 team_id: Optional[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[str]:
        return pulumi.get(self, "app_bundle_identifier")

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


@pulumi.output_type
class ClientNativeSocialLogin(dict):
    def __init__(__self__, *,
                 apple: Optional['outputs.ClientNativeSocialLoginApple'] = None,
                 facebook: Optional['outputs.ClientNativeSocialLoginFacebook'] = None):
        if apple is not None:
            pulumi.set(__self__, "apple", apple)
        if facebook is not None:
            pulumi.set(__self__, "facebook", facebook)

    @property
    @pulumi.getter
    def apple(self) -> Optional['outputs.ClientNativeSocialLoginApple']:
        return pulumi.get(self, "apple")

    @property
    @pulumi.getter
    def facebook(self) -> Optional['outputs.ClientNativeSocialLoginFacebook']:
        return pulumi.get(self, "facebook")


@pulumi.output_type
class ClientNativeSocialLoginApple(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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


@pulumi.output_type
class ClientNativeSocialLoginFacebook(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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


@pulumi.output_type
class ClientRefreshToken(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "expirationType":
            suggest = "expiration_type"
        elif key == "rotationType":
            suggest = "rotation_type"
        elif key == "idleTokenLifetime":
            suggest = "idle_token_lifetime"
        elif key == "infiniteIdleTokenLifetime":
            suggest = "infinite_idle_token_lifetime"
        elif key == "infiniteTokenLifetime":
            suggest = "infinite_token_lifetime"
        elif key == "tokenLifetime":
            suggest = "token_lifetime"

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

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

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

    def __init__(__self__, *,
                 expiration_type: str,
                 rotation_type: str,
                 idle_token_lifetime: Optional[int] = None,
                 infinite_idle_token_lifetime: Optional[bool] = None,
                 infinite_token_lifetime: Optional[bool] = None,
                 leeway: Optional[int] = None,
                 token_lifetime: Optional[int] = None):
        """
        :param str expiration_type: 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 str rotation_type: 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 int idle_token_lifetime: The time in seconds after which inactive refresh tokens will expire.
        :param bool infinite_idle_token_lifetime: Whether inactive refresh tokens should remain valid indefinitely.
        :param bool infinite_token_lifetime: Whether refresh tokens should remain valid indefinitely. If false, `token_lifetime` should also be set.
        :param int leeway: The amount of time in seconds in which a refresh token may be reused without triggering reuse detection.
        :param int token_lifetime: 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) -> str:
        """
        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")

    @property
    @pulumi.getter(name="rotationType")
    def rotation_type(self) -> str:
        """
        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")

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

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

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

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

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


@pulumi.output_type
class ConnectionOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adfsServer":
            suggest = "adfs_server"
        elif key == "allowedAudiences":
            suggest = "allowed_audiences"
        elif key == "apiEnableUsers":
            suggest = "api_enable_users"
        elif key == "appId":
            suggest = "app_id"
        elif key == "attributeMap":
            suggest = "attribute_map"
        elif key == "authParams":
            suggest = "auth_params"
        elif key == "authorizationEndpoint":
            suggest = "authorization_endpoint"
        elif key == "bruteForceProtection":
            suggest = "brute_force_protection"
        elif key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "communityBaseUrl":
            suggest = "community_base_url"
        elif key == "connectionSettings":
            suggest = "connection_settings"
        elif key == "customScripts":
            suggest = "custom_scripts"
        elif key == "decryptionKey":
            suggest = "decryption_key"
        elif key == "digestAlgorithm":
            suggest = "digest_algorithm"
        elif key == "disableCache":
            suggest = "disable_cache"
        elif key == "disableSelfServiceChangePassword":
            suggest = "disable_self_service_change_password"
        elif key == "disableSignOut":
            suggest = "disable_sign_out"
        elif key == "disableSignup":
            suggest = "disable_signup"
        elif key == "discoveryUrl":
            suggest = "discovery_url"
        elif key == "domainAliases":
            suggest = "domain_aliases"
        elif key == "enableScriptContext":
            suggest = "enable_script_context"
        elif key == "enabledDatabaseCustomization":
            suggest = "enabled_database_customization"
        elif key == "entityId":
            suggest = "entity_id"
        elif key == "fedMetadataXml":
            suggest = "fed_metadata_xml"
        elif key == "fieldsMap":
            suggest = "fields_map"
        elif key == "forwardRequestInfo":
            suggest = "forward_request_info"
        elif key == "from":
            suggest = "from_"
        elif key == "gatewayAuthentication":
            suggest = "gateway_authentication"
        elif key == "gatewayUrl":
            suggest = "gateway_url"
        elif key == "iconUrl":
            suggest = "icon_url"
        elif key == "identityApi":
            suggest = "identity_api"
        elif key == "idpInitiated":
            suggest = "idp_initiated"
        elif key == "importMode":
            suggest = "import_mode"
        elif key == "jwksUri":
            suggest = "jwks_uri"
        elif key == "keyId":
            suggest = "key_id"
        elif key == "mapUserIdToId":
            suggest = "map_user_id_to_id"
        elif key == "maxGroupsToRetrieve":
            suggest = "max_groups_to_retrieve"
        elif key == "messagingServiceSid":
            suggest = "messaging_service_sid"
        elif key == "metadataUrl":
            suggest = "metadata_url"
        elif key == "metadataXml":
            suggest = "metadata_xml"
        elif key == "nonPersistentAttrs":
            suggest = "non_persistent_attrs"
        elif key == "passwordComplexityOptions":
            suggest = "password_complexity_options"
        elif key == "passwordDictionary":
            suggest = "password_dictionary"
        elif key == "passwordHistories":
            suggest = "password_histories"
        elif key == "passwordNoPersonalInfo":
            suggest = "password_no_personal_info"
        elif key == "passwordPolicy":
            suggest = "password_policy"
        elif key == "pingFederateBaseUrl":
            suggest = "ping_federate_base_url"
        elif key == "pkceEnabled":
            suggest = "pkce_enabled"
        elif key == "protocolBinding":
            suggest = "protocol_binding"
        elif key == "requestTemplate":
            suggest = "request_template"
        elif key == "requiresUsername":
            suggest = "requires_username"
        elif key == "setUserRootAttributes":
            suggest = "set_user_root_attributes"
        elif key == "shouldTrustEmailVerifiedConnection":
            suggest = "should_trust_email_verified_connection"
        elif key == "signInEndpoint":
            suggest = "sign_in_endpoint"
        elif key == "signOutEndpoint":
            suggest = "sign_out_endpoint"
        elif key == "signSamlRequest":
            suggest = "sign_saml_request"
        elif key == "signatureAlgorithm":
            suggest = "signature_algorithm"
        elif key == "signingCert":
            suggest = "signing_cert"
        elif key == "signingKey":
            suggest = "signing_key"
        elif key == "strategyVersion":
            suggest = "strategy_version"
        elif key == "teamId":
            suggest = "team_id"
        elif key == "tenantDomain":
            suggest = "tenant_domain"
        elif key == "tokenEndpoint":
            suggest = "token_endpoint"
        elif key == "twilioSid":
            suggest = "twilio_sid"
        elif key == "twilioToken":
            suggest = "twilio_token"
        elif key == "upstreamParams":
            suggest = "upstream_params"
        elif key == "useCertAuth":
            suggest = "use_cert_auth"
        elif key == "useKerberos":
            suggest = "use_kerberos"
        elif key == "useWsfed":
            suggest = "use_wsfed"
        elif key == "userIdAttribute":
            suggest = "user_id_attribute"
        elif key == "userinfoEndpoint":
            suggest = "userinfo_endpoint"
        elif key == "waadCommonEndpoint":
            suggest = "waad_common_endpoint"
        elif key == "waadProtocol":
            suggest = "waad_protocol"

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

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

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

    def __init__(__self__, *,
                 adfs_server: Optional[str] = None,
                 allowed_audiences: Optional[Sequence[str]] = None,
                 api_enable_users: Optional[bool] = None,
                 app_id: Optional[str] = None,
                 attribute_map: Optional['outputs.ConnectionOptionsAttributeMap'] = None,
                 auth_params: Optional[Mapping[str, str]] = None,
                 authorization_endpoint: Optional[str] = None,
                 brute_force_protection: Optional[bool] = None,
                 client_id: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 community_base_url: Optional[str] = None,
                 configuration: Optional[Mapping[str, Any]] = None,
                 connection_settings: Optional['outputs.ConnectionOptionsConnectionSettings'] = None,
                 custom_scripts: Optional[Mapping[str, str]] = None,
                 debug: Optional[bool] = None,
                 decryption_key: Optional['outputs.ConnectionOptionsDecryptionKey'] = None,
                 digest_algorithm: Optional[str] = None,
                 disable_cache: Optional[bool] = None,
                 disable_self_service_change_password: Optional[bool] = None,
                 disable_sign_out: Optional[bool] = None,
                 disable_signup: Optional[bool] = None,
                 discovery_url: Optional[str] = None,
                 domain: Optional[str] = None,
                 domain_aliases: Optional[Sequence[str]] = None,
                 enable_script_context: Optional[bool] = None,
                 enabled_database_customization: Optional[bool] = None,
                 entity_id: Optional[str] = None,
                 fed_metadata_xml: Optional[str] = None,
                 fields_map: Optional[str] = None,
                 forward_request_info: Optional[bool] = None,
                 from_: Optional[str] = None,
                 gateway_authentication: Optional['outputs.ConnectionOptionsGatewayAuthentication'] = None,
                 gateway_url: Optional[str] = None,
                 icon_url: Optional[str] = None,
                 identity_api: Optional[str] = None,
                 idp_initiated: Optional['outputs.ConnectionOptionsIdpInitiated'] = None,
                 import_mode: Optional[bool] = None,
                 ips: Optional[Sequence[str]] = None,
                 issuer: Optional[str] = None,
                 jwks_uri: Optional[str] = None,
                 key_id: Optional[str] = None,
                 map_user_id_to_id: Optional[bool] = None,
                 max_groups_to_retrieve: Optional[str] = None,
                 messaging_service_sid: Optional[str] = None,
                 metadata_url: Optional[str] = None,
                 metadata_xml: Optional[str] = None,
                 mfa: Optional['outputs.ConnectionOptionsMfa'] = None,
                 name: Optional[str] = None,
                 non_persistent_attrs: Optional[Sequence[str]] = None,
                 password_complexity_options: Optional['outputs.ConnectionOptionsPasswordComplexityOptions'] = None,
                 password_dictionary: Optional['outputs.ConnectionOptionsPasswordDictionary'] = None,
                 password_histories: Optional[Sequence['outputs.ConnectionOptionsPasswordHistory']] = None,
                 password_no_personal_info: Optional['outputs.ConnectionOptionsPasswordNoPersonalInfo'] = None,
                 password_policy: Optional[str] = None,
                 ping_federate_base_url: Optional[str] = None,
                 pkce_enabled: Optional[bool] = None,
                 protocol_binding: Optional[str] = None,
                 provider: Optional[str] = None,
                 request_template: Optional[str] = None,
                 requires_username: Optional[bool] = None,
                 scopes: Optional[Sequence[str]] = None,
                 scripts: Optional[Mapping[str, str]] = None,
                 set_user_root_attributes: Optional[str] = None,
                 should_trust_email_verified_connection: Optional[str] = None,
                 sign_in_endpoint: Optional[str] = None,
                 sign_out_endpoint: Optional[str] = None,
                 sign_saml_request: Optional[bool] = None,
                 signature_algorithm: Optional[str] = None,
                 signing_cert: Optional[str] = None,
                 signing_key: Optional['outputs.ConnectionOptionsSigningKey'] = None,
                 strategy_version: Optional[int] = None,
                 subject: Optional[str] = None,
                 syntax: Optional[str] = None,
                 team_id: Optional[str] = None,
                 template: Optional[str] = None,
                 tenant_domain: Optional[str] = None,
                 token_endpoint: Optional[str] = None,
                 totp: Optional['outputs.ConnectionOptionsTotp'] = None,
                 twilio_sid: Optional[str] = None,
                 twilio_token: Optional[str] = None,
                 type: Optional[str] = None,
                 upstream_params: Optional[str] = None,
                 use_cert_auth: Optional[bool] = None,
                 use_kerberos: Optional[bool] = None,
                 use_wsfed: Optional[bool] = None,
                 user_id_attribute: Optional[str] = None,
                 userinfo_endpoint: Optional[str] = None,
                 validation: Optional['outputs.ConnectionOptionsValidation'] = None,
                 waad_common_endpoint: Optional[bool] = None,
                 waad_protocol: Optional[str] = None):
        """
        :param str adfs_server: ADFS URL where to fetch the metadata source.
        :param Sequence[str] allowed_audiences: List of allowed audiences.
        :param bool api_enable_users: Enable API Access to users.
        :param str app_id: App ID.
        :param 'ConnectionOptionsAttributeMapArgs' attribute_map: OpenID Connect and Okta Workforce connections can automatically map claims received from the identity provider (IdP). You can configure this mapping through a library template provided by Auth0 or by entering your own template directly. Click [here](https://auth0.com/docs/authenticate/identity-providers/enterprise-identity-providers/configure-pkce-claim-mapping-for-oidc#map-claims-for-oidc-connections) for more info.
        :param Mapping[str, str] auth_params: Query string parameters to be included as part of the generated passwordless email link.
        :param str authorization_endpoint: Authorization endpoint.
        :param bool brute_force_protection: Indicates whether to enable brute force protection, which will limit the number of signups and failed logins from a suspicious IP address.
        :param str client_id: The strategy's client ID.
        :param str client_secret: The strategy's client secret.
        :param str community_base_url: Salesforce community base URL.
        :param Mapping[str, Any] configuration: A case-sensitive map of key value pairs used as configuration variables for the `custom_script`.
        :param 'ConnectionOptionsConnectionSettingsArgs' connection_settings: Proof Key for Code Exchange (PKCE) configuration settings for an OIDC or Okta Workforce connection.
        :param Mapping[str, str] custom_scripts: A map of scripts used to integrate with a custom database.
        :param bool debug: When enabled, additional debug information will be generated.
        :param 'ConnectionOptionsDecryptionKeyArgs' decryption_key: The key used to decrypt encrypted responses from the connection. Uses the `key` and `cert` properties to provide the private key and certificate respectively.
        :param str digest_algorithm: Sign Request Algorithm Digest.
        :param bool disable_cache: Indicates whether to disable the cache or not.
        :param bool disable_self_service_change_password: Indicates whether to remove the forgot password link within the New Universal Login.
        :param bool disable_sign_out: When enabled, will disable sign out.
        :param bool disable_signup: Indicates whether to allow user sign-ups to your application.
        :param str discovery_url: OpenID discovery URL, e.g. `https://auth.example.com/.well-known/openid-configuration`.
        :param str domain: Domain name.
        :param Sequence[str] domain_aliases: List of the domains that can be authenticated using the identity provider. Only needed for Identifier First authentication flows.
        :param bool enable_script_context: Set to `true` to inject context into custom DB scripts (warning: cannot be disabled once enabled).
        :param bool enabled_database_customization: Set to `true` to use a legacy user store.
        :param str entity_id: Custom Entity ID for the connection.
        :param str fed_metadata_xml: Federation Metadata for the ADFS connection.
        :param str fields_map: If you're configuring a SAML enterprise connection for a non-standard PingFederate Server, you must update the attribute mappings.
        :param bool forward_request_info: Specifies whether or not request info should be forwarded to sms gateway.
        :param str from_: Address to use as the sender.
        :param 'ConnectionOptionsGatewayAuthenticationArgs' gateway_authentication: Defines the parameters used to generate the auth token for the custom gateway.
        :param str gateway_url: Defines a custom sms gateway to use instead of Twilio.
        :param str icon_url: Icon URL.
        :param str identity_api: Azure AD Identity API. Available options are: `microsoft-identity-platform-v2.0` or `azure-active-directory-v1.0`.
        :param 'ConnectionOptionsIdpInitiatedArgs' idp_initiated: Configuration options for IDP Initiated Authentication. This is an object with the properties: `client_id`, `client_protocol`, and `client_authorize_query`.
        :param bool import_mode: Indicates whether you have a legacy user store and want to gradually migrate those users to the Auth0 user store.
        :param Sequence[str] ips: A list of IPs.
        :param str issuer: Issuer URL, e.g. `https://auth.example.com`.
        :param str jwks_uri: JWKS URI.
        :param str key_id: Apple Key ID.
        :param bool map_user_id_to_id: By default Auth0 maps `user_id` to `email`. Enabling this setting changes the behavior to map `user_id` to 'id' instead. This can only be defined on a new Google Workspace connection and can not be changed once set.
        :param str max_groups_to_retrieve: Maximum number of groups to retrieve.
        :param str messaging_service_sid: SID for Copilot. Used when SMS Source is Copilot.
        :param str metadata_url: The URL of the SAML metadata document.
        :param str metadata_xml: The XML content for the SAML metadata document. Values within the xml will take precedence over other attributes set on the options block.
        :param 'ConnectionOptionsMfaArgs' mfa: Configuration options for multifactor authentication.
        :param str name: The public name of the email or SMS Connection. In most cases this is the same name as the connection name.
        :param Sequence[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 here.
        :param 'ConnectionOptionsPasswordComplexityOptionsArgs' password_complexity_options: Configuration settings for password complexity.
        :param 'ConnectionOptionsPasswordDictionaryArgs' password_dictionary: Configuration settings for the password dictionary check, which does not allow passwords that are part of the password dictionary.
        :param Sequence['ConnectionOptionsPasswordHistoryArgs'] password_histories: Configuration settings for the password history that is maintained for each user to prevent the reuse of passwords.
        :param '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`.
        :param 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 str ping_federate_base_url: Ping Federate Server URL.
        :param bool pkce_enabled: Enables Proof Key for Code Exchange (PKCE) functionality for OAuth2 connections.
        :param str protocol_binding: The SAML Response Binding: how the SAML token is received by Auth0 from the IdP.
        :param str provider: Defines the custom `sms_gateway` provider.
        :param str request_template: Template that formats the SAML request.
        :param bool requires_username: Indicates whether the user is required to provide a username in addition to an email address.
        :param Sequence[str] scopes: Permissions to grant to the connection. Within the Auth0 dashboard these appear under the "Attributes" and "Extended Attributes" sections. Some examples: `basic_profile`, `ext_profile`, `ext_nested_groups`, etc.
        :param Mapping[str, str] scripts: A map of scripts used for an OAuth connection. Only accepts a `fetchUserProfile` script.
        :param str set_user_root_attributes: Determines whether to sync user profile attributes (`name`, `given_name`, `family_name`, `nickname`, `picture`) at each login or only on the first login. Options include: `on_each_login`, `on_first_login`. Default value: `on_each_login`.
        :param str should_trust_email_verified_connection: Choose how Auth0 sets the email_verified field in the user profile.
        :param str sign_in_endpoint: SAML single login URL for the connection.
        :param str sign_out_endpoint: SAML single logout URL for the connection.
        :param bool sign_saml_request: When enabled, the SAML authentication request will be signed.
        :param str signature_algorithm: Sign Request Algorithm.
        :param str signing_cert: X.509 signing certificate (encoded in PEM or CER) you retrieved from the IdP, Base64-encoded.
        :param 'ConnectionOptionsSigningKeyArgs' signing_key: The key used to sign requests in the connection. Uses the `key` and `cert` properties to provide the private key and certificate respectively.
        :param int strategy_version: Version 1 is deprecated, use version 2.
        :param str subject: Subject line of the email.
        :param str syntax: Syntax of the template body.
        :param str team_id: Apple Team ID.
        :param str template: Body of the template.
        :param str tenant_domain: Tenant domain name.
        :param str token_endpoint: Token endpoint.
        :param 'ConnectionOptionsTotpArgs' totp: Configuration options for one-time passwords.
        :param str twilio_sid: SID for your Twilio account.
        :param str twilio_token: AuthToken for your Twilio account.
        :param str type: Value can be `back_channel` or `front_channel`. Front Channel will use OIDC protocol with `response_mode=form_post` and `response_type=id_token`. Back Channel will use `response_type=code`.
        :param str upstream_params: You can pass provider-specific parameters to an identity provider during authentication. The values can either be static per connection or dynamic per user.
        :param bool use_cert_auth: Indicates whether to use cert auth or not.
        :param bool use_kerberos: Indicates whether to use Kerberos or not.
        :param bool use_wsfed: Whether to use WS-Fed.
        :param str user_id_attribute: Attribute in the SAML token that will be mapped to the user_id property in Auth0.
        :param str userinfo_endpoint: User info endpoint.
        :param 'ConnectionOptionsValidationArgs' validation: Validation of the minimum and maximum values allowed for a user to have as username.
        :param bool waad_common_endpoint: Indicates whether 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.
        :param str waad_protocol: Protocol to use.
        """
        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_id is not None:
            pulumi.set(__self__, "app_id", app_id)
        if attribute_map is not None:
            pulumi.set(__self__, "attribute_map", attribute_map)
        if auth_params is not None:
            pulumi.set(__self__, "auth_params", auth_params)
        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 connection_settings is not None:
            pulumi.set(__self__, "connection_settings", connection_settings)
        if custom_scripts is not None:
            pulumi.set(__self__, "custom_scripts", custom_scripts)
        if debug is not None:
            pulumi.set(__self__, "debug", debug)
        if decryption_key is not None:
            pulumi.set(__self__, "decryption_key", decryption_key)
        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_self_service_change_password is not None:
            pulumi.set(__self__, "disable_self_service_change_password", disable_self_service_change_password)
        if disable_sign_out is not None:
            pulumi.set(__self__, "disable_sign_out", disable_sign_out)
        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 enable_script_context is not None:
            pulumi.set(__self__, "enable_script_context", enable_script_context)
        if enabled_database_customization is not None:
            pulumi.set(__self__, "enabled_database_customization", enabled_database_customization)
        if entity_id is not None:
            pulumi.set(__self__, "entity_id", entity_id)
        if fed_metadata_xml is not None:
            pulumi.set(__self__, "fed_metadata_xml", fed_metadata_xml)
        if fields_map is not None:
            pulumi.set(__self__, "fields_map", fields_map)
        if forward_request_info is not None:
            pulumi.set(__self__, "forward_request_info", forward_request_info)
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if gateway_authentication is not None:
            pulumi.set(__self__, "gateway_authentication", gateway_authentication)
        if gateway_url is not None:
            pulumi.set(__self__, "gateway_url", gateway_url)
        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 map_user_id_to_id is not None:
            pulumi.set(__self__, "map_user_id_to_id", map_user_id_to_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 metadata_url is not None:
            pulumi.set(__self__, "metadata_url", metadata_url)
        if metadata_xml is not None:
            pulumi.set(__self__, "metadata_xml", metadata_xml)
        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 ping_federate_base_url is not None:
            pulumi.set(__self__, "ping_federate_base_url", ping_federate_base_url)
        if pkce_enabled is not None:
            pulumi.set(__self__, "pkce_enabled", pkce_enabled)
        if protocol_binding is not None:
            pulumi.set(__self__, "protocol_binding", protocol_binding)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        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 signing_key is not None:
            pulumi.set(__self__, "signing_key", signing_key)
        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 upstream_params is not None:
            pulumi.set(__self__, "upstream_params", upstream_params)
        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[str]:
        """
        ADFS URL where to fetch the metadata source.
        """
        return pulumi.get(self, "adfs_server")

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

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

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

    @property
    @pulumi.getter(name="attributeMap")
    def attribute_map(self) -> Optional['outputs.ConnectionOptionsAttributeMap']:
        """
        OpenID Connect and Okta Workforce connections can automatically map claims received from the identity provider (IdP). You can configure this mapping through a library template provided by Auth0 or by entering your own template directly. Click [here](https://auth0.com/docs/authenticate/identity-providers/enterprise-identity-providers/configure-pkce-claim-mapping-for-oidc#map-claims-for-oidc-connections) for more info.
        """
        return pulumi.get(self, "attribute_map")

    @property
    @pulumi.getter(name="authParams")
    def auth_params(self) -> Optional[Mapping[str, str]]:
        """
        Query string parameters to be included as part of the generated passwordless email link.
        """
        return pulumi.get(self, "auth_params")

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

    @property
    @pulumi.getter(name="bruteForceProtection")
    def brute_force_protection(self) -> Optional[bool]:
        """
        Indicates whether 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")

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

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> Optional[str]:
        """
        The strategy's client secret.
        """
        return pulumi.get(self, "client_secret")

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

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

    @property
    @pulumi.getter(name="connectionSettings")
    def connection_settings(self) -> Optional['outputs.ConnectionOptionsConnectionSettings']:
        """
        Proof Key for Code Exchange (PKCE) configuration settings for an OIDC or Okta Workforce connection.
        """
        return pulumi.get(self, "connection_settings")

    @property
    @pulumi.getter(name="customScripts")
    def custom_scripts(self) -> Optional[Mapping[str, str]]:
        """
        A map of scripts used to integrate with a custom database.
        """
        return pulumi.get(self, "custom_scripts")

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

    @property
    @pulumi.getter(name="decryptionKey")
    def decryption_key(self) -> Optional['outputs.ConnectionOptionsDecryptionKey']:
        """
        The key used to decrypt encrypted responses from the connection. Uses the `key` and `cert` properties to provide the private key and certificate respectively.
        """
        return pulumi.get(self, "decryption_key")

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

    @property
    @pulumi.getter(name="disableCache")
    def disable_cache(self) -> Optional[bool]:
        """
        Indicates whether to disable the cache or not.
        """
        return pulumi.get(self, "disable_cache")

    @property
    @pulumi.getter(name="disableSelfServiceChangePassword")
    def disable_self_service_change_password(self) -> Optional[bool]:
        """
        Indicates whether to remove the forgot password link within the New Universal Login.
        """
        return pulumi.get(self, "disable_self_service_change_password")

    @property
    @pulumi.getter(name="disableSignOut")
    def disable_sign_out(self) -> Optional[bool]:
        """
        When enabled, will disable sign out.
        """
        return pulumi.get(self, "disable_sign_out")

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

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

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

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

    @property
    @pulumi.getter(name="enableScriptContext")
    def enable_script_context(self) -> Optional[bool]:
        """
        Set to `true` to inject context into custom DB scripts (warning: cannot be disabled once enabled).
        """
        return pulumi.get(self, "enable_script_context")

    @property
    @pulumi.getter(name="enabledDatabaseCustomization")
    def enabled_database_customization(self) -> Optional[bool]:
        """
        Set to `true` to use a legacy user store.
        """
        return pulumi.get(self, "enabled_database_customization")

    @property
    @pulumi.getter(name="entityId")
    def entity_id(self) -> Optional[str]:
        """
        Custom Entity ID for the connection.
        """
        return pulumi.get(self, "entity_id")

    @property
    @pulumi.getter(name="fedMetadataXml")
    def fed_metadata_xml(self) -> Optional[str]:
        """
        Federation Metadata for the ADFS connection.
        """
        return pulumi.get(self, "fed_metadata_xml")

    @property
    @pulumi.getter(name="fieldsMap")
    def fields_map(self) -> Optional[str]:
        """
        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")

    @property
    @pulumi.getter(name="forwardRequestInfo")
    def forward_request_info(self) -> Optional[bool]:
        """
        Specifies whether or not request info should be forwarded to sms gateway.
        """
        return pulumi.get(self, "forward_request_info")

    @property
    @pulumi.getter(name="from")
    def from_(self) -> Optional[str]:
        """
        Address to use as the sender.
        """
        return pulumi.get(self, "from_")

    @property
    @pulumi.getter(name="gatewayAuthentication")
    def gateway_authentication(self) -> Optional['outputs.ConnectionOptionsGatewayAuthentication']:
        """
        Defines the parameters used to generate the auth token for the custom gateway.
        """
        return pulumi.get(self, "gateway_authentication")

    @property
    @pulumi.getter(name="gatewayUrl")
    def gateway_url(self) -> Optional[str]:
        """
        Defines a custom sms gateway to use instead of Twilio.
        """
        return pulumi.get(self, "gateway_url")

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

    @property
    @pulumi.getter(name="identityApi")
    def identity_api(self) -> Optional[str]:
        """
        Azure AD Identity API. Available options are: `microsoft-identity-platform-v2.0` or `azure-active-directory-v1.0`.
        """
        return pulumi.get(self, "identity_api")

    @property
    @pulumi.getter(name="idpInitiated")
    def idp_initiated(self) -> Optional['outputs.ConnectionOptionsIdpInitiated']:
        """
        Configuration options for IDP Initiated Authentication. This is an object with the properties: `client_id`, `client_protocol`, and `client_authorize_query`.
        """
        return pulumi.get(self, "idp_initiated")

    @property
    @pulumi.getter(name="importMode")
    def import_mode(self) -> Optional[bool]:
        """
        Indicates whether you have a legacy user store and want to gradually migrate those users to the Auth0 user store.
        """
        return pulumi.get(self, "import_mode")

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

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

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

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

    @property
    @pulumi.getter(name="mapUserIdToId")
    def map_user_id_to_id(self) -> Optional[bool]:
        """
        By default Auth0 maps `user_id` to `email`. Enabling this setting changes the behavior to map `user_id` to 'id' instead. This can only be defined on a new Google Workspace connection and can not be changed once set.
        """
        return pulumi.get(self, "map_user_id_to_id")

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

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

    @property
    @pulumi.getter(name="metadataUrl")
    def metadata_url(self) -> Optional[str]:
        """
        The URL of the SAML metadata document.
        """
        return pulumi.get(self, "metadata_url")

    @property
    @pulumi.getter(name="metadataXml")
    def metadata_xml(self) -> Optional[str]:
        """
        The XML content for the SAML metadata document. Values within the xml will take precedence over other attributes set on the options block.
        """
        return pulumi.get(self, "metadata_xml")

    @property
    @pulumi.getter
    def mfa(self) -> Optional['outputs.ConnectionOptionsMfa']:
        """
        Configuration options for multifactor authentication.
        """
        return pulumi.get(self, "mfa")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The public name of the email or SMS Connection. In most cases this is the same name as the connection name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nonPersistentAttrs")
    def non_persistent_attrs(self) -> Optional[Sequence[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 here.
        """
        return pulumi.get(self, "non_persistent_attrs")

    @property
    @pulumi.getter(name="passwordComplexityOptions")
    def password_complexity_options(self) -> Optional['outputs.ConnectionOptionsPasswordComplexityOptions']:
        """
        Configuration settings for password complexity.
        """
        return pulumi.get(self, "password_complexity_options")

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

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

    @property
    @pulumi.getter(name="passwordNoPersonalInfo")
    def password_no_personal_info(self) -> Optional['outputs.ConnectionOptionsPasswordNoPersonalInfo']:
        """
        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`.
        """
        return pulumi.get(self, "password_no_personal_info")

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

    @property
    @pulumi.getter(name="pingFederateBaseUrl")
    def ping_federate_base_url(self) -> Optional[str]:
        """
        Ping Federate Server URL.
        """
        return pulumi.get(self, "ping_federate_base_url")

    @property
    @pulumi.getter(name="pkceEnabled")
    def pkce_enabled(self) -> Optional[bool]:
        """
        Enables Proof Key for Code Exchange (PKCE) functionality for OAuth2 connections.
        """
        return pulumi.get(self, "pkce_enabled")

    @property
    @pulumi.getter(name="protocolBinding")
    def protocol_binding(self) -> Optional[str]:
        """
        The SAML Response Binding: how the SAML token is received by Auth0 from the IdP.
        """
        return pulumi.get(self, "protocol_binding")

    @property
    @pulumi.getter
    def provider(self) -> Optional[str]:
        """
        Defines the custom `sms_gateway` provider.
        """
        return pulumi.get(self, "provider")

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

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

    @property
    @pulumi.getter
    def scopes(self) -> Optional[Sequence[str]]:
        """
        Permissions to grant to the connection. Within the Auth0 dashboard these appear under the "Attributes" and "Extended Attributes" sections. Some examples: `basic_profile`, `ext_profile`, `ext_nested_groups`, etc.
        """
        return pulumi.get(self, "scopes")

    @property
    @pulumi.getter
    def scripts(self) -> Optional[Mapping[str, str]]:
        """
        A map of scripts used for an OAuth connection. Only accepts a `fetchUserProfile` script.
        """
        return pulumi.get(self, "scripts")

    @property
    @pulumi.getter(name="setUserRootAttributes")
    def set_user_root_attributes(self) -> Optional[str]:
        """
        Determines whether to sync user profile attributes (`name`, `given_name`, `family_name`, `nickname`, `picture`) at each login or only on the first login. Options include: `on_each_login`, `on_first_login`. Default value: `on_each_login`.
        """
        return pulumi.get(self, "set_user_root_attributes")

    @property
    @pulumi.getter(name="shouldTrustEmailVerifiedConnection")
    def should_trust_email_verified_connection(self) -> Optional[str]:
        """
        Choose how Auth0 sets the email_verified field in the user profile.
        """
        return pulumi.get(self, "should_trust_email_verified_connection")

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

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

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

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

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

    @property
    @pulumi.getter(name="signingKey")
    def signing_key(self) -> Optional['outputs.ConnectionOptionsSigningKey']:
        """
        The key used to sign requests in the connection. Uses the `key` and `cert` properties to provide the private key and certificate respectively.
        """
        return pulumi.get(self, "signing_key")

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

    @property
    @pulumi.getter
    def subject(self) -> Optional[str]:
        """
        Subject line of the email.
        """
        return pulumi.get(self, "subject")

    @property
    @pulumi.getter
    def syntax(self) -> Optional[str]:
        """
        Syntax of the template body.
        """
        return pulumi.get(self, "syntax")

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

    @property
    @pulumi.getter
    def template(self) -> Optional[str]:
        """
        Body of the template.
        """
        return pulumi.get(self, "template")

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

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

    @property
    @pulumi.getter
    def totp(self) -> Optional['outputs.ConnectionOptionsTotp']:
        """
        Configuration options for one-time passwords.
        """
        return pulumi.get(self, "totp")

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

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

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Value can be `back_channel` or `front_channel`. Front Channel will use OIDC protocol with `response_mode=form_post` and `response_type=id_token`. Back Channel will use `response_type=code`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="upstreamParams")
    def upstream_params(self) -> Optional[str]:
        """
        You can pass provider-specific parameters to an identity provider during authentication. The values can either be static per connection or dynamic per user.
        """
        return pulumi.get(self, "upstream_params")

    @property
    @pulumi.getter(name="useCertAuth")
    def use_cert_auth(self) -> Optional[bool]:
        """
        Indicates whether to use cert auth or not.
        """
        return pulumi.get(self, "use_cert_auth")

    @property
    @pulumi.getter(name="useKerberos")
    def use_kerberos(self) -> Optional[bool]:
        """
        Indicates whether to use Kerberos or not.
        """
        return pulumi.get(self, "use_kerberos")

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

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

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

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

    @property
    @pulumi.getter(name="waadCommonEndpoint")
    def waad_common_endpoint(self) -> Optional[bool]:
        """
        Indicates whether 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")

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


@pulumi.output_type
class ConnectionOptionsAttributeMap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mappingMode":
            suggest = "mapping_mode"
        elif key == "userinfoScope":
            suggest = "userinfo_scope"

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

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

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

    def __init__(__self__, *,
                 mapping_mode: str,
                 attributes: Optional[str] = None,
                 userinfo_scope: Optional[str] = None):
        """
        :param str mapping_mode: Method used to map incoming claims. Possible values: `use_map` (Okta or OIDC), `bind_all` (OIDC) or `basic_profile` (Okta).
        :param str attributes: This property is an object containing mapping information that allows Auth0 to interpret incoming claims from the IdP. Mapping information must be provided as key/value pairs.
        :param str userinfo_scope: This property defines the scopes that Auth0 sends to the IdP’s UserInfo endpoint when requested.
        """
        pulumi.set(__self__, "mapping_mode", mapping_mode)
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)
        if userinfo_scope is not None:
            pulumi.set(__self__, "userinfo_scope", userinfo_scope)

    @property
    @pulumi.getter(name="mappingMode")
    def mapping_mode(self) -> str:
        """
        Method used to map incoming claims. Possible values: `use_map` (Okta or OIDC), `bind_all` (OIDC) or `basic_profile` (Okta).
        """
        return pulumi.get(self, "mapping_mode")

    @property
    @pulumi.getter
    def attributes(self) -> Optional[str]:
        """
        This property is an object containing mapping information that allows Auth0 to interpret incoming claims from the IdP. Mapping information must be provided as key/value pairs.
        """
        return pulumi.get(self, "attributes")

    @property
    @pulumi.getter(name="userinfoScope")
    def userinfo_scope(self) -> Optional[str]:
        """
        This property defines the scopes that Auth0 sends to the IdP’s UserInfo endpoint when requested.
        """
        return pulumi.get(self, "userinfo_scope")


@pulumi.output_type
class ConnectionOptionsConnectionSettings(dict):
    def __init__(__self__, *,
                 pkce: str):
        """
        :param str pkce: PKCE configuration. Possible values: `auto` (uses the strongest algorithm available), `S256` (uses the SHA-256 algorithm), `plain` (uses plaintext as described in the PKCE specification) or `disabled` (disables support for PKCE).
        """
        pulumi.set(__self__, "pkce", pkce)

    @property
    @pulumi.getter
    def pkce(self) -> str:
        """
        PKCE configuration. Possible values: `auto` (uses the strongest algorithm available), `S256` (uses the SHA-256 algorithm), `plain` (uses plaintext as described in the PKCE specification) or `disabled` (disables support for PKCE).
        """
        return pulumi.get(self, "pkce")


@pulumi.output_type
class ConnectionOptionsDecryptionKey(dict):
    def __init__(__self__, *,
                 cert: str,
                 key: str):
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def cert(self) -> str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")


@pulumi.output_type
class ConnectionOptionsGatewayAuthentication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretBase64Encoded":
            suggest = "secret_base64_encoded"

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

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

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

    def __init__(__self__, *,
                 audience: Optional[str] = None,
                 method: Optional[str] = None,
                 secret: Optional[str] = None,
                 secret_base64_encoded: Optional[bool] = None,
                 subject: Optional[str] = None):
        """
        :param str audience: Audience claim for the HS256 token sent to `gateway_url`.
        :param str method: Authentication method (default is `bearer` token).
        :param str secret: Secret used to sign the HS256 token sent to `gateway_url`.
        :param bool secret_base64_encoded: Specifies whether or not the secret is Base64-encoded.
        :param str subject: Subject claim for the HS256 token sent to `gateway_url`.
        """
        if audience is not None:
            pulumi.set(__self__, "audience", audience)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if secret_base64_encoded is not None:
            pulumi.set(__self__, "secret_base64_encoded", secret_base64_encoded)
        if subject is not None:
            pulumi.set(__self__, "subject", subject)

    @property
    @pulumi.getter
    def audience(self) -> Optional[str]:
        """
        Audience claim for the HS256 token sent to `gateway_url`.
        """
        return pulumi.get(self, "audience")

    @property
    @pulumi.getter
    def method(self) -> Optional[str]:
        """
        Authentication method (default is `bearer` token).
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def secret(self) -> Optional[str]:
        """
        Secret used to sign the HS256 token sent to `gateway_url`.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter(name="secretBase64Encoded")
    def secret_base64_encoded(self) -> Optional[bool]:
        """
        Specifies whether or not the secret is Base64-encoded.
        """
        return pulumi.get(self, "secret_base64_encoded")

    @property
    @pulumi.getter
    def subject(self) -> Optional[str]:
        """
        Subject claim for the HS256 token sent to `gateway_url`.
        """
        return pulumi.get(self, "subject")


@pulumi.output_type
class ConnectionOptionsIdpInitiated(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientAuthorizeQuery":
            suggest = "client_authorize_query"
        elif key == "clientId":
            suggest = "client_id"
        elif key == "clientProtocol":
            suggest = "client_protocol"

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

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

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

    def __init__(__self__, *,
                 client_authorize_query: Optional[str] = None,
                 client_id: Optional[str] = None,
                 client_protocol: Optional[str] = None):
        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[str]:
        return pulumi.get(self, "client_authorize_query")

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

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


@pulumi.output_type
class ConnectionOptionsMfa(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "returnEnrollSettings":
            suggest = "return_enroll_settings"

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

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

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

    def __init__(__self__, *,
                 active: Optional[bool] = None,
                 return_enroll_settings: Optional[bool] = None):
        """
        :param bool active: Indicates whether multifactor authentication is enabled for this connection.
        :param 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[bool]:
        """
        Indicates whether multifactor authentication is enabled for this connection.
        """
        return pulumi.get(self, "active")

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


@pulumi.output_type
class ConnectionOptionsPasswordComplexityOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "minLength":
            suggest = "min_length"

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

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

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

    def __init__(__self__, *,
                 min_length: Optional[int] = None):
        """
        :param 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[int]:
        """
        Minimum number of characters allowed in passwords.
        """
        return pulumi.get(self, "min_length")


@pulumi.output_type
class ConnectionOptionsPasswordDictionary(dict):
    def __init__(__self__, *,
                 dictionaries: Optional[Sequence[str]] = None,
                 enable: Optional[bool] = None):
        """
        :param Sequence[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 bool enable: Indicates whether the password dictionary check is enabled for this connection.
        """
        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[Sequence[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")

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


@pulumi.output_type
class ConnectionOptionsPasswordHistory(dict):
    def __init__(__self__, *,
                 enable: Optional[bool] = None,
                 size: Optional[int] = None):
        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[bool]:
        return pulumi.get(self, "enable")

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


@pulumi.output_type
class ConnectionOptionsPasswordNoPersonalInfo(dict):
    def __init__(__self__, *,
                 enable: Optional[bool] = None):
        if enable is not None:
            pulumi.set(__self__, "enable", enable)

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


@pulumi.output_type
class ConnectionOptionsSigningKey(dict):
    def __init__(__self__, *,
                 cert: str,
                 key: str):
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def cert(self) -> str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")


@pulumi.output_type
class ConnectionOptionsTotp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeStep":
            suggest = "time_step"

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

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

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

    def __init__(__self__, *,
                 length: Optional[int] = None,
                 time_step: Optional[int] = None):
        """
        :param int length: Length of the one-time password.
        :param int time_step: 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[int]:
        """
        Length of the one-time password.
        """
        return pulumi.get(self, "length")

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


@pulumi.output_type
class ConnectionOptionsValidation(dict):
    def __init__(__self__, *,
                 username: Optional['outputs.ConnectionOptionsValidationUsername'] = None):
        """
        :param 'ConnectionOptionsValidationUsernameArgs' username: Specifies the `min` and `max` values of username length.
        """
        if username is not None:
            pulumi.set(__self__, "username", username)

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


@pulumi.output_type
class ConnectionOptionsValidationUsername(dict):
    def __init__(__self__, *,
                 max: Optional[int] = None,
                 min: Optional[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[int]:
        return pulumi.get(self, "max")

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


@pulumi.output_type
class CustomDomainVerification(dict):
    def __init__(__self__, *,
                 methods: Optional[Sequence[Any]] = None):
        """
        :param Sequence[Any] methods: Verification methods for the domain.
        """
        if methods is not None:
            pulumi.set(__self__, "methods", methods)

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


@pulumi.output_type
class EmailProviderCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKeyId":
            suggest = "access_key_id"
        elif key == "apiKey":
            suggest = "api_key"
        elif key == "azureCsConnectionString":
            suggest = "azure_cs_connection_string"
        elif key == "ms365ClientId":
            suggest = "ms365_client_id"
        elif key == "ms365ClientSecret":
            suggest = "ms365_client_secret"
        elif key == "ms365TenantId":
            suggest = "ms365_tenant_id"
        elif key == "secretAccessKey":
            suggest = "secret_access_key"
        elif key == "smtpHost":
            suggest = "smtp_host"
        elif key == "smtpPass":
            suggest = "smtp_pass"
        elif key == "smtpPort":
            suggest = "smtp_port"
        elif key == "smtpUser":
            suggest = "smtp_user"

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

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

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

    def __init__(__self__, *,
                 access_key_id: Optional[str] = None,
                 api_key: Optional[str] = None,
                 azure_cs_connection_string: Optional[str] = None,
                 domain: Optional[str] = None,
                 ms365_client_id: Optional[str] = None,
                 ms365_client_secret: Optional[str] = None,
                 ms365_tenant_id: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_access_key: Optional[str] = None,
                 smtp_host: Optional[str] = None,
                 smtp_pass: Optional[str] = None,
                 smtp_port: Optional[int] = None,
                 smtp_user: Optional[str] = None):
        """
        :param str access_key_id: AWS Access Key ID. Used only for AWS.
        :param str api_key: API Key for your email service. Will always be encrypted in our database.
        :param str azure_cs_connection_string: Azure Communication Services Connection String.
        :param str domain: Domain name.
        :param str ms365_client_id: Microsoft 365 Client ID.
        :param str ms365_client_secret: Microsoft 365 Client Secret.
        :param str ms365_tenant_id: Microsoft 365 Tenant ID.
        :param str region: Default region. Used only for AWS, Mailgun, and SparkPost.
        :param str secret_access_key: AWS Secret Key. Will always be encrypted in our database. Used only for AWS.
        :param str smtp_host: Hostname or IP address of your SMTP server. Used only for SMTP.
        :param str smtp_pass: SMTP password. Used only for SMTP.
        :param int smtp_port: 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 str smtp_user: 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 azure_cs_connection_string is not None:
            pulumi.set(__self__, "azure_cs_connection_string", azure_cs_connection_string)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if ms365_client_id is not None:
            pulumi.set(__self__, "ms365_client_id", ms365_client_id)
        if ms365_client_secret is not None:
            pulumi.set(__self__, "ms365_client_secret", ms365_client_secret)
        if ms365_tenant_id is not None:
            pulumi.set(__self__, "ms365_tenant_id", ms365_tenant_id)
        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[str]:
        """
        AWS Access Key ID. Used only for AWS.
        """
        return pulumi.get(self, "access_key_id")

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

    @property
    @pulumi.getter(name="azureCsConnectionString")
    def azure_cs_connection_string(self) -> Optional[str]:
        """
        Azure Communication Services Connection String.
        """
        return pulumi.get(self, "azure_cs_connection_string")

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

    @property
    @pulumi.getter(name="ms365ClientId")
    def ms365_client_id(self) -> Optional[str]:
        """
        Microsoft 365 Client ID.
        """
        return pulumi.get(self, "ms365_client_id")

    @property
    @pulumi.getter(name="ms365ClientSecret")
    def ms365_client_secret(self) -> Optional[str]:
        """
        Microsoft 365 Client Secret.
        """
        return pulumi.get(self, "ms365_client_secret")

    @property
    @pulumi.getter(name="ms365TenantId")
    def ms365_tenant_id(self) -> Optional[str]:
        """
        Microsoft 365 Tenant ID.
        """
        return pulumi.get(self, "ms365_tenant_id")

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

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

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

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

    @property
    @pulumi.getter(name="smtpPort")
    def smtp_port(self) -> Optional[int]:
        """
        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")

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


@pulumi.output_type
class EmailProviderSettings(dict):
    def __init__(__self__, *,
                 headers: Optional['outputs.EmailProviderSettingsHeaders'] = None,
                 message: Optional['outputs.EmailProviderSettingsMessage'] = None):
        """
        :param 'EmailProviderSettingsHeadersArgs' headers: Headers settings for the `smtp` email provider.
        :param 'EmailProviderSettingsMessageArgs' message: Message settings for the `mandrill` or `ses` email provider.
        """
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if message is not None:
            pulumi.set(__self__, "message", message)

    @property
    @pulumi.getter
    def headers(self) -> Optional['outputs.EmailProviderSettingsHeaders']:
        """
        Headers settings for the `smtp` email provider.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def message(self) -> Optional['outputs.EmailProviderSettingsMessage']:
        """
        Message settings for the `mandrill` or `ses` email provider.
        """
        return pulumi.get(self, "message")


@pulumi.output_type
class EmailProviderSettingsHeaders(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "xMcViewContentLink":
            suggest = "x_mc_view_content_link"
        elif key == "xSesConfigurationSet":
            suggest = "x_ses_configuration_set"

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

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

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

    def __init__(__self__, *,
                 x_mc_view_content_link: Optional[str] = None,
                 x_ses_configuration_set: Optional[str] = None):
        """
        :param str x_mc_view_content_link: Disable or enable the default View Content Link for sensitive emails.
        :param str x_ses_configuration_set: SES Configuration set to include when sending emails.
        """
        if x_mc_view_content_link is not None:
            pulumi.set(__self__, "x_mc_view_content_link", x_mc_view_content_link)
        if x_ses_configuration_set is not None:
            pulumi.set(__self__, "x_ses_configuration_set", x_ses_configuration_set)

    @property
    @pulumi.getter(name="xMcViewContentLink")
    def x_mc_view_content_link(self) -> Optional[str]:
        """
        Disable or enable the default View Content Link for sensitive emails.
        """
        return pulumi.get(self, "x_mc_view_content_link")

    @property
    @pulumi.getter(name="xSesConfigurationSet")
    def x_ses_configuration_set(self) -> Optional[str]:
        """
        SES Configuration set to include when sending emails.
        """
        return pulumi.get(self, "x_ses_configuration_set")


@pulumi.output_type
class EmailProviderSettingsMessage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configurationSetName":
            suggest = "configuration_set_name"
        elif key == "viewContentLink":
            suggest = "view_content_link"

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

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

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

    def __init__(__self__, *,
                 configuration_set_name: Optional[str] = None,
                 view_content_link: Optional[bool] = None):
        """
        :param str configuration_set_name: Setting for the `ses` email provider. The name of the configuration set to apply to the sent emails.
        :param bool view_content_link: Setting for the `mandrill` email provider. Set to `true` to see the content of individual emails sent to users.
        """
        if configuration_set_name is not None:
            pulumi.set(__self__, "configuration_set_name", configuration_set_name)
        if view_content_link is not None:
            pulumi.set(__self__, "view_content_link", view_content_link)

    @property
    @pulumi.getter(name="configurationSetName")
    def configuration_set_name(self) -> Optional[str]:
        """
        Setting for the `ses` email provider. The name of the configuration set to apply to the sent emails.
        """
        return pulumi.get(self, "configuration_set_name")

    @property
    @pulumi.getter(name="viewContentLink")
    def view_content_link(self) -> Optional[bool]:
        """
        Setting for the `mandrill` email provider. Set to `true` to see the content of individual emails sent to users.
        """
        return pulumi.get(self, "view_content_link")


@pulumi.output_type
class GuardianDuo(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "integrationKey":
            suggest = "integration_key"
        elif key == "secretKey":
            suggest = "secret_key"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 hostname: Optional[str] = None,
                 integration_key: Optional[str] = None,
                 secret_key: Optional[str] = None):
        """
        :param bool enabled: Indicates whether Duo MFA is enabled.
        :param str hostname: Duo API Hostname, see the Duo documentation for more details on Duo setup.
        :param str integration_key: Duo client ID, see the Duo documentation for more details on Duo setup.
        :param str secret_key: Duo client secret, see the Duo documentation for more details on Duo setup.
        """
        pulumi.set(__self__, "enabled", enabled)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if integration_key is not None:
            pulumi.set(__self__, "integration_key", integration_key)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether Duo MFA is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def hostname(self) -> Optional[str]:
        """
        Duo API Hostname, see the Duo documentation for more details on Duo setup.
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter(name="integrationKey")
    def integration_key(self) -> Optional[str]:
        """
        Duo client ID, see the Duo documentation for more details on Duo setup.
        """
        return pulumi.get(self, "integration_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        """
        Duo client secret, see the Duo documentation for more details on Duo setup.
        """
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GuardianPhone(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "messageTypes":
            suggest = "message_types"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 message_types: Optional[Sequence[str]] = None,
                 options: Optional['outputs.GuardianPhoneOptions'] = None,
                 provider: Optional[str] = None):
        """
        :param bool enabled: Indicates whether Phone MFA is enabled.
        :param Sequence[str] message_types: Message types to use, array of `sms` and/or `voice`. Adding both to the array should enable the user to choose.
        :param 'GuardianPhoneOptionsArgs' options: Options for the various providers.
        :param str provider: Provider to use, one of `auth0`, `twilio` or `phone-message-hook`. Selecting `phone-message-hook` will require a Phone Message Action to be created before. [Learn how](https://auth0.com/docs/customize/actions/flows-and-triggers/send-phone-message-flow).
        """
        pulumi.set(__self__, "enabled", enabled)
        if message_types is not None:
            pulumi.set(__self__, "message_types", message_types)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether Phone MFA is enabled.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def options(self) -> Optional['outputs.GuardianPhoneOptions']:
        """
        Options for the various providers.
        """
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> Optional[str]:
        """
        Provider to use, one of `auth0`, `twilio` or `phone-message-hook`. Selecting `phone-message-hook` will require a Phone Message Action to be created before. [Learn how](https://auth0.com/docs/customize/actions/flows-and-triggers/send-phone-message-flow).
        """
        return pulumi.get(self, "provider")


@pulumi.output_type
class GuardianPhoneOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authToken":
            suggest = "auth_token"
        elif key == "enrollmentMessage":
            suggest = "enrollment_message"
        elif key == "from":
            suggest = "from_"
        elif key == "messagingServiceSid":
            suggest = "messaging_service_sid"
        elif key == "verificationMessage":
            suggest = "verification_message"

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

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

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

    def __init__(__self__, *,
                 auth_token: Optional[str] = None,
                 enrollment_message: Optional[str] = None,
                 from_: Optional[str] = None,
                 messaging_service_sid: Optional[str] = None,
                 sid: Optional[str] = None,
                 verification_message: Optional[str] = None):
        """
        :param str auth_token: AuthToken for your Twilio account.
        :param str enrollment_message: 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/customize/customize-sms-or-voice-messages).
        :param str from_: Phone number to use as the sender.
        :param str messaging_service_sid: Messaging service SID.
        :param str sid: SID for your Twilio account.
        :param str verification_message: This message will be sent whenever a user logs in after the enrollment. Supports Liquid syntax, see [Auth0 docs](https://auth0.com/docs/customize/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[str]:
        """
        AuthToken for your Twilio account.
        """
        return pulumi.get(self, "auth_token")

    @property
    @pulumi.getter(name="enrollmentMessage")
    def enrollment_message(self) -> Optional[str]:
        """
        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/customize/customize-sms-or-voice-messages).
        """
        return pulumi.get(self, "enrollment_message")

    @property
    @pulumi.getter(name="from")
    def from_(self) -> Optional[str]:
        """
        Phone number to use as the sender.
        """
        return pulumi.get(self, "from_")

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

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

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


@pulumi.output_type
class GuardianPush(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "amazonSns":
            suggest = "amazon_sns"
        elif key == "customApp":
            suggest = "custom_app"
        elif key == "directApns":
            suggest = "direct_apns"
        elif key == "directFcm":
            suggest = "direct_fcm"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 amazon_sns: Optional['outputs.GuardianPushAmazonSns'] = None,
                 custom_app: Optional['outputs.GuardianPushCustomApp'] = None,
                 direct_apns: Optional['outputs.GuardianPushDirectApns'] = None,
                 direct_fcm: Optional['outputs.GuardianPushDirectFcm'] = None,
                 provider: Optional[str] = None):
        """
        :param bool enabled: Indicates whether Push MFA is enabled.
        :param 'GuardianPushAmazonSnsArgs' amazon_sns: Configuration for Amazon SNS.
        :param 'GuardianPushCustomAppArgs' custom_app: Configuration for the Guardian Custom App.
        :param 'GuardianPushDirectApnsArgs' direct_apns: Configuration for the Apple Push Notification service (APNs) settings.
        :param 'GuardianPushDirectFcmArgs' direct_fcm: Configuration for Firebase Cloud Messaging (FCM) settings.
        :param str provider: Provider to use, one of `direct`, `guardian`, `sns`.
        """
        pulumi.set(__self__, "enabled", enabled)
        if amazon_sns is not None:
            pulumi.set(__self__, "amazon_sns", amazon_sns)
        if custom_app is not None:
            pulumi.set(__self__, "custom_app", custom_app)
        if direct_apns is not None:
            pulumi.set(__self__, "direct_apns", direct_apns)
        if direct_fcm is not None:
            pulumi.set(__self__, "direct_fcm", direct_fcm)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether Push MFA is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="amazonSns")
    def amazon_sns(self) -> Optional['outputs.GuardianPushAmazonSns']:
        """
        Configuration for Amazon SNS.
        """
        return pulumi.get(self, "amazon_sns")

    @property
    @pulumi.getter(name="customApp")
    def custom_app(self) -> Optional['outputs.GuardianPushCustomApp']:
        """
        Configuration for the Guardian Custom App.
        """
        return pulumi.get(self, "custom_app")

    @property
    @pulumi.getter(name="directApns")
    def direct_apns(self) -> Optional['outputs.GuardianPushDirectApns']:
        """
        Configuration for the Apple Push Notification service (APNs) settings.
        """
        return pulumi.get(self, "direct_apns")

    @property
    @pulumi.getter(name="directFcm")
    def direct_fcm(self) -> Optional['outputs.GuardianPushDirectFcm']:
        """
        Configuration for Firebase Cloud Messaging (FCM) settings.
        """
        return pulumi.get(self, "direct_fcm")

    @property
    @pulumi.getter
    def provider(self) -> Optional[str]:
        """
        Provider to use, one of `direct`, `guardian`, `sns`.
        """
        return pulumi.get(self, "provider")


@pulumi.output_type
class GuardianPushAmazonSns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsAccessKeyId":
            suggest = "aws_access_key_id"
        elif key == "awsRegion":
            suggest = "aws_region"
        elif key == "awsSecretAccessKey":
            suggest = "aws_secret_access_key"
        elif key == "snsApnsPlatformApplicationArn":
            suggest = "sns_apns_platform_application_arn"
        elif key == "snsGcmPlatformApplicationArn":
            suggest = "sns_gcm_platform_application_arn"

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

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

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

    def __init__(__self__, *,
                 aws_access_key_id: str,
                 aws_region: str,
                 aws_secret_access_key: str,
                 sns_apns_platform_application_arn: str,
                 sns_gcm_platform_application_arn: str):
        """
        :param str aws_access_key_id: Your AWS Access Key ID.
        :param str aws_region: Your AWS application's region.
        :param str aws_secret_access_key: Your AWS Secret Access Key.
        :param str sns_apns_platform_application_arn: The Amazon Resource Name for your Apple Push Notification Service.
        :param str sns_gcm_platform_application_arn: The Amazon Resource Name for your Firebase Cloud Messaging Service.
        """
        pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        pulumi.set(__self__, "aws_region", aws_region)
        pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        pulumi.set(__self__, "sns_apns_platform_application_arn", sns_apns_platform_application_arn)
        pulumi.set(__self__, "sns_gcm_platform_application_arn", sns_gcm_platform_application_arn)

    @property
    @pulumi.getter(name="awsAccessKeyId")
    def aws_access_key_id(self) -> str:
        """
        Your AWS Access Key ID.
        """
        return pulumi.get(self, "aws_access_key_id")

    @property
    @pulumi.getter(name="awsRegion")
    def aws_region(self) -> str:
        """
        Your AWS application's region.
        """
        return pulumi.get(self, "aws_region")

    @property
    @pulumi.getter(name="awsSecretAccessKey")
    def aws_secret_access_key(self) -> str:
        """
        Your AWS Secret Access Key.
        """
        return pulumi.get(self, "aws_secret_access_key")

    @property
    @pulumi.getter(name="snsApnsPlatformApplicationArn")
    def sns_apns_platform_application_arn(self) -> str:
        """
        The Amazon Resource Name for your Apple Push Notification Service.
        """
        return pulumi.get(self, "sns_apns_platform_application_arn")

    @property
    @pulumi.getter(name="snsGcmPlatformApplicationArn")
    def sns_gcm_platform_application_arn(self) -> str:
        """
        The Amazon Resource Name for your Firebase Cloud Messaging Service.
        """
        return pulumi.get(self, "sns_gcm_platform_application_arn")


@pulumi.output_type
class GuardianPushCustomApp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appName":
            suggest = "app_name"
        elif key == "appleAppLink":
            suggest = "apple_app_link"
        elif key == "googleAppLink":
            suggest = "google_app_link"

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

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

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

    def __init__(__self__, *,
                 app_name: Optional[str] = None,
                 apple_app_link: Optional[str] = None,
                 google_app_link: Optional[str] = None):
        """
        :param str app_name: Custom Application Name.
        :param str apple_app_link: Apple App Store URL. Must be HTTPS or an empty string.
        :param str google_app_link: Google Store URL. Must be HTTPS or an empty string.
        """
        if app_name is not None:
            pulumi.set(__self__, "app_name", app_name)
        if apple_app_link is not None:
            pulumi.set(__self__, "apple_app_link", apple_app_link)
        if google_app_link is not None:
            pulumi.set(__self__, "google_app_link", google_app_link)

    @property
    @pulumi.getter(name="appName")
    def app_name(self) -> Optional[str]:
        """
        Custom Application Name.
        """
        return pulumi.get(self, "app_name")

    @property
    @pulumi.getter(name="appleAppLink")
    def apple_app_link(self) -> Optional[str]:
        """
        Apple App Store URL. Must be HTTPS or an empty string.
        """
        return pulumi.get(self, "apple_app_link")

    @property
    @pulumi.getter(name="googleAppLink")
    def google_app_link(self) -> Optional[str]:
        """
        Google Store URL. Must be HTTPS or an empty string.
        """
        return pulumi.get(self, "google_app_link")


@pulumi.output_type
class GuardianPushDirectApns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bundleId":
            suggest = "bundle_id"

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

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

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

    def __init__(__self__, *,
                 bundle_id: str,
                 p12: str,
                 sandbox: bool,
                 enabled: Optional[bool] = None):
        """
        :param str bundle_id: The Apple Push Notification service Bundle ID.
        :param str p12: The base64 encoded certificate in P12 format.
        :param bool sandbox: Set to true to use the sandbox iOS app environment, otherwise set to false to use the production iOS app environment.
        :param bool enabled: Indicates whether the Apple Push Notification service is enabled.
        """
        pulumi.set(__self__, "bundle_id", bundle_id)
        pulumi.set(__self__, "p12", p12)
        pulumi.set(__self__, "sandbox", sandbox)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="bundleId")
    def bundle_id(self) -> str:
        """
        The Apple Push Notification service Bundle ID.
        """
        return pulumi.get(self, "bundle_id")

    @property
    @pulumi.getter
    def p12(self) -> str:
        """
        The base64 encoded certificate in P12 format.
        """
        return pulumi.get(self, "p12")

    @property
    @pulumi.getter
    def sandbox(self) -> bool:
        """
        Set to true to use the sandbox iOS app environment, otherwise set to false to use the production iOS app environment.
        """
        return pulumi.get(self, "sandbox")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Indicates whether the Apple Push Notification service is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GuardianPushDirectFcm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serverKey":
            suggest = "server_key"

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

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

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

    def __init__(__self__, *,
                 server_key: str):
        """
        :param str server_key: The Firebase Cloud Messaging Server Key. For security purposes, we don’t retrieve your existing FCM server key to check for drift.
        """
        pulumi.set(__self__, "server_key", server_key)

    @property
    @pulumi.getter(name="serverKey")
    def server_key(self) -> str:
        """
        The Firebase Cloud Messaging Server Key. For security purposes, we don’t retrieve your existing FCM server key to check for drift.
        """
        return pulumi.get(self, "server_key")


@pulumi.output_type
class GuardianWebauthnPlatform(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "overrideRelyingParty":
            suggest = "override_relying_party"
        elif key == "relyingPartyIdentifier":
            suggest = "relying_party_identifier"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 override_relying_party: Optional[bool] = None,
                 relying_party_identifier: Optional[str] = None):
        """
        :param bool enabled: Indicates whether WebAuthn with FIDO Device Biometrics MFA is enabled.
        :param bool override_relying_party: The Relying Party is the domain for which the WebAuthn keys will be issued, set to `true` if you are customizing the identifier.
        :param str relying_party_identifier: The Relying Party should be a suffix of the custom domain.
        """
        pulumi.set(__self__, "enabled", enabled)
        if override_relying_party is not None:
            pulumi.set(__self__, "override_relying_party", override_relying_party)
        if relying_party_identifier is not None:
            pulumi.set(__self__, "relying_party_identifier", relying_party_identifier)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether WebAuthn with FIDO Device Biometrics MFA is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="overrideRelyingParty")
    def override_relying_party(self) -> Optional[bool]:
        """
        The Relying Party is the domain for which the WebAuthn keys will be issued, set to `true` if you are customizing the identifier.
        """
        return pulumi.get(self, "override_relying_party")

    @property
    @pulumi.getter(name="relyingPartyIdentifier")
    def relying_party_identifier(self) -> Optional[str]:
        """
        The Relying Party should be a suffix of the custom domain.
        """
        return pulumi.get(self, "relying_party_identifier")


@pulumi.output_type
class GuardianWebauthnRoaming(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "overrideRelyingParty":
            suggest = "override_relying_party"
        elif key == "relyingPartyIdentifier":
            suggest = "relying_party_identifier"
        elif key == "userVerification":
            suggest = "user_verification"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 override_relying_party: Optional[bool] = None,
                 relying_party_identifier: Optional[str] = None,
                 user_verification: Optional[str] = None):
        """
        :param bool enabled: Indicates whether WebAuthn with FIDO Security Keys MFA is enabled.
        :param bool override_relying_party: The Relying Party is the domain for which the WebAuthn keys will be issued, set to `true` if you are customizing the identifier.
        :param str relying_party_identifier: The Relying Party should be a suffix of the custom domain.
        :param str user_verification: User verification, one of `discouraged`, `preferred` or `required`.
        """
        pulumi.set(__self__, "enabled", enabled)
        if override_relying_party is not None:
            pulumi.set(__self__, "override_relying_party", override_relying_party)
        if relying_party_identifier is not None:
            pulumi.set(__self__, "relying_party_identifier", relying_party_identifier)
        if user_verification is not None:
            pulumi.set(__self__, "user_verification", user_verification)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether WebAuthn with FIDO Security Keys MFA is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="overrideRelyingParty")
    def override_relying_party(self) -> Optional[bool]:
        """
        The Relying Party is the domain for which the WebAuthn keys will be issued, set to `true` if you are customizing the identifier.
        """
        return pulumi.get(self, "override_relying_party")

    @property
    @pulumi.getter(name="relyingPartyIdentifier")
    def relying_party_identifier(self) -> Optional[str]:
        """
        The Relying Party should be a suffix of the custom domain.
        """
        return pulumi.get(self, "relying_party_identifier")

    @property
    @pulumi.getter(name="userVerification")
    def user_verification(self) -> Optional[str]:
        """
        User verification, one of `discouraged`, `preferred` or `required`.
        """
        return pulumi.get(self, "user_verification")


@pulumi.output_type
class LogStreamSink(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsAccountId":
            suggest = "aws_account_id"
        elif key == "awsPartnerEventSource":
            suggest = "aws_partner_event_source"
        elif key == "awsRegion":
            suggest = "aws_region"
        elif key == "azurePartnerTopic":
            suggest = "azure_partner_topic"
        elif key == "azureRegion":
            suggest = "azure_region"
        elif key == "azureResourceGroup":
            suggest = "azure_resource_group"
        elif key == "azureSubscriptionId":
            suggest = "azure_subscription_id"
        elif key == "datadogApiKey":
            suggest = "datadog_api_key"
        elif key == "datadogRegion":
            suggest = "datadog_region"
        elif key == "httpAuthorization":
            suggest = "http_authorization"
        elif key == "httpContentFormat":
            suggest = "http_content_format"
        elif key == "httpContentType":
            suggest = "http_content_type"
        elif key == "httpCustomHeaders":
            suggest = "http_custom_headers"
        elif key == "httpEndpoint":
            suggest = "http_endpoint"
        elif key == "mixpanelProjectId":
            suggest = "mixpanel_project_id"
        elif key == "mixpanelRegion":
            suggest = "mixpanel_region"
        elif key == "mixpanelServiceAccountPassword":
            suggest = "mixpanel_service_account_password"
        elif key == "mixpanelServiceAccountUsername":
            suggest = "mixpanel_service_account_username"
        elif key == "segmentWriteKey":
            suggest = "segment_write_key"
        elif key == "splunkDomain":
            suggest = "splunk_domain"
        elif key == "splunkPort":
            suggest = "splunk_port"
        elif key == "splunkSecure":
            suggest = "splunk_secure"
        elif key == "splunkToken":
            suggest = "splunk_token"
        elif key == "sumoSourceAddress":
            suggest = "sumo_source_address"

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

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

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

    def __init__(__self__, *,
                 aws_account_id: Optional[str] = None,
                 aws_partner_event_source: Optional[str] = None,
                 aws_region: Optional[str] = None,
                 azure_partner_topic: Optional[str] = None,
                 azure_region: Optional[str] = None,
                 azure_resource_group: Optional[str] = None,
                 azure_subscription_id: Optional[str] = None,
                 datadog_api_key: Optional[str] = None,
                 datadog_region: Optional[str] = None,
                 http_authorization: Optional[str] = None,
                 http_content_format: Optional[str] = None,
                 http_content_type: Optional[str] = None,
                 http_custom_headers: Optional[Sequence[Mapping[str, str]]] = None,
                 http_endpoint: Optional[str] = None,
                 mixpanel_project_id: Optional[str] = None,
                 mixpanel_region: Optional[str] = None,
                 mixpanel_service_account_password: Optional[str] = None,
                 mixpanel_service_account_username: Optional[str] = None,
                 segment_write_key: Optional[str] = None,
                 splunk_domain: Optional[str] = None,
                 splunk_port: Optional[str] = None,
                 splunk_secure: Optional[bool] = None,
                 splunk_token: Optional[str] = None,
                 sumo_source_address: Optional[str] = None):
        """
        :param str aws_account_id: The AWS Account ID.
        :param str aws_partner_event_source: Name of the Partner Event Source to be used with AWS. Generally generated by Auth0 and passed to AWS, so this should be an output attribute.
        :param str aws_region: The region in which the EventBridge event source will be created. Possible values: `ap-east-1`, `ap-northeast-1`, `ap-northeast-2`, `ap-northeast-3`, `ap-south-1`, `ap-southeast-1`, `ap-southeast-2`, `ca-central-1`, `cn-north-1`, `cn-northwest-1`, `eu-central-1`, `eu-north-1`, `eu-west-1`, `eu-west-2`, `eu-west-3`, `me-south-1`, `sa-east-1`, `us-gov-east-1`, `us-gov-west-1`, `us-east-1`, `us-east-2`, `us-west-1`, `us-west-2`.
        :param str azure_partner_topic: Name of the Partner Topic to be used with Azure. Generally should not be specified.
        :param str azure_region: The Azure region code. Possible values: `australiacentral`, `australiaeast`, `australiasoutheast`, `brazilsouth`, `canadacentral`, `canadaeast`, `centralindia`, `centralus`, `eastasia`, `eastus`, `eastus2`, `francecentral`, `germanywestcentral`, `japaneast`, `japanwest`, `koreacentral`, `koreasouth`, `northcentralus`, `northeurope`, `norwayeast`, `southafricanorth`, `southcentralus`, `southeastasia`, `southindia`, `switzerlandnorth`, `uaenorth`, `uksouth`, `ukwest`, `westcentralus`, `westeurope`, `westindia`, `westus`, `westus2`.
        :param str azure_resource_group: The Azure EventGrid resource group which allows you to manage all Azure assets within one subscription.
        :param str azure_subscription_id: The unique alphanumeric string that identifies your Azure subscription.
        :param str datadog_api_key: The Datadog API key.
        :param str datadog_region: The Datadog region. Possible values: `us`, `eu`, `us3`, `us5`.
        :param str http_authorization: Sent in the HTTP "Authorization" header with each request.
        :param str http_content_format: The format of data sent over HTTP. Options are "JSONLINES", "JSONARRAY" or "JSONOBJECT"
        :param str http_content_type: The "Content-Type" header to send over HTTP. Common value is "application/json".
        :param Sequence[Mapping[str, str]] http_custom_headers: Additional HTTP headers to be included as part of the HTTP request.
        :param str http_endpoint: The HTTP endpoint to send streaming logs.
        :param str mixpanel_project_id: The Mixpanel project ID, found on the Project Settings page.
        :param str mixpanel_region: The Mixpanel region. Options are ["us", "eu"]. EU is required for customers with EU data residency requirements.
        :param str mixpanel_service_account_password: The Mixpanel Service Account password.
        :param str mixpanel_service_account_username: The Mixpanel Service Account username. Services Accounts can be created in the Project Settings page.
        :param str segment_write_key: The [Segment Write Key](https://segment.com/docs/connections/find-writekey/).
        :param str splunk_domain: The Splunk domain name.
        :param str splunk_port: The Splunk port.
        :param bool splunk_secure: This toggle should be turned off when using self-signed certificates.
        :param str splunk_token: The Splunk access token.
        :param str sumo_source_address: Generated URL for your defined HTTP source in Sumo Logic for collecting streaming data from Auth0.
        """
        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 mixpanel_project_id is not None:
            pulumi.set(__self__, "mixpanel_project_id", mixpanel_project_id)
        if mixpanel_region is not None:
            pulumi.set(__self__, "mixpanel_region", mixpanel_region)
        if mixpanel_service_account_password is not None:
            pulumi.set(__self__, "mixpanel_service_account_password", mixpanel_service_account_password)
        if mixpanel_service_account_username is not None:
            pulumi.set(__self__, "mixpanel_service_account_username", mixpanel_service_account_username)
        if segment_write_key is not None:
            pulumi.set(__self__, "segment_write_key", segment_write_key)
        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[str]:
        """
        The AWS Account ID.
        """
        return pulumi.get(self, "aws_account_id")

    @property
    @pulumi.getter(name="awsPartnerEventSource")
    def aws_partner_event_source(self) -> Optional[str]:
        """
        Name of the Partner Event Source to be used with AWS. Generally generated by Auth0 and passed to AWS, so this should be an output attribute.
        """
        return pulumi.get(self, "aws_partner_event_source")

    @property
    @pulumi.getter(name="awsRegion")
    def aws_region(self) -> Optional[str]:
        """
        The region in which the EventBridge event source will be created. Possible values: `ap-east-1`, `ap-northeast-1`, `ap-northeast-2`, `ap-northeast-3`, `ap-south-1`, `ap-southeast-1`, `ap-southeast-2`, `ca-central-1`, `cn-north-1`, `cn-northwest-1`, `eu-central-1`, `eu-north-1`, `eu-west-1`, `eu-west-2`, `eu-west-3`, `me-south-1`, `sa-east-1`, `us-gov-east-1`, `us-gov-west-1`, `us-east-1`, `us-east-2`, `us-west-1`, `us-west-2`.
        """
        return pulumi.get(self, "aws_region")

    @property
    @pulumi.getter(name="azurePartnerTopic")
    def azure_partner_topic(self) -> Optional[str]:
        """
        Name of the Partner Topic to be used with Azure. Generally should not be specified.
        """
        return pulumi.get(self, "azure_partner_topic")

    @property
    @pulumi.getter(name="azureRegion")
    def azure_region(self) -> Optional[str]:
        """
        The Azure region code. Possible values: `australiacentral`, `australiaeast`, `australiasoutheast`, `brazilsouth`, `canadacentral`, `canadaeast`, `centralindia`, `centralus`, `eastasia`, `eastus`, `eastus2`, `francecentral`, `germanywestcentral`, `japaneast`, `japanwest`, `koreacentral`, `koreasouth`, `northcentralus`, `northeurope`, `norwayeast`, `southafricanorth`, `southcentralus`, `southeastasia`, `southindia`, `switzerlandnorth`, `uaenorth`, `uksouth`, `ukwest`, `westcentralus`, `westeurope`, `westindia`, `westus`, `westus2`.
        """
        return pulumi.get(self, "azure_region")

    @property
    @pulumi.getter(name="azureResourceGroup")
    def azure_resource_group(self) -> Optional[str]:
        """
        The Azure EventGrid resource group which allows you to manage all Azure assets within one subscription.
        """
        return pulumi.get(self, "azure_resource_group")

    @property
    @pulumi.getter(name="azureSubscriptionId")
    def azure_subscription_id(self) -> Optional[str]:
        """
        The unique alphanumeric string that identifies your Azure subscription.
        """
        return pulumi.get(self, "azure_subscription_id")

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

    @property
    @pulumi.getter(name="datadogRegion")
    def datadog_region(self) -> Optional[str]:
        """
        The Datadog region. Possible values: `us`, `eu`, `us3`, `us5`.
        """
        return pulumi.get(self, "datadog_region")

    @property
    @pulumi.getter(name="httpAuthorization")
    def http_authorization(self) -> Optional[str]:
        """
        Sent in the HTTP "Authorization" header with each request.
        """
        return pulumi.get(self, "http_authorization")

    @property
    @pulumi.getter(name="httpContentFormat")
    def http_content_format(self) -> Optional[str]:
        """
        The format of data sent over HTTP. Options are "JSONLINES", "JSONARRAY" or "JSONOBJECT"
        """
        return pulumi.get(self, "http_content_format")

    @property
    @pulumi.getter(name="httpContentType")
    def http_content_type(self) -> Optional[str]:
        """
        The "Content-Type" header to send over HTTP. Common value is "application/json".
        """
        return pulumi.get(self, "http_content_type")

    @property
    @pulumi.getter(name="httpCustomHeaders")
    def http_custom_headers(self) -> Optional[Sequence[Mapping[str, str]]]:
        """
        Additional HTTP headers to be included as part of the HTTP request.
        """
        return pulumi.get(self, "http_custom_headers")

    @property
    @pulumi.getter(name="httpEndpoint")
    def http_endpoint(self) -> Optional[str]:
        """
        The HTTP endpoint to send streaming logs.
        """
        return pulumi.get(self, "http_endpoint")

    @property
    @pulumi.getter(name="mixpanelProjectId")
    def mixpanel_project_id(self) -> Optional[str]:
        """
        The Mixpanel project ID, found on the Project Settings page.
        """
        return pulumi.get(self, "mixpanel_project_id")

    @property
    @pulumi.getter(name="mixpanelRegion")
    def mixpanel_region(self) -> Optional[str]:
        """
        The Mixpanel region. Options are ["us", "eu"]. EU is required for customers with EU data residency requirements.
        """
        return pulumi.get(self, "mixpanel_region")

    @property
    @pulumi.getter(name="mixpanelServiceAccountPassword")
    def mixpanel_service_account_password(self) -> Optional[str]:
        """
        The Mixpanel Service Account password.
        """
        return pulumi.get(self, "mixpanel_service_account_password")

    @property
    @pulumi.getter(name="mixpanelServiceAccountUsername")
    def mixpanel_service_account_username(self) -> Optional[str]:
        """
        The Mixpanel Service Account username. Services Accounts can be created in the Project Settings page.
        """
        return pulumi.get(self, "mixpanel_service_account_username")

    @property
    @pulumi.getter(name="segmentWriteKey")
    def segment_write_key(self) -> Optional[str]:
        """
        The [Segment Write Key](https://segment.com/docs/connections/find-writekey/).
        """
        return pulumi.get(self, "segment_write_key")

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

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

    @property
    @pulumi.getter(name="splunkSecure")
    def splunk_secure(self) -> Optional[bool]:
        """
        This toggle should be turned off when using self-signed certificates.
        """
        return pulumi.get(self, "splunk_secure")

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

    @property
    @pulumi.getter(name="sumoSourceAddress")
    def sumo_source_address(self) -> Optional[str]:
        """
        Generated URL for your defined HTTP source in Sumo Logic for collecting streaming data from Auth0.
        """
        return pulumi.get(self, "sumo_source_address")


@pulumi.output_type
class OrganizationBranding(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logoUrl":
            suggest = "logo_url"

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

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

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

    def __init__(__self__, *,
                 colors: Optional[Mapping[str, str]] = None,
                 logo_url: Optional[str] = None):
        """
        :param Mapping[str, str] colors: Color scheme used to customize the login pages.
        :param str logo_url: URL of logo to display on login page.
        """
        if colors is not None:
            pulumi.set(__self__, "colors", colors)
        if logo_url is not None:
            pulumi.set(__self__, "logo_url", logo_url)

    @property
    @pulumi.getter
    def colors(self) -> Optional[Mapping[str, str]]:
        """
        Color scheme used to customize the login pages.
        """
        return pulumi.get(self, "colors")

    @property
    @pulumi.getter(name="logoUrl")
    def logo_url(self) -> Optional[str]:
        """
        URL of logo to display on login page.
        """
        return pulumi.get(self, "logo_url")


@pulumi.output_type
class OrganizationConnectionsEnabledConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionId":
            suggest = "connection_id"
        elif key == "assignMembershipOnLogin":
            suggest = "assign_membership_on_login"

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

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

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

    def __init__(__self__, *,
                 connection_id: str,
                 assign_membership_on_login: Optional[bool] = None):
        """
        :param str connection_id: The ID of the connection to enable for the organization.
        :param bool assign_membership_on_login: When true, all users that log in with this connection will be automatically granted membership in the organization. When false, users must be granted membership in the organization before logging in with this connection.
        """
        pulumi.set(__self__, "connection_id", connection_id)
        if assign_membership_on_login is not None:
            pulumi.set(__self__, "assign_membership_on_login", assign_membership_on_login)

    @property
    @pulumi.getter(name="connectionId")
    def connection_id(self) -> str:
        """
        The ID of the connection to enable for the organization.
        """
        return pulumi.get(self, "connection_id")

    @property
    @pulumi.getter(name="assignMembershipOnLogin")
    def assign_membership_on_login(self) -> Optional[bool]:
        """
        When true, all users that log in with this connection will be automatically granted membership in the organization. When false, users must be granted membership in the organization before logging in with this connection.
        """
        return pulumi.get(self, "assign_membership_on_login")


@pulumi.output_type
class PagesChangePassword(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 html: str):
        """
        :param bool enabled: Indicates whether to use the custom Reset Password HTML (`true`) or the default Auth0 page (`false`).
        :param str html: Customized content for the Reset Password page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "html", html)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether to use the custom Reset Password HTML (`true`) or the default Auth0 page (`false`).
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def html(self) -> str:
        """
        Customized content for the Reset Password page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        return pulumi.get(self, "html")


@pulumi.output_type
class PagesError(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "showLogLink":
            suggest = "show_log_link"

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

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

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

    def __init__(__self__, *,
                 show_log_link: bool,
                 html: Optional[str] = None,
                 url: Optional[str] = None):
        """
        :param bool show_log_link: Indicates whether to show the link to logs as part of the default error page.
        :param str html: Customized content for the Error page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        :param str url: URL to redirect to when an error occurs, instead of showing the default error page.
        """
        pulumi.set(__self__, "show_log_link", show_log_link)
        if html is not None:
            pulumi.set(__self__, "html", html)
        if url is not None:
            pulumi.set(__self__, "url", url)

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

    @property
    @pulumi.getter
    def html(self) -> Optional[str]:
        """
        Customized content for the Error page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        return pulumi.get(self, "html")

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


@pulumi.output_type
class PagesGuardianMfa(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 html: str):
        """
        :param bool enabled: Indicates whether to use the custom Guardian MFA HTML (`true`) or the default Auth0 page (`false`).
        :param str html: Customized content for the Guardian MFA page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "html", html)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether to use the custom Guardian MFA HTML (`true`) or the default Auth0 page (`false`).
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def html(self) -> str:
        """
        Customized content for the Guardian MFA page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        return pulumi.get(self, "html")


@pulumi.output_type
class PagesLogin(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 html: str):
        """
        :param bool enabled: Indicates whether to use the custom Login page HTML (`true`) or the default Auth0 page (`false`).
        :param str html: Customized content for the Login page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "html", html)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether to use the custom Login page HTML (`true`) or the default Auth0 page (`false`).
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def html(self) -> str:
        """
        Customized content for the Login page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        return pulumi.get(self, "html")


@pulumi.output_type
class ResourceServerScopesScope(dict):
    def __init__(__self__, *,
                 name: str,
                 description: Optional[str] = None):
        """
        :param str name: Name of the scope (permission). Examples include `read:appointments` or `delete:appointments`.
        :param str description: User-friendly description of the scope (permission).
        """
        pulumi.set(__self__, "name", name)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

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


@pulumi.output_type
class RolePermissionsPermission(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceServerIdentifier":
            suggest = "resource_server_identifier"
        elif key == "resourceServerName":
            suggest = "resource_server_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 resource_server_identifier: str,
                 description: Optional[str] = None,
                 resource_server_name: Optional[str] = None):
        """
        :param str name: Name of permission.
        :param str resource_server_identifier: Resource server identifier associated with the permission.
        :param str description: Description of the permission.
        :param str resource_server_name: Name of resource server that the permission is associated with.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_server_identifier", resource_server_identifier)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if resource_server_name is not None:
            pulumi.set(__self__, "resource_server_name", resource_server_name)

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

    @property
    @pulumi.getter(name="resourceServerIdentifier")
    def resource_server_identifier(self) -> str:
        """
        Resource server identifier associated with the permission.
        """
        return pulumi.get(self, "resource_server_identifier")

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

    @property
    @pulumi.getter(name="resourceServerName")
    def resource_server_name(self) -> Optional[str]:
        """
        Name of resource server that the permission is associated with.
        """
        return pulumi.get(self, "resource_server_name")


@pulumi.output_type
class TenantFlags(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowLegacyDelegationGrantTypes":
            suggest = "allow_legacy_delegation_grant_types"
        elif key == "allowLegacyRoGrantTypes":
            suggest = "allow_legacy_ro_grant_types"
        elif key == "allowLegacyTokeninfoEndpoint":
            suggest = "allow_legacy_tokeninfo_endpoint"
        elif key == "dashboardInsightsView":
            suggest = "dashboard_insights_view"
        elif key == "dashboardLogStreamsNext":
            suggest = "dashboard_log_streams_next"
        elif key == "disableClickjackProtectionHeaders":
            suggest = "disable_clickjack_protection_headers"
        elif key == "disableFieldsMapFix":
            suggest = "disable_fields_map_fix"
        elif key == "disableManagementApiSmsObfuscation":
            suggest = "disable_management_api_sms_obfuscation"
        elif key == "enableAdfsWaadEmailVerification":
            suggest = "enable_adfs_waad_email_verification"
        elif key == "enableApisSection":
            suggest = "enable_apis_section"
        elif key == "enableClientConnections":
            suggest = "enable_client_connections"
        elif key == "enableCustomDomainInEmails":
            suggest = "enable_custom_domain_in_emails"
        elif key == "enableDynamicClientRegistration":
            suggest = "enable_dynamic_client_registration"
        elif key == "enableIdtokenApi2":
            suggest = "enable_idtoken_api2"
        elif key == "enableLegacyLogsSearchV2":
            suggest = "enable_legacy_logs_search_v2"
        elif key == "enableLegacyProfile":
            suggest = "enable_legacy_profile"
        elif key == "enablePipeline2":
            suggest = "enable_pipeline2"
        elif key == "enablePublicSignupUserExistsError":
            suggest = "enable_public_signup_user_exists_error"
        elif key == "mfaShowFactorListOnEnrollment":
            suggest = "mfa_show_factor_list_on_enrollment"
        elif key == "noDiscloseEnterpriseConnections":
            suggest = "no_disclose_enterprise_connections"
        elif key == "requirePushedAuthorizationRequests":
            suggest = "require_pushed_authorization_requests"
        elif key == "revokeRefreshTokenGrant":
            suggest = "revoke_refresh_token_grant"
        elif key == "useScopeDescriptionsForConsent":
            suggest = "use_scope_descriptions_for_consent"

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

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

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

    def __init__(__self__, *,
                 allow_legacy_delegation_grant_types: Optional[bool] = None,
                 allow_legacy_ro_grant_types: Optional[bool] = None,
                 allow_legacy_tokeninfo_endpoint: Optional[bool] = None,
                 dashboard_insights_view: Optional[bool] = None,
                 dashboard_log_streams_next: Optional[bool] = None,
                 disable_clickjack_protection_headers: Optional[bool] = None,
                 disable_fields_map_fix: Optional[bool] = None,
                 disable_management_api_sms_obfuscation: Optional[bool] = None,
                 enable_adfs_waad_email_verification: Optional[bool] = None,
                 enable_apis_section: Optional[bool] = None,
                 enable_client_connections: Optional[bool] = None,
                 enable_custom_domain_in_emails: Optional[bool] = None,
                 enable_dynamic_client_registration: Optional[bool] = None,
                 enable_idtoken_api2: Optional[bool] = None,
                 enable_legacy_logs_search_v2: Optional[bool] = None,
                 enable_legacy_profile: Optional[bool] = None,
                 enable_pipeline2: Optional[bool] = None,
                 enable_public_signup_user_exists_error: Optional[bool] = None,
                 mfa_show_factor_list_on_enrollment: Optional[bool] = None,
                 no_disclose_enterprise_connections: Optional[bool] = None,
                 require_pushed_authorization_requests: Optional[bool] = None,
                 revoke_refresh_token_grant: Optional[bool] = None,
                 use_scope_descriptions_for_consent: Optional[bool] = None):
        """
        :param bool allow_legacy_delegation_grant_types: Whether the legacy delegation endpoint will be enabled for your account (true) or not available (false).
        :param bool allow_legacy_ro_grant_types: Whether the legacy `auth/ro` endpoint (used with resource owner password and passwordless features) will be enabled for your account (true) or not available (false).
        :param bool allow_legacy_tokeninfo_endpoint: If enabled, customers can use Tokeninfo Endpoint, otherwise they can not use it.
        :param bool dashboard_insights_view: Enables new insights activity page view.
        :param bool dashboard_log_streams_next: Enables beta access to log streaming changes.
        :param bool disable_clickjack_protection_headers: Indicates whether classic Universal Login prompts include additional security headers to prevent clickjacking.
        :param bool disable_fields_map_fix: Disables SAML fields map fix for bad mappings with repeated attributes.
        :param bool disable_management_api_sms_obfuscation: If true, SMS phone numbers will not be obfuscated in Management API GET calls.
        :param bool enable_adfs_waad_email_verification: If enabled, users will be presented with an email verification prompt during their first login when using Azure AD or ADFS connections.
        :param bool enable_apis_section: Indicates whether the APIs section is enabled for the tenant.
        :param bool enable_client_connections: Indicates whether all current connections should be enabled when a new client is created.
        :param bool enable_custom_domain_in_emails: Indicates whether the tenant allows custom domains in emails. Before enabling this flag, you must have a custom domain with status: `ready`.
        :param bool enable_dynamic_client_registration: Indicates whether the tenant allows dynamic client registration.
        :param bool enable_idtoken_api2: Whether ID tokens can be used to authorize some types of requests to API v2 (true) or not (false).
        :param bool enable_legacy_logs_search_v2: Indicates whether to use the older v2 legacy logs search.
        :param bool enable_legacy_profile: Whether ID tokens and the userinfo endpoint includes a complete user profile (true) or only OpenID Connect claims (false).
        :param bool enable_pipeline2: Indicates whether advanced API Authorization scenarios are enabled.
        :param bool enable_public_signup_user_exists_error: Indicates whether the public sign up process shows a `user_exists` error if the user already exists.
        :param bool mfa_show_factor_list_on_enrollment: Used to allow users to pick which factor to enroll with from the list of available MFA factors.
        :param bool no_disclose_enterprise_connections: Do not Publish Enterprise Connections Information with IdP domains on the lock configuration file.
        :param bool require_pushed_authorization_requests: Makes the use of Pushed Authorization Requests mandatory for all clients across the tenant. This feature currently needs to be enabled on the tenant in order to make use of it.
        :param bool revoke_refresh_token_grant: Delete underlying grant when a refresh token is revoked via the Authentication API.
        :param bool use_scope_descriptions_for_consent: Indicates whether to use scope descriptions for consent.
        """
        if allow_legacy_delegation_grant_types is not None:
            pulumi.set(__self__, "allow_legacy_delegation_grant_types", allow_legacy_delegation_grant_types)
        if allow_legacy_ro_grant_types is not None:
            pulumi.set(__self__, "allow_legacy_ro_grant_types", allow_legacy_ro_grant_types)
        if allow_legacy_tokeninfo_endpoint is not None:
            pulumi.set(__self__, "allow_legacy_tokeninfo_endpoint", allow_legacy_tokeninfo_endpoint)
        if dashboard_insights_view is not None:
            pulumi.set(__self__, "dashboard_insights_view", dashboard_insights_view)
        if dashboard_log_streams_next is not None:
            pulumi.set(__self__, "dashboard_log_streams_next", dashboard_log_streams_next)
        if disable_clickjack_protection_headers is not None:
            pulumi.set(__self__, "disable_clickjack_protection_headers", disable_clickjack_protection_headers)
        if disable_fields_map_fix is not None:
            pulumi.set(__self__, "disable_fields_map_fix", disable_fields_map_fix)
        if disable_management_api_sms_obfuscation is not None:
            pulumi.set(__self__, "disable_management_api_sms_obfuscation", disable_management_api_sms_obfuscation)
        if enable_adfs_waad_email_verification is not None:
            pulumi.set(__self__, "enable_adfs_waad_email_verification", enable_adfs_waad_email_verification)
        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_idtoken_api2 is not None:
            pulumi.set(__self__, "enable_idtoken_api2", enable_idtoken_api2)
        if enable_legacy_logs_search_v2 is not None:
            pulumi.set(__self__, "enable_legacy_logs_search_v2", enable_legacy_logs_search_v2)
        if enable_legacy_profile is not None:
            pulumi.set(__self__, "enable_legacy_profile", enable_legacy_profile)
        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 mfa_show_factor_list_on_enrollment is not None:
            pulumi.set(__self__, "mfa_show_factor_list_on_enrollment", mfa_show_factor_list_on_enrollment)
        if no_disclose_enterprise_connections is not None:
            pulumi.set(__self__, "no_disclose_enterprise_connections", no_disclose_enterprise_connections)
        if require_pushed_authorization_requests is not None:
            pulumi.set(__self__, "require_pushed_authorization_requests", require_pushed_authorization_requests)
        if revoke_refresh_token_grant is not None:
            pulumi.set(__self__, "revoke_refresh_token_grant", revoke_refresh_token_grant)
        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="allowLegacyDelegationGrantTypes")
    def allow_legacy_delegation_grant_types(self) -> Optional[bool]:
        """
        Whether the legacy delegation endpoint will be enabled for your account (true) or not available (false).
        """
        return pulumi.get(self, "allow_legacy_delegation_grant_types")

    @property
    @pulumi.getter(name="allowLegacyRoGrantTypes")
    def allow_legacy_ro_grant_types(self) -> Optional[bool]:
        """
        Whether the legacy `auth/ro` endpoint (used with resource owner password and passwordless features) will be enabled for your account (true) or not available (false).
        """
        return pulumi.get(self, "allow_legacy_ro_grant_types")

    @property
    @pulumi.getter(name="allowLegacyTokeninfoEndpoint")
    def allow_legacy_tokeninfo_endpoint(self) -> Optional[bool]:
        """
        If enabled, customers can use Tokeninfo Endpoint, otherwise they can not use it.
        """
        return pulumi.get(self, "allow_legacy_tokeninfo_endpoint")

    @property
    @pulumi.getter(name="dashboardInsightsView")
    def dashboard_insights_view(self) -> Optional[bool]:
        """
        Enables new insights activity page view.
        """
        return pulumi.get(self, "dashboard_insights_view")

    @property
    @pulumi.getter(name="dashboardLogStreamsNext")
    def dashboard_log_streams_next(self) -> Optional[bool]:
        """
        Enables beta access to log streaming changes.
        """
        return pulumi.get(self, "dashboard_log_streams_next")

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

    @property
    @pulumi.getter(name="disableFieldsMapFix")
    def disable_fields_map_fix(self) -> Optional[bool]:
        """
        Disables SAML fields map fix for bad mappings with repeated attributes.
        """
        return pulumi.get(self, "disable_fields_map_fix")

    @property
    @pulumi.getter(name="disableManagementApiSmsObfuscation")
    def disable_management_api_sms_obfuscation(self) -> Optional[bool]:
        """
        If true, SMS phone numbers will not be obfuscated in Management API GET calls.
        """
        return pulumi.get(self, "disable_management_api_sms_obfuscation")

    @property
    @pulumi.getter(name="enableAdfsWaadEmailVerification")
    def enable_adfs_waad_email_verification(self) -> Optional[bool]:
        """
        If enabled, users will be presented with an email verification prompt during their first login when using Azure AD or ADFS connections.
        """
        return pulumi.get(self, "enable_adfs_waad_email_verification")

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

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

    @property
    @pulumi.getter(name="enableCustomDomainInEmails")
    def enable_custom_domain_in_emails(self) -> Optional[bool]:
        """
        Indicates whether the tenant allows custom domains in emails. Before enabling this flag, you must have a custom domain with status: `ready`.
        """
        return pulumi.get(self, "enable_custom_domain_in_emails")

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

    @property
    @pulumi.getter(name="enableIdtokenApi2")
    def enable_idtoken_api2(self) -> Optional[bool]:
        """
        Whether ID tokens can be used to authorize some types of requests to API v2 (true) or not (false).
        """
        return pulumi.get(self, "enable_idtoken_api2")

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

    @property
    @pulumi.getter(name="enableLegacyProfile")
    def enable_legacy_profile(self) -> Optional[bool]:
        """
        Whether ID tokens and the userinfo endpoint includes a complete user profile (true) or only OpenID Connect claims (false).
        """
        return pulumi.get(self, "enable_legacy_profile")

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

    @property
    @pulumi.getter(name="enablePublicSignupUserExistsError")
    def enable_public_signup_user_exists_error(self) -> Optional[bool]:
        """
        Indicates whether 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")

    @property
    @pulumi.getter(name="mfaShowFactorListOnEnrollment")
    def mfa_show_factor_list_on_enrollment(self) -> Optional[bool]:
        """
        Used to allow users to pick which factor to enroll with from the list of available MFA factors.
        """
        return pulumi.get(self, "mfa_show_factor_list_on_enrollment")

    @property
    @pulumi.getter(name="noDiscloseEnterpriseConnections")
    def no_disclose_enterprise_connections(self) -> Optional[bool]:
        """
        Do not Publish Enterprise Connections Information with IdP domains on the lock configuration file.
        """
        return pulumi.get(self, "no_disclose_enterprise_connections")

    @property
    @pulumi.getter(name="requirePushedAuthorizationRequests")
    def require_pushed_authorization_requests(self) -> Optional[bool]:
        """
        Makes the use of Pushed Authorization Requests mandatory for all clients across the tenant. This feature currently needs to be enabled on the tenant in order to make use of it.
        """
        return pulumi.get(self, "require_pushed_authorization_requests")

    @property
    @pulumi.getter(name="revokeRefreshTokenGrant")
    def revoke_refresh_token_grant(self) -> Optional[bool]:
        """
        Delete underlying grant when a refresh token is revoked via the Authentication API.
        """
        return pulumi.get(self, "revoke_refresh_token_grant")

    @property
    @pulumi.getter(name="useScopeDescriptionsForConsent")
    def use_scope_descriptions_for_consent(self) -> Optional[bool]:
        """
        Indicates whether to use scope descriptions for consent.
        """
        return pulumi.get(self, "use_scope_descriptions_for_consent")


@pulumi.output_type
class TenantSessionCookie(dict):
    def __init__(__self__, *,
                 mode: Optional[str] = None):
        """
        :param str mode: Behavior of tenant session cookie. Accepts either "persistent" or "non-persistent".
        """
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        Behavior of tenant session cookie. Accepts either "persistent" or "non-persistent".
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class TenantSessions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "oidcLogoutPromptEnabled":
            suggest = "oidc_logout_prompt_enabled"

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

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

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

    def __init__(__self__, *,
                 oidc_logout_prompt_enabled: bool):
        """
        :param bool oidc_logout_prompt_enabled: When active, users will be presented with a consent prompt to confirm the logout request if the request is not trustworthy. Turn off the consent prompt to bypass user confirmation.
        """
        pulumi.set(__self__, "oidc_logout_prompt_enabled", oidc_logout_prompt_enabled)

    @property
    @pulumi.getter(name="oidcLogoutPromptEnabled")
    def oidc_logout_prompt_enabled(self) -> bool:
        """
        When active, users will be presented with a consent prompt to confirm the logout request if the request is not trustworthy. Turn off the consent prompt to bypass user confirmation.
        """
        return pulumi.get(self, "oidc_logout_prompt_enabled")


@pulumi.output_type
class TriggerActionsAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "displayName":
            suggest = "display_name"

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

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

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

    def __init__(__self__, *,
                 display_name: str,
                 id: str):
        """
        :param str display_name: The display name of the action within the flow.
        :param str id: Action ID.
        """
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        The display name of the action within the flow.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Action ID.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class UserPermissionsPermission(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceServerIdentifier":
            suggest = "resource_server_identifier"
        elif key == "resourceServerName":
            suggest = "resource_server_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 resource_server_identifier: str,
                 description: Optional[str] = None,
                 resource_server_name: Optional[str] = None):
        """
        :param str name: Name of permission.
        :param str resource_server_identifier: Resource server identifier associated with the permission.
        :param str description: Description of the permission.
        :param str resource_server_name: Name of resource server that the permission is associated with.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_server_identifier", resource_server_identifier)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if resource_server_name is not None:
            pulumi.set(__self__, "resource_server_name", resource_server_name)

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

    @property
    @pulumi.getter(name="resourceServerIdentifier")
    def resource_server_identifier(self) -> str:
        """
        Resource server identifier associated with the permission.
        """
        return pulumi.get(self, "resource_server_identifier")

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

    @property
    @pulumi.getter(name="resourceServerName")
    def resource_server_name(self) -> Optional[str]:
        """
        Name of resource server that the permission is associated with.
        """
        return pulumi.get(self, "resource_server_name")


@pulumi.output_type
class GetAttackProtectionBreachedPasswordDetectionResult(dict):
    def __init__(__self__, *,
                 admin_notification_frequencies: Sequence[str],
                 enabled: bool,
                 method: str,
                 pre_user_registrations: Sequence['outputs.GetAttackProtectionBreachedPasswordDetectionPreUserRegistrationResult'],
                 shields: Sequence[str]):
        """
        :param Sequence[str] admin_notification_frequencies: When `admin_notification` is enabled within the `shields` property, determines how often email notifications are sent. Possible values: `immediately`, `daily`, `weekly`, `monthly`.
        :param bool enabled: Whether breached password detection is active.
        :param str method: The subscription level for breached password detection methods. Use "enhanced" to enable Credential Guard. Possible values: `standard`, `enhanced`.
        :param Sequence['GetAttackProtectionBreachedPasswordDetectionPreUserRegistrationArgs'] pre_user_registrations: Configuration options that apply before every user registration attempt. Only available on public tenants.
        :param Sequence[str] shields: Action to take when a breached password is detected. Options include: `block` (block compromised user accounts), `user_notification` (send an email to user when we detect that they are using compromised credentials) and `admin_notification` (send an email with a summary of the number of accounts logging in with compromised credentials).
        """
        pulumi.set(__self__, "admin_notification_frequencies", admin_notification_frequencies)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "method", method)
        pulumi.set(__self__, "pre_user_registrations", pre_user_registrations)
        pulumi.set(__self__, "shields", shields)

    @property
    @pulumi.getter(name="adminNotificationFrequencies")
    def admin_notification_frequencies(self) -> Sequence[str]:
        """
        When `admin_notification` is enabled within the `shields` property, determines how often email notifications are sent. Possible values: `immediately`, `daily`, `weekly`, `monthly`.
        """
        return pulumi.get(self, "admin_notification_frequencies")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether breached password detection is active.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def method(self) -> str:
        """
        The subscription level for breached password detection methods. Use "enhanced" to enable Credential Guard. Possible values: `standard`, `enhanced`.
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter(name="preUserRegistrations")
    def pre_user_registrations(self) -> Sequence['outputs.GetAttackProtectionBreachedPasswordDetectionPreUserRegistrationResult']:
        """
        Configuration options that apply before every user registration attempt. Only available on public tenants.
        """
        return pulumi.get(self, "pre_user_registrations")

    @property
    @pulumi.getter
    def shields(self) -> Sequence[str]:
        """
        Action to take when a breached password is detected. Options include: `block` (block compromised user accounts), `user_notification` (send an email to user when we detect that they are using compromised credentials) and `admin_notification` (send an email with a summary of the number of accounts logging in with compromised credentials).
        """
        return pulumi.get(self, "shields")


@pulumi.output_type
class GetAttackProtectionBreachedPasswordDetectionPreUserRegistrationResult(dict):
    def __init__(__self__, *,
                 shields: Sequence[str]):
        """
        :param Sequence[str] shields: Action to take when a breached password is detected during a signup. Possible values: `block` (block compromised credentials for new accounts), `admin_notification` (send an email notification with a summary of compromised credentials in new accounts).
        """
        pulumi.set(__self__, "shields", shields)

    @property
    @pulumi.getter
    def shields(self) -> Sequence[str]:
        """
        Action to take when a breached password is detected during a signup. Possible values: `block` (block compromised credentials for new accounts), `admin_notification` (send an email notification with a summary of compromised credentials in new accounts).
        """
        return pulumi.get(self, "shields")


@pulumi.output_type
class GetAttackProtectionBruteForceProtectionResult(dict):
    def __init__(__self__, *,
                 allowlists: Sequence[str],
                 enabled: bool,
                 max_attempts: int,
                 mode: str,
                 shields: Sequence[str]):
        """
        :param Sequence[str] allowlists: List of trusted IP addresses that will not have attack protection enforced against them. This field allows you to specify multiple IP addresses, or ranges. You can use IPv4 or IPv6 addresses and CIDR notation.
        :param bool enabled: Whether brute force attack protections are active.
        :param int max_attempts: Maximum number of consecutive failed login attempts from a single user before blocking is triggered. Only available on public tenants.
        :param str mode: Determines whether the IP address is used when counting failed attempts. Possible values: `count_per_identifier_and_ip` (lockout an account from a given IP Address) or `count_per_identifier` (lockout an account regardless of IP Address).
        :param Sequence[str] shields: Action to take when a brute force protection threshold is violated. Possible values: `block` (block login attempts for a flagged user account), `user_notification` (send an email to user when their account has been blocked).
        """
        pulumi.set(__self__, "allowlists", allowlists)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "max_attempts", max_attempts)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "shields", shields)

    @property
    @pulumi.getter
    def allowlists(self) -> Sequence[str]:
        """
        List of trusted IP addresses that will not have attack protection enforced against them. This field allows you to specify multiple IP addresses, or ranges. You can use IPv4 or IPv6 addresses and CIDR notation.
        """
        return pulumi.get(self, "allowlists")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether brute force attack protections are active.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="maxAttempts")
    def max_attempts(self) -> int:
        """
        Maximum number of consecutive failed login attempts from a single user before blocking is triggered. Only available on public tenants.
        """
        return pulumi.get(self, "max_attempts")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Determines whether the IP address is used when counting failed attempts. Possible values: `count_per_identifier_and_ip` (lockout an account from a given IP Address) or `count_per_identifier` (lockout an account regardless of IP Address).
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def shields(self) -> Sequence[str]:
        """
        Action to take when a brute force protection threshold is violated. Possible values: `block` (block login attempts for a flagged user account), `user_notification` (send an email to user when their account has been blocked).
        """
        return pulumi.get(self, "shields")


@pulumi.output_type
class GetAttackProtectionSuspiciousIpThrottlingResult(dict):
    def __init__(__self__, *,
                 allowlists: Sequence[str],
                 enabled: bool,
                 pre_logins: Sequence['outputs.GetAttackProtectionSuspiciousIpThrottlingPreLoginResult'],
                 pre_user_registrations: Sequence['outputs.GetAttackProtectionSuspiciousIpThrottlingPreUserRegistrationResult'],
                 shields: Sequence[str]):
        """
        :param Sequence[str] allowlists: List of trusted IP addresses that will not have attack protection enforced against them. This field allows you to specify multiple IP addresses, or ranges. You can use IPv4 or IPv6 addresses and CIDR notation.
        :param bool enabled: Whether suspicious IP throttling attack protections are active.
        :param Sequence['GetAttackProtectionSuspiciousIpThrottlingPreLoginArgs'] pre_logins: Configuration options that apply before every login attempt. Only available on public tenants.
        :param Sequence['GetAttackProtectionSuspiciousIpThrottlingPreUserRegistrationArgs'] pre_user_registrations: Configuration options that apply before every user registration attempt. Only available on public tenants.
        :param Sequence[str] shields: Action to take when a suspicious IP throttling threshold is violated. Possible values: `block` (throttle traffic from an IP address when there is a high number of login attempts targeting too many different accounts), `admin_notification` (send an email notification when traffic is throttled on one or more IP addresses due to high-velocity traffic).
        """
        pulumi.set(__self__, "allowlists", allowlists)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "pre_logins", pre_logins)
        pulumi.set(__self__, "pre_user_registrations", pre_user_registrations)
        pulumi.set(__self__, "shields", shields)

    @property
    @pulumi.getter
    def allowlists(self) -> Sequence[str]:
        """
        List of trusted IP addresses that will not have attack protection enforced against them. This field allows you to specify multiple IP addresses, or ranges. You can use IPv4 or IPv6 addresses and CIDR notation.
        """
        return pulumi.get(self, "allowlists")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether suspicious IP throttling attack protections are active.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="preLogins")
    def pre_logins(self) -> Sequence['outputs.GetAttackProtectionSuspiciousIpThrottlingPreLoginResult']:
        """
        Configuration options that apply before every login attempt. Only available on public tenants.
        """
        return pulumi.get(self, "pre_logins")

    @property
    @pulumi.getter(name="preUserRegistrations")
    def pre_user_registrations(self) -> Sequence['outputs.GetAttackProtectionSuspiciousIpThrottlingPreUserRegistrationResult']:
        """
        Configuration options that apply before every user registration attempt. Only available on public tenants.
        """
        return pulumi.get(self, "pre_user_registrations")

    @property
    @pulumi.getter
    def shields(self) -> Sequence[str]:
        """
        Action to take when a suspicious IP throttling threshold is violated. Possible values: `block` (throttle traffic from an IP address when there is a high number of login attempts targeting too many different accounts), `admin_notification` (send an email notification when traffic is throttled on one or more IP addresses due to high-velocity traffic).
        """
        return pulumi.get(self, "shields")


@pulumi.output_type
class GetAttackProtectionSuspiciousIpThrottlingPreLoginResult(dict):
    def __init__(__self__, *,
                 max_attempts: int,
                 rate: int):
        """
        :param int max_attempts: The maximum number of failed login attempts allowed from a single IP address.
        :param int rate: Interval of time, given in milliseconds at which new login tokens will become available after they have been used by an IP address. Each login attempt will be added on the defined throttling rate.
        """
        pulumi.set(__self__, "max_attempts", max_attempts)
        pulumi.set(__self__, "rate", rate)

    @property
    @pulumi.getter(name="maxAttempts")
    def max_attempts(self) -> int:
        """
        The maximum number of failed login attempts allowed from a single IP address.
        """
        return pulumi.get(self, "max_attempts")

    @property
    @pulumi.getter
    def rate(self) -> int:
        """
        Interval of time, given in milliseconds at which new login tokens will become available after they have been used by an IP address. Each login attempt will be added on the defined throttling rate.
        """
        return pulumi.get(self, "rate")


@pulumi.output_type
class GetAttackProtectionSuspiciousIpThrottlingPreUserRegistrationResult(dict):
    def __init__(__self__, *,
                 max_attempts: int,
                 rate: int):
        """
        :param int max_attempts: The maximum number of sign up attempts allowed from a single IP address.
        :param int rate: Interval of time, given in milliseconds at which new sign up tokens will become available after they have been used by an IP address. Each sign up attempt will be added on the defined throttling rate.
        """
        pulumi.set(__self__, "max_attempts", max_attempts)
        pulumi.set(__self__, "rate", rate)

    @property
    @pulumi.getter(name="maxAttempts")
    def max_attempts(self) -> int:
        """
        The maximum number of sign up attempts allowed from a single IP address.
        """
        return pulumi.get(self, "max_attempts")

    @property
    @pulumi.getter
    def rate(self) -> int:
        """
        Interval of time, given in milliseconds at which new sign up tokens will become available after they have been used by an IP address. Each sign up attempt will be added on the defined throttling rate.
        """
        return pulumi.get(self, "rate")


@pulumi.output_type
class GetBrandingColorResult(dict):
    def __init__(__self__, *,
                 page_background: str,
                 primary: str):
        """
        :param str page_background: Background color of login pages in hexadecimal.
        :param str primary: Primary button background color in hexadecimal.
        """
        pulumi.set(__self__, "page_background", page_background)
        pulumi.set(__self__, "primary", primary)

    @property
    @pulumi.getter(name="pageBackground")
    def page_background(self) -> str:
        """
        Background color of login pages in hexadecimal.
        """
        return pulumi.get(self, "page_background")

    @property
    @pulumi.getter
    def primary(self) -> str:
        """
        Primary button background color in hexadecimal.
        """
        return pulumi.get(self, "primary")


@pulumi.output_type
class GetBrandingFontResult(dict):
    def __init__(__self__, *,
                 url: str):
        """
        :param str url: URL for the custom font.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        URL for the custom font.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetBrandingThemeBorderResult(dict):
    def __init__(__self__, *,
                 button_border_radius: float,
                 button_border_weight: float,
                 buttons_style: str,
                 input_border_radius: float,
                 input_border_weight: float,
                 inputs_style: str,
                 show_widget_shadow: bool,
                 widget_border_weight: float,
                 widget_corner_radius: float):
        """
        :param float button_border_radius: Button border radius. Value needs to be between `1` and `10`. Defaults to `3.0`.
        :param float button_border_weight: Button border weight. Value needs to be between `0` and `10`. Defaults to `1.0`.
        :param str buttons_style: Buttons style. Available options: `pill`, `rounded`, `sharp`. Defaults to `rounded`.
        :param float input_border_radius: Input border radius. Value needs to be between `0` and `10`. Defaults to `3.0`.
        :param float input_border_weight: Input border weight. Value needs to be between `0` and `3`. Defaults to `1.0`.
        :param str inputs_style: Inputs style. Available options: `pill`, `rounded`, `sharp`. Defaults to `rounded`.
        :param bool show_widget_shadow: Show widget shadow. Defaults to `true`.
        :param float widget_border_weight: Widget border weight. Value needs to be between `0` and `10`. Defaults to `0.0`.
        :param float widget_corner_radius: Widget corner radius. Value needs to be between `0` and `50`. Defaults to `5.0`.
        """
        pulumi.set(__self__, "button_border_radius", button_border_radius)
        pulumi.set(__self__, "button_border_weight", button_border_weight)
        pulumi.set(__self__, "buttons_style", buttons_style)
        pulumi.set(__self__, "input_border_radius", input_border_radius)
        pulumi.set(__self__, "input_border_weight", input_border_weight)
        pulumi.set(__self__, "inputs_style", inputs_style)
        pulumi.set(__self__, "show_widget_shadow", show_widget_shadow)
        pulumi.set(__self__, "widget_border_weight", widget_border_weight)
        pulumi.set(__self__, "widget_corner_radius", widget_corner_radius)

    @property
    @pulumi.getter(name="buttonBorderRadius")
    def button_border_radius(self) -> float:
        """
        Button border radius. Value needs to be between `1` and `10`. Defaults to `3.0`.
        """
        return pulumi.get(self, "button_border_radius")

    @property
    @pulumi.getter(name="buttonBorderWeight")
    def button_border_weight(self) -> float:
        """
        Button border weight. Value needs to be between `0` and `10`. Defaults to `1.0`.
        """
        return pulumi.get(self, "button_border_weight")

    @property
    @pulumi.getter(name="buttonsStyle")
    def buttons_style(self) -> str:
        """
        Buttons style. Available options: `pill`, `rounded`, `sharp`. Defaults to `rounded`.
        """
        return pulumi.get(self, "buttons_style")

    @property
    @pulumi.getter(name="inputBorderRadius")
    def input_border_radius(self) -> float:
        """
        Input border radius. Value needs to be between `0` and `10`. Defaults to `3.0`.
        """
        return pulumi.get(self, "input_border_radius")

    @property
    @pulumi.getter(name="inputBorderWeight")
    def input_border_weight(self) -> float:
        """
        Input border weight. Value needs to be between `0` and `3`. Defaults to `1.0`.
        """
        return pulumi.get(self, "input_border_weight")

    @property
    @pulumi.getter(name="inputsStyle")
    def inputs_style(self) -> str:
        """
        Inputs style. Available options: `pill`, `rounded`, `sharp`. Defaults to `rounded`.
        """
        return pulumi.get(self, "inputs_style")

    @property
    @pulumi.getter(name="showWidgetShadow")
    def show_widget_shadow(self) -> bool:
        """
        Show widget shadow. Defaults to `true`.
        """
        return pulumi.get(self, "show_widget_shadow")

    @property
    @pulumi.getter(name="widgetBorderWeight")
    def widget_border_weight(self) -> float:
        """
        Widget border weight. Value needs to be between `0` and `10`. Defaults to `0.0`.
        """
        return pulumi.get(self, "widget_border_weight")

    @property
    @pulumi.getter(name="widgetCornerRadius")
    def widget_corner_radius(self) -> float:
        """
        Widget corner radius. Value needs to be between `0` and `50`. Defaults to `5.0`.
        """
        return pulumi.get(self, "widget_corner_radius")


@pulumi.output_type
class GetBrandingThemeColorResult(dict):
    def __init__(__self__, *,
                 base_focus_color: str,
                 base_hover_color: str,
                 body_text: str,
                 error: str,
                 header: str,
                 icons: str,
                 input_background: str,
                 input_border: str,
                 input_filled_text: str,
                 input_labels_placeholders: str,
                 links_focused_components: str,
                 primary_button: str,
                 primary_button_label: str,
                 secondary_button_border: str,
                 secondary_button_label: str,
                 success: str,
                 widget_background: str,
                 widget_border: str):
        """
        :param str base_focus_color: Base focus color. Defaults to `#635dff`.
        :param str base_hover_color: Base hover color. Defaults to `#000000`.
        :param str body_text: Body text. Defaults to `#1e212a`.
        :param str error: Error. Defaults to `#d03c38`.
        :param str header: Header. Defaults to `#1e212a`.
        :param str icons: Icons. Defaults to `#65676e`.
        :param str input_background: Input background. Defaults to `#ffffff`.
        :param str input_border: Input border. Defaults to `#c9cace`.
        :param str input_filled_text: Input filled text. Defaults to `#000000`.
        :param str input_labels_placeholders: Input labels & placeholders. Defaults to `#65676e`.
        :param str links_focused_components: Links & focused components. Defaults to `#635dff`.
        :param str primary_button: Primary button. Defaults to `#635dff`.
        :param str primary_button_label: Primary button label. Defaults to `#ffffff`.
        :param str secondary_button_border: Secondary button border. Defaults to `#c9cace`.
        :param str secondary_button_label: Secondary button label. Defaults to `#1e212a`.
        :param str success: Success. Defaults to `#13a688`.
        :param str widget_background: Widget background. Defaults to `#ffffff`.
        :param str widget_border: Widget border. Defaults to `#c9cace`.
        """
        pulumi.set(__self__, "base_focus_color", base_focus_color)
        pulumi.set(__self__, "base_hover_color", base_hover_color)
        pulumi.set(__self__, "body_text", body_text)
        pulumi.set(__self__, "error", error)
        pulumi.set(__self__, "header", header)
        pulumi.set(__self__, "icons", icons)
        pulumi.set(__self__, "input_background", input_background)
        pulumi.set(__self__, "input_border", input_border)
        pulumi.set(__self__, "input_filled_text", input_filled_text)
        pulumi.set(__self__, "input_labels_placeholders", input_labels_placeholders)
        pulumi.set(__self__, "links_focused_components", links_focused_components)
        pulumi.set(__self__, "primary_button", primary_button)
        pulumi.set(__self__, "primary_button_label", primary_button_label)
        pulumi.set(__self__, "secondary_button_border", secondary_button_border)
        pulumi.set(__self__, "secondary_button_label", secondary_button_label)
        pulumi.set(__self__, "success", success)
        pulumi.set(__self__, "widget_background", widget_background)
        pulumi.set(__self__, "widget_border", widget_border)

    @property
    @pulumi.getter(name="baseFocusColor")
    def base_focus_color(self) -> str:
        """
        Base focus color. Defaults to `#635dff`.
        """
        return pulumi.get(self, "base_focus_color")

    @property
    @pulumi.getter(name="baseHoverColor")
    def base_hover_color(self) -> str:
        """
        Base hover color. Defaults to `#000000`.
        """
        return pulumi.get(self, "base_hover_color")

    @property
    @pulumi.getter(name="bodyText")
    def body_text(self) -> str:
        """
        Body text. Defaults to `#1e212a`.
        """
        return pulumi.get(self, "body_text")

    @property
    @pulumi.getter
    def error(self) -> str:
        """
        Error. Defaults to `#d03c38`.
        """
        return pulumi.get(self, "error")

    @property
    @pulumi.getter
    def header(self) -> str:
        """
        Header. Defaults to `#1e212a`.
        """
        return pulumi.get(self, "header")

    @property
    @pulumi.getter
    def icons(self) -> str:
        """
        Icons. Defaults to `#65676e`.
        """
        return pulumi.get(self, "icons")

    @property
    @pulumi.getter(name="inputBackground")
    def input_background(self) -> str:
        """
        Input background. Defaults to `#ffffff`.
        """
        return pulumi.get(self, "input_background")

    @property
    @pulumi.getter(name="inputBorder")
    def input_border(self) -> str:
        """
        Input border. Defaults to `#c9cace`.
        """
        return pulumi.get(self, "input_border")

    @property
    @pulumi.getter(name="inputFilledText")
    def input_filled_text(self) -> str:
        """
        Input filled text. Defaults to `#000000`.
        """
        return pulumi.get(self, "input_filled_text")

    @property
    @pulumi.getter(name="inputLabelsPlaceholders")
    def input_labels_placeholders(self) -> str:
        """
        Input labels & placeholders. Defaults to `#65676e`.
        """
        return pulumi.get(self, "input_labels_placeholders")

    @property
    @pulumi.getter(name="linksFocusedComponents")
    def links_focused_components(self) -> str:
        """
        Links & focused components. Defaults to `#635dff`.
        """
        return pulumi.get(self, "links_focused_components")

    @property
    @pulumi.getter(name="primaryButton")
    def primary_button(self) -> str:
        """
        Primary button. Defaults to `#635dff`.
        """
        return pulumi.get(self, "primary_button")

    @property
    @pulumi.getter(name="primaryButtonLabel")
    def primary_button_label(self) -> str:
        """
        Primary button label. Defaults to `#ffffff`.
        """
        return pulumi.get(self, "primary_button_label")

    @property
    @pulumi.getter(name="secondaryButtonBorder")
    def secondary_button_border(self) -> str:
        """
        Secondary button border. Defaults to `#c9cace`.
        """
        return pulumi.get(self, "secondary_button_border")

    @property
    @pulumi.getter(name="secondaryButtonLabel")
    def secondary_button_label(self) -> str:
        """
        Secondary button label. Defaults to `#1e212a`.
        """
        return pulumi.get(self, "secondary_button_label")

    @property
    @pulumi.getter
    def success(self) -> str:
        """
        Success. Defaults to `#13a688`.
        """
        return pulumi.get(self, "success")

    @property
    @pulumi.getter(name="widgetBackground")
    def widget_background(self) -> str:
        """
        Widget background. Defaults to `#ffffff`.
        """
        return pulumi.get(self, "widget_background")

    @property
    @pulumi.getter(name="widgetBorder")
    def widget_border(self) -> str:
        """
        Widget border. Defaults to `#c9cace`.
        """
        return pulumi.get(self, "widget_border")


@pulumi.output_type
class GetBrandingThemeFontResult(dict):
    def __init__(__self__, *,
                 body_texts: Sequence['outputs.GetBrandingThemeFontBodyTextResult'],
                 buttons_texts: Sequence['outputs.GetBrandingThemeFontButtonsTextResult'],
                 font_url: str,
                 input_labels: Sequence['outputs.GetBrandingThemeFontInputLabelResult'],
                 links: Sequence['outputs.GetBrandingThemeFontLinkResult'],
                 links_style: str,
                 reference_text_size: float,
                 subtitles: Sequence['outputs.GetBrandingThemeFontSubtitleResult'],
                 titles: Sequence['outputs.GetBrandingThemeFontTitleResult']):
        """
        :param Sequence['GetBrandingThemeFontBodyTextArgs'] body_texts: Body text.
        :param Sequence['GetBrandingThemeFontButtonsTextArgs'] buttons_texts: Buttons text.
        :param str font_url: Font URL. Defaults to an empty string.
        :param Sequence['GetBrandingThemeFontInputLabelArgs'] input_labels: Input labels.
        :param Sequence['GetBrandingThemeFontLinkArgs'] links: Links.
        :param str links_style: Links style. Defaults to `normal`.
        :param float reference_text_size: Reference text size. Value needs to be between `12` and `24`. Defaults to `16.0`.
        :param Sequence['GetBrandingThemeFontSubtitleArgs'] subtitles: Subtitle.
        :param Sequence['GetBrandingThemeFontTitleArgs'] titles: Title.
        """
        pulumi.set(__self__, "body_texts", body_texts)
        pulumi.set(__self__, "buttons_texts", buttons_texts)
        pulumi.set(__self__, "font_url", font_url)
        pulumi.set(__self__, "input_labels", input_labels)
        pulumi.set(__self__, "links", links)
        pulumi.set(__self__, "links_style", links_style)
        pulumi.set(__self__, "reference_text_size", reference_text_size)
        pulumi.set(__self__, "subtitles", subtitles)
        pulumi.set(__self__, "titles", titles)

    @property
    @pulumi.getter(name="bodyTexts")
    def body_texts(self) -> Sequence['outputs.GetBrandingThemeFontBodyTextResult']:
        """
        Body text.
        """
        return pulumi.get(self, "body_texts")

    @property
    @pulumi.getter(name="buttonsTexts")
    def buttons_texts(self) -> Sequence['outputs.GetBrandingThemeFontButtonsTextResult']:
        """
        Buttons text.
        """
        return pulumi.get(self, "buttons_texts")

    @property
    @pulumi.getter(name="fontUrl")
    def font_url(self) -> str:
        """
        Font URL. Defaults to an empty string.
        """
        return pulumi.get(self, "font_url")

    @property
    @pulumi.getter(name="inputLabels")
    def input_labels(self) -> Sequence['outputs.GetBrandingThemeFontInputLabelResult']:
        """
        Input labels.
        """
        return pulumi.get(self, "input_labels")

    @property
    @pulumi.getter
    def links(self) -> Sequence['outputs.GetBrandingThemeFontLinkResult']:
        """
        Links.
        """
        return pulumi.get(self, "links")

    @property
    @pulumi.getter(name="linksStyle")
    def links_style(self) -> str:
        """
        Links style. Defaults to `normal`.
        """
        return pulumi.get(self, "links_style")

    @property
    @pulumi.getter(name="referenceTextSize")
    def reference_text_size(self) -> float:
        """
        Reference text size. Value needs to be between `12` and `24`. Defaults to `16.0`.
        """
        return pulumi.get(self, "reference_text_size")

    @property
    @pulumi.getter
    def subtitles(self) -> Sequence['outputs.GetBrandingThemeFontSubtitleResult']:
        """
        Subtitle.
        """
        return pulumi.get(self, "subtitles")

    @property
    @pulumi.getter
    def titles(self) -> Sequence['outputs.GetBrandingThemeFontTitleResult']:
        """
        Title.
        """
        return pulumi.get(self, "titles")


@pulumi.output_type
class GetBrandingThemeFontBodyTextResult(dict):
    def __init__(__self__, *,
                 bold: bool,
                 size: float):
        """
        :param bool bold: Body text bold. Defaults to `false`.
        :param float size: Body text size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        pulumi.set(__self__, "bold", bold)
        pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> bool:
        """
        Body text bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Body text size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class GetBrandingThemeFontButtonsTextResult(dict):
    def __init__(__self__, *,
                 bold: bool,
                 size: float):
        """
        :param bool bold: Buttons text bold. Defaults to `false`.
        :param float size: Buttons text size. Value needs to be between `0` and `150`. Defaults to `100.0`.
        """
        pulumi.set(__self__, "bold", bold)
        pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> bool:
        """
        Buttons text bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Buttons text size. Value needs to be between `0` and `150`. Defaults to `100.0`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class GetBrandingThemeFontInputLabelResult(dict):
    def __init__(__self__, *,
                 bold: bool,
                 size: float):
        """
        :param bool bold: Input labels bold. Defaults to `false`.
        :param float size: Input labels size. Value needs to be between `0` and `150`. Defaults to `100.0`.
        """
        pulumi.set(__self__, "bold", bold)
        pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> bool:
        """
        Input labels bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Input labels size. Value needs to be between `0` and `150`. Defaults to `100.0`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class GetBrandingThemeFontLinkResult(dict):
    def __init__(__self__, *,
                 bold: bool,
                 size: float):
        """
        :param bool bold: Links bold. Defaults to `true`.
        :param float size: Links size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        pulumi.set(__self__, "bold", bold)
        pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> bool:
        """
        Links bold. Defaults to `true`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Links size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class GetBrandingThemeFontSubtitleResult(dict):
    def __init__(__self__, *,
                 bold: bool,
                 size: float):
        """
        :param bool bold: Subtitle bold. Defaults to `false`.
        :param float size: Subtitle size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        pulumi.set(__self__, "bold", bold)
        pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> bool:
        """
        Subtitle bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Subtitle size. Value needs to be between `0` and `150`. Defaults to `87.5`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class GetBrandingThemeFontTitleResult(dict):
    def __init__(__self__, *,
                 bold: bool,
                 size: float):
        """
        :param bool bold: Title bold. Defaults to `false`.
        :param float size: Title size. Value needs to be between `75` and `150`. Defaults to `150.0`.
        """
        pulumi.set(__self__, "bold", bold)
        pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def bold(self) -> bool:
        """
        Title bold. Defaults to `false`.
        """
        return pulumi.get(self, "bold")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Title size. Value needs to be between `75` and `150`. Defaults to `150.0`.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class GetBrandingThemePageBackgroundResult(dict):
    def __init__(__self__, *,
                 background_color: str,
                 background_image_url: str,
                 page_layout: str):
        """
        :param str background_color: Background color. Defaults to `#000000`.
        :param str background_image_url: Background image url. Defaults to an empty string.
        :param str page_layout: Page layout. Available options: `center`, `left`, `right`. Defaults to `center`.
        """
        pulumi.set(__self__, "background_color", background_color)
        pulumi.set(__self__, "background_image_url", background_image_url)
        pulumi.set(__self__, "page_layout", page_layout)

    @property
    @pulumi.getter(name="backgroundColor")
    def background_color(self) -> str:
        """
        Background color. Defaults to `#000000`.
        """
        return pulumi.get(self, "background_color")

    @property
    @pulumi.getter(name="backgroundImageUrl")
    def background_image_url(self) -> str:
        """
        Background image url. Defaults to an empty string.
        """
        return pulumi.get(self, "background_image_url")

    @property
    @pulumi.getter(name="pageLayout")
    def page_layout(self) -> str:
        """
        Page layout. Available options: `center`, `left`, `right`. Defaults to `center`.
        """
        return pulumi.get(self, "page_layout")


@pulumi.output_type
class GetBrandingThemeWidgetResult(dict):
    def __init__(__self__, *,
                 header_text_alignment: str,
                 logo_height: float,
                 logo_position: str,
                 logo_url: str,
                 social_buttons_layout: str):
        """
        :param str header_text_alignment: Header text alignment. Available options: `center`, `left`, `right`. Defaults to `center`.
        :param float logo_height: Logo height. Value needs to be between `1` and `100`. Defaults to `52.0`.
        :param str logo_position: Logo position. Available options: `center`, `left`, `right`, `none`. Defaults to `center`.
        :param str logo_url: Logo url. Defaults to an empty string.
        :param str social_buttons_layout: Social buttons layout. Available options: `bottom`, `top`. Defaults to `bottom`.
        """
        pulumi.set(__self__, "header_text_alignment", header_text_alignment)
        pulumi.set(__self__, "logo_height", logo_height)
        pulumi.set(__self__, "logo_position", logo_position)
        pulumi.set(__self__, "logo_url", logo_url)
        pulumi.set(__self__, "social_buttons_layout", social_buttons_layout)

    @property
    @pulumi.getter(name="headerTextAlignment")
    def header_text_alignment(self) -> str:
        """
        Header text alignment. Available options: `center`, `left`, `right`. Defaults to `center`.
        """
        return pulumi.get(self, "header_text_alignment")

    @property
    @pulumi.getter(name="logoHeight")
    def logo_height(self) -> float:
        """
        Logo height. Value needs to be between `1` and `100`. Defaults to `52.0`.
        """
        return pulumi.get(self, "logo_height")

    @property
    @pulumi.getter(name="logoPosition")
    def logo_position(self) -> str:
        """
        Logo position. Available options: `center`, `left`, `right`, `none`. Defaults to `center`.
        """
        return pulumi.get(self, "logo_position")

    @property
    @pulumi.getter(name="logoUrl")
    def logo_url(self) -> str:
        """
        Logo url. Defaults to an empty string.
        """
        return pulumi.get(self, "logo_url")

    @property
    @pulumi.getter(name="socialButtonsLayout")
    def social_buttons_layout(self) -> str:
        """
        Social buttons layout. Available options: `bottom`, `top`. Defaults to `bottom`.
        """
        return pulumi.get(self, "social_buttons_layout")


@pulumi.output_type
class GetBrandingUniversalLoginResult(dict):
    def __init__(__self__, *,
                 body: str):
        """
        :param str body: The html template for the New Universal Login Experience.
        """
        pulumi.set(__self__, "body", body)

    @property
    @pulumi.getter
    def body(self) -> str:
        """
        The html template for the New Universal Login Experience.
        """
        return pulumi.get(self, "body")


@pulumi.output_type
class GetClientAddonResult(dict):
    def __init__(__self__, *,
                 aws: Sequence['outputs.GetClientAddonAwResult'],
                 azure_blobs: Sequence['outputs.GetClientAddonAzureBlobResult'],
                 azure_sbs: Sequence['outputs.GetClientAddonAzureSbResult'],
                 boxes: Sequence['outputs.GetClientAddonBoxResult'],
                 cloudbees: Sequence['outputs.GetClientAddonCloudbeeResult'],
                 concurs: Sequence['outputs.GetClientAddonConcurResult'],
                 dropboxes: Sequence['outputs.GetClientAddonDropboxResult'],
                 echosigns: Sequence['outputs.GetClientAddonEchosignResult'],
                 egnytes: Sequence['outputs.GetClientAddonEgnyteResult'],
                 firebases: Sequence['outputs.GetClientAddonFirebaseResult'],
                 layers: Sequence['outputs.GetClientAddonLayerResult'],
                 mscrms: Sequence['outputs.GetClientAddonMscrmResult'],
                 newrelics: Sequence['outputs.GetClientAddonNewrelicResult'],
                 office365s: Sequence['outputs.GetClientAddonOffice365Result'],
                 rms: Sequence['outputs.GetClientAddonRmResult'],
                 salesforce_apis: Sequence['outputs.GetClientAddonSalesforceApiResult'],
                 salesforce_sandbox_apis: Sequence['outputs.GetClientAddonSalesforceSandboxApiResult'],
                 salesforces: Sequence['outputs.GetClientAddonSalesforceResult'],
                 samlps: Sequence['outputs.GetClientAddonSamlpResult'],
                 sap_apis: Sequence['outputs.GetClientAddonSapApiResult'],
                 sentries: Sequence['outputs.GetClientAddonSentryResult'],
                 sharepoints: Sequence['outputs.GetClientAddonSharepointResult'],
                 slacks: Sequence['outputs.GetClientAddonSlackResult'],
                 springcms: Sequence['outputs.GetClientAddonSpringcmResult'],
                 sso_integrations: Sequence['outputs.GetClientAddonSsoIntegrationResult'],
                 wams: Sequence['outputs.GetClientAddonWamResult'],
                 wsfeds: Sequence['outputs.GetClientAddonWsfedResult'],
                 zendesks: Sequence['outputs.GetClientAddonZendeskResult'],
                 zooms: Sequence['outputs.GetClientAddonZoomResult']):
        """
        :param Sequence['GetClientAddonAwArgs'] aws: AWS Addon configuration.
        :param Sequence['GetClientAddonAzureBlobArgs'] azure_blobs: Azure Blob Storage Addon configuration.
        :param Sequence['GetClientAddonAzureSbArgs'] azure_sbs: Azure Storage Bus Addon configuration.
        :param Sequence['GetClientAddonBoxArgs'] boxes: Box SSO indicator (no configuration settings needed for Box SSO).
        :param Sequence['GetClientAddonCloudbeeArgs'] cloudbees: CloudBees SSO indicator (no configuration settings needed for CloudBees SSO).
        :param Sequence['GetClientAddonConcurArgs'] concurs: Concur SSO indicator (no configuration settings needed for Concur SSO).
        :param Sequence['GetClientAddonDropboxArgs'] dropboxes: Dropbox SSO indicator (no configuration settings needed for Dropbox SSO).
        :param Sequence['GetClientAddonEchosignArgs'] echosigns: Adobe EchoSign SSO configuration.
        :param Sequence['GetClientAddonEgnyteArgs'] egnytes: Egnyte SSO configuration.
        :param Sequence['GetClientAddonFirebaseArgs'] firebases: Google Firebase addon configuration.
        :param Sequence['GetClientAddonLayerArgs'] layers: Layer addon configuration.
        :param Sequence['GetClientAddonMscrmArgs'] mscrms: Microsoft Dynamics CRM SSO configuration.
        :param Sequence['GetClientAddonNewrelicArgs'] newrelics: New Relic SSO configuration.
        :param Sequence['GetClientAddonOffice365Args'] office365s: Microsoft Office 365 SSO configuration.
        :param Sequence['GetClientAddonRmArgs'] rms: Active Directory Rights Management Service SSO configuration.
        :param Sequence['GetClientAddonSalesforceApiArgs'] salesforce_apis: Salesforce API addon configuration.
        :param Sequence['GetClientAddonSalesforceSandboxApiArgs'] salesforce_sandbox_apis: Salesforce Sandbox addon configuration.
        :param Sequence['GetClientAddonSalesforceArgs'] salesforces: Salesforce SSO configuration.
        :param Sequence['GetClientAddonSamlpArgs'] samlps: Configuration settings for a SAML add-on.
        :param Sequence['GetClientAddonSapApiArgs'] sap_apis: SAP API addon configuration.
        :param Sequence['GetClientAddonSentryArgs'] sentries: Sentry SSO configuration.
        :param Sequence['GetClientAddonSharepointArgs'] sharepoints: SharePoint SSO configuration.
        :param Sequence['GetClientAddonSlackArgs'] slacks: Slack team or workspace name usually first segment in your Slack URL, for example `https://acme-org.slack.com` would be `acme-org`.
        :param Sequence['GetClientAddonSpringcmArgs'] springcms: SpringCM SSO configuration.
        :param Sequence['GetClientAddonSsoIntegrationArgs'] sso_integrations: Generic SSO configuration.
        :param Sequence['GetClientAddonWamArgs'] wams: Windows Azure Mobile Services addon configuration.
        :param Sequence['GetClientAddonWsfedArgs'] wsfeds: WS-Fed (WIF) addon indicator. Actual configuration is stored in `callback` and `client_aliases` properties on the client.
        :param Sequence['GetClientAddonZendeskArgs'] zendesks: Zendesk SSO configuration.
        :param Sequence['GetClientAddonZoomArgs'] zooms: Zoom SSO configuration.
        """
        pulumi.set(__self__, "aws", aws)
        pulumi.set(__self__, "azure_blobs", azure_blobs)
        pulumi.set(__self__, "azure_sbs", azure_sbs)
        pulumi.set(__self__, "boxes", boxes)
        pulumi.set(__self__, "cloudbees", cloudbees)
        pulumi.set(__self__, "concurs", concurs)
        pulumi.set(__self__, "dropboxes", dropboxes)
        pulumi.set(__self__, "echosigns", echosigns)
        pulumi.set(__self__, "egnytes", egnytes)
        pulumi.set(__self__, "firebases", firebases)
        pulumi.set(__self__, "layers", layers)
        pulumi.set(__self__, "mscrms", mscrms)
        pulumi.set(__self__, "newrelics", newrelics)
        pulumi.set(__self__, "office365s", office365s)
        pulumi.set(__self__, "rms", rms)
        pulumi.set(__self__, "salesforce_apis", salesforce_apis)
        pulumi.set(__self__, "salesforce_sandbox_apis", salesforce_sandbox_apis)
        pulumi.set(__self__, "salesforces", salesforces)
        pulumi.set(__self__, "samlps", samlps)
        pulumi.set(__self__, "sap_apis", sap_apis)
        pulumi.set(__self__, "sentries", sentries)
        pulumi.set(__self__, "sharepoints", sharepoints)
        pulumi.set(__self__, "slacks", slacks)
        pulumi.set(__self__, "springcms", springcms)
        pulumi.set(__self__, "sso_integrations", sso_integrations)
        pulumi.set(__self__, "wams", wams)
        pulumi.set(__self__, "wsfeds", wsfeds)
        pulumi.set(__self__, "zendesks", zendesks)
        pulumi.set(__self__, "zooms", zooms)

    @property
    @pulumi.getter
    def aws(self) -> Sequence['outputs.GetClientAddonAwResult']:
        """
        AWS Addon configuration.
        """
        return pulumi.get(self, "aws")

    @property
    @pulumi.getter(name="azureBlobs")
    def azure_blobs(self) -> Sequence['outputs.GetClientAddonAzureBlobResult']:
        """
        Azure Blob Storage Addon configuration.
        """
        return pulumi.get(self, "azure_blobs")

    @property
    @pulumi.getter(name="azureSbs")
    def azure_sbs(self) -> Sequence['outputs.GetClientAddonAzureSbResult']:
        """
        Azure Storage Bus Addon configuration.
        """
        return pulumi.get(self, "azure_sbs")

    @property
    @pulumi.getter
    def boxes(self) -> Sequence['outputs.GetClientAddonBoxResult']:
        """
        Box SSO indicator (no configuration settings needed for Box SSO).
        """
        return pulumi.get(self, "boxes")

    @property
    @pulumi.getter
    def cloudbees(self) -> Sequence['outputs.GetClientAddonCloudbeeResult']:
        """
        CloudBees SSO indicator (no configuration settings needed for CloudBees SSO).
        """
        return pulumi.get(self, "cloudbees")

    @property
    @pulumi.getter
    def concurs(self) -> Sequence['outputs.GetClientAddonConcurResult']:
        """
        Concur SSO indicator (no configuration settings needed for Concur SSO).
        """
        return pulumi.get(self, "concurs")

    @property
    @pulumi.getter
    def dropboxes(self) -> Sequence['outputs.GetClientAddonDropboxResult']:
        """
        Dropbox SSO indicator (no configuration settings needed for Dropbox SSO).
        """
        return pulumi.get(self, "dropboxes")

    @property
    @pulumi.getter
    def echosigns(self) -> Sequence['outputs.GetClientAddonEchosignResult']:
        """
        Adobe EchoSign SSO configuration.
        """
        return pulumi.get(self, "echosigns")

    @property
    @pulumi.getter
    def egnytes(self) -> Sequence['outputs.GetClientAddonEgnyteResult']:
        """
        Egnyte SSO configuration.
        """
        return pulumi.get(self, "egnytes")

    @property
    @pulumi.getter
    def firebases(self) -> Sequence['outputs.GetClientAddonFirebaseResult']:
        """
        Google Firebase addon configuration.
        """
        return pulumi.get(self, "firebases")

    @property
    @pulumi.getter
    def layers(self) -> Sequence['outputs.GetClientAddonLayerResult']:
        """
        Layer addon configuration.
        """
        return pulumi.get(self, "layers")

    @property
    @pulumi.getter
    def mscrms(self) -> Sequence['outputs.GetClientAddonMscrmResult']:
        """
        Microsoft Dynamics CRM SSO configuration.
        """
        return pulumi.get(self, "mscrms")

    @property
    @pulumi.getter
    def newrelics(self) -> Sequence['outputs.GetClientAddonNewrelicResult']:
        """
        New Relic SSO configuration.
        """
        return pulumi.get(self, "newrelics")

    @property
    @pulumi.getter
    def office365s(self) -> Sequence['outputs.GetClientAddonOffice365Result']:
        """
        Microsoft Office 365 SSO configuration.
        """
        return pulumi.get(self, "office365s")

    @property
    @pulumi.getter
    def rms(self) -> Sequence['outputs.GetClientAddonRmResult']:
        """
        Active Directory Rights Management Service SSO configuration.
        """
        return pulumi.get(self, "rms")

    @property
    @pulumi.getter(name="salesforceApis")
    def salesforce_apis(self) -> Sequence['outputs.GetClientAddonSalesforceApiResult']:
        """
        Salesforce API addon configuration.
        """
        return pulumi.get(self, "salesforce_apis")

    @property
    @pulumi.getter(name="salesforceSandboxApis")
    def salesforce_sandbox_apis(self) -> Sequence['outputs.GetClientAddonSalesforceSandboxApiResult']:
        """
        Salesforce Sandbox addon configuration.
        """
        return pulumi.get(self, "salesforce_sandbox_apis")

    @property
    @pulumi.getter
    def salesforces(self) -> Sequence['outputs.GetClientAddonSalesforceResult']:
        """
        Salesforce SSO configuration.
        """
        return pulumi.get(self, "salesforces")

    @property
    @pulumi.getter
    def samlps(self) -> Sequence['outputs.GetClientAddonSamlpResult']:
        """
        Configuration settings for a SAML add-on.
        """
        return pulumi.get(self, "samlps")

    @property
    @pulumi.getter(name="sapApis")
    def sap_apis(self) -> Sequence['outputs.GetClientAddonSapApiResult']:
        """
        SAP API addon configuration.
        """
        return pulumi.get(self, "sap_apis")

    @property
    @pulumi.getter
    def sentries(self) -> Sequence['outputs.GetClientAddonSentryResult']:
        """
        Sentry SSO configuration.
        """
        return pulumi.get(self, "sentries")

    @property
    @pulumi.getter
    def sharepoints(self) -> Sequence['outputs.GetClientAddonSharepointResult']:
        """
        SharePoint SSO configuration.
        """
        return pulumi.get(self, "sharepoints")

    @property
    @pulumi.getter
    def slacks(self) -> Sequence['outputs.GetClientAddonSlackResult']:
        """
        Slack team or workspace name usually first segment in your Slack URL, for example `https://acme-org.slack.com` would be `acme-org`.
        """
        return pulumi.get(self, "slacks")

    @property
    @pulumi.getter
    def springcms(self) -> Sequence['outputs.GetClientAddonSpringcmResult']:
        """
        SpringCM SSO configuration.
        """
        return pulumi.get(self, "springcms")

    @property
    @pulumi.getter(name="ssoIntegrations")
    def sso_integrations(self) -> Sequence['outputs.GetClientAddonSsoIntegrationResult']:
        """
        Generic SSO configuration.
        """
        return pulumi.get(self, "sso_integrations")

    @property
    @pulumi.getter
    def wams(self) -> Sequence['outputs.GetClientAddonWamResult']:
        """
        Windows Azure Mobile Services addon configuration.
        """
        return pulumi.get(self, "wams")

    @property
    @pulumi.getter
    def wsfeds(self) -> Sequence['outputs.GetClientAddonWsfedResult']:
        """
        WS-Fed (WIF) addon indicator. Actual configuration is stored in `callback` and `client_aliases` properties on the client.
        """
        return pulumi.get(self, "wsfeds")

    @property
    @pulumi.getter
    def zendesks(self) -> Sequence['outputs.GetClientAddonZendeskResult']:
        """
        Zendesk SSO configuration.
        """
        return pulumi.get(self, "zendesks")

    @property
    @pulumi.getter
    def zooms(self) -> Sequence['outputs.GetClientAddonZoomResult']:
        """
        Zoom SSO configuration.
        """
        return pulumi.get(self, "zooms")


@pulumi.output_type
class GetClientAddonAwResult(dict):
    def __init__(__self__, *,
                 lifetime_in_seconds: int,
                 principal: str,
                 role: str):
        """
        :param int lifetime_in_seconds: AWS token lifetime in seconds.
        :param str principal: AWS principal ARN, for example `arn:aws:iam::010616021751:saml-provider/idpname`.
        :param str role: AWS role ARN, for example `arn:aws:iam::010616021751:role/foo`.
        """
        pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        pulumi.set(__self__, "principal", principal)
        pulumi.set(__self__, "role", role)

    @property
    @pulumi.getter(name="lifetimeInSeconds")
    def lifetime_in_seconds(self) -> int:
        """
        AWS token lifetime in seconds.
        """
        return pulumi.get(self, "lifetime_in_seconds")

    @property
    @pulumi.getter
    def principal(self) -> str:
        """
        AWS principal ARN, for example `arn:aws:iam::010616021751:saml-provider/idpname`.
        """
        return pulumi.get(self, "principal")

    @property
    @pulumi.getter
    def role(self) -> str:
        """
        AWS role ARN, for example `arn:aws:iam::010616021751:role/foo`.
        """
        return pulumi.get(self, "role")


@pulumi.output_type
class GetClientAddonAzureBlobResult(dict):
    def __init__(__self__, *,
                 account_name: str,
                 blob_delete: bool,
                 blob_name: str,
                 blob_read: bool,
                 blob_write: bool,
                 container_delete: bool,
                 container_list: bool,
                 container_name: str,
                 container_read: bool,
                 container_write: bool,
                 expiration: int,
                 signed_identifier: str,
                 storage_access_key: str):
        """
        :param str account_name: Your Azure storage account name. Usually first segment in your Azure storage URL, for example `https://acme-org.blob.core.windows.net` would be the account name `acme-org`.
        :param bool blob_delete: Indicates if the issued token has permission to delete the blob.
        :param str blob_name: Entity to request a token for, such as `my-blob`. If blank the computed SAS will apply to the entire storage container.
        :param bool blob_read: Indicates if the issued token has permission to read the content, properties, metadata and block list. Use the blob as the source of a copy operation.
        :param bool blob_write: Indicates if the issued token has permission to create or write content, properties, metadata, or block list. Snapshot or lease the blob. Resize the blob (page blob only). Use the blob as the destination of a copy operation within the same account.
        :param bool container_delete: Indicates if issued token has permission to delete any blob in the container.
        :param bool container_list: Indicates if the issued token has permission to list blobs in the container.
        :param str container_name: Container to request a token for, such as `my-container`.
        :param bool container_read: Indicates if the issued token has permission to read the content, properties, metadata or block list of any blob in the container. Use any blob in the container as the source of a copy operation.
        :param bool container_write: Indicates that for any blob in the container if the issued token has permission to create or write content, properties, metadata, or block list. Snapshot or lease the blob. Resize the blob (page blob only). Use the blob as the destination of a copy operation within the same account.
        :param int expiration: Expiration in minutes for the generated token (default of 5 minutes).
        :param str signed_identifier: Shared access policy identifier defined in your storage account resource.
        :param str storage_access_key: Access key associated with this storage account.
        """
        pulumi.set(__self__, "account_name", account_name)
        pulumi.set(__self__, "blob_delete", blob_delete)
        pulumi.set(__self__, "blob_name", blob_name)
        pulumi.set(__self__, "blob_read", blob_read)
        pulumi.set(__self__, "blob_write", blob_write)
        pulumi.set(__self__, "container_delete", container_delete)
        pulumi.set(__self__, "container_list", container_list)
        pulumi.set(__self__, "container_name", container_name)
        pulumi.set(__self__, "container_read", container_read)
        pulumi.set(__self__, "container_write", container_write)
        pulumi.set(__self__, "expiration", expiration)
        pulumi.set(__self__, "signed_identifier", signed_identifier)
        pulumi.set(__self__, "storage_access_key", storage_access_key)

    @property
    @pulumi.getter(name="accountName")
    def account_name(self) -> str:
        """
        Your Azure storage account name. Usually first segment in your Azure storage URL, for example `https://acme-org.blob.core.windows.net` would be the account name `acme-org`.
        """
        return pulumi.get(self, "account_name")

    @property
    @pulumi.getter(name="blobDelete")
    def blob_delete(self) -> bool:
        """
        Indicates if the issued token has permission to delete the blob.
        """
        return pulumi.get(self, "blob_delete")

    @property
    @pulumi.getter(name="blobName")
    def blob_name(self) -> str:
        """
        Entity to request a token for, such as `my-blob`. If blank the computed SAS will apply to the entire storage container.
        """
        return pulumi.get(self, "blob_name")

    @property
    @pulumi.getter(name="blobRead")
    def blob_read(self) -> bool:
        """
        Indicates if the issued token has permission to read the content, properties, metadata and block list. Use the blob as the source of a copy operation.
        """
        return pulumi.get(self, "blob_read")

    @property
    @pulumi.getter(name="blobWrite")
    def blob_write(self) -> bool:
        """
        Indicates if the issued token has permission to create or write content, properties, metadata, or block list. Snapshot or lease the blob. Resize the blob (page blob only). Use the blob as the destination of a copy operation within the same account.
        """
        return pulumi.get(self, "blob_write")

    @property
    @pulumi.getter(name="containerDelete")
    def container_delete(self) -> bool:
        """
        Indicates if issued token has permission to delete any blob in the container.
        """
        return pulumi.get(self, "container_delete")

    @property
    @pulumi.getter(name="containerList")
    def container_list(self) -> bool:
        """
        Indicates if the issued token has permission to list blobs in the container.
        """
        return pulumi.get(self, "container_list")

    @property
    @pulumi.getter(name="containerName")
    def container_name(self) -> str:
        """
        Container to request a token for, such as `my-container`.
        """
        return pulumi.get(self, "container_name")

    @property
    @pulumi.getter(name="containerRead")
    def container_read(self) -> bool:
        """
        Indicates if the issued token has permission to read the content, properties, metadata or block list of any blob in the container. Use any blob in the container as the source of a copy operation.
        """
        return pulumi.get(self, "container_read")

    @property
    @pulumi.getter(name="containerWrite")
    def container_write(self) -> bool:
        """
        Indicates that for any blob in the container if the issued token has permission to create or write content, properties, metadata, or block list. Snapshot or lease the blob. Resize the blob (page blob only). Use the blob as the destination of a copy operation within the same account.
        """
        return pulumi.get(self, "container_write")

    @property
    @pulumi.getter
    def expiration(self) -> int:
        """
        Expiration in minutes for the generated token (default of 5 minutes).
        """
        return pulumi.get(self, "expiration")

    @property
    @pulumi.getter(name="signedIdentifier")
    def signed_identifier(self) -> str:
        """
        Shared access policy identifier defined in your storage account resource.
        """
        return pulumi.get(self, "signed_identifier")

    @property
    @pulumi.getter(name="storageAccessKey")
    def storage_access_key(self) -> str:
        """
        Access key associated with this storage account.
        """
        return pulumi.get(self, "storage_access_key")


@pulumi.output_type
class GetClientAddonAzureSbResult(dict):
    def __init__(__self__, *,
                 entity_path: str,
                 expiration: int,
                 namespace: str,
                 sas_key: str,
                 sas_key_name: str):
        """
        :param str entity_path: Entity you want to request a token for, such as `my-queue`.
        :param int expiration: Optional expiration in minutes for the generated token. Defaults to 5 minutes.
        :param str namespace: Your Azure Service Bus namespace. Usually the first segment of your Service Bus URL (for example `https://acme-org.servicebus.windows.net` would be `acme-org`).
        :param str sas_key: Primary Key associated with your shared access policy.
        :param str sas_key_name: Your shared access policy name defined in your Service Bus entity.
        """
        pulumi.set(__self__, "entity_path", entity_path)
        pulumi.set(__self__, "expiration", expiration)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "sas_key", sas_key)
        pulumi.set(__self__, "sas_key_name", sas_key_name)

    @property
    @pulumi.getter(name="entityPath")
    def entity_path(self) -> str:
        """
        Entity you want to request a token for, such as `my-queue`.
        """
        return pulumi.get(self, "entity_path")

    @property
    @pulumi.getter
    def expiration(self) -> int:
        """
        Optional expiration in minutes for the generated token. Defaults to 5 minutes.
        """
        return pulumi.get(self, "expiration")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        Your Azure Service Bus namespace. Usually the first segment of your Service Bus URL (for example `https://acme-org.servicebus.windows.net` would be `acme-org`).
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="sasKey")
    def sas_key(self) -> str:
        """
        Primary Key associated with your shared access policy.
        """
        return pulumi.get(self, "sas_key")

    @property
    @pulumi.getter(name="sasKeyName")
    def sas_key_name(self) -> str:
        """
        Your shared access policy name defined in your Service Bus entity.
        """
        return pulumi.get(self, "sas_key_name")


@pulumi.output_type
class GetClientAddonBoxResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetClientAddonCloudbeeResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetClientAddonConcurResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetClientAddonDropboxResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetClientAddonEchosignResult(dict):
    def __init__(__self__, *,
                 domain: str):
        """
        :param str domain: Your custom domain found in your EchoSign URL, for example `https://acme-org.echosign.com` would be `acme-org`.
        """
        pulumi.set(__self__, "domain", domain)

    @property
    @pulumi.getter
    def domain(self) -> str:
        """
        Your custom domain found in your EchoSign URL, for example `https://acme-org.echosign.com` would be `acme-org`.
        """
        return pulumi.get(self, "domain")


@pulumi.output_type
class GetClientAddonEgnyteResult(dict):
    def __init__(__self__, *,
                 domain: str):
        """
        :param str domain: Your custom domain found in your Egnyte URL, for example `https://acme-org.echosign.com` would be `acme-org`.
        """
        pulumi.set(__self__, "domain", domain)

    @property
    @pulumi.getter
    def domain(self) -> str:
        """
        Your custom domain found in your Egnyte URL, for example `https://acme-org.echosign.com` would be `acme-org`.
        """
        return pulumi.get(self, "domain")


@pulumi.output_type
class GetClientAddonFirebaseResult(dict):
    def __init__(__self__, *,
                 client_email: str,
                 lifetime_in_seconds: int,
                 private_key: str,
                 private_key_id: str,
                 secret: str):
        """
        :param str client_email: ID of the Service Account you have created (shown as `client_email` in the generated JSON file, SDK v3+ tokens only).
        :param int lifetime_in_seconds: Optional expiration in seconds for the generated token. Defaults to 3600 seconds (SDK v3+ tokens only).
        :param str private_key: Private Key for signing the token (SDK v3+ tokens only).
        :param str private_key_id: Optional ID of the private key to obtain the `kid` header claim from the issued token (SDK v3+ tokens only).
        :param str secret: Google Firebase Secret. (SDK v2 only).
        """
        pulumi.set(__self__, "client_email", client_email)
        pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        pulumi.set(__self__, "private_key", private_key)
        pulumi.set(__self__, "private_key_id", private_key_id)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter(name="clientEmail")
    def client_email(self) -> str:
        """
        ID of the Service Account you have created (shown as `client_email` in the generated JSON file, SDK v3+ tokens only).
        """
        return pulumi.get(self, "client_email")

    @property
    @pulumi.getter(name="lifetimeInSeconds")
    def lifetime_in_seconds(self) -> int:
        """
        Optional expiration in seconds for the generated token. Defaults to 3600 seconds (SDK v3+ tokens only).
        """
        return pulumi.get(self, "lifetime_in_seconds")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        Private Key for signing the token (SDK v3+ tokens only).
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="privateKeyId")
    def private_key_id(self) -> str:
        """
        Optional ID of the private key to obtain the `kid` header claim from the issued token (SDK v3+ tokens only).
        """
        return pulumi.get(self, "private_key_id")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        Google Firebase Secret. (SDK v2 only).
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetClientAddonLayerResult(dict):
    def __init__(__self__, *,
                 expiration: int,
                 key_id: str,
                 principal: str,
                 private_key: str,
                 provider_id: str):
        """
        :param int expiration: Optional expiration in minutes for the generated token. Defaults to 5 minutes.
        :param str key_id: Authentication Key identifier used to sign the Layer token.
        :param str principal: Name of the property used as the unique user ID in Layer. If not specified `user_id` is used.
        :param str private_key: Private key for signing the Layer token.
        :param str provider_id: Provider ID of your Layer account.
        """
        pulumi.set(__self__, "expiration", expiration)
        pulumi.set(__self__, "key_id", key_id)
        pulumi.set(__self__, "principal", principal)
        pulumi.set(__self__, "private_key", private_key)
        pulumi.set(__self__, "provider_id", provider_id)

    @property
    @pulumi.getter
    def expiration(self) -> int:
        """
        Optional expiration in minutes for the generated token. Defaults to 5 minutes.
        """
        return pulumi.get(self, "expiration")

    @property
    @pulumi.getter(name="keyId")
    def key_id(self) -> str:
        """
        Authentication Key identifier used to sign the Layer token.
        """
        return pulumi.get(self, "key_id")

    @property
    @pulumi.getter
    def principal(self) -> str:
        """
        Name of the property used as the unique user ID in Layer. If not specified `user_id` is used.
        """
        return pulumi.get(self, "principal")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        Private key for signing the Layer token.
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="providerId")
    def provider_id(self) -> str:
        """
        Provider ID of your Layer account.
        """
        return pulumi.get(self, "provider_id")


@pulumi.output_type
class GetClientAddonMscrmResult(dict):
    def __init__(__self__, *,
                 url: str):
        """
        :param str url: Microsoft Dynamics CRM application URL.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Microsoft Dynamics CRM application URL.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClientAddonNewrelicResult(dict):
    def __init__(__self__, *,
                 account: str):
        """
        :param str account: Your New Relic Account ID found in your New Relic URL after the `/accounts/` path, for example `https://rpm.newrelic.com/accounts/123456/query` would be `123456`.
        """
        pulumi.set(__self__, "account", account)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        Your New Relic Account ID found in your New Relic URL after the `/accounts/` path, for example `https://rpm.newrelic.com/accounts/123456/query` would be `123456`.
        """
        return pulumi.get(self, "account")


@pulumi.output_type
class GetClientAddonOffice365Result(dict):
    def __init__(__self__, *,
                 connection: str,
                 domain: str):
        """
        :param str connection: Optional Auth0 database connection for testing an already-configured Office 365 tenant.
        :param str domain: Your Office 365 domain name, for example `acme-org.com`.
        """
        pulumi.set(__self__, "connection", connection)
        pulumi.set(__self__, "domain", domain)

    @property
    @pulumi.getter
    def connection(self) -> str:
        """
        Optional Auth0 database connection for testing an already-configured Office 365 tenant.
        """
        return pulumi.get(self, "connection")

    @property
    @pulumi.getter
    def domain(self) -> str:
        """
        Your Office 365 domain name, for example `acme-org.com`.
        """
        return pulumi.get(self, "domain")


@pulumi.output_type
class GetClientAddonRmResult(dict):
    def __init__(__self__, *,
                 url: str):
        """
        :param str url: URL of your Rights Management Server. It can be internal or external, but users will have to be able to reach it.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        URL of your Rights Management Server. It can be internal or external, but users will have to be able to reach it.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClientAddonSalesforceResult(dict):
    def __init__(__self__, *,
                 entity_id: str):
        """
        :param str entity_id: Arbitrary logical URL that identifies the Saleforce resource, for example `https://acme-org.com`.
        """
        pulumi.set(__self__, "entity_id", entity_id)

    @property
    @pulumi.getter(name="entityId")
    def entity_id(self) -> str:
        """
        Arbitrary logical URL that identifies the Saleforce resource, for example `https://acme-org.com`.
        """
        return pulumi.get(self, "entity_id")


@pulumi.output_type
class GetClientAddonSalesforceApiResult(dict):
    def __init__(__self__, *,
                 client_id: str,
                 community_name: str,
                 community_url_section: str,
                 principal: str):
        """
        :param str client_id: Consumer Key assigned by Salesforce to the Connected App.
        :param str community_name: Community name.
        :param str community_url_section: Community URL section.
        :param str principal: Name of the property in the user object that maps to a Salesforce username, for example `email`.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "community_name", community_name)
        pulumi.set(__self__, "community_url_section", community_url_section)
        pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        Consumer Key assigned by Salesforce to the Connected App.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="communityName")
    def community_name(self) -> str:
        """
        Community name.
        """
        return pulumi.get(self, "community_name")

    @property
    @pulumi.getter(name="communityUrlSection")
    def community_url_section(self) -> str:
        """
        Community URL section.
        """
        return pulumi.get(self, "community_url_section")

    @property
    @pulumi.getter
    def principal(self) -> str:
        """
        Name of the property in the user object that maps to a Salesforce username, for example `email`.
        """
        return pulumi.get(self, "principal")


@pulumi.output_type
class GetClientAddonSalesforceSandboxApiResult(dict):
    def __init__(__self__, *,
                 client_id: str,
                 community_name: str,
                 community_url_section: str,
                 principal: str):
        """
        :param str client_id: Consumer Key assigned by Salesforce to the Connected App.
        :param str community_name: Community name.
        :param str community_url_section: Community URL section.
        :param str principal: Name of the property in the user object that maps to a Salesforce username, for example `email`.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "community_name", community_name)
        pulumi.set(__self__, "community_url_section", community_url_section)
        pulumi.set(__self__, "principal", principal)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        Consumer Key assigned by Salesforce to the Connected App.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="communityName")
    def community_name(self) -> str:
        """
        Community name.
        """
        return pulumi.get(self, "community_name")

    @property
    @pulumi.getter(name="communityUrlSection")
    def community_url_section(self) -> str:
        """
        Community URL section.
        """
        return pulumi.get(self, "community_url_section")

    @property
    @pulumi.getter
    def principal(self) -> str:
        """
        Name of the property in the user object that maps to a Salesforce username, for example `email`.
        """
        return pulumi.get(self, "principal")


@pulumi.output_type
class GetClientAddonSamlpResult(dict):
    def __init__(__self__, *,
                 audience: str,
                 authn_context_class_ref: str,
                 binding: str,
                 create_upn_claim: bool,
                 destination: str,
                 digest_algorithm: str,
                 include_attribute_name_format: bool,
                 issuer: str,
                 lifetime_in_seconds: int,
                 logouts: Sequence['outputs.GetClientAddonSamlpLogoutResult'],
                 map_identities: bool,
                 map_unknown_claims_as_is: bool,
                 mappings: Mapping[str, Any],
                 name_identifier_format: str,
                 name_identifier_probes: Sequence[str],
                 passthrough_claims_with_no_mapping: bool,
                 recipient: str,
                 sign_response: bool,
                 signature_algorithm: str,
                 signing_cert: str,
                 typed_attributes: bool):
        """
        :param str audience: Audience of the SAML Assertion. Default will be the Issuer on SAMLRequest.
        :param str authn_context_class_ref: Class reference of the authentication context.
        :param str binding: Protocol binding used for SAML logout responses.
        :param bool create_upn_claim: Indicates whether a UPN claim should be created. Defaults to `true`.
        :param str destination: Destination of the SAML Response. If not specified, it will be `AssertionConsumerUrl` of SAMLRequest or callback URL if there was no SAMLRequest.
        :param str digest_algorithm: Algorithm used to calculate the digest of the SAML Assertion or response. Options include `sha1` and `sha256`. Defaults to `sha1`.
        :param bool include_attribute_name_format: 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. Defaults to `true`.
        :param str issuer: Issuer of the SAML Assertion.
        :param int lifetime_in_seconds: Number of seconds during which the token is valid. Defaults to `3600` seconds.
        :param Sequence['GetClientAddonSamlpLogoutArgs'] logouts: Configuration settings for logout.
        :param bool map_identities: Indicates whether or not to add additional identity information in the token, such as the provider used and the `access_token`, if available. Defaults to `true`.
        :param bool map_unknown_claims_as_is: Indicates whether 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. Defaults to `false`.
        :param Mapping[str, Any] mappings: Mappings between the Auth0 user profile property name (`name`) and the output attributes on the SAML attribute in the assertion (`value`).
        :param str name_identifier_format: Format of the name identifier. Defaults to `urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`.
        :param Sequence[str] name_identifier_probes: 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 bool passthrough_claims_with_no_mapping: Indicates whether or not to passthrough claims that are not mapped to the common profile in the output assertion. Defaults to `true`.
        :param str recipient: Recipient of the SAML Assertion (SubjectConfirmationData). Default is `AssertionConsumerUrl` on SAMLRequest or callback URL if no SAMLRequest was sent.
        :param bool sign_response: Indicates whether or not the SAML Response should be signed instead of the SAML Assertion.
        :param str signature_algorithm: Algorithm used to sign the SAML Assertion or response. Options include `rsa-sha1` and `rsa-sha256`. Defaults to `rsa-sha1`.
        :param str signing_cert: Optionally indicates the public key certificate used to validate SAML requests. If set, SAML requests will be required to be signed. A sample value would be `-----BEGIN PUBLIC KEY-----\\nMIGf...bpP/t3\\n+JGNGIRMj1hF1rnb6QIDAQAB\\n-----END PUBLIC KEY-----\\n`.
        :param bool typed_attributes: 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`. Defaults to `true`.
        """
        pulumi.set(__self__, "audience", audience)
        pulumi.set(__self__, "authn_context_class_ref", authn_context_class_ref)
        pulumi.set(__self__, "binding", binding)
        pulumi.set(__self__, "create_upn_claim", create_upn_claim)
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "digest_algorithm", digest_algorithm)
        pulumi.set(__self__, "include_attribute_name_format", include_attribute_name_format)
        pulumi.set(__self__, "issuer", issuer)
        pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        pulumi.set(__self__, "logouts", logouts)
        pulumi.set(__self__, "map_identities", map_identities)
        pulumi.set(__self__, "map_unknown_claims_as_is", map_unknown_claims_as_is)
        pulumi.set(__self__, "mappings", mappings)
        pulumi.set(__self__, "name_identifier_format", name_identifier_format)
        pulumi.set(__self__, "name_identifier_probes", name_identifier_probes)
        pulumi.set(__self__, "passthrough_claims_with_no_mapping", passthrough_claims_with_no_mapping)
        pulumi.set(__self__, "recipient", recipient)
        pulumi.set(__self__, "sign_response", sign_response)
        pulumi.set(__self__, "signature_algorithm", signature_algorithm)
        pulumi.set(__self__, "signing_cert", signing_cert)
        pulumi.set(__self__, "typed_attributes", typed_attributes)

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

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

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

    @property
    @pulumi.getter(name="createUpnClaim")
    def create_upn_claim(self) -> bool:
        """
        Indicates whether a UPN claim should be created. Defaults to `true`.
        """
        return pulumi.get(self, "create_upn_claim")

    @property
    @pulumi.getter
    def destination(self) -> str:
        """
        Destination of the SAML Response. If not specified, it will be `AssertionConsumerUrl` of SAMLRequest or callback URL if there was no SAMLRequest.
        """
        return pulumi.get(self, "destination")

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

    @property
    @pulumi.getter(name="includeAttributeNameFormat")
    def include_attribute_name_format(self) -> bool:
        """
        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. Defaults to `true`.
        """
        return pulumi.get(self, "include_attribute_name_format")

    @property
    @pulumi.getter
    def issuer(self) -> str:
        """
        Issuer of the SAML Assertion.
        """
        return pulumi.get(self, "issuer")

    @property
    @pulumi.getter(name="lifetimeInSeconds")
    def lifetime_in_seconds(self) -> int:
        """
        Number of seconds during which the token is valid. Defaults to `3600` seconds.
        """
        return pulumi.get(self, "lifetime_in_seconds")

    @property
    @pulumi.getter
    def logouts(self) -> Sequence['outputs.GetClientAddonSamlpLogoutResult']:
        """
        Configuration settings for logout.
        """
        return pulumi.get(self, "logouts")

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

    @property
    @pulumi.getter(name="mapUnknownClaimsAsIs")
    def map_unknown_claims_as_is(self) -> bool:
        """
        Indicates whether 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. Defaults to `false`.
        """
        return pulumi.get(self, "map_unknown_claims_as_is")

    @property
    @pulumi.getter
    def mappings(self) -> Mapping[str, Any]:
        """
        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")

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

    @property
    @pulumi.getter(name="nameIdentifierProbes")
    def name_identifier_probes(self) -> Sequence[str]:
        """
        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")

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

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

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

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

    @property
    @pulumi.getter(name="signingCert")
    def signing_cert(self) -> str:
        """
        Optionally indicates the public key certificate used to validate SAML requests. If set, SAML requests will be required to be signed. A sample value would be `-----BEGIN PUBLIC KEY-----\\nMIGf...bpP/t3\\n+JGNGIRMj1hF1rnb6QIDAQAB\\n-----END PUBLIC KEY-----\\n`.
        """
        return pulumi.get(self, "signing_cert")

    @property
    @pulumi.getter(name="typedAttributes")
    def typed_attributes(self) -> bool:
        """
        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`. Defaults to `true`.
        """
        return pulumi.get(self, "typed_attributes")


@pulumi.output_type
class GetClientAddonSamlpLogoutResult(dict):
    def __init__(__self__, *,
                 callback: str,
                 slo_enabled: bool):
        """
        :param str callback: The service provider (client application)'s Single Logout Service URL, where Auth0 will send logout requests and responses.
        :param bool slo_enabled: Controls whether Auth0 should notify service providers of session termination.
        """
        pulumi.set(__self__, "callback", callback)
        pulumi.set(__self__, "slo_enabled", slo_enabled)

    @property
    @pulumi.getter
    def callback(self) -> str:
        """
        The service provider (client application)'s Single Logout Service URL, where Auth0 will send logout requests and responses.
        """
        return pulumi.get(self, "callback")

    @property
    @pulumi.getter(name="sloEnabled")
    def slo_enabled(self) -> bool:
        """
        Controls whether Auth0 should notify service providers of session termination.
        """
        return pulumi.get(self, "slo_enabled")


@pulumi.output_type
class GetClientAddonSapApiResult(dict):
    def __init__(__self__, *,
                 client_id: str,
                 name_identifier_format: str,
                 scope: str,
                 service_password: str,
                 token_endpoint_url: str,
                 username_attribute: str):
        """
        :param str client_id: If activated in the OAuth 2.0 client configuration (transaction `SOAUTH2) the SAML attribute `client_id` must be set and equal the `client_id` form parameter of the access token request.
        :param str name_identifier_format: NameID element of the Subject which can be used to express the user's identity. Defaults to `urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`.
        :param str scope: Requested scope for SAP APIs.
        :param str service_password: Service account password to use to authenticate API calls to the token endpoint.
        :param str token_endpoint_url: The OAuth2 token endpoint URL of your SAP OData server.
        :param str username_attribute: Name of the property in the user object that maps to a SAP username, for example `email`.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "name_identifier_format", name_identifier_format)
        pulumi.set(__self__, "scope", scope)
        pulumi.set(__self__, "service_password", service_password)
        pulumi.set(__self__, "token_endpoint_url", token_endpoint_url)
        pulumi.set(__self__, "username_attribute", username_attribute)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        If activated in the OAuth 2.0 client configuration (transaction `SOAUTH2) the SAML attribute `client_id` must be set and equal the `client_id` form parameter of the access token request.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="nameIdentifierFormat")
    def name_identifier_format(self) -> str:
        """
        NameID element of the Subject which can be used to express the user's identity. Defaults to `urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`.
        """
        return pulumi.get(self, "name_identifier_format")

    @property
    @pulumi.getter
    def scope(self) -> str:
        """
        Requested scope for SAP APIs.
        """
        return pulumi.get(self, "scope")

    @property
    @pulumi.getter(name="servicePassword")
    def service_password(self) -> str:
        """
        Service account password to use to authenticate API calls to the token endpoint.
        """
        return pulumi.get(self, "service_password")

    @property
    @pulumi.getter(name="tokenEndpointUrl")
    def token_endpoint_url(self) -> str:
        """
        The OAuth2 token endpoint URL of your SAP OData server.
        """
        return pulumi.get(self, "token_endpoint_url")

    @property
    @pulumi.getter(name="usernameAttribute")
    def username_attribute(self) -> str:
        """
        Name of the property in the user object that maps to a SAP username, for example `email`.
        """
        return pulumi.get(self, "username_attribute")


@pulumi.output_type
class GetClientAddonSentryResult(dict):
    def __init__(__self__, *,
                 base_url: str,
                 org_slug: str):
        """
        :param str base_url: URL prefix only if running Sentry Community Edition, otherwise leave empty.
        :param str org_slug: Generated slug for your Sentry organization. Found in your Sentry URL, for example `https://sentry.acme.com/acme-org/` would be `acme-org`.
        """
        pulumi.set(__self__, "base_url", base_url)
        pulumi.set(__self__, "org_slug", org_slug)

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> str:
        """
        URL prefix only if running Sentry Community Edition, otherwise leave empty.
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter(name="orgSlug")
    def org_slug(self) -> str:
        """
        Generated slug for your Sentry organization. Found in your Sentry URL, for example `https://sentry.acme.com/acme-org/` would be `acme-org`.
        """
        return pulumi.get(self, "org_slug")


@pulumi.output_type
class GetClientAddonSharepointResult(dict):
    def __init__(__self__, *,
                 external_urls: Sequence[str],
                 url: str):
        """
        :param Sequence[str] external_urls: External SharePoint application URLs if exposed to the Internet.
        :param str url: Internal SharePoint application URL.
        """
        pulumi.set(__self__, "external_urls", external_urls)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Sequence[str]:
        """
        External SharePoint application URLs if exposed to the Internet.
        """
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Internal SharePoint application URL.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClientAddonSlackResult(dict):
    def __init__(__self__, *,
                 team: str):
        """
        :param str team: Slack team name.
        """
        pulumi.set(__self__, "team", team)

    @property
    @pulumi.getter
    def team(self) -> str:
        """
        Slack team name.
        """
        return pulumi.get(self, "team")


@pulumi.output_type
class GetClientAddonSpringcmResult(dict):
    def __init__(__self__, *,
                 acs_url: str):
        """
        :param str acs_url: SpringCM ACS URL, for example `https://na11.springcm.com/atlas/sso/SSOEndpoint.ashx`.
        """
        pulumi.set(__self__, "acs_url", acs_url)

    @property
    @pulumi.getter(name="acsUrl")
    def acs_url(self) -> str:
        """
        SpringCM ACS URL, for example `https://na11.springcm.com/atlas/sso/SSOEndpoint.ashx`.
        """
        return pulumi.get(self, "acs_url")


@pulumi.output_type
class GetClientAddonSsoIntegrationResult(dict):
    def __init__(__self__, *,
                 name: str,
                 version: str):
        """
        :param str name: SSO integration name.
        :param str version: SSO integration version installed.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        SSO integration name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        SSO integration version installed.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClientAddonWamResult(dict):
    def __init__(__self__, *,
                 master_key: str):
        """
        :param str master_key: Your master key for Windows Azure Mobile Services.
        """
        pulumi.set(__self__, "master_key", master_key)

    @property
    @pulumi.getter(name="masterKey")
    def master_key(self) -> str:
        """
        Your master key for Windows Azure Mobile Services.
        """
        return pulumi.get(self, "master_key")


@pulumi.output_type
class GetClientAddonWsfedResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetClientAddonZendeskResult(dict):
    def __init__(__self__, *,
                 account_name: str):
        """
        :param str account_name: Zendesk account name. Usually the first segment in your Zendesk URL, for example `https://acme-org.zendesk.com` would be `acme-org`.
        """
        pulumi.set(__self__, "account_name", account_name)

    @property
    @pulumi.getter(name="accountName")
    def account_name(self) -> str:
        """
        Zendesk account name. Usually the first segment in your Zendesk URL, for example `https://acme-org.zendesk.com` would be `acme-org`.
        """
        return pulumi.get(self, "account_name")


@pulumi.output_type
class GetClientAddonZoomResult(dict):
    def __init__(__self__, *,
                 account: str):
        """
        :param str account: Zoom account name. Usually the first segment of your Zoom URL, for example `https://acme-org.zoom.us` would be `acme-org`.
        """
        pulumi.set(__self__, "account", account)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        Zoom account name. Usually the first segment of your Zoom URL, for example `https://acme-org.zoom.us` would be `acme-org`.
        """
        return pulumi.get(self, "account")


@pulumi.output_type
class GetClientJwtConfigurationResult(dict):
    def __init__(__self__, *,
                 alg: str,
                 lifetime_in_seconds: int,
                 scopes: Mapping[str, str],
                 secret_encoded: bool):
        """
        :param str alg: Algorithm used to sign JWTs.
        :param int lifetime_in_seconds: Number of seconds during which the JWT will be valid.
        :param Mapping[str, str] scopes: Permissions (scopes) included in JWTs.
        :param bool secret_encoded: Indicates whether the client secret is Base64-encoded.
        """
        pulumi.set(__self__, "alg", alg)
        pulumi.set(__self__, "lifetime_in_seconds", lifetime_in_seconds)
        pulumi.set(__self__, "scopes", scopes)
        pulumi.set(__self__, "secret_encoded", secret_encoded)

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

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

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

    @property
    @pulumi.getter(name="secretEncoded")
    def secret_encoded(self) -> bool:
        """
        Indicates whether the client secret is Base64-encoded.
        """
        return pulumi.get(self, "secret_encoded")


@pulumi.output_type
class GetClientMobileResult(dict):
    def __init__(__self__, *,
                 androids: Sequence['outputs.GetClientMobileAndroidResult'],
                 ios: Sequence['outputs.GetClientMobileIoResult']):
        """
        :param Sequence['GetClientMobileAndroidArgs'] androids: Configuration settings for Android native apps.
        :param Sequence['GetClientMobileIoArgs'] ios: Configuration settings for i0S native apps.
        """
        pulumi.set(__self__, "androids", androids)
        pulumi.set(__self__, "ios", ios)

    @property
    @pulumi.getter
    def androids(self) -> Sequence['outputs.GetClientMobileAndroidResult']:
        """
        Configuration settings for Android native apps.
        """
        return pulumi.get(self, "androids")

    @property
    @pulumi.getter
    def ios(self) -> Sequence['outputs.GetClientMobileIoResult']:
        """
        Configuration settings for i0S native apps.
        """
        return pulumi.get(self, "ios")


@pulumi.output_type
class GetClientMobileAndroidResult(dict):
    def __init__(__self__, *,
                 app_package_name: str,
                 sha256_cert_fingerprints: Sequence[str]):
        pulumi.set(__self__, "app_package_name", app_package_name)
        pulumi.set(__self__, "sha256_cert_fingerprints", sha256_cert_fingerprints)

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

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


@pulumi.output_type
class GetClientMobileIoResult(dict):
    def __init__(__self__, *,
                 app_bundle_identifier: str,
                 team_id: str):
        pulumi.set(__self__, "app_bundle_identifier", app_bundle_identifier)
        pulumi.set(__self__, "team_id", team_id)

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

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


@pulumi.output_type
class GetClientNativeSocialLoginResult(dict):
    def __init__(__self__, *,
                 apples: Sequence['outputs.GetClientNativeSocialLoginAppleResult'],
                 facebooks: Sequence['outputs.GetClientNativeSocialLoginFacebookResult']):
        pulumi.set(__self__, "apples", apples)
        pulumi.set(__self__, "facebooks", facebooks)

    @property
    @pulumi.getter
    def apples(self) -> Sequence['outputs.GetClientNativeSocialLoginAppleResult']:
        return pulumi.get(self, "apples")

    @property
    @pulumi.getter
    def facebooks(self) -> Sequence['outputs.GetClientNativeSocialLoginFacebookResult']:
        return pulumi.get(self, "facebooks")


@pulumi.output_type
class GetClientNativeSocialLoginAppleResult(dict):
    def __init__(__self__, *,
                 enabled: bool):
        pulumi.set(__self__, "enabled", enabled)

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


@pulumi.output_type
class GetClientNativeSocialLoginFacebookResult(dict):
    def __init__(__self__, *,
                 enabled: bool):
        pulumi.set(__self__, "enabled", enabled)

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


@pulumi.output_type
class GetClientRefreshTokenResult(dict):
    def __init__(__self__, *,
                 expiration_type: str,
                 idle_token_lifetime: int,
                 infinite_idle_token_lifetime: bool,
                 infinite_token_lifetime: bool,
                 leeway: int,
                 rotation_type: str,
                 token_lifetime: int):
        """
        :param str expiration_type: 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 int idle_token_lifetime: The time in seconds after which inactive refresh tokens will expire.
        :param bool infinite_idle_token_lifetime: Whether inactive refresh tokens should remain valid indefinitely.
        :param bool infinite_token_lifetime: Whether refresh tokens should remain valid indefinitely. If false, `token_lifetime` should also be set.
        :param int leeway: The amount of time in seconds in which a refresh token may be reused without triggering reuse detection.
        :param str rotation_type: 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 int token_lifetime: The absolute lifetime of a refresh token in seconds.
        """
        pulumi.set(__self__, "expiration_type", expiration_type)
        pulumi.set(__self__, "idle_token_lifetime", idle_token_lifetime)
        pulumi.set(__self__, "infinite_idle_token_lifetime", infinite_idle_token_lifetime)
        pulumi.set(__self__, "infinite_token_lifetime", infinite_token_lifetime)
        pulumi.set(__self__, "leeway", leeway)
        pulumi.set(__self__, "rotation_type", rotation_type)
        pulumi.set(__self__, "token_lifetime", token_lifetime)

    @property
    @pulumi.getter(name="expirationType")
    def expiration_type(self) -> str:
        """
        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")

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

    @property
    @pulumi.getter(name="infiniteIdleTokenLifetime")
    def infinite_idle_token_lifetime(self) -> bool:
        """
        Whether inactive refresh tokens should remain valid indefinitely.
        """
        return pulumi.get(self, "infinite_idle_token_lifetime")

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

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

    @property
    @pulumi.getter(name="rotationType")
    def rotation_type(self) -> str:
        """
        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")

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


@pulumi.output_type
class GetConnectionOptionResult(dict):
    def __init__(__self__, *,
                 adfs_server: str,
                 allowed_audiences: Sequence[str],
                 api_enable_users: bool,
                 app_id: str,
                 attribute_maps: Sequence['outputs.GetConnectionOptionAttributeMapResult'],
                 auth_params: Mapping[str, str],
                 authorization_endpoint: str,
                 brute_force_protection: bool,
                 client_id: str,
                 client_secret: str,
                 community_base_url: str,
                 configuration: Mapping[str, Any],
                 connection_settings: Sequence['outputs.GetConnectionOptionConnectionSettingResult'],
                 custom_scripts: Mapping[str, str],
                 debug: bool,
                 decryption_keys: Sequence['outputs.GetConnectionOptionDecryptionKeyResult'],
                 digest_algorithm: str,
                 disable_cache: bool,
                 disable_self_service_change_password: bool,
                 disable_sign_out: bool,
                 disable_signup: bool,
                 discovery_url: str,
                 domain: str,
                 domain_aliases: Sequence[str],
                 enable_script_context: bool,
                 enabled_database_customization: bool,
                 entity_id: str,
                 fed_metadata_xml: str,
                 fields_map: str,
                 forward_request_info: bool,
                 from_: str,
                 gateway_authentications: Sequence['outputs.GetConnectionOptionGatewayAuthenticationResult'],
                 gateway_url: str,
                 icon_url: str,
                 identity_api: str,
                 idp_initiateds: Sequence['outputs.GetConnectionOptionIdpInitiatedResult'],
                 import_mode: bool,
                 ips: Sequence[str],
                 issuer: str,
                 jwks_uri: str,
                 key_id: str,
                 map_user_id_to_id: bool,
                 max_groups_to_retrieve: str,
                 messaging_service_sid: str,
                 metadata_url: str,
                 metadata_xml: str,
                 mfas: Sequence['outputs.GetConnectionOptionMfaResult'],
                 name: str,
                 non_persistent_attrs: Sequence[str],
                 password_complexity_options: Sequence['outputs.GetConnectionOptionPasswordComplexityOptionResult'],
                 password_dictionaries: Sequence['outputs.GetConnectionOptionPasswordDictionaryResult'],
                 password_histories: Sequence['outputs.GetConnectionOptionPasswordHistoryResult'],
                 password_no_personal_infos: Sequence['outputs.GetConnectionOptionPasswordNoPersonalInfoResult'],
                 password_policy: str,
                 ping_federate_base_url: str,
                 pkce_enabled: bool,
                 protocol_binding: str,
                 provider: str,
                 request_template: str,
                 requires_username: bool,
                 scopes: Sequence[str],
                 scripts: Mapping[str, str],
                 set_user_root_attributes: str,
                 should_trust_email_verified_connection: str,
                 sign_in_endpoint: str,
                 sign_out_endpoint: str,
                 sign_saml_request: bool,
                 signature_algorithm: str,
                 signing_cert: str,
                 signing_keys: Sequence['outputs.GetConnectionOptionSigningKeyResult'],
                 strategy_version: int,
                 subject: str,
                 syntax: str,
                 team_id: str,
                 template: str,
                 tenant_domain: str,
                 token_endpoint: str,
                 totps: Sequence['outputs.GetConnectionOptionTotpResult'],
                 twilio_sid: str,
                 twilio_token: str,
                 type: str,
                 upstream_params: str,
                 use_cert_auth: bool,
                 use_kerberos: bool,
                 use_wsfed: bool,
                 user_id_attribute: str,
                 userinfo_endpoint: str,
                 validations: Sequence['outputs.GetConnectionOptionValidationResult'],
                 waad_common_endpoint: bool,
                 waad_protocol: str):
        """
        :param str adfs_server: ADFS URL where to fetch the metadata source.
        :param Sequence[str] allowed_audiences: List of allowed audiences.
        :param bool api_enable_users: Enable API Access to users.
        :param str app_id: App ID.
        :param Sequence['GetConnectionOptionAttributeMapArgs'] attribute_maps: OpenID Connect and Okta Workforce connections can automatically map claims received from the identity provider (IdP). You can configure this mapping through a library template provided by Auth0 or by entering your own template directly. Click [here](https://auth0.com/docs/authenticate/identity-providers/enterprise-identity-providers/configure-pkce-claim-mapping-for-oidc#map-claims-for-oidc-connections) for more info.
        :param Mapping[str, str] auth_params: Query string parameters to be included as part of the generated passwordless email link.
        :param str authorization_endpoint: Authorization endpoint.
        :param bool brute_force_protection: Indicates whether to enable brute force protection, which will limit the number of signups and failed logins from a suspicious IP address.
        :param str client_id: The strategy's client ID.
        :param str client_secret: The strategy's client secret.
        :param str community_base_url: Salesforce community base URL.
        :param Mapping[str, Any] configuration: A case-sensitive map of key value pairs used as configuration variables for the `custom_script`.
        :param Sequence['GetConnectionOptionConnectionSettingArgs'] connection_settings: Proof Key for Code Exchange (PKCE) configuration settings for an OIDC or Okta Workforce connection.
        :param Mapping[str, str] custom_scripts: A map of scripts used to integrate with a custom database.
        :param bool debug: When enabled, additional debug information will be generated.
        :param Sequence['GetConnectionOptionDecryptionKeyArgs'] decryption_keys: The key used to decrypt encrypted responses from the connection. Uses the `key` and `cert` properties to provide the private key and certificate respectively.
        :param str digest_algorithm: Sign Request Algorithm Digest.
        :param bool disable_cache: Indicates whether to disable the cache or not.
        :param bool disable_self_service_change_password: Indicates whether to remove the forgot password link within the New Universal Login.
        :param bool disable_sign_out: When enabled, will disable sign out.
        :param bool disable_signup: Indicates whether to allow user sign-ups to your application.
        :param str discovery_url: OpenID discovery URL, e.g. `https://auth.example.com/.well-known/openid-configuration`.
        :param str domain: Domain name.
        :param Sequence[str] domain_aliases: List of the domains that can be authenticated using the identity provider. Only needed for Identifier First authentication flows.
        :param bool enable_script_context: Set to `true` to inject context into custom DB scripts (warning: cannot be disabled once enabled).
        :param bool enabled_database_customization: Set to `true` to use a legacy user store.
        :param str entity_id: Custom Entity ID for the connection.
        :param str fed_metadata_xml: Federation Metadata for the ADFS connection.
        :param str fields_map: If you're configuring a SAML enterprise connection for a non-standard PingFederate Server, you must update the attribute mappings.
        :param bool forward_request_info: Specifies whether or not request info should be forwarded to sms gateway.
        :param str from_: Address to use as the sender.
        :param Sequence['GetConnectionOptionGatewayAuthenticationArgs'] gateway_authentications: Defines the parameters used to generate the auth token for the custom gateway.
        :param str gateway_url: Defines a custom sms gateway to use instead of Twilio.
        :param str icon_url: Icon URL.
        :param str identity_api: Azure AD Identity API. Available options are: `microsoft-identity-platform-v2.0` or `azure-active-directory-v1.0`.
        :param Sequence['GetConnectionOptionIdpInitiatedArgs'] idp_initiateds: Configuration options for IDP Initiated Authentication. This is an object with the properties: `client_id`, `client_protocol`, and `client_authorize_query`.
        :param bool import_mode: Indicates whether you have a legacy user store and want to gradually migrate those users to the Auth0 user store.
        :param Sequence[str] ips: A list of IPs.
        :param str issuer: Issuer URL, e.g. `https://auth.example.com`.
        :param str jwks_uri: JWKS URI.
        :param str key_id: Apple Key ID.
        :param bool map_user_id_to_id: By default Auth0 maps `user_id` to `email`. Enabling this setting changes the behavior to map `user_id` to 'id' instead. This can only be defined on a new Google Workspace connection and can not be changed once set.
        :param str max_groups_to_retrieve: Maximum number of groups to retrieve.
        :param str messaging_service_sid: SID for Copilot. Used when SMS Source is Copilot.
        :param str metadata_url: The URL of the SAML metadata document.
        :param str metadata_xml: The XML content for the SAML metadata document. Values within the xml will take precedence over other attributes set on the options block.
        :param Sequence['GetConnectionOptionMfaArgs'] mfas: Configuration options for multifactor authentication.
        :param str name: The public name of the email or SMS Connection. In most cases this is the same name as the connection name.
        :param Sequence[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 here.
        :param Sequence['GetConnectionOptionPasswordComplexityOptionArgs'] password_complexity_options: Configuration settings for password complexity.
        :param Sequence['GetConnectionOptionPasswordDictionaryArgs'] password_dictionaries: Configuration settings for the password dictionary check, which does not allow passwords that are part of the password dictionary.
        :param Sequence['GetConnectionOptionPasswordHistoryArgs'] password_histories: Configuration settings for the password history that is maintained for each user to prevent the reuse of passwords.
        :param Sequence['GetConnectionOptionPasswordNoPersonalInfoArgs'] password_no_personal_infos: 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`.
        :param 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 str ping_federate_base_url: Ping Federate Server URL.
        :param bool pkce_enabled: Enables Proof Key for Code Exchange (PKCE) functionality for OAuth2 connections.
        :param str protocol_binding: The SAML Response Binding: how the SAML token is received by Auth0 from the IdP.
        :param str provider: Defines the custom `sms_gateway` provider.
        :param str request_template: Template that formats the SAML request.
        :param bool requires_username: Indicates whether the user is required to provide a username in addition to an email address.
        :param Sequence[str] scopes: Permissions to grant to the connection. Within the Auth0 dashboard these appear under the "Attributes" and "Extended Attributes" sections. Some examples: `basic_profile`, `ext_profile`, `ext_nested_groups`, etc.
        :param Mapping[str, str] scripts: A map of scripts used for an OAuth connection. Only accepts a `fetchUserProfile` script.
        :param str set_user_root_attributes: Determines whether to sync user profile attributes (`name`, `given_name`, `family_name`, `nickname`, `picture`) at each login or only on the first login. Options include: `on_each_login`, `on_first_login`. Default value: `on_each_login`.
        :param str should_trust_email_verified_connection: Choose how Auth0 sets the email_verified field in the user profile.
        :param str sign_in_endpoint: SAML single login URL for the connection.
        :param str sign_out_endpoint: SAML single logout URL for the connection.
        :param bool sign_saml_request: When enabled, the SAML authentication request will be signed.
        :param str signature_algorithm: Sign Request Algorithm.
        :param str signing_cert: X.509 signing certificate (encoded in PEM or CER) you retrieved from the IdP, Base64-encoded.
        :param Sequence['GetConnectionOptionSigningKeyArgs'] signing_keys: The key used to sign requests in the connection. Uses the `key` and `cert` properties to provide the private key and certificate respectively.
        :param int strategy_version: Version 1 is deprecated, use version 2.
        :param str subject: Subject line of the email.
        :param str syntax: Syntax of the template body.
        :param str team_id: Apple Team ID.
        :param str template: Body of the template.
        :param str tenant_domain: Tenant domain name.
        :param str token_endpoint: Token endpoint.
        :param Sequence['GetConnectionOptionTotpArgs'] totps: Configuration options for one-time passwords.
        :param str twilio_sid: SID for your Twilio account.
        :param str twilio_token: AuthToken for your Twilio account.
        :param str type: Value can be `back_channel` or `front_channel`. Front Channel will use OIDC protocol with `response_mode=form_post` and `response_type=id_token`. Back Channel will use `response_type=code`.
        :param str upstream_params: You can pass provider-specific parameters to an identity provider during authentication. The values can either be static per connection or dynamic per user.
        :param bool use_cert_auth: Indicates whether to use cert auth or not.
        :param bool use_kerberos: Indicates whether to use Kerberos or not.
        :param bool use_wsfed: Whether to use WS-Fed.
        :param str user_id_attribute: Attribute in the SAML token that will be mapped to the user_id property in Auth0.
        :param str userinfo_endpoint: User info endpoint.
        :param Sequence['GetConnectionOptionValidationArgs'] validations: Validation of the minimum and maximum values allowed for a user to have as username.
        :param bool waad_common_endpoint: Indicates whether 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.
        :param str waad_protocol: Protocol to use.
        """
        pulumi.set(__self__, "adfs_server", adfs_server)
        pulumi.set(__self__, "allowed_audiences", allowed_audiences)
        pulumi.set(__self__, "api_enable_users", api_enable_users)
        pulumi.set(__self__, "app_id", app_id)
        pulumi.set(__self__, "attribute_maps", attribute_maps)
        pulumi.set(__self__, "auth_params", auth_params)
        pulumi.set(__self__, "authorization_endpoint", authorization_endpoint)
        pulumi.set(__self__, "brute_force_protection", brute_force_protection)
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "community_base_url", community_base_url)
        pulumi.set(__self__, "configuration", configuration)
        pulumi.set(__self__, "connection_settings", connection_settings)
        pulumi.set(__self__, "custom_scripts", custom_scripts)
        pulumi.set(__self__, "debug", debug)
        pulumi.set(__self__, "decryption_keys", decryption_keys)
        pulumi.set(__self__, "digest_algorithm", digest_algorithm)
        pulumi.set(__self__, "disable_cache", disable_cache)
        pulumi.set(__self__, "disable_self_service_change_password", disable_self_service_change_password)
        pulumi.set(__self__, "disable_sign_out", disable_sign_out)
        pulumi.set(__self__, "disable_signup", disable_signup)
        pulumi.set(__self__, "discovery_url", discovery_url)
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "domain_aliases", domain_aliases)
        pulumi.set(__self__, "enable_script_context", enable_script_context)
        pulumi.set(__self__, "enabled_database_customization", enabled_database_customization)
        pulumi.set(__self__, "entity_id", entity_id)
        pulumi.set(__self__, "fed_metadata_xml", fed_metadata_xml)
        pulumi.set(__self__, "fields_map", fields_map)
        pulumi.set(__self__, "forward_request_info", forward_request_info)
        pulumi.set(__self__, "from_", from_)
        pulumi.set(__self__, "gateway_authentications", gateway_authentications)
        pulumi.set(__self__, "gateway_url", gateway_url)
        pulumi.set(__self__, "icon_url", icon_url)
        pulumi.set(__self__, "identity_api", identity_api)
        pulumi.set(__self__, "idp_initiateds", idp_initiateds)
        pulumi.set(__self__, "import_mode", import_mode)
        pulumi.set(__self__, "ips", ips)
        pulumi.set(__self__, "issuer", issuer)
        pulumi.set(__self__, "jwks_uri", jwks_uri)
        pulumi.set(__self__, "key_id", key_id)
        pulumi.set(__self__, "map_user_id_to_id", map_user_id_to_id)
        pulumi.set(__self__, "max_groups_to_retrieve", max_groups_to_retrieve)
        pulumi.set(__self__, "messaging_service_sid", messaging_service_sid)
        pulumi.set(__self__, "metadata_url", metadata_url)
        pulumi.set(__self__, "metadata_xml", metadata_xml)
        pulumi.set(__self__, "mfas", mfas)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "non_persistent_attrs", non_persistent_attrs)
        pulumi.set(__self__, "password_complexity_options", password_complexity_options)
        pulumi.set(__self__, "password_dictionaries", password_dictionaries)
        pulumi.set(__self__, "password_histories", password_histories)
        pulumi.set(__self__, "password_no_personal_infos", password_no_personal_infos)
        pulumi.set(__self__, "password_policy", password_policy)
        pulumi.set(__self__, "ping_federate_base_url", ping_federate_base_url)
        pulumi.set(__self__, "pkce_enabled", pkce_enabled)
        pulumi.set(__self__, "protocol_binding", protocol_binding)
        pulumi.set(__self__, "provider", provider)
        pulumi.set(__self__, "request_template", request_template)
        pulumi.set(__self__, "requires_username", requires_username)
        pulumi.set(__self__, "scopes", scopes)
        pulumi.set(__self__, "scripts", scripts)
        pulumi.set(__self__, "set_user_root_attributes", set_user_root_attributes)
        pulumi.set(__self__, "should_trust_email_verified_connection", should_trust_email_verified_connection)
        pulumi.set(__self__, "sign_in_endpoint", sign_in_endpoint)
        pulumi.set(__self__, "sign_out_endpoint", sign_out_endpoint)
        pulumi.set(__self__, "sign_saml_request", sign_saml_request)
        pulumi.set(__self__, "signature_algorithm", signature_algorithm)
        pulumi.set(__self__, "signing_cert", signing_cert)
        pulumi.set(__self__, "signing_keys", signing_keys)
        pulumi.set(__self__, "strategy_version", strategy_version)
        pulumi.set(__self__, "subject", subject)
        pulumi.set(__self__, "syntax", syntax)
        pulumi.set(__self__, "team_id", team_id)
        pulumi.set(__self__, "template", template)
        pulumi.set(__self__, "tenant_domain", tenant_domain)
        pulumi.set(__self__, "token_endpoint", token_endpoint)
        pulumi.set(__self__, "totps", totps)
        pulumi.set(__self__, "twilio_sid", twilio_sid)
        pulumi.set(__self__, "twilio_token", twilio_token)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "upstream_params", upstream_params)
        pulumi.set(__self__, "use_cert_auth", use_cert_auth)
        pulumi.set(__self__, "use_kerberos", use_kerberos)
        pulumi.set(__self__, "use_wsfed", use_wsfed)
        pulumi.set(__self__, "user_id_attribute", user_id_attribute)
        pulumi.set(__self__, "userinfo_endpoint", userinfo_endpoint)
        pulumi.set(__self__, "validations", validations)
        pulumi.set(__self__, "waad_common_endpoint", waad_common_endpoint)
        pulumi.set(__self__, "waad_protocol", waad_protocol)

    @property
    @pulumi.getter(name="adfsServer")
    def adfs_server(self) -> str:
        """
        ADFS URL where to fetch the metadata source.
        """
        return pulumi.get(self, "adfs_server")

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

    @property
    @pulumi.getter(name="apiEnableUsers")
    def api_enable_users(self) -> bool:
        """
        Enable API Access to users.
        """
        return pulumi.get(self, "api_enable_users")

    @property
    @pulumi.getter(name="appId")
    def app_id(self) -> str:
        """
        App ID.
        """
        return pulumi.get(self, "app_id")

    @property
    @pulumi.getter(name="attributeMaps")
    def attribute_maps(self) -> Sequence['outputs.GetConnectionOptionAttributeMapResult']:
        """
        OpenID Connect and Okta Workforce connections can automatically map claims received from the identity provider (IdP). You can configure this mapping through a library template provided by Auth0 or by entering your own template directly. Click [here](https://auth0.com/docs/authenticate/identity-providers/enterprise-identity-providers/configure-pkce-claim-mapping-for-oidc#map-claims-for-oidc-connections) for more info.
        """
        return pulumi.get(self, "attribute_maps")

    @property
    @pulumi.getter(name="authParams")
    def auth_params(self) -> Mapping[str, str]:
        """
        Query string parameters to be included as part of the generated passwordless email link.
        """
        return pulumi.get(self, "auth_params")

    @property
    @pulumi.getter(name="authorizationEndpoint")
    def authorization_endpoint(self) -> str:
        """
        Authorization endpoint.
        """
        return pulumi.get(self, "authorization_endpoint")

    @property
    @pulumi.getter(name="bruteForceProtection")
    def brute_force_protection(self) -> bool:
        """
        Indicates whether 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")

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The strategy's client ID.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> str:
        """
        The strategy's client secret.
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="communityBaseUrl")
    def community_base_url(self) -> str:
        """
        Salesforce community base URL.
        """
        return pulumi.get(self, "community_base_url")

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

    @property
    @pulumi.getter(name="connectionSettings")
    def connection_settings(self) -> Sequence['outputs.GetConnectionOptionConnectionSettingResult']:
        """
        Proof Key for Code Exchange (PKCE) configuration settings for an OIDC or Okta Workforce connection.
        """
        return pulumi.get(self, "connection_settings")

    @property
    @pulumi.getter(name="customScripts")
    def custom_scripts(self) -> Mapping[str, str]:
        """
        A map of scripts used to integrate with a custom database.
        """
        return pulumi.get(self, "custom_scripts")

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

    @property
    @pulumi.getter(name="decryptionKeys")
    def decryption_keys(self) -> Sequence['outputs.GetConnectionOptionDecryptionKeyResult']:
        """
        The key used to decrypt encrypted responses from the connection. Uses the `key` and `cert` properties to provide the private key and certificate respectively.
        """
        return pulumi.get(self, "decryption_keys")

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

    @property
    @pulumi.getter(name="disableCache")
    def disable_cache(self) -> bool:
        """
        Indicates whether to disable the cache or not.
        """
        return pulumi.get(self, "disable_cache")

    @property
    @pulumi.getter(name="disableSelfServiceChangePassword")
    def disable_self_service_change_password(self) -> bool:
        """
        Indicates whether to remove the forgot password link within the New Universal Login.
        """
        return pulumi.get(self, "disable_self_service_change_password")

    @property
    @pulumi.getter(name="disableSignOut")
    def disable_sign_out(self) -> bool:
        """
        When enabled, will disable sign out.
        """
        return pulumi.get(self, "disable_sign_out")

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

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

    @property
    @pulumi.getter
    def domain(self) -> str:
        """
        Domain name.
        """
        return pulumi.get(self, "domain")

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

    @property
    @pulumi.getter(name="enableScriptContext")
    def enable_script_context(self) -> bool:
        """
        Set to `true` to inject context into custom DB scripts (warning: cannot be disabled once enabled).
        """
        return pulumi.get(self, "enable_script_context")

    @property
    @pulumi.getter(name="enabledDatabaseCustomization")
    def enabled_database_customization(self) -> bool:
        """
        Set to `true` to use a legacy user store.
        """
        return pulumi.get(self, "enabled_database_customization")

    @property
    @pulumi.getter(name="entityId")
    def entity_id(self) -> str:
        """
        Custom Entity ID for the connection.
        """
        return pulumi.get(self, "entity_id")

    @property
    @pulumi.getter(name="fedMetadataXml")
    def fed_metadata_xml(self) -> str:
        """
        Federation Metadata for the ADFS connection.
        """
        return pulumi.get(self, "fed_metadata_xml")

    @property
    @pulumi.getter(name="fieldsMap")
    def fields_map(self) -> str:
        """
        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")

    @property
    @pulumi.getter(name="forwardRequestInfo")
    def forward_request_info(self) -> bool:
        """
        Specifies whether or not request info should be forwarded to sms gateway.
        """
        return pulumi.get(self, "forward_request_info")

    @property
    @pulumi.getter(name="from")
    def from_(self) -> str:
        """
        Address to use as the sender.
        """
        return pulumi.get(self, "from_")

    @property
    @pulumi.getter(name="gatewayAuthentications")
    def gateway_authentications(self) -> Sequence['outputs.GetConnectionOptionGatewayAuthenticationResult']:
        """
        Defines the parameters used to generate the auth token for the custom gateway.
        """
        return pulumi.get(self, "gateway_authentications")

    @property
    @pulumi.getter(name="gatewayUrl")
    def gateway_url(self) -> str:
        """
        Defines a custom sms gateway to use instead of Twilio.
        """
        return pulumi.get(self, "gateway_url")

    @property
    @pulumi.getter(name="iconUrl")
    def icon_url(self) -> str:
        """
        Icon URL.
        """
        return pulumi.get(self, "icon_url")

    @property
    @pulumi.getter(name="identityApi")
    def identity_api(self) -> str:
        """
        Azure AD Identity API. Available options are: `microsoft-identity-platform-v2.0` or `azure-active-directory-v1.0`.
        """
        return pulumi.get(self, "identity_api")

    @property
    @pulumi.getter(name="idpInitiateds")
    def idp_initiateds(self) -> Sequence['outputs.GetConnectionOptionIdpInitiatedResult']:
        """
        Configuration options for IDP Initiated Authentication. This is an object with the properties: `client_id`, `client_protocol`, and `client_authorize_query`.
        """
        return pulumi.get(self, "idp_initiateds")

    @property
    @pulumi.getter(name="importMode")
    def import_mode(self) -> bool:
        """
        Indicates whether you have a legacy user store and want to gradually migrate those users to the Auth0 user store.
        """
        return pulumi.get(self, "import_mode")

    @property
    @pulumi.getter
    def ips(self) -> Sequence[str]:
        """
        A list of IPs.
        """
        return pulumi.get(self, "ips")

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

    @property
    @pulumi.getter(name="jwksUri")
    def jwks_uri(self) -> str:
        """
        JWKS URI.
        """
        return pulumi.get(self, "jwks_uri")

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

    @property
    @pulumi.getter(name="mapUserIdToId")
    def map_user_id_to_id(self) -> bool:
        """
        By default Auth0 maps `user_id` to `email`. Enabling this setting changes the behavior to map `user_id` to 'id' instead. This can only be defined on a new Google Workspace connection and can not be changed once set.
        """
        return pulumi.get(self, "map_user_id_to_id")

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

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

    @property
    @pulumi.getter(name="metadataUrl")
    def metadata_url(self) -> str:
        """
        The URL of the SAML metadata document.
        """
        return pulumi.get(self, "metadata_url")

    @property
    @pulumi.getter(name="metadataXml")
    def metadata_xml(self) -> str:
        """
        The XML content for the SAML metadata document. Values within the xml will take precedence over other attributes set on the options block.
        """
        return pulumi.get(self, "metadata_xml")

    @property
    @pulumi.getter
    def mfas(self) -> Sequence['outputs.GetConnectionOptionMfaResult']:
        """
        Configuration options for multifactor authentication.
        """
        return pulumi.get(self, "mfas")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The public name of the email or SMS Connection. In most cases this is the same name as the connection name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nonPersistentAttrs")
    def non_persistent_attrs(self) -> Sequence[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 here.
        """
        return pulumi.get(self, "non_persistent_attrs")

    @property
    @pulumi.getter(name="passwordComplexityOptions")
    def password_complexity_options(self) -> Sequence['outputs.GetConnectionOptionPasswordComplexityOptionResult']:
        """
        Configuration settings for password complexity.
        """
        return pulumi.get(self, "password_complexity_options")

    @property
    @pulumi.getter(name="passwordDictionaries")
    def password_dictionaries(self) -> Sequence['outputs.GetConnectionOptionPasswordDictionaryResult']:
        """
        Configuration settings for the password dictionary check, which does not allow passwords that are part of the password dictionary.
        """
        return pulumi.get(self, "password_dictionaries")

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

    @property
    @pulumi.getter(name="passwordNoPersonalInfos")
    def password_no_personal_infos(self) -> Sequence['outputs.GetConnectionOptionPasswordNoPersonalInfoResult']:
        """
        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`.
        """
        return pulumi.get(self, "password_no_personal_infos")

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

    @property
    @pulumi.getter(name="pingFederateBaseUrl")
    def ping_federate_base_url(self) -> str:
        """
        Ping Federate Server URL.
        """
        return pulumi.get(self, "ping_federate_base_url")

    @property
    @pulumi.getter(name="pkceEnabled")
    def pkce_enabled(self) -> bool:
        """
        Enables Proof Key for Code Exchange (PKCE) functionality for OAuth2 connections.
        """
        return pulumi.get(self, "pkce_enabled")

    @property
    @pulumi.getter(name="protocolBinding")
    def protocol_binding(self) -> str:
        """
        The SAML Response Binding: how the SAML token is received by Auth0 from the IdP.
        """
        return pulumi.get(self, "protocol_binding")

    @property
    @pulumi.getter
    def provider(self) -> str:
        """
        Defines the custom `sms_gateway` provider.
        """
        return pulumi.get(self, "provider")

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

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

    @property
    @pulumi.getter
    def scopes(self) -> Sequence[str]:
        """
        Permissions to grant to the connection. Within the Auth0 dashboard these appear under the "Attributes" and "Extended Attributes" sections. Some examples: `basic_profile`, `ext_profile`, `ext_nested_groups`, etc.
        """
        return pulumi.get(self, "scopes")

    @property
    @pulumi.getter
    def scripts(self) -> Mapping[str, str]:
        """
        A map of scripts used for an OAuth connection. Only accepts a `fetchUserProfile` script.
        """
        return pulumi.get(self, "scripts")

    @property
    @pulumi.getter(name="setUserRootAttributes")
    def set_user_root_attributes(self) -> str:
        """
        Determines whether to sync user profile attributes (`name`, `given_name`, `family_name`, `nickname`, `picture`) at each login or only on the first login. Options include: `on_each_login`, `on_first_login`. Default value: `on_each_login`.
        """
        return pulumi.get(self, "set_user_root_attributes")

    @property
    @pulumi.getter(name="shouldTrustEmailVerifiedConnection")
    def should_trust_email_verified_connection(self) -> str:
        """
        Choose how Auth0 sets the email_verified field in the user profile.
        """
        return pulumi.get(self, "should_trust_email_verified_connection")

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

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

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

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

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

    @property
    @pulumi.getter(name="signingKeys")
    def signing_keys(self) -> Sequence['outputs.GetConnectionOptionSigningKeyResult']:
        """
        The key used to sign requests in the connection. Uses the `key` and `cert` properties to provide the private key and certificate respectively.
        """
        return pulumi.get(self, "signing_keys")

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

    @property
    @pulumi.getter
    def subject(self) -> str:
        """
        Subject line of the email.
        """
        return pulumi.get(self, "subject")

    @property
    @pulumi.getter
    def syntax(self) -> str:
        """
        Syntax of the template body.
        """
        return pulumi.get(self, "syntax")

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

    @property
    @pulumi.getter
    def template(self) -> str:
        """
        Body of the template.
        """
        return pulumi.get(self, "template")

    @property
    @pulumi.getter(name="tenantDomain")
    def tenant_domain(self) -> str:
        """
        Tenant domain name.
        """
        return pulumi.get(self, "tenant_domain")

    @property
    @pulumi.getter(name="tokenEndpoint")
    def token_endpoint(self) -> str:
        """
        Token endpoint.
        """
        return pulumi.get(self, "token_endpoint")

    @property
    @pulumi.getter
    def totps(self) -> Sequence['outputs.GetConnectionOptionTotpResult']:
        """
        Configuration options for one-time passwords.
        """
        return pulumi.get(self, "totps")

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

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

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Value can be `back_channel` or `front_channel`. Front Channel will use OIDC protocol with `response_mode=form_post` and `response_type=id_token`. Back Channel will use `response_type=code`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="upstreamParams")
    def upstream_params(self) -> str:
        """
        You can pass provider-specific parameters to an identity provider during authentication. The values can either be static per connection or dynamic per user.
        """
        return pulumi.get(self, "upstream_params")

    @property
    @pulumi.getter(name="useCertAuth")
    def use_cert_auth(self) -> bool:
        """
        Indicates whether to use cert auth or not.
        """
        return pulumi.get(self, "use_cert_auth")

    @property
    @pulumi.getter(name="useKerberos")
    def use_kerberos(self) -> bool:
        """
        Indicates whether to use Kerberos or not.
        """
        return pulumi.get(self, "use_kerberos")

    @property
    @pulumi.getter(name="useWsfed")
    def use_wsfed(self) -> bool:
        """
        Whether to use WS-Fed.
        """
        return pulumi.get(self, "use_wsfed")

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

    @property
    @pulumi.getter(name="userinfoEndpoint")
    def userinfo_endpoint(self) -> str:
        """
        User info endpoint.
        """
        return pulumi.get(self, "userinfo_endpoint")

    @property
    @pulumi.getter
    def validations(self) -> Sequence['outputs.GetConnectionOptionValidationResult']:
        """
        Validation of the minimum and maximum values allowed for a user to have as username.
        """
        return pulumi.get(self, "validations")

    @property
    @pulumi.getter(name="waadCommonEndpoint")
    def waad_common_endpoint(self) -> bool:
        """
        Indicates whether 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")

    @property
    @pulumi.getter(name="waadProtocol")
    def waad_protocol(self) -> str:
        """
        Protocol to use.
        """
        return pulumi.get(self, "waad_protocol")


@pulumi.output_type
class GetConnectionOptionAttributeMapResult(dict):
    def __init__(__self__, *,
                 attributes: str,
                 mapping_mode: str,
                 userinfo_scope: str):
        """
        :param str attributes: This property is an object containing mapping information that allows Auth0 to interpret incoming claims from the IdP. Mapping information must be provided as key/value pairs.
        :param str mapping_mode: Method used to map incoming claims. Possible values: `use_map` (Okta or OIDC), `bind_all` (OIDC) or `basic_profile` (Okta).
        :param str userinfo_scope: This property defines the scopes that Auth0 sends to the IdP’s UserInfo endpoint when requested.
        """
        pulumi.set(__self__, "attributes", attributes)
        pulumi.set(__self__, "mapping_mode", mapping_mode)
        pulumi.set(__self__, "userinfo_scope", userinfo_scope)

    @property
    @pulumi.getter
    def attributes(self) -> str:
        """
        This property is an object containing mapping information that allows Auth0 to interpret incoming claims from the IdP. Mapping information must be provided as key/value pairs.
        """
        return pulumi.get(self, "attributes")

    @property
    @pulumi.getter(name="mappingMode")
    def mapping_mode(self) -> str:
        """
        Method used to map incoming claims. Possible values: `use_map` (Okta or OIDC), `bind_all` (OIDC) or `basic_profile` (Okta).
        """
        return pulumi.get(self, "mapping_mode")

    @property
    @pulumi.getter(name="userinfoScope")
    def userinfo_scope(self) -> str:
        """
        This property defines the scopes that Auth0 sends to the IdP’s UserInfo endpoint when requested.
        """
        return pulumi.get(self, "userinfo_scope")


@pulumi.output_type
class GetConnectionOptionConnectionSettingResult(dict):
    def __init__(__self__, *,
                 pkce: str):
        """
        :param str pkce: PKCE configuration. Possible values: `auto` (uses the strongest algorithm available), `S256` (uses the SHA-256 algorithm), `plain` (uses plaintext as described in the PKCE specification) or `disabled` (disables support for PKCE).
        """
        pulumi.set(__self__, "pkce", pkce)

    @property
    @pulumi.getter
    def pkce(self) -> str:
        """
        PKCE configuration. Possible values: `auto` (uses the strongest algorithm available), `S256` (uses the SHA-256 algorithm), `plain` (uses plaintext as described in the PKCE specification) or `disabled` (disables support for PKCE).
        """
        return pulumi.get(self, "pkce")


@pulumi.output_type
class GetConnectionOptionDecryptionKeyResult(dict):
    def __init__(__self__, *,
                 cert: str,
                 key: str):
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def cert(self) -> str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")


@pulumi.output_type
class GetConnectionOptionGatewayAuthenticationResult(dict):
    def __init__(__self__, *,
                 audience: str,
                 method: str,
                 secret: str,
                 secret_base64_encoded: bool,
                 subject: str):
        """
        :param str audience: Audience claim for the HS256 token sent to `gateway_url`.
        :param str method: Authentication method (default is `bearer` token).
        :param str secret: Secret used to sign the HS256 token sent to `gateway_url`.
        :param bool secret_base64_encoded: Specifies whether or not the secret is Base64-encoded.
        :param str subject: Subject claim for the HS256 token sent to `gateway_url`.
        """
        pulumi.set(__self__, "audience", audience)
        pulumi.set(__self__, "method", method)
        pulumi.set(__self__, "secret", secret)
        pulumi.set(__self__, "secret_base64_encoded", secret_base64_encoded)
        pulumi.set(__self__, "subject", subject)

    @property
    @pulumi.getter
    def audience(self) -> str:
        """
        Audience claim for the HS256 token sent to `gateway_url`.
        """
        return pulumi.get(self, "audience")

    @property
    @pulumi.getter
    def method(self) -> str:
        """
        Authentication method (default is `bearer` token).
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        Secret used to sign the HS256 token sent to `gateway_url`.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter(name="secretBase64Encoded")
    def secret_base64_encoded(self) -> bool:
        """
        Specifies whether or not the secret is Base64-encoded.
        """
        return pulumi.get(self, "secret_base64_encoded")

    @property
    @pulumi.getter
    def subject(self) -> str:
        """
        Subject claim for the HS256 token sent to `gateway_url`.
        """
        return pulumi.get(self, "subject")


@pulumi.output_type
class GetConnectionOptionIdpInitiatedResult(dict):
    def __init__(__self__, *,
                 client_authorize_query: str,
                 client_id: str,
                 client_protocol: str):
        pulumi.set(__self__, "client_authorize_query", client_authorize_query)
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_protocol", client_protocol)

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

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        return pulumi.get(self, "client_id")

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


@pulumi.output_type
class GetConnectionOptionMfaResult(dict):
    def __init__(__self__, *,
                 active: bool,
                 return_enroll_settings: bool):
        """
        :param bool active: Indicates whether multifactor authentication is enabled for this connection.
        :param bool return_enroll_settings: Indicates whether multifactor authentication enrollment settings will be returned.
        """
        pulumi.set(__self__, "active", active)
        pulumi.set(__self__, "return_enroll_settings", return_enroll_settings)

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

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


@pulumi.output_type
class GetConnectionOptionPasswordComplexityOptionResult(dict):
    def __init__(__self__, *,
                 min_length: int):
        """
        :param int min_length: Minimum number of characters allowed in passwords.
        """
        pulumi.set(__self__, "min_length", min_length)

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


@pulumi.output_type
class GetConnectionOptionPasswordDictionaryResult(dict):
    def __init__(__self__, *,
                 dictionaries: Sequence[str],
                 enable: bool):
        """
        :param Sequence[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 bool enable: Indicates whether the password dictionary check is enabled for this connection.
        """
        pulumi.set(__self__, "dictionaries", dictionaries)
        pulumi.set(__self__, "enable", enable)

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

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


@pulumi.output_type
class GetConnectionOptionPasswordHistoryResult(dict):
    def __init__(__self__, *,
                 enable: bool,
                 size: int):
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def enable(self) -> bool:
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def size(self) -> int:
        return pulumi.get(self, "size")


@pulumi.output_type
class GetConnectionOptionPasswordNoPersonalInfoResult(dict):
    def __init__(__self__, *,
                 enable: bool):
        pulumi.set(__self__, "enable", enable)

    @property
    @pulumi.getter
    def enable(self) -> bool:
        return pulumi.get(self, "enable")


@pulumi.output_type
class GetConnectionOptionSigningKeyResult(dict):
    def __init__(__self__, *,
                 cert: str,
                 key: str):
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def cert(self) -> str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")


@pulumi.output_type
class GetConnectionOptionTotpResult(dict):
    def __init__(__self__, *,
                 length: int,
                 time_step: int):
        """
        :param int length: Length of the one-time password.
        :param int time_step: Seconds between allowed generation of new passwords.
        """
        pulumi.set(__self__, "length", length)
        pulumi.set(__self__, "time_step", time_step)

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

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


@pulumi.output_type
class GetConnectionOptionValidationResult(dict):
    def __init__(__self__, *,
                 usernames: Sequence['outputs.GetConnectionOptionValidationUsernameResult']):
        """
        :param Sequence['GetConnectionOptionValidationUsernameArgs'] usernames: Specifies the `min` and `max` values of username length.
        """
        pulumi.set(__self__, "usernames", usernames)

    @property
    @pulumi.getter
    def usernames(self) -> Sequence['outputs.GetConnectionOptionValidationUsernameResult']:
        """
        Specifies the `min` and `max` values of username length.
        """
        return pulumi.get(self, "usernames")


@pulumi.output_type
class GetConnectionOptionValidationUsernameResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

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

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


@pulumi.output_type
class GetCustomDomainVerificationResult(dict):
    def __init__(__self__, *,
                 methods: Sequence[Any]):
        """
        :param Sequence[Any] methods: Verification methods for the domain.
        """
        pulumi.set(__self__, "methods", methods)

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


@pulumi.output_type
class GetOrganizationBrandingResult(dict):
    def __init__(__self__, *,
                 colors: Mapping[str, str],
                 logo_url: str):
        """
        :param Mapping[str, str] colors: Color scheme used to customize the login pages.
        :param str logo_url: URL of logo to display on login page.
        """
        pulumi.set(__self__, "colors", colors)
        pulumi.set(__self__, "logo_url", logo_url)

    @property
    @pulumi.getter
    def colors(self) -> Mapping[str, str]:
        """
        Color scheme used to customize the login pages.
        """
        return pulumi.get(self, "colors")

    @property
    @pulumi.getter(name="logoUrl")
    def logo_url(self) -> str:
        """
        URL of logo to display on login page.
        """
        return pulumi.get(self, "logo_url")


@pulumi.output_type
class GetOrganizationConnectionResult(dict):
    def __init__(__self__, *,
                 assign_membership_on_login: bool,
                 connection_id: str):
        """
        :param bool assign_membership_on_login: When `true`, all users that log in with this connection will be automatically granted membership in the organization. When `false`, users must be granted membership in the organization before logging in with this connection.
        :param str connection_id: The ID of the enabled connection on the organization.
        """
        pulumi.set(__self__, "assign_membership_on_login", assign_membership_on_login)
        pulumi.set(__self__, "connection_id", connection_id)

    @property
    @pulumi.getter(name="assignMembershipOnLogin")
    def assign_membership_on_login(self) -> bool:
        """
        When `true`, all users that log in with this connection will be automatically granted membership in the organization. When `false`, users must be granted membership in the organization before logging in with this connection.
        """
        return pulumi.get(self, "assign_membership_on_login")

    @property
    @pulumi.getter(name="connectionId")
    def connection_id(self) -> str:
        """
        The ID of the enabled connection on the organization.
        """
        return pulumi.get(self, "connection_id")


@pulumi.output_type
class GetPagesChangePasswordResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 html: str):
        """
        :param bool enabled: Indicates whether to use the custom Reset Password HTML (`true`) or the default Auth0 page (`false`).
        :param str html: Customized content for the Reset Password page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "html", html)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether to use the custom Reset Password HTML (`true`) or the default Auth0 page (`false`).
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def html(self) -> str:
        """
        Customized content for the Reset Password page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        return pulumi.get(self, "html")


@pulumi.output_type
class GetPagesErrorResult(dict):
    def __init__(__self__, *,
                 html: str,
                 show_log_link: bool,
                 url: str):
        """
        :param str html: Customized content for the Error page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        :param bool show_log_link: Indicates whether to show the link to logs as part of the default error page.
        :param str url: URL to redirect to when an error occurs, instead of 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) -> str:
        """
        Customized content for the Error page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        return pulumi.get(self, "html")

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

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        URL to redirect to when an error occurs, instead of showing the default error page.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetPagesGuardianMfaResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 html: str):
        """
        :param bool enabled: Indicates whether to use the custom Guardian MFA HTML (`true`) or the default Auth0 page (`false`).
        :param str html: Customized content for the Guardian MFA page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "html", html)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether to use the custom Guardian MFA HTML (`true`) or the default Auth0 page (`false`).
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def html(self) -> str:
        """
        Customized content for the Guardian MFA page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        return pulumi.get(self, "html")


@pulumi.output_type
class GetPagesLoginResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 html: str):
        """
        :param bool enabled: Indicates whether to use the custom Login page HTML (`true`) or the default Auth0 page (`false`).
        :param str html: Customized content for the Login page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "html", html)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether to use the custom Login page HTML (`true`) or the default Auth0 page (`false`).
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def html(self) -> str:
        """
        Customized content for the Login page. HTML format with supported [Liquid syntax](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers).
        """
        return pulumi.get(self, "html")


@pulumi.output_type
class GetResourceServerScopeResult(dict):
    def __init__(__self__, *,
                 description: str,
                 name: str):
        """
        :param str description: Description of the permission (scope).
        :param str name: Name of the permission (scope). Examples include `read:appointments` or `delete:appointments`.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class GetRolePermissionResult(dict):
    def __init__(__self__, *,
                 description: str,
                 name: str,
                 resource_server_identifier: str,
                 resource_server_name: str):
        """
        :param str description: Description of the permission.
        :param str name: Name of the permission (scope) configured on the resource server (API).
        :param str resource_server_identifier: Unique identifier for the resource server (API).
        :param str resource_server_name: Name of resource server (API) that the permission is associated with.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_server_identifier", resource_server_identifier)
        pulumi.set(__self__, "resource_server_name", resource_server_name)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description of the permission.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the permission (scope) configured on the resource server (API).
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="resourceServerName")
    def resource_server_name(self) -> str:
        """
        Name of resource server (API) that the permission is associated with.
        """
        return pulumi.get(self, "resource_server_name")


@pulumi.output_type
class GetSigningKeysSigningKeyResult(dict):
    def __init__(__self__, *,
                 cert: str,
                 current: bool,
                 fingerprint: str,
                 kid: str,
                 next: bool,
                 pkcs7: str,
                 previous: bool,
                 revoked: bool,
                 thumbprint: str):
        """
        :param str cert: The public certificate of the signing key.
        :param bool current: True if the key is the the current key.
        :param str fingerprint: The cert fingerprint.
        :param str kid: The key ID of the signing key.
        :param bool next: True if the key is the the next key.
        :param str pkcs7: The public certificate of the signing key in PKCS7 format.
        :param bool previous: True if the key is the the previous key.
        :param bool revoked: True if the key is revoked.
        :param str thumbprint: The cert thumbprint.
        """
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "current", current)
        pulumi.set(__self__, "fingerprint", fingerprint)
        pulumi.set(__self__, "kid", kid)
        pulumi.set(__self__, "next", next)
        pulumi.set(__self__, "pkcs7", pkcs7)
        pulumi.set(__self__, "previous", previous)
        pulumi.set(__self__, "revoked", revoked)
        pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter
    def cert(self) -> str:
        """
        The public certificate of the signing key.
        """
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def current(self) -> bool:
        """
        True if the key is the the current key.
        """
        return pulumi.get(self, "current")

    @property
    @pulumi.getter
    def fingerprint(self) -> str:
        """
        The cert fingerprint.
        """
        return pulumi.get(self, "fingerprint")

    @property
    @pulumi.getter
    def kid(self) -> str:
        """
        The key ID of the signing key.
        """
        return pulumi.get(self, "kid")

    @property
    @pulumi.getter
    def next(self) -> bool:
        """
        True if the key is the the next key.
        """
        return pulumi.get(self, "next")

    @property
    @pulumi.getter
    def pkcs7(self) -> str:
        """
        The public certificate of the signing key in PKCS7 format.
        """
        return pulumi.get(self, "pkcs7")

    @property
    @pulumi.getter
    def previous(self) -> bool:
        """
        True if the key is the the previous key.
        """
        return pulumi.get(self, "previous")

    @property
    @pulumi.getter
    def revoked(self) -> bool:
        """
        True if the key is revoked.
        """
        return pulumi.get(self, "revoked")

    @property
    @pulumi.getter
    def thumbprint(self) -> str:
        """
        The cert thumbprint.
        """
        return pulumi.get(self, "thumbprint")


@pulumi.output_type
class GetTenantFlagResult(dict):
    def __init__(__self__, *,
                 allow_legacy_delegation_grant_types: bool,
                 allow_legacy_ro_grant_types: bool,
                 allow_legacy_tokeninfo_endpoint: bool,
                 dashboard_insights_view: bool,
                 dashboard_log_streams_next: bool,
                 disable_clickjack_protection_headers: bool,
                 disable_fields_map_fix: bool,
                 disable_management_api_sms_obfuscation: bool,
                 enable_adfs_waad_email_verification: bool,
                 enable_apis_section: bool,
                 enable_client_connections: bool,
                 enable_custom_domain_in_emails: bool,
                 enable_dynamic_client_registration: bool,
                 enable_idtoken_api2: bool,
                 enable_legacy_logs_search_v2: bool,
                 enable_legacy_profile: bool,
                 enable_pipeline2: bool,
                 enable_public_signup_user_exists_error: bool,
                 mfa_show_factor_list_on_enrollment: bool,
                 no_disclose_enterprise_connections: bool,
                 require_pushed_authorization_requests: bool,
                 revoke_refresh_token_grant: bool,
                 use_scope_descriptions_for_consent: bool):
        """
        :param bool allow_legacy_delegation_grant_types: Whether the legacy delegation endpoint will be enabled for your account (true) or not available (false).
        :param bool allow_legacy_ro_grant_types: Whether the legacy `auth/ro` endpoint (used with resource owner password and passwordless features) will be enabled for your account (true) or not available (false).
        :param bool allow_legacy_tokeninfo_endpoint: If enabled, customers can use Tokeninfo Endpoint, otherwise they can not use it.
        :param bool dashboard_insights_view: Enables new insights activity page view.
        :param bool dashboard_log_streams_next: Enables beta access to log streaming changes.
        :param bool disable_clickjack_protection_headers: Indicates whether classic Universal Login prompts include additional security headers to prevent clickjacking.
        :param bool disable_fields_map_fix: Disables SAML fields map fix for bad mappings with repeated attributes.
        :param bool disable_management_api_sms_obfuscation: If true, SMS phone numbers will not be obfuscated in Management API GET calls.
        :param bool enable_adfs_waad_email_verification: If enabled, users will be presented with an email verification prompt during their first login when using Azure AD or ADFS connections.
        :param bool enable_apis_section: Indicates whether the APIs section is enabled for the tenant.
        :param bool enable_client_connections: Indicates whether all current connections should be enabled when a new client is created.
        :param bool enable_custom_domain_in_emails: Indicates whether the tenant allows custom domains in emails. Before enabling this flag, you must have a custom domain with status: `ready`.
        :param bool enable_dynamic_client_registration: Indicates whether the tenant allows dynamic client registration.
        :param bool enable_idtoken_api2: Whether ID tokens can be used to authorize some types of requests to API v2 (true) or not (false).
        :param bool enable_legacy_logs_search_v2: Indicates whether to use the older v2 legacy logs search.
        :param bool enable_legacy_profile: Whether ID tokens and the userinfo endpoint includes a complete user profile (true) or only OpenID Connect claims (false).
        :param bool enable_pipeline2: Indicates whether advanced API Authorization scenarios are enabled.
        :param bool enable_public_signup_user_exists_error: Indicates whether the public sign up process shows a `user_exists` error if the user already exists.
        :param bool mfa_show_factor_list_on_enrollment: Used to allow users to pick which factor to enroll with from the list of available MFA factors.
        :param bool no_disclose_enterprise_connections: Do not Publish Enterprise Connections Information with IdP domains on the lock configuration file.
        :param bool require_pushed_authorization_requests: Makes the use of Pushed Authorization Requests mandatory for all clients across the tenant. This feature currently needs to be enabled on the tenant in order to make use of it.
        :param bool revoke_refresh_token_grant: Delete underlying grant when a refresh token is revoked via the Authentication API.
        :param bool use_scope_descriptions_for_consent: Indicates whether to use scope descriptions for consent.
        """
        pulumi.set(__self__, "allow_legacy_delegation_grant_types", allow_legacy_delegation_grant_types)
        pulumi.set(__self__, "allow_legacy_ro_grant_types", allow_legacy_ro_grant_types)
        pulumi.set(__self__, "allow_legacy_tokeninfo_endpoint", allow_legacy_tokeninfo_endpoint)
        pulumi.set(__self__, "dashboard_insights_view", dashboard_insights_view)
        pulumi.set(__self__, "dashboard_log_streams_next", dashboard_log_streams_next)
        pulumi.set(__self__, "disable_clickjack_protection_headers", disable_clickjack_protection_headers)
        pulumi.set(__self__, "disable_fields_map_fix", disable_fields_map_fix)
        pulumi.set(__self__, "disable_management_api_sms_obfuscation", disable_management_api_sms_obfuscation)
        pulumi.set(__self__, "enable_adfs_waad_email_verification", enable_adfs_waad_email_verification)
        pulumi.set(__self__, "enable_apis_section", enable_apis_section)
        pulumi.set(__self__, "enable_client_connections", enable_client_connections)
        pulumi.set(__self__, "enable_custom_domain_in_emails", enable_custom_domain_in_emails)
        pulumi.set(__self__, "enable_dynamic_client_registration", enable_dynamic_client_registration)
        pulumi.set(__self__, "enable_idtoken_api2", enable_idtoken_api2)
        pulumi.set(__self__, "enable_legacy_logs_search_v2", enable_legacy_logs_search_v2)
        pulumi.set(__self__, "enable_legacy_profile", enable_legacy_profile)
        pulumi.set(__self__, "enable_pipeline2", enable_pipeline2)
        pulumi.set(__self__, "enable_public_signup_user_exists_error", enable_public_signup_user_exists_error)
        pulumi.set(__self__, "mfa_show_factor_list_on_enrollment", mfa_show_factor_list_on_enrollment)
        pulumi.set(__self__, "no_disclose_enterprise_connections", no_disclose_enterprise_connections)
        pulumi.set(__self__, "require_pushed_authorization_requests", require_pushed_authorization_requests)
        pulumi.set(__self__, "revoke_refresh_token_grant", revoke_refresh_token_grant)
        pulumi.set(__self__, "use_scope_descriptions_for_consent", use_scope_descriptions_for_consent)

    @property
    @pulumi.getter(name="allowLegacyDelegationGrantTypes")
    def allow_legacy_delegation_grant_types(self) -> bool:
        """
        Whether the legacy delegation endpoint will be enabled for your account (true) or not available (false).
        """
        return pulumi.get(self, "allow_legacy_delegation_grant_types")

    @property
    @pulumi.getter(name="allowLegacyRoGrantTypes")
    def allow_legacy_ro_grant_types(self) -> bool:
        """
        Whether the legacy `auth/ro` endpoint (used with resource owner password and passwordless features) will be enabled for your account (true) or not available (false).
        """
        return pulumi.get(self, "allow_legacy_ro_grant_types")

    @property
    @pulumi.getter(name="allowLegacyTokeninfoEndpoint")
    def allow_legacy_tokeninfo_endpoint(self) -> bool:
        """
        If enabled, customers can use Tokeninfo Endpoint, otherwise they can not use it.
        """
        return pulumi.get(self, "allow_legacy_tokeninfo_endpoint")

    @property
    @pulumi.getter(name="dashboardInsightsView")
    def dashboard_insights_view(self) -> bool:
        """
        Enables new insights activity page view.
        """
        return pulumi.get(self, "dashboard_insights_view")

    @property
    @pulumi.getter(name="dashboardLogStreamsNext")
    def dashboard_log_streams_next(self) -> bool:
        """
        Enables beta access to log streaming changes.
        """
        return pulumi.get(self, "dashboard_log_streams_next")

    @property
    @pulumi.getter(name="disableClickjackProtectionHeaders")
    def disable_clickjack_protection_headers(self) -> bool:
        """
        Indicates whether classic Universal Login prompts include additional security headers to prevent clickjacking.
        """
        return pulumi.get(self, "disable_clickjack_protection_headers")

    @property
    @pulumi.getter(name="disableFieldsMapFix")
    def disable_fields_map_fix(self) -> bool:
        """
        Disables SAML fields map fix for bad mappings with repeated attributes.
        """
        return pulumi.get(self, "disable_fields_map_fix")

    @property
    @pulumi.getter(name="disableManagementApiSmsObfuscation")
    def disable_management_api_sms_obfuscation(self) -> bool:
        """
        If true, SMS phone numbers will not be obfuscated in Management API GET calls.
        """
        return pulumi.get(self, "disable_management_api_sms_obfuscation")

    @property
    @pulumi.getter(name="enableAdfsWaadEmailVerification")
    def enable_adfs_waad_email_verification(self) -> bool:
        """
        If enabled, users will be presented with an email verification prompt during their first login when using Azure AD or ADFS connections.
        """
        return pulumi.get(self, "enable_adfs_waad_email_verification")

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

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

    @property
    @pulumi.getter(name="enableCustomDomainInEmails")
    def enable_custom_domain_in_emails(self) -> bool:
        """
        Indicates whether the tenant allows custom domains in emails. Before enabling this flag, you must have a custom domain with status: `ready`.
        """
        return pulumi.get(self, "enable_custom_domain_in_emails")

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

    @property
    @pulumi.getter(name="enableIdtokenApi2")
    def enable_idtoken_api2(self) -> bool:
        """
        Whether ID tokens can be used to authorize some types of requests to API v2 (true) or not (false).
        """
        return pulumi.get(self, "enable_idtoken_api2")

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

    @property
    @pulumi.getter(name="enableLegacyProfile")
    def enable_legacy_profile(self) -> bool:
        """
        Whether ID tokens and the userinfo endpoint includes a complete user profile (true) or only OpenID Connect claims (false).
        """
        return pulumi.get(self, "enable_legacy_profile")

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

    @property
    @pulumi.getter(name="enablePublicSignupUserExistsError")
    def enable_public_signup_user_exists_error(self) -> bool:
        """
        Indicates whether 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")

    @property
    @pulumi.getter(name="mfaShowFactorListOnEnrollment")
    def mfa_show_factor_list_on_enrollment(self) -> bool:
        """
        Used to allow users to pick which factor to enroll with from the list of available MFA factors.
        """
        return pulumi.get(self, "mfa_show_factor_list_on_enrollment")

    @property
    @pulumi.getter(name="noDiscloseEnterpriseConnections")
    def no_disclose_enterprise_connections(self) -> bool:
        """
        Do not Publish Enterprise Connections Information with IdP domains on the lock configuration file.
        """
        return pulumi.get(self, "no_disclose_enterprise_connections")

    @property
    @pulumi.getter(name="requirePushedAuthorizationRequests")
    def require_pushed_authorization_requests(self) -> bool:
        """
        Makes the use of Pushed Authorization Requests mandatory for all clients across the tenant. This feature currently needs to be enabled on the tenant in order to make use of it.
        """
        return pulumi.get(self, "require_pushed_authorization_requests")

    @property
    @pulumi.getter(name="revokeRefreshTokenGrant")
    def revoke_refresh_token_grant(self) -> bool:
        """
        Delete underlying grant when a refresh token is revoked via the Authentication API.
        """
        return pulumi.get(self, "revoke_refresh_token_grant")

    @property
    @pulumi.getter(name="useScopeDescriptionsForConsent")
    def use_scope_descriptions_for_consent(self) -> bool:
        """
        Indicates whether to use scope descriptions for consent.
        """
        return pulumi.get(self, "use_scope_descriptions_for_consent")


@pulumi.output_type
class GetTenantSessionResult(dict):
    def __init__(__self__, *,
                 oidc_logout_prompt_enabled: bool):
        """
        :param bool oidc_logout_prompt_enabled: When active, users will be presented with a consent prompt to confirm the logout request if the request is not trustworthy. Turn off the consent prompt to bypass user confirmation.
        """
        pulumi.set(__self__, "oidc_logout_prompt_enabled", oidc_logout_prompt_enabled)

    @property
    @pulumi.getter(name="oidcLogoutPromptEnabled")
    def oidc_logout_prompt_enabled(self) -> bool:
        """
        When active, users will be presented with a consent prompt to confirm the logout request if the request is not trustworthy. Turn off the consent prompt to bypass user confirmation.
        """
        return pulumi.get(self, "oidc_logout_prompt_enabled")


@pulumi.output_type
class GetTenantSessionCookyResult(dict):
    def __init__(__self__, *,
                 mode: str):
        """
        :param str mode: Behavior of tenant session cookie. Accepts either "persistent" or "non-persistent".
        """
        pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Behavior of tenant session cookie. Accepts either "persistent" or "non-persistent".
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetUserPermissionResult(dict):
    def __init__(__self__, *,
                 description: str,
                 name: str,
                 resource_server_identifier: str,
                 resource_server_name: str):
        """
        :param str description: Description of the permission.
        :param str name: Name of the permission.
        :param str resource_server_identifier: Resource server identifier associated with the permission.
        :param str resource_server_name: Name of resource server that the permission is associated with.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_server_identifier", resource_server_identifier)
        pulumi.set(__self__, "resource_server_name", resource_server_name)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description of the permission.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="resourceServerIdentifier")
    def resource_server_identifier(self) -> str:
        """
        Resource server identifier associated with the permission.
        """
        return pulumi.get(self, "resource_server_identifier")

    @property
    @pulumi.getter(name="resourceServerName")
    def resource_server_name(self) -> str:
        """
        Name of resource server that the permission is associated with.
        """
        return pulumi.get(self, "resource_server_name")


