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

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

__all__ = [
    'GroupPermissionsManageMembersScope',
    'GroupPermissionsManageMembershipScope',
    'GroupPermissionsManageScope',
    'GroupPermissionsViewMembersScope',
    'GroupPermissionsViewScope',
    'RealmInternationalization',
    'RealmOtpPolicy',
    'RealmSecurityDefenses',
    'RealmSecurityDefensesBruteForceDetection',
    'RealmSecurityDefensesHeaders',
    'RealmSmtpServer',
    'RealmSmtpServerAuth',
    'RealmWebAuthnPasswordlessPolicy',
    'RealmWebAuthnPolicy',
    'UserFederatedIdentity',
    'UserInitialPassword',
    'UsersPermissionsImpersonateScope',
    'UsersPermissionsManageGroupMembershipScope',
    'UsersPermissionsManageScope',
    'UsersPermissionsMapRolesScope',
    'UsersPermissionsUserImpersonatedScope',
    'UsersPermissionsViewScope',
    'GetClientDescriptionConverterProtocolMapperResult',
    'GetRealmInternationalizationResult',
    'GetRealmKeysKeyResult',
    'GetRealmOtpPolicyResult',
    'GetRealmSecurityDefenseResult',
    'GetRealmSecurityDefenseBruteForceDetectionResult',
    'GetRealmSecurityDefenseHeaderResult',
    'GetRealmSmtpServerResult',
    'GetRealmSmtpServerAuthResult',
    'GetRealmWebAuthnPasswordlessPolicyResult',
    'GetRealmWebAuthnPolicyResult',
]

@pulumi.output_type
class GroupPermissionsManageMembersScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class GroupPermissionsManageMembershipScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class GroupPermissionsManageScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class GroupPermissionsViewMembersScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class GroupPermissionsViewScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class RealmInternationalization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultLocale":
            suggest = "default_locale"
        elif key == "supportedLocales":
            suggest = "supported_locales"

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

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

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

    def __init__(__self__, *,
                 default_locale: str,
                 supported_locales: Sequence[str]):
        """
        :param str default_locale: The locale to use by default. This locale code must be present within the `supported_locales` list.
        :param Sequence[str] supported_locales: A list of [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) locale codes that the realm should support.
        """
        pulumi.set(__self__, "default_locale", default_locale)
        pulumi.set(__self__, "supported_locales", supported_locales)

    @property
    @pulumi.getter(name="defaultLocale")
    def default_locale(self) -> str:
        """
        The locale to use by default. This locale code must be present within the `supported_locales` list.
        """
        return pulumi.get(self, "default_locale")

    @property
    @pulumi.getter(name="supportedLocales")
    def supported_locales(self) -> Sequence[str]:
        """
        A list of [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) locale codes that the realm should support.
        """
        return pulumi.get(self, "supported_locales")


@pulumi.output_type
class RealmOtpPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "initialCounter":
            suggest = "initial_counter"
        elif key == "lookAheadWindow":
            suggest = "look_ahead_window"

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

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

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

    def __init__(__self__, *,
                 algorithm: Optional[str] = None,
                 digits: Optional[int] = None,
                 initial_counter: Optional[int] = None,
                 look_ahead_window: Optional[int] = None,
                 period: Optional[int] = None,
                 type: Optional[str] = None):
        """
        :param str algorithm: What hashing algorithm should be used to generate the OTP, Valid options are `HmacSHA1`,`HmacSHA256` and `HmacSHA512`. Defaults to `HmacSHA1`.
        :param int digits: How many digits the OTP have. Defaults to `6`.
        :param int initial_counter: What should the initial counter value be. Defaults to `2`.
        :param int look_ahead_window: How far ahead should the server look just in case the token generator and server are out of time sync or counter sync. Defaults to `1`.
        :param int period: How many seconds should an OTP token be valid. Defaults to `30`.
        :param str type: One Time Password Type, supported Values are `totp` for Time-Based One Time Password and `hotp` for Counter Based. Defaults to `totp`.
        """
        if algorithm is not None:
            pulumi.set(__self__, "algorithm", algorithm)
        if digits is not None:
            pulumi.set(__self__, "digits", digits)
        if initial_counter is not None:
            pulumi.set(__self__, "initial_counter", initial_counter)
        if look_ahead_window is not None:
            pulumi.set(__self__, "look_ahead_window", look_ahead_window)
        if period is not None:
            pulumi.set(__self__, "period", period)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def algorithm(self) -> Optional[str]:
        """
        What hashing algorithm should be used to generate the OTP, Valid options are `HmacSHA1`,`HmacSHA256` and `HmacSHA512`. Defaults to `HmacSHA1`.
        """
        return pulumi.get(self, "algorithm")

    @property
    @pulumi.getter
    def digits(self) -> Optional[int]:
        """
        How many digits the OTP have. Defaults to `6`.
        """
        return pulumi.get(self, "digits")

    @property
    @pulumi.getter(name="initialCounter")
    def initial_counter(self) -> Optional[int]:
        """
        What should the initial counter value be. Defaults to `2`.
        """
        return pulumi.get(self, "initial_counter")

    @property
    @pulumi.getter(name="lookAheadWindow")
    def look_ahead_window(self) -> Optional[int]:
        """
        How far ahead should the server look just in case the token generator and server are out of time sync or counter sync. Defaults to `1`.
        """
        return pulumi.get(self, "look_ahead_window")

    @property
    @pulumi.getter
    def period(self) -> Optional[int]:
        """
        How many seconds should an OTP token be valid. Defaults to `30`.
        """
        return pulumi.get(self, "period")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        One Time Password Type, supported Values are `totp` for Time-Based One Time Password and `hotp` for Counter Based. Defaults to `totp`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class RealmSecurityDefenses(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bruteForceDetection":
            suggest = "brute_force_detection"

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

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

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

    def __init__(__self__, *,
                 brute_force_detection: Optional['outputs.RealmSecurityDefensesBruteForceDetection'] = None,
                 headers: Optional['outputs.RealmSecurityDefensesHeaders'] = None):
        if brute_force_detection is not None:
            pulumi.set(__self__, "brute_force_detection", brute_force_detection)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)

    @property
    @pulumi.getter(name="bruteForceDetection")
    def brute_force_detection(self) -> Optional['outputs.RealmSecurityDefensesBruteForceDetection']:
        return pulumi.get(self, "brute_force_detection")

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


@pulumi.output_type
class RealmSecurityDefensesBruteForceDetection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureResetTimeSeconds":
            suggest = "failure_reset_time_seconds"
        elif key == "maxFailureWaitSeconds":
            suggest = "max_failure_wait_seconds"
        elif key == "maxLoginFailures":
            suggest = "max_login_failures"
        elif key == "minimumQuickLoginWaitSeconds":
            suggest = "minimum_quick_login_wait_seconds"
        elif key == "permanentLockout":
            suggest = "permanent_lockout"
        elif key == "quickLoginCheckMilliSeconds":
            suggest = "quick_login_check_milli_seconds"
        elif key == "waitIncrementSeconds":
            suggest = "wait_increment_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_reset_time_seconds: Optional[int] = None,
                 max_failure_wait_seconds: Optional[int] = None,
                 max_login_failures: Optional[int] = None,
                 minimum_quick_login_wait_seconds: Optional[int] = None,
                 permanent_lockout: Optional[bool] = None,
                 quick_login_check_milli_seconds: Optional[int] = None,
                 wait_increment_seconds: Optional[int] = None):
        """
        :param int failure_reset_time_seconds: When will failure count be reset?
        :param int max_login_failures: How many failures before wait is triggered.
        :param int minimum_quick_login_wait_seconds: How long to wait after a quick login failure.
               - `max_failure_wait_seconds ` - (Optional) Max. time a user will be locked out.
        :param bool permanent_lockout: When `true`, this will lock the user permanently when the user exceeds the maximum login failures.
        :param int quick_login_check_milli_seconds: Configures the amount of time, in milliseconds, for consecutive failures to lock a user out.
        :param int wait_increment_seconds: This represents the amount of time a user should be locked out when the login failure threshold has been met.
        """
        if failure_reset_time_seconds is not None:
            pulumi.set(__self__, "failure_reset_time_seconds", failure_reset_time_seconds)
        if max_failure_wait_seconds is not None:
            pulumi.set(__self__, "max_failure_wait_seconds", max_failure_wait_seconds)
        if max_login_failures is not None:
            pulumi.set(__self__, "max_login_failures", max_login_failures)
        if minimum_quick_login_wait_seconds is not None:
            pulumi.set(__self__, "minimum_quick_login_wait_seconds", minimum_quick_login_wait_seconds)
        if permanent_lockout is not None:
            pulumi.set(__self__, "permanent_lockout", permanent_lockout)
        if quick_login_check_milli_seconds is not None:
            pulumi.set(__self__, "quick_login_check_milli_seconds", quick_login_check_milli_seconds)
        if wait_increment_seconds is not None:
            pulumi.set(__self__, "wait_increment_seconds", wait_increment_seconds)

    @property
    @pulumi.getter(name="failureResetTimeSeconds")
    def failure_reset_time_seconds(self) -> Optional[int]:
        """
        When will failure count be reset?
        """
        return pulumi.get(self, "failure_reset_time_seconds")

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

    @property
    @pulumi.getter(name="maxLoginFailures")
    def max_login_failures(self) -> Optional[int]:
        """
        How many failures before wait is triggered.
        """
        return pulumi.get(self, "max_login_failures")

    @property
    @pulumi.getter(name="minimumQuickLoginWaitSeconds")
    def minimum_quick_login_wait_seconds(self) -> Optional[int]:
        """
        How long to wait after a quick login failure.
        - `max_failure_wait_seconds ` - (Optional) Max. time a user will be locked out.
        """
        return pulumi.get(self, "minimum_quick_login_wait_seconds")

    @property
    @pulumi.getter(name="permanentLockout")
    def permanent_lockout(self) -> Optional[bool]:
        """
        When `true`, this will lock the user permanently when the user exceeds the maximum login failures.
        """
        return pulumi.get(self, "permanent_lockout")

    @property
    @pulumi.getter(name="quickLoginCheckMilliSeconds")
    def quick_login_check_milli_seconds(self) -> Optional[int]:
        """
        Configures the amount of time, in milliseconds, for consecutive failures to lock a user out.
        """
        return pulumi.get(self, "quick_login_check_milli_seconds")

    @property
    @pulumi.getter(name="waitIncrementSeconds")
    def wait_increment_seconds(self) -> Optional[int]:
        """
        This represents the amount of time a user should be locked out when the login failure threshold has been met.
        """
        return pulumi.get(self, "wait_increment_seconds")


@pulumi.output_type
class RealmSecurityDefensesHeaders(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentSecurityPolicy":
            suggest = "content_security_policy"
        elif key == "contentSecurityPolicyReportOnly":
            suggest = "content_security_policy_report_only"
        elif key == "strictTransportSecurity":
            suggest = "strict_transport_security"
        elif key == "xContentTypeOptions":
            suggest = "x_content_type_options"
        elif key == "xFrameOptions":
            suggest = "x_frame_options"
        elif key == "xRobotsTag":
            suggest = "x_robots_tag"
        elif key == "xXssProtection":
            suggest = "x_xss_protection"

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

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

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

    def __init__(__self__, *,
                 content_security_policy: Optional[str] = None,
                 content_security_policy_report_only: Optional[str] = None,
                 strict_transport_security: Optional[str] = None,
                 x_content_type_options: Optional[str] = None,
                 x_frame_options: Optional[str] = None,
                 x_robots_tag: Optional[str] = None,
                 x_xss_protection: Optional[str] = None):
        """
        :param str content_security_policy: Sets the Content Security Policy, which can be used for prevent pages from being included by non-origin iframes. More information can be found in the [W3C-CSP](https://www.w3.org/TR/CSP/) Abstract.
        :param str content_security_policy_report_only: Used for testing Content Security Policies.
        :param str strict_transport_security: The Script-Transport-Security HTTP header tells browsers to always use HTTPS.
        :param str x_content_type_options: Sets the X-Content-Type-Options, which can be used for prevent MIME-sniffing a response away from the declared content-type
        :param str x_frame_options: Sets the x-frame-option, which can be used to prevent pages from being included by non-origin iframes. More information can be found in the [RFC7034](https://tools.ietf.org/html/rfc7034)
        :param str x_robots_tag: Prevent pages from appearing in search engines.
        :param str x_xss_protection: This header configures the Cross-site scripting (XSS) filter in your browser.
        """
        if content_security_policy is not None:
            pulumi.set(__self__, "content_security_policy", content_security_policy)
        if content_security_policy_report_only is not None:
            pulumi.set(__self__, "content_security_policy_report_only", content_security_policy_report_only)
        if strict_transport_security is not None:
            pulumi.set(__self__, "strict_transport_security", strict_transport_security)
        if x_content_type_options is not None:
            pulumi.set(__self__, "x_content_type_options", x_content_type_options)
        if x_frame_options is not None:
            pulumi.set(__self__, "x_frame_options", x_frame_options)
        if x_robots_tag is not None:
            pulumi.set(__self__, "x_robots_tag", x_robots_tag)
        if x_xss_protection is not None:
            pulumi.set(__self__, "x_xss_protection", x_xss_protection)

    @property
    @pulumi.getter(name="contentSecurityPolicy")
    def content_security_policy(self) -> Optional[str]:
        """
        Sets the Content Security Policy, which can be used for prevent pages from being included by non-origin iframes. More information can be found in the [W3C-CSP](https://www.w3.org/TR/CSP/) Abstract.
        """
        return pulumi.get(self, "content_security_policy")

    @property
    @pulumi.getter(name="contentSecurityPolicyReportOnly")
    def content_security_policy_report_only(self) -> Optional[str]:
        """
        Used for testing Content Security Policies.
        """
        return pulumi.get(self, "content_security_policy_report_only")

    @property
    @pulumi.getter(name="strictTransportSecurity")
    def strict_transport_security(self) -> Optional[str]:
        """
        The Script-Transport-Security HTTP header tells browsers to always use HTTPS.
        """
        return pulumi.get(self, "strict_transport_security")

    @property
    @pulumi.getter(name="xContentTypeOptions")
    def x_content_type_options(self) -> Optional[str]:
        """
        Sets the X-Content-Type-Options, which can be used for prevent MIME-sniffing a response away from the declared content-type
        """
        return pulumi.get(self, "x_content_type_options")

    @property
    @pulumi.getter(name="xFrameOptions")
    def x_frame_options(self) -> Optional[str]:
        """
        Sets the x-frame-option, which can be used to prevent pages from being included by non-origin iframes. More information can be found in the [RFC7034](https://tools.ietf.org/html/rfc7034)
        """
        return pulumi.get(self, "x_frame_options")

    @property
    @pulumi.getter(name="xRobotsTag")
    def x_robots_tag(self) -> Optional[str]:
        """
        Prevent pages from appearing in search engines.
        """
        return pulumi.get(self, "x_robots_tag")

    @property
    @pulumi.getter(name="xXssProtection")
    def x_xss_protection(self) -> Optional[str]:
        """
        This header configures the Cross-site scripting (XSS) filter in your browser.
        """
        return pulumi.get(self, "x_xss_protection")


@pulumi.output_type
class RealmSmtpServer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "from":
            suggest = "from_"
        elif key == "envelopeFrom":
            suggest = "envelope_from"
        elif key == "fromDisplayName":
            suggest = "from_display_name"
        elif key == "replyTo":
            suggest = "reply_to"
        elif key == "replyToDisplayName":
            suggest = "reply_to_display_name"

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

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

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

    def __init__(__self__, *,
                 from_: str,
                 host: str,
                 auth: Optional['outputs.RealmSmtpServerAuth'] = None,
                 envelope_from: Optional[str] = None,
                 from_display_name: Optional[str] = None,
                 port: Optional[str] = None,
                 reply_to: Optional[str] = None,
                 reply_to_display_name: Optional[str] = None,
                 ssl: Optional[bool] = None,
                 starttls: Optional[bool] = None):
        """
        :param str from_: The email address for the sender.
        :param str host: The host of the SMTP server.
        :param 'RealmSmtpServerAuthArgs' auth: Enables authentication to the SMTP server.  This block supports the following arguments:
        :param str envelope_from: The email address uses for bounces.
        :param str from_display_name: The display name of the sender email address.
        :param str port: The port of the SMTP server (defaults to 25).
        :param str reply_to: The "reply to" email address.
        :param str reply_to_display_name: The display name of the "reply to" email address.
        :param bool ssl: When `true`, enables SSL. Defaults to `false`.
        :param bool starttls: When `true`, enables StartTLS. Defaults to `false`.
        """
        pulumi.set(__self__, "from_", from_)
        pulumi.set(__self__, "host", host)
        if auth is not None:
            pulumi.set(__self__, "auth", auth)
        if envelope_from is not None:
            pulumi.set(__self__, "envelope_from", envelope_from)
        if from_display_name is not None:
            pulumi.set(__self__, "from_display_name", from_display_name)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if reply_to is not None:
            pulumi.set(__self__, "reply_to", reply_to)
        if reply_to_display_name is not None:
            pulumi.set(__self__, "reply_to_display_name", reply_to_display_name)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if starttls is not None:
            pulumi.set(__self__, "starttls", starttls)

    @property
    @pulumi.getter(name="from")
    def from_(self) -> str:
        """
        The email address for the sender.
        """
        return pulumi.get(self, "from_")

    @property
    @pulumi.getter
    def host(self) -> str:
        """
        The host of the SMTP server.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def auth(self) -> Optional['outputs.RealmSmtpServerAuth']:
        """
        Enables authentication to the SMTP server.  This block supports the following arguments:
        """
        return pulumi.get(self, "auth")

    @property
    @pulumi.getter(name="envelopeFrom")
    def envelope_from(self) -> Optional[str]:
        """
        The email address uses for bounces.
        """
        return pulumi.get(self, "envelope_from")

    @property
    @pulumi.getter(name="fromDisplayName")
    def from_display_name(self) -> Optional[str]:
        """
        The display name of the sender email address.
        """
        return pulumi.get(self, "from_display_name")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        """
        The port of the SMTP server (defaults to 25).
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="replyTo")
    def reply_to(self) -> Optional[str]:
        """
        The "reply to" email address.
        """
        return pulumi.get(self, "reply_to")

    @property
    @pulumi.getter(name="replyToDisplayName")
    def reply_to_display_name(self) -> Optional[str]:
        """
        The display name of the "reply to" email address.
        """
        return pulumi.get(self, "reply_to_display_name")

    @property
    @pulumi.getter
    def ssl(self) -> Optional[bool]:
        """
        When `true`, enables SSL. Defaults to `false`.
        """
        return pulumi.get(self, "ssl")

    @property
    @pulumi.getter
    def starttls(self) -> Optional[bool]:
        """
        When `true`, enables StartTLS. Defaults to `false`.
        """
        return pulumi.get(self, "starttls")


@pulumi.output_type
class RealmSmtpServerAuth(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The SMTP server password.
        :param str username: The SMTP server username.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The SMTP server password.
        """
        return pulumi.get(self, "password")

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


@pulumi.output_type
class RealmWebAuthnPasswordlessPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "acceptableAaguids":
            suggest = "acceptable_aaguids"
        elif key == "attestationConveyancePreference":
            suggest = "attestation_conveyance_preference"
        elif key == "authenticatorAttachment":
            suggest = "authenticator_attachment"
        elif key == "avoidSameAuthenticatorRegister":
            suggest = "avoid_same_authenticator_register"
        elif key == "createTimeout":
            suggest = "create_timeout"
        elif key == "relyingPartyEntityName":
            suggest = "relying_party_entity_name"
        elif key == "relyingPartyId":
            suggest = "relying_party_id"
        elif key == "requireResidentKey":
            suggest = "require_resident_key"
        elif key == "signatureAlgorithms":
            suggest = "signature_algorithms"
        elif key == "userVerificationRequirement":
            suggest = "user_verification_requirement"

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

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

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

    def __init__(__self__, *,
                 acceptable_aaguids: Optional[Sequence[str]] = None,
                 attestation_conveyance_preference: Optional[str] = None,
                 authenticator_attachment: Optional[str] = None,
                 avoid_same_authenticator_register: Optional[bool] = None,
                 create_timeout: Optional[int] = None,
                 relying_party_entity_name: Optional[str] = None,
                 relying_party_id: Optional[str] = None,
                 require_resident_key: Optional[str] = None,
                 signature_algorithms: Optional[Sequence[str]] = None,
                 user_verification_requirement: Optional[str] = None):
        """
        :param Sequence[str] acceptable_aaguids: A set of AAGUIDs for which an authenticator can be registered.
        :param str attestation_conveyance_preference: The preference of how to generate a WebAuthn attestation statement. Valid options are `not specified`, `none`, `indirect`, `direct`, or `enterprise`. Defaults to `not specified`.
        :param str authenticator_attachment: The acceptable attachment pattern for the WebAuthn authenticator. Valid options are `not specified`, `platform`, or `cross-platform`. Defaults to `not specified`.
        :param bool avoid_same_authenticator_register: When `true`, Keycloak will avoid registering the authenticator for WebAuthn if it has already been registered. Defaults to `false`.
        :param int create_timeout: The timeout value for creating a user's public key credential in seconds. When set to `0`, this timeout option is not adapted. Defaults to `0`.
        :param str relying_party_entity_name: A human readable server name for the WebAuthn Relying Party. Defaults to `keycloak`.
        :param str relying_party_id: The WebAuthn relying party ID.
        :param str require_resident_key: Specifies whether or not a public key should be created to represent the resident key. Valid options are `not specified`, `Yes`, or `No`. Defaults to `not specified`.
        :param Sequence[str] signature_algorithms: A set of signature algorithms that should be used for the authentication assertion. Valid options at the time these docs were written are `ES256`, `ES384`, `ES512`, `RS256`, `RS384`, `RS512`, and `RS1`.
        :param str user_verification_requirement: Specifies the policy for verifying a user logging in via WebAuthn. Valid options are `not specified`, `required`, `preferred`, or `discouraged`. Defaults to `not specified`.
        """
        if acceptable_aaguids is not None:
            pulumi.set(__self__, "acceptable_aaguids", acceptable_aaguids)
        if attestation_conveyance_preference is not None:
            pulumi.set(__self__, "attestation_conveyance_preference", attestation_conveyance_preference)
        if authenticator_attachment is not None:
            pulumi.set(__self__, "authenticator_attachment", authenticator_attachment)
        if avoid_same_authenticator_register is not None:
            pulumi.set(__self__, "avoid_same_authenticator_register", avoid_same_authenticator_register)
        if create_timeout is not None:
            pulumi.set(__self__, "create_timeout", create_timeout)
        if relying_party_entity_name is not None:
            pulumi.set(__self__, "relying_party_entity_name", relying_party_entity_name)
        if relying_party_id is not None:
            pulumi.set(__self__, "relying_party_id", relying_party_id)
        if require_resident_key is not None:
            pulumi.set(__self__, "require_resident_key", require_resident_key)
        if signature_algorithms is not None:
            pulumi.set(__self__, "signature_algorithms", signature_algorithms)
        if user_verification_requirement is not None:
            pulumi.set(__self__, "user_verification_requirement", user_verification_requirement)

    @property
    @pulumi.getter(name="acceptableAaguids")
    def acceptable_aaguids(self) -> Optional[Sequence[str]]:
        """
        A set of AAGUIDs for which an authenticator can be registered.
        """
        return pulumi.get(self, "acceptable_aaguids")

    @property
    @pulumi.getter(name="attestationConveyancePreference")
    def attestation_conveyance_preference(self) -> Optional[str]:
        """
        The preference of how to generate a WebAuthn attestation statement. Valid options are `not specified`, `none`, `indirect`, `direct`, or `enterprise`. Defaults to `not specified`.
        """
        return pulumi.get(self, "attestation_conveyance_preference")

    @property
    @pulumi.getter(name="authenticatorAttachment")
    def authenticator_attachment(self) -> Optional[str]:
        """
        The acceptable attachment pattern for the WebAuthn authenticator. Valid options are `not specified`, `platform`, or `cross-platform`. Defaults to `not specified`.
        """
        return pulumi.get(self, "authenticator_attachment")

    @property
    @pulumi.getter(name="avoidSameAuthenticatorRegister")
    def avoid_same_authenticator_register(self) -> Optional[bool]:
        """
        When `true`, Keycloak will avoid registering the authenticator for WebAuthn if it has already been registered. Defaults to `false`.
        """
        return pulumi.get(self, "avoid_same_authenticator_register")

    @property
    @pulumi.getter(name="createTimeout")
    def create_timeout(self) -> Optional[int]:
        """
        The timeout value for creating a user's public key credential in seconds. When set to `0`, this timeout option is not adapted. Defaults to `0`.
        """
        return pulumi.get(self, "create_timeout")

    @property
    @pulumi.getter(name="relyingPartyEntityName")
    def relying_party_entity_name(self) -> Optional[str]:
        """
        A human readable server name for the WebAuthn Relying Party. Defaults to `keycloak`.
        """
        return pulumi.get(self, "relying_party_entity_name")

    @property
    @pulumi.getter(name="relyingPartyId")
    def relying_party_id(self) -> Optional[str]:
        """
        The WebAuthn relying party ID.
        """
        return pulumi.get(self, "relying_party_id")

    @property
    @pulumi.getter(name="requireResidentKey")
    def require_resident_key(self) -> Optional[str]:
        """
        Specifies whether or not a public key should be created to represent the resident key. Valid options are `not specified`, `Yes`, or `No`. Defaults to `not specified`.
        """
        return pulumi.get(self, "require_resident_key")

    @property
    @pulumi.getter(name="signatureAlgorithms")
    def signature_algorithms(self) -> Optional[Sequence[str]]:
        """
        A set of signature algorithms that should be used for the authentication assertion. Valid options at the time these docs were written are `ES256`, `ES384`, `ES512`, `RS256`, `RS384`, `RS512`, and `RS1`.
        """
        return pulumi.get(self, "signature_algorithms")

    @property
    @pulumi.getter(name="userVerificationRequirement")
    def user_verification_requirement(self) -> Optional[str]:
        """
        Specifies the policy for verifying a user logging in via WebAuthn. Valid options are `not specified`, `required`, `preferred`, or `discouraged`. Defaults to `not specified`.
        """
        return pulumi.get(self, "user_verification_requirement")


@pulumi.output_type
class RealmWebAuthnPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "acceptableAaguids":
            suggest = "acceptable_aaguids"
        elif key == "attestationConveyancePreference":
            suggest = "attestation_conveyance_preference"
        elif key == "authenticatorAttachment":
            suggest = "authenticator_attachment"
        elif key == "avoidSameAuthenticatorRegister":
            suggest = "avoid_same_authenticator_register"
        elif key == "createTimeout":
            suggest = "create_timeout"
        elif key == "relyingPartyEntityName":
            suggest = "relying_party_entity_name"
        elif key == "relyingPartyId":
            suggest = "relying_party_id"
        elif key == "requireResidentKey":
            suggest = "require_resident_key"
        elif key == "signatureAlgorithms":
            suggest = "signature_algorithms"
        elif key == "userVerificationRequirement":
            suggest = "user_verification_requirement"

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

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

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

    def __init__(__self__, *,
                 acceptable_aaguids: Optional[Sequence[str]] = None,
                 attestation_conveyance_preference: Optional[str] = None,
                 authenticator_attachment: Optional[str] = None,
                 avoid_same_authenticator_register: Optional[bool] = None,
                 create_timeout: Optional[int] = None,
                 relying_party_entity_name: Optional[str] = None,
                 relying_party_id: Optional[str] = None,
                 require_resident_key: Optional[str] = None,
                 signature_algorithms: Optional[Sequence[str]] = None,
                 user_verification_requirement: Optional[str] = None):
        """
        :param Sequence[str] acceptable_aaguids: A set of AAGUIDs for which an authenticator can be registered.
        :param str attestation_conveyance_preference: The preference of how to generate a WebAuthn attestation statement. Valid options are `not specified`, `none`, `indirect`, `direct`, or `enterprise`. Defaults to `not specified`.
        :param str authenticator_attachment: The acceptable attachment pattern for the WebAuthn authenticator. Valid options are `not specified`, `platform`, or `cross-platform`. Defaults to `not specified`.
        :param bool avoid_same_authenticator_register: When `true`, Keycloak will avoid registering the authenticator for WebAuthn if it has already been registered. Defaults to `false`.
        :param int create_timeout: The timeout value for creating a user's public key credential in seconds. When set to `0`, this timeout option is not adapted. Defaults to `0`.
        :param str relying_party_entity_name: A human readable server name for the WebAuthn Relying Party. Defaults to `keycloak`.
        :param str relying_party_id: The WebAuthn relying party ID.
        :param str require_resident_key: Specifies whether or not a public key should be created to represent the resident key. Valid options are `not specified`, `Yes`, or `No`. Defaults to `not specified`.
        :param Sequence[str] signature_algorithms: A set of signature algorithms that should be used for the authentication assertion. Valid options at the time these docs were written are `ES256`, `ES384`, `ES512`, `RS256`, `RS384`, `RS512`, and `RS1`.
        :param str user_verification_requirement: Specifies the policy for verifying a user logging in via WebAuthn. Valid options are `not specified`, `required`, `preferred`, or `discouraged`. Defaults to `not specified`.
        """
        if acceptable_aaguids is not None:
            pulumi.set(__self__, "acceptable_aaguids", acceptable_aaguids)
        if attestation_conveyance_preference is not None:
            pulumi.set(__self__, "attestation_conveyance_preference", attestation_conveyance_preference)
        if authenticator_attachment is not None:
            pulumi.set(__self__, "authenticator_attachment", authenticator_attachment)
        if avoid_same_authenticator_register is not None:
            pulumi.set(__self__, "avoid_same_authenticator_register", avoid_same_authenticator_register)
        if create_timeout is not None:
            pulumi.set(__self__, "create_timeout", create_timeout)
        if relying_party_entity_name is not None:
            pulumi.set(__self__, "relying_party_entity_name", relying_party_entity_name)
        if relying_party_id is not None:
            pulumi.set(__self__, "relying_party_id", relying_party_id)
        if require_resident_key is not None:
            pulumi.set(__self__, "require_resident_key", require_resident_key)
        if signature_algorithms is not None:
            pulumi.set(__self__, "signature_algorithms", signature_algorithms)
        if user_verification_requirement is not None:
            pulumi.set(__self__, "user_verification_requirement", user_verification_requirement)

    @property
    @pulumi.getter(name="acceptableAaguids")
    def acceptable_aaguids(self) -> Optional[Sequence[str]]:
        """
        A set of AAGUIDs for which an authenticator can be registered.
        """
        return pulumi.get(self, "acceptable_aaguids")

    @property
    @pulumi.getter(name="attestationConveyancePreference")
    def attestation_conveyance_preference(self) -> Optional[str]:
        """
        The preference of how to generate a WebAuthn attestation statement. Valid options are `not specified`, `none`, `indirect`, `direct`, or `enterprise`. Defaults to `not specified`.
        """
        return pulumi.get(self, "attestation_conveyance_preference")

    @property
    @pulumi.getter(name="authenticatorAttachment")
    def authenticator_attachment(self) -> Optional[str]:
        """
        The acceptable attachment pattern for the WebAuthn authenticator. Valid options are `not specified`, `platform`, or `cross-platform`. Defaults to `not specified`.
        """
        return pulumi.get(self, "authenticator_attachment")

    @property
    @pulumi.getter(name="avoidSameAuthenticatorRegister")
    def avoid_same_authenticator_register(self) -> Optional[bool]:
        """
        When `true`, Keycloak will avoid registering the authenticator for WebAuthn if it has already been registered. Defaults to `false`.
        """
        return pulumi.get(self, "avoid_same_authenticator_register")

    @property
    @pulumi.getter(name="createTimeout")
    def create_timeout(self) -> Optional[int]:
        """
        The timeout value for creating a user's public key credential in seconds. When set to `0`, this timeout option is not adapted. Defaults to `0`.
        """
        return pulumi.get(self, "create_timeout")

    @property
    @pulumi.getter(name="relyingPartyEntityName")
    def relying_party_entity_name(self) -> Optional[str]:
        """
        A human readable server name for the WebAuthn Relying Party. Defaults to `keycloak`.
        """
        return pulumi.get(self, "relying_party_entity_name")

    @property
    @pulumi.getter(name="relyingPartyId")
    def relying_party_id(self) -> Optional[str]:
        """
        The WebAuthn relying party ID.
        """
        return pulumi.get(self, "relying_party_id")

    @property
    @pulumi.getter(name="requireResidentKey")
    def require_resident_key(self) -> Optional[str]:
        """
        Specifies whether or not a public key should be created to represent the resident key. Valid options are `not specified`, `Yes`, or `No`. Defaults to `not specified`.
        """
        return pulumi.get(self, "require_resident_key")

    @property
    @pulumi.getter(name="signatureAlgorithms")
    def signature_algorithms(self) -> Optional[Sequence[str]]:
        """
        A set of signature algorithms that should be used for the authentication assertion. Valid options at the time these docs were written are `ES256`, `ES384`, `ES512`, `RS256`, `RS384`, `RS512`, and `RS1`.
        """
        return pulumi.get(self, "signature_algorithms")

    @property
    @pulumi.getter(name="userVerificationRequirement")
    def user_verification_requirement(self) -> Optional[str]:
        """
        Specifies the policy for verifying a user logging in via WebAuthn. Valid options are `not specified`, `required`, `preferred`, or `discouraged`. Defaults to `not specified`.
        """
        return pulumi.get(self, "user_verification_requirement")


@pulumi.output_type
class UserFederatedIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityProvider":
            suggest = "identity_provider"
        elif key == "userId":
            suggest = "user_id"
        elif key == "userName":
            suggest = "user_name"

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

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

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

    def __init__(__self__, *,
                 identity_provider: str,
                 user_id: str,
                 user_name: str):
        """
        :param str identity_provider: The name of the identity provider
        :param str user_id: The ID of the user defined in the identity provider
        :param str user_name: The user name of the user defined in the identity provider
        """
        pulumi.set(__self__, "identity_provider", identity_provider)
        pulumi.set(__self__, "user_id", user_id)
        pulumi.set(__self__, "user_name", user_name)

    @property
    @pulumi.getter(name="identityProvider")
    def identity_provider(self) -> str:
        """
        The name of the identity provider
        """
        return pulumi.get(self, "identity_provider")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> str:
        """
        The ID of the user defined in the identity provider
        """
        return pulumi.get(self, "user_id")

    @property
    @pulumi.getter(name="userName")
    def user_name(self) -> str:
        """
        The user name of the user defined in the identity provider
        """
        return pulumi.get(self, "user_name")


@pulumi.output_type
class UserInitialPassword(dict):
    def __init__(__self__, *,
                 value: str,
                 temporary: Optional[bool] = None):
        """
        :param str value: The initial password.
        :param bool temporary: If set to `true`, the initial password is set up for renewal on first use. Default to `false`.
        """
        pulumi.set(__self__, "value", value)
        if temporary is not None:
            pulumi.set(__self__, "temporary", temporary)

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

    @property
    @pulumi.getter
    def temporary(self) -> Optional[bool]:
        """
        If set to `true`, the initial password is set up for renewal on first use. Default to `false`.
        """
        return pulumi.get(self, "temporary")


@pulumi.output_type
class UsersPermissionsImpersonateScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class UsersPermissionsManageGroupMembershipScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class UsersPermissionsManageScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class UsersPermissionsMapRolesScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class UsersPermissionsUserImpersonatedScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class UsersPermissionsViewScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "decisionStrategy":
            suggest = "decision_strategy"

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

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

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

    def __init__(__self__, *,
                 decision_strategy: Optional[str] = None,
                 description: Optional[str] = None,
                 policies: Optional[Sequence[str]] = None):
        if decision_strategy is not None:
            pulumi.set(__self__, "decision_strategy", decision_strategy)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if policies is not None:
            pulumi.set(__self__, "policies", policies)

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

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

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


@pulumi.output_type
class GetClientDescriptionConverterProtocolMapperResult(dict):
    def __init__(__self__, *,
                 config: Mapping[str, Any],
                 id: str,
                 name: str,
                 protocol: str,
                 protocol_mapper: str):
        pulumi.set(__self__, "config", config)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "protocol_mapper", protocol_mapper)

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

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

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

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

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


@pulumi.output_type
class GetRealmInternationalizationResult(dict):
    def __init__(__self__, *,
                 default_locale: str,
                 supported_locales: Sequence[str]):
        pulumi.set(__self__, "default_locale", default_locale)
        pulumi.set(__self__, "supported_locales", supported_locales)

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

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


@pulumi.output_type
class GetRealmKeysKeyResult(dict):
    def __init__(__self__, *,
                 algorithm: str,
                 certificate: str,
                 kid: str,
                 provider_id: str,
                 provider_priority: int,
                 public_key: str,
                 status: str,
                 type: str):
        """
        :param str algorithm: Key algorithm (string)
        :param str certificate: Key certificate (string)
        :param str kid: Key ID (string)
        :param str provider_id: Key provider ID (string)
        :param int provider_priority: Key provider priority (int64)
        :param str public_key: Key public key (string)
        :param str status: When specified, keys will be filtered by status. The statuses can be any of `ACTIVE`, `DISABLED` and `PASSIVE`.
        :param str type: Key type (string)
        """
        pulumi.set(__self__, "algorithm", algorithm)
        pulumi.set(__self__, "certificate", certificate)
        pulumi.set(__self__, "kid", kid)
        pulumi.set(__self__, "provider_id", provider_id)
        pulumi.set(__self__, "provider_priority", provider_priority)
        pulumi.set(__self__, "public_key", public_key)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "type", type)

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

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

    @property
    @pulumi.getter
    def kid(self) -> str:
        """
        Key ID (string)
        """
        return pulumi.get(self, "kid")

    @property
    @pulumi.getter(name="providerId")
    def provider_id(self) -> str:
        """
        Key provider ID (string)
        """
        return pulumi.get(self, "provider_id")

    @property
    @pulumi.getter(name="providerPriority")
    def provider_priority(self) -> int:
        """
        Key provider priority (int64)
        """
        return pulumi.get(self, "provider_priority")

    @property
    @pulumi.getter(name="publicKey")
    def public_key(self) -> str:
        """
        Key public key (string)
        """
        return pulumi.get(self, "public_key")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        When specified, keys will be filtered by status. The statuses can be any of `ACTIVE`, `DISABLED` and `PASSIVE`.
        """
        return pulumi.get(self, "status")

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


@pulumi.output_type
class GetRealmOtpPolicyResult(dict):
    def __init__(__self__, *,
                 algorithm: str,
                 digits: int,
                 initial_counter: int,
                 look_ahead_window: int,
                 period: int,
                 type: str):
        pulumi.set(__self__, "algorithm", algorithm)
        pulumi.set(__self__, "digits", digits)
        pulumi.set(__self__, "initial_counter", initial_counter)
        pulumi.set(__self__, "look_ahead_window", look_ahead_window)
        pulumi.set(__self__, "period", period)
        pulumi.set(__self__, "type", type)

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

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

    @property
    @pulumi.getter(name="initialCounter")
    def initial_counter(self) -> int:
        return pulumi.get(self, "initial_counter")

    @property
    @pulumi.getter(name="lookAheadWindow")
    def look_ahead_window(self) -> int:
        return pulumi.get(self, "look_ahead_window")

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

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


@pulumi.output_type
class GetRealmSecurityDefenseResult(dict):
    def __init__(__self__, *,
                 brute_force_detections: Sequence['outputs.GetRealmSecurityDefenseBruteForceDetectionResult'],
                 headers: Sequence['outputs.GetRealmSecurityDefenseHeaderResult']):
        pulumi.set(__self__, "brute_force_detections", brute_force_detections)
        pulumi.set(__self__, "headers", headers)

    @property
    @pulumi.getter(name="bruteForceDetections")
    def brute_force_detections(self) -> Sequence['outputs.GetRealmSecurityDefenseBruteForceDetectionResult']:
        return pulumi.get(self, "brute_force_detections")

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


@pulumi.output_type
class GetRealmSecurityDefenseBruteForceDetectionResult(dict):
    def __init__(__self__, *,
                 failure_reset_time_seconds: int,
                 max_failure_wait_seconds: int,
                 max_login_failures: int,
                 minimum_quick_login_wait_seconds: int,
                 permanent_lockout: bool,
                 quick_login_check_milli_seconds: int,
                 wait_increment_seconds: int):
        pulumi.set(__self__, "failure_reset_time_seconds", failure_reset_time_seconds)
        pulumi.set(__self__, "max_failure_wait_seconds", max_failure_wait_seconds)
        pulumi.set(__self__, "max_login_failures", max_login_failures)
        pulumi.set(__self__, "minimum_quick_login_wait_seconds", minimum_quick_login_wait_seconds)
        pulumi.set(__self__, "permanent_lockout", permanent_lockout)
        pulumi.set(__self__, "quick_login_check_milli_seconds", quick_login_check_milli_seconds)
        pulumi.set(__self__, "wait_increment_seconds", wait_increment_seconds)

    @property
    @pulumi.getter(name="failureResetTimeSeconds")
    def failure_reset_time_seconds(self) -> int:
        return pulumi.get(self, "failure_reset_time_seconds")

    @property
    @pulumi.getter(name="maxFailureWaitSeconds")
    def max_failure_wait_seconds(self) -> int:
        return pulumi.get(self, "max_failure_wait_seconds")

    @property
    @pulumi.getter(name="maxLoginFailures")
    def max_login_failures(self) -> int:
        return pulumi.get(self, "max_login_failures")

    @property
    @pulumi.getter(name="minimumQuickLoginWaitSeconds")
    def minimum_quick_login_wait_seconds(self) -> int:
        return pulumi.get(self, "minimum_quick_login_wait_seconds")

    @property
    @pulumi.getter(name="permanentLockout")
    def permanent_lockout(self) -> bool:
        return pulumi.get(self, "permanent_lockout")

    @property
    @pulumi.getter(name="quickLoginCheckMilliSeconds")
    def quick_login_check_milli_seconds(self) -> int:
        return pulumi.get(self, "quick_login_check_milli_seconds")

    @property
    @pulumi.getter(name="waitIncrementSeconds")
    def wait_increment_seconds(self) -> int:
        return pulumi.get(self, "wait_increment_seconds")


@pulumi.output_type
class GetRealmSecurityDefenseHeaderResult(dict):
    def __init__(__self__, *,
                 content_security_policy: str,
                 content_security_policy_report_only: str,
                 strict_transport_security: str,
                 x_content_type_options: str,
                 x_frame_options: str,
                 x_robots_tag: str,
                 x_xss_protection: str):
        pulumi.set(__self__, "content_security_policy", content_security_policy)
        pulumi.set(__self__, "content_security_policy_report_only", content_security_policy_report_only)
        pulumi.set(__self__, "strict_transport_security", strict_transport_security)
        pulumi.set(__self__, "x_content_type_options", x_content_type_options)
        pulumi.set(__self__, "x_frame_options", x_frame_options)
        pulumi.set(__self__, "x_robots_tag", x_robots_tag)
        pulumi.set(__self__, "x_xss_protection", x_xss_protection)

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

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

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

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

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

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

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


@pulumi.output_type
class GetRealmSmtpServerResult(dict):
    def __init__(__self__, *,
                 auths: Sequence['outputs.GetRealmSmtpServerAuthResult'],
                 envelope_from: str,
                 from_: str,
                 from_display_name: str,
                 host: str,
                 port: str,
                 reply_to: str,
                 reply_to_display_name: str,
                 ssl: bool,
                 starttls: bool):
        pulumi.set(__self__, "auths", auths)
        pulumi.set(__self__, "envelope_from", envelope_from)
        pulumi.set(__self__, "from_", from_)
        pulumi.set(__self__, "from_display_name", from_display_name)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "reply_to", reply_to)
        pulumi.set(__self__, "reply_to_display_name", reply_to_display_name)
        pulumi.set(__self__, "ssl", ssl)
        pulumi.set(__self__, "starttls", starttls)

    @property
    @pulumi.getter
    def auths(self) -> Sequence['outputs.GetRealmSmtpServerAuthResult']:
        return pulumi.get(self, "auths")

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetRealmSmtpServerAuthResult(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

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

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


@pulumi.output_type
class GetRealmWebAuthnPasswordlessPolicyResult(dict):
    def __init__(__self__, *,
                 acceptable_aaguids: Sequence[str],
                 attestation_conveyance_preference: str,
                 authenticator_attachment: str,
                 avoid_same_authenticator_register: bool,
                 create_timeout: int,
                 relying_party_entity_name: str,
                 relying_party_id: str,
                 require_resident_key: str,
                 signature_algorithms: Sequence[str],
                 user_verification_requirement: str):
        pulumi.set(__self__, "acceptable_aaguids", acceptable_aaguids)
        pulumi.set(__self__, "attestation_conveyance_preference", attestation_conveyance_preference)
        pulumi.set(__self__, "authenticator_attachment", authenticator_attachment)
        pulumi.set(__self__, "avoid_same_authenticator_register", avoid_same_authenticator_register)
        pulumi.set(__self__, "create_timeout", create_timeout)
        pulumi.set(__self__, "relying_party_entity_name", relying_party_entity_name)
        pulumi.set(__self__, "relying_party_id", relying_party_id)
        pulumi.set(__self__, "require_resident_key", require_resident_key)
        pulumi.set(__self__, "signature_algorithms", signature_algorithms)
        pulumi.set(__self__, "user_verification_requirement", user_verification_requirement)

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

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

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

    @property
    @pulumi.getter(name="avoidSameAuthenticatorRegister")
    def avoid_same_authenticator_register(self) -> bool:
        return pulumi.get(self, "avoid_same_authenticator_register")

    @property
    @pulumi.getter(name="createTimeout")
    def create_timeout(self) -> int:
        return pulumi.get(self, "create_timeout")

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

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

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

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

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


@pulumi.output_type
class GetRealmWebAuthnPolicyResult(dict):
    def __init__(__self__, *,
                 acceptable_aaguids: Sequence[str],
                 attestation_conveyance_preference: str,
                 authenticator_attachment: str,
                 avoid_same_authenticator_register: bool,
                 create_timeout: int,
                 relying_party_entity_name: str,
                 relying_party_id: str,
                 require_resident_key: str,
                 signature_algorithms: Sequence[str],
                 user_verification_requirement: str):
        pulumi.set(__self__, "acceptable_aaguids", acceptable_aaguids)
        pulumi.set(__self__, "attestation_conveyance_preference", attestation_conveyance_preference)
        pulumi.set(__self__, "authenticator_attachment", authenticator_attachment)
        pulumi.set(__self__, "avoid_same_authenticator_register", avoid_same_authenticator_register)
        pulumi.set(__self__, "create_timeout", create_timeout)
        pulumi.set(__self__, "relying_party_entity_name", relying_party_entity_name)
        pulumi.set(__self__, "relying_party_id", relying_party_id)
        pulumi.set(__self__, "require_resident_key", require_resident_key)
        pulumi.set(__self__, "signature_algorithms", signature_algorithms)
        pulumi.set(__self__, "user_verification_requirement", user_verification_requirement)

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

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

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

    @property
    @pulumi.getter(name="avoidSameAuthenticatorRegister")
    def avoid_same_authenticator_register(self) -> bool:
        return pulumi.get(self, "avoid_same_authenticator_register")

    @property
    @pulumi.getter(name="createTimeout")
    def create_timeout(self) -> int:
        return pulumi.get(self, "create_timeout")

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

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

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

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

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


