# 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, Callable, Mapping, Optional, Sequence, Union, overload
from . import _utilities

__all__ = [
    'AppGroupAssignmentsGroup',
    'AppSignonPolicyRulePlatformInclude',
    'AppUserSchemaPropertyArrayOneOf',
    'AppUserSchemaPropertyOneOf',
    'DomainDnsRecord',
    'EmailSenderDnsRecord',
    'EventHookHeader',
    'GroupSchemaPropertyArrayOneOf',
    'GroupSchemaPropertyMasterOverridePriority',
    'GroupSchemaPropertyOneOf',
    'PolicyRuleProfileEnrollmentProfileAttribute',
    'TemplateSmsTranslation',
    'UserSchemaPropertyArrayOneOf',
    'UserSchemaPropertyMasterOverridePriority',
    'UserSchemaPropertyOneOf',
    'GetAuthServerClaimsClaimResult',
    'GetBehavioursBehaviorResult',
    'GetBrandsBrandResult',
    'GetEmailCustomizationsEmailCustomizationResult',
    'GetGroupsGroupResult',
    'GetTemplatesEmailTemplateResult',
    'GetThemesThemeResult',
    'GetTrustedOriginsTrustedOriginResult',
    'GetUserSecurityQuestionsQuestionResult',
]

@pulumi.output_type
class AppGroupAssignmentsGroup(dict):
    def __init__(__self__, *,
                 id: str,
                 profile: str,
                 priority: Optional[int] = None):
        """
        :param str id: A group to associate with the application
        :param str profile: JSON document containing [application profile](https://developer.okta.com/docs/reference/api/apps/#profile-object)
        :param int priority: Priority of group assignment
        """
        AppGroupAssignmentsGroup._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            id=id,
            profile=profile,
            priority=priority,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             id: str,
             profile: str,
             priority: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("id", id)
        _setter("profile", profile)
        if priority is not None:
            _setter("priority", priority)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        A group to associate with the application
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def profile(self) -> str:
        """
        JSON document containing [application profile](https://developer.okta.com/docs/reference/api/apps/#profile-object)
        """
        return pulumi.get(self, "profile")

    @property
    @pulumi.getter
    def priority(self) -> Optional[int]:
        """
        Priority of group assignment
        """
        return pulumi.get(self, "priority")


@pulumi.output_type
class AppSignonPolicyRulePlatformInclude(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "osExpression":
            suggest = "os_expression"
        elif key == "osType":
            suggest = "os_type"

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

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

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

    def __init__(__self__, *,
                 os_expression: Optional[str] = None,
                 os_type: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str os_expression: Only available with OTHER OS type
        """
        AppSignonPolicyRulePlatformInclude._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            os_expression=os_expression,
            os_type=os_type,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             os_expression: Optional[str] = None,
             os_type: Optional[str] = None,
             type: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'osExpression' in kwargs:
            os_expression = kwargs['osExpression']
        if 'osType' in kwargs:
            os_type = kwargs['osType']

        if os_expression is not None:
            _setter("os_expression", os_expression)
        if os_type is not None:
            _setter("os_type", os_type)
        if type is not None:
            _setter("type", type)

    @property
    @pulumi.getter(name="osExpression")
    def os_expression(self) -> Optional[str]:
        """
        Only available with OTHER OS type
        """
        return pulumi.get(self, "os_expression")

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

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


@pulumi.output_type
class AppUserSchemaPropertyArrayOneOf(dict):
    def __init__(__self__, *,
                 const: str,
                 title: str):
        """
        :param str const: Enum value
        :param str title: Enum title
        """
        AppUserSchemaPropertyArrayOneOf._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            const=const,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             const: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("const", const)
        _setter("title", title)

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

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


@pulumi.output_type
class AppUserSchemaPropertyOneOf(dict):
    def __init__(__self__, *,
                 const: str,
                 title: str):
        """
        :param str const: Enum value
        :param str title: Enum title
        """
        AppUserSchemaPropertyOneOf._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            const=const,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             const: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("const", const)
        _setter("title", title)

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

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


@pulumi.output_type
class DomainDnsRecord(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordType":
            suggest = "record_type"

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

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

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

    def __init__(__self__, *,
                 expiration: Optional[str] = None,
                 fqdn: Optional[str] = None,
                 record_type: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        DomainDnsRecord._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            expiration=expiration,
            fqdn=fqdn,
            record_type=record_type,
            values=values,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             expiration: Optional[str] = None,
             fqdn: Optional[str] = None,
             record_type: Optional[str] = None,
             values: Optional[Sequence[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'recordType' in kwargs:
            record_type = kwargs['recordType']

        if expiration is not None:
            _setter("expiration", expiration)
        if fqdn is not None:
            _setter("fqdn", fqdn)
        if record_type is not None:
            _setter("record_type", record_type)
        if values is not None:
            _setter("values", values)

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

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

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

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


@pulumi.output_type
class EmailSenderDnsRecord(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordType":
            suggest = "record_type"

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

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

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

    def __init__(__self__, *,
                 fqdn: Optional[str] = None,
                 record_type: Optional[str] = None,
                 value: Optional[str] = None):
        EmailSenderDnsRecord._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            fqdn=fqdn,
            record_type=record_type,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             fqdn: Optional[str] = None,
             record_type: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'recordType' in kwargs:
            record_type = kwargs['recordType']

        if fqdn is not None:
            _setter("fqdn", fqdn)
        if record_type is not None:
            _setter("record_type", record_type)
        if value is not None:
            _setter("value", value)

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

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

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


@pulumi.output_type
class EventHookHeader(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        EventHookHeader._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key=key,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if key is not None:
            _setter("key", key)
        if value is not None:
            _setter("value", value)

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

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


@pulumi.output_type
class GroupSchemaPropertyArrayOneOf(dict):
    def __init__(__self__, *,
                 const: str,
                 title: str):
        """
        :param str const: Enum value
        :param str title: Enum title
        """
        GroupSchemaPropertyArrayOneOf._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            const=const,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             const: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("const", const)
        _setter("title", title)

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

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


@pulumi.output_type
class GroupSchemaPropertyMasterOverridePriority(dict):
    def __init__(__self__, *,
                 value: str,
                 type: Optional[str] = None):
        GroupSchemaPropertyMasterOverridePriority._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            value=value,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             value: str,
             type: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("value", value)
        if type is not None:
            _setter("type", type)

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

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


@pulumi.output_type
class GroupSchemaPropertyOneOf(dict):
    def __init__(__self__, *,
                 const: str,
                 title: str):
        """
        :param str const: Enum value
        :param str title: Enum title
        """
        GroupSchemaPropertyOneOf._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            const=const,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             const: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("const", const)
        _setter("title", title)

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

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


@pulumi.output_type
class PolicyRuleProfileEnrollmentProfileAttribute(dict):
    def __init__(__self__, *,
                 label: str,
                 name: str,
                 required: Optional[bool] = None):
        """
        :param str label: A display-friendly label for this property
        :param str name: The name of a User Profile property
        :param bool required: Indicates if this property is required for enrollment
        """
        PolicyRuleProfileEnrollmentProfileAttribute._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            label=label,
            name=name,
            required=required,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             label: str,
             name: str,
             required: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("label", label)
        _setter("name", name)
        if required is not None:
            _setter("required", required)

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        A display-friendly label for this property
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def required(self) -> Optional[bool]:
        """
        Indicates if this property is required for enrollment
        """
        return pulumi.get(self, "required")


@pulumi.output_type
class TemplateSmsTranslation(dict):
    def __init__(__self__, *,
                 language: str,
                 template: str):
        TemplateSmsTranslation._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            language=language,
            template=template,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             language: str,
             template: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("language", language)
        _setter("template", template)

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

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


@pulumi.output_type
class UserSchemaPropertyArrayOneOf(dict):
    def __init__(__self__, *,
                 const: str,
                 title: str):
        """
        :param str const: Enum value
        :param str title: Enum title
        """
        UserSchemaPropertyArrayOneOf._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            const=const,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             const: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("const", const)
        _setter("title", title)

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

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


@pulumi.output_type
class UserSchemaPropertyMasterOverridePriority(dict):
    def __init__(__self__, *,
                 value: str,
                 type: Optional[str] = None):
        UserSchemaPropertyMasterOverridePriority._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            value=value,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             value: str,
             type: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("value", value)
        if type is not None:
            _setter("type", type)

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

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


@pulumi.output_type
class UserSchemaPropertyOneOf(dict):
    def __init__(__self__, *,
                 const: str,
                 title: str):
        """
        :param str const: Enum value
        :param str title: Enum title
        """
        UserSchemaPropertyOneOf._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            const=const,
            title=title,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             const: str,
             title: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("const", const)
        _setter("title", title)

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

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


@pulumi.output_type
class GetAuthServerClaimsClaimResult(dict):
    def __init__(__self__, *,
                 always_include_in_token: bool,
                 claim_type: str,
                 id: str,
                 name: str,
                 scopes: Sequence[str],
                 status: str,
                 value: str,
                 value_type: str):
        GetAuthServerClaimsClaimResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            always_include_in_token=always_include_in_token,
            claim_type=claim_type,
            id=id,
            name=name,
            scopes=scopes,
            status=status,
            value=value,
            value_type=value_type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             always_include_in_token: bool,
             claim_type: str,
             id: str,
             name: str,
             scopes: Sequence[str],
             status: str,
             value: str,
             value_type: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'alwaysIncludeInToken' in kwargs:
            always_include_in_token = kwargs['alwaysIncludeInToken']
        if 'claimType' in kwargs:
            claim_type = kwargs['claimType']
        if 'valueType' in kwargs:
            value_type = kwargs['valueType']

        _setter("always_include_in_token", always_include_in_token)
        _setter("claim_type", claim_type)
        _setter("id", id)
        _setter("name", name)
        _setter("scopes", scopes)
        _setter("status", status)
        _setter("value", value)
        _setter("value_type", value_type)

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

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

    @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 scopes(self) -> Sequence[str]:
        return pulumi.get(self, "scopes")

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

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

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


@pulumi.output_type
class GetBehavioursBehaviorResult(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str,
                 settings: Mapping[str, str],
                 status: str,
                 type: str):
        GetBehavioursBehaviorResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            id=id,
            name=name,
            settings=settings,
            status=status,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             id: str,
             name: str,
             settings: Mapping[str, str],
             status: str,
             type: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("id", id)
        _setter("name", name)
        _setter("settings", settings)
        _setter("status", status)
        _setter("type", type)

    @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 settings(self) -> Mapping[str, str]:
        return pulumi.get(self, "settings")

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

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


@pulumi.output_type
class GetBrandsBrandResult(dict):
    def __init__(__self__, *,
                 custom_privacy_policy_url: str,
                 id: str,
                 links: str,
                 name: str,
                 remove_powered_by_okta: bool):
        GetBrandsBrandResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            custom_privacy_policy_url=custom_privacy_policy_url,
            id=id,
            links=links,
            name=name,
            remove_powered_by_okta=remove_powered_by_okta,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             custom_privacy_policy_url: str,
             id: str,
             links: str,
             name: str,
             remove_powered_by_okta: bool,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'customPrivacyPolicyUrl' in kwargs:
            custom_privacy_policy_url = kwargs['customPrivacyPolicyUrl']
        if 'removePoweredByOkta' in kwargs:
            remove_powered_by_okta = kwargs['removePoweredByOkta']

        _setter("custom_privacy_policy_url", custom_privacy_policy_url)
        _setter("id", id)
        _setter("links", links)
        _setter("name", name)
        _setter("remove_powered_by_okta", remove_powered_by_okta)

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

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

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

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

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


@pulumi.output_type
class GetEmailCustomizationsEmailCustomizationResult(dict):
    def __init__(__self__, *,
                 body: str,
                 id: str,
                 is_default: bool,
                 language: str,
                 links: str,
                 subject: str):
        GetEmailCustomizationsEmailCustomizationResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            body=body,
            id=id,
            is_default=is_default,
            language=language,
            links=links,
            subject=subject,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             body: str,
             id: str,
             is_default: bool,
             language: str,
             links: str,
             subject: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'isDefault' in kwargs:
            is_default = kwargs['isDefault']

        _setter("body", body)
        _setter("id", id)
        _setter("is_default", is_default)
        _setter("language", language)
        _setter("links", links)
        _setter("subject", subject)

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

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

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

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

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

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


@pulumi.output_type
class GetGroupsGroupResult(dict):
    def __init__(__self__, *,
                 custom_profile_attributes: str,
                 description: str,
                 id: str,
                 name: str,
                 type: str):
        GetGroupsGroupResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            custom_profile_attributes=custom_profile_attributes,
            description=description,
            id=id,
            name=name,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             custom_profile_attributes: str,
             description: str,
             id: str,
             name: str,
             type: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'customProfileAttributes' in kwargs:
            custom_profile_attributes = kwargs['customProfileAttributes']

        _setter("custom_profile_attributes", custom_profile_attributes)
        _setter("description", description)
        _setter("id", id)
        _setter("name", name)
        _setter("type", type)

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

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

    @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 type(self) -> str:
        return pulumi.get(self, "type")


@pulumi.output_type
class GetTemplatesEmailTemplateResult(dict):
    def __init__(__self__, *,
                 links: str,
                 name: str):
        GetTemplatesEmailTemplateResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            links=links,
            name=name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             links: str,
             name: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("links", links)
        _setter("name", name)

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

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


@pulumi.output_type
class GetThemesThemeResult(dict):
    def __init__(__self__, *,
                 background_image_url: str,
                 email_template_touch_point_variant: str,
                 end_user_dashboard_touch_point_variant: str,
                 error_page_touch_point_variant: str,
                 favicon_url: str,
                 id: str,
                 links: str,
                 logo_url: str,
                 primary_color_contrast_hex: str,
                 primary_color_hex: str,
                 secondary_color_contrast_hex: str,
                 secondary_color_hex: str,
                 sign_in_page_touch_point_variant: str):
        GetThemesThemeResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            background_image_url=background_image_url,
            email_template_touch_point_variant=email_template_touch_point_variant,
            end_user_dashboard_touch_point_variant=end_user_dashboard_touch_point_variant,
            error_page_touch_point_variant=error_page_touch_point_variant,
            favicon_url=favicon_url,
            id=id,
            links=links,
            logo_url=logo_url,
            primary_color_contrast_hex=primary_color_contrast_hex,
            primary_color_hex=primary_color_hex,
            secondary_color_contrast_hex=secondary_color_contrast_hex,
            secondary_color_hex=secondary_color_hex,
            sign_in_page_touch_point_variant=sign_in_page_touch_point_variant,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             background_image_url: str,
             email_template_touch_point_variant: str,
             end_user_dashboard_touch_point_variant: str,
             error_page_touch_point_variant: str,
             favicon_url: str,
             id: str,
             links: str,
             logo_url: str,
             primary_color_contrast_hex: str,
             primary_color_hex: str,
             secondary_color_contrast_hex: str,
             secondary_color_hex: str,
             sign_in_page_touch_point_variant: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'backgroundImageUrl' in kwargs:
            background_image_url = kwargs['backgroundImageUrl']
        if 'emailTemplateTouchPointVariant' in kwargs:
            email_template_touch_point_variant = kwargs['emailTemplateTouchPointVariant']
        if 'endUserDashboardTouchPointVariant' in kwargs:
            end_user_dashboard_touch_point_variant = kwargs['endUserDashboardTouchPointVariant']
        if 'errorPageTouchPointVariant' in kwargs:
            error_page_touch_point_variant = kwargs['errorPageTouchPointVariant']
        if 'faviconUrl' in kwargs:
            favicon_url = kwargs['faviconUrl']
        if 'logoUrl' in kwargs:
            logo_url = kwargs['logoUrl']
        if 'primaryColorContrastHex' in kwargs:
            primary_color_contrast_hex = kwargs['primaryColorContrastHex']
        if 'primaryColorHex' in kwargs:
            primary_color_hex = kwargs['primaryColorHex']
        if 'secondaryColorContrastHex' in kwargs:
            secondary_color_contrast_hex = kwargs['secondaryColorContrastHex']
        if 'secondaryColorHex' in kwargs:
            secondary_color_hex = kwargs['secondaryColorHex']
        if 'signInPageTouchPointVariant' in kwargs:
            sign_in_page_touch_point_variant = kwargs['signInPageTouchPointVariant']

        _setter("background_image_url", background_image_url)
        _setter("email_template_touch_point_variant", email_template_touch_point_variant)
        _setter("end_user_dashboard_touch_point_variant", end_user_dashboard_touch_point_variant)
        _setter("error_page_touch_point_variant", error_page_touch_point_variant)
        _setter("favicon_url", favicon_url)
        _setter("id", id)
        _setter("links", links)
        _setter("logo_url", logo_url)
        _setter("primary_color_contrast_hex", primary_color_contrast_hex)
        _setter("primary_color_hex", primary_color_hex)
        _setter("secondary_color_contrast_hex", secondary_color_contrast_hex)
        _setter("secondary_color_hex", secondary_color_hex)
        _setter("sign_in_page_touch_point_variant", sign_in_page_touch_point_variant)

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetTrustedOriginsTrustedOriginResult(dict):
    def __init__(__self__, *,
                 active: bool,
                 id: str,
                 name: str,
                 origin: str,
                 scopes: Sequence[str]):
        GetTrustedOriginsTrustedOriginResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            active=active,
            id=id,
            name=name,
            origin=origin,
            scopes=scopes,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             active: bool,
             id: str,
             name: str,
             origin: str,
             scopes: Sequence[str],
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("active", active)
        _setter("id", id)
        _setter("name", name)
        _setter("origin", origin)
        _setter("scopes", scopes)

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

    @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 origin(self) -> str:
        return pulumi.get(self, "origin")

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


@pulumi.output_type
class GetUserSecurityQuestionsQuestionResult(dict):
    def __init__(__self__, *,
                 key: str,
                 text: str):
        GetUserSecurityQuestionsQuestionResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key=key,
            text=text,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key: str,
             text: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        _setter("key", key)
        _setter("text", text)

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

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


