pulumi-gcp 7.30.0a1719470057__py3-none-any.whl → 7.30.0a1719555549__py3-none-any.whl

pulumi_gcp/identityplatform/_inputs.py

@@ -4,48 +4,104 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'ConfigBlockingFunctionsArgs',
+    'ConfigBlockingFunctionsArgsDict',
     'ConfigBlockingFunctionsForwardInboundCredentialsArgs',
+    'ConfigBlockingFunctionsForwardInboundCredentialsArgsDict',
     'ConfigBlockingFunctionsTriggerArgs',
+    'ConfigBlockingFunctionsTriggerArgsDict',
     'ConfigClientArgs',
+    'ConfigClientArgsDict',
     'ConfigClientPermissionsArgs',
+    'ConfigClientPermissionsArgsDict',
     'ConfigMfaArgs',
+    'ConfigMfaArgsDict',
     'ConfigMfaProviderConfigArgs',
+    'ConfigMfaProviderConfigArgsDict',
     'ConfigMfaProviderConfigTotpProviderConfigArgs',
+    'ConfigMfaProviderConfigTotpProviderConfigArgsDict',
     'ConfigMonitoringArgs',
+    'ConfigMonitoringArgsDict',
     'ConfigMonitoringRequestLoggingArgs',
+    'ConfigMonitoringRequestLoggingArgsDict',
     'ConfigMultiTenantArgs',
+    'ConfigMultiTenantArgsDict',
     'ConfigQuotaArgs',
+    'ConfigQuotaArgsDict',
     'ConfigQuotaSignUpQuotaConfigArgs',
+    'ConfigQuotaSignUpQuotaConfigArgsDict',
     'ConfigSignInArgs',
+    'ConfigSignInArgsDict',
     'ConfigSignInAnonymousArgs',
+    'ConfigSignInAnonymousArgsDict',
     'ConfigSignInEmailArgs',
+    'ConfigSignInEmailArgsDict',
     'ConfigSignInHashConfigArgs',
+    'ConfigSignInHashConfigArgsDict',
     'ConfigSignInPhoneNumberArgs',
+    'ConfigSignInPhoneNumberArgsDict',
     'ConfigSmsRegionConfigArgs',
+    'ConfigSmsRegionConfigArgsDict',
     'ConfigSmsRegionConfigAllowByDefaultArgs',
+    'ConfigSmsRegionConfigAllowByDefaultArgsDict',
     'ConfigSmsRegionConfigAllowlistOnlyArgs',
+    'ConfigSmsRegionConfigAllowlistOnlyArgsDict',
     'InboundSamlConfigIdpConfigArgs',
+    'InboundSamlConfigIdpConfigArgsDict',
     'InboundSamlConfigIdpConfigIdpCertificateArgs',
+    'InboundSamlConfigIdpConfigIdpCertificateArgsDict',
     'InboundSamlConfigSpConfigArgs',
+    'InboundSamlConfigSpConfigArgsDict',
     'InboundSamlConfigSpConfigSpCertificateArgs',
+    'InboundSamlConfigSpConfigSpCertificateArgsDict',
     'ProjectDefaultConfigSignInArgs',
+    'ProjectDefaultConfigSignInArgsDict',
     'ProjectDefaultConfigSignInAnonymousArgs',
+    'ProjectDefaultConfigSignInAnonymousArgsDict',
     'ProjectDefaultConfigSignInEmailArgs',
+    'ProjectDefaultConfigSignInEmailArgsDict',
     'ProjectDefaultConfigSignInHashConfigArgs',
+    'ProjectDefaultConfigSignInHashConfigArgsDict',
     'ProjectDefaultConfigSignInPhoneNumberArgs',
+    'ProjectDefaultConfigSignInPhoneNumberArgsDict',
     'TenantInboundSamlConfigIdpConfigArgs',
+    'TenantInboundSamlConfigIdpConfigArgsDict',
     'TenantInboundSamlConfigIdpConfigIdpCertificateArgs',
+    'TenantInboundSamlConfigIdpConfigIdpCertificateArgsDict',
     'TenantInboundSamlConfigSpConfigArgs',
+    'TenantInboundSamlConfigSpConfigArgsDict',
     'TenantInboundSamlConfigSpConfigSpCertificateArgs',
+    'TenantInboundSamlConfigSpConfigSpCertificateArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class ConfigBlockingFunctionsArgsDict(TypedDict):
+        triggers: pulumi.Input[Sequence[pulumi.Input['ConfigBlockingFunctionsTriggerArgsDict']]]
+        """
+        Map of Trigger to event type. Key should be one of the supported event types: "beforeCreate", "beforeSignIn".
+        Structure is documented below.
+        """
+        forward_inbound_credentials: NotRequired[pulumi.Input['ConfigBlockingFunctionsForwardInboundCredentialsArgsDict']]
+        """
+        The user credentials to include in the JWT payload that is sent to the registered Blocking Functions.
+        Structure is documented below.
+        """
+elif False:
+    ConfigBlockingFunctionsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigBlockingFunctionsArgs:
     def __init__(__self__, *,
@@ -88,6 +144,23 @@ class ConfigBlockingFunctionsArgs:
         pulumi.set(self, "forward_inbound_credentials", value)
 
 
+if not MYPY:
+    class ConfigBlockingFunctionsForwardInboundCredentialsArgsDict(TypedDict):
+        access_token: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to pass the user's OAuth identity provider's access token.
+        """
+        id_token: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to pass the user's OIDC identity provider's ID token.
+        """
+        refresh_token: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to pass the user's OAuth identity provider's refresh token.
+        """
+elif False:
+    ConfigBlockingFunctionsForwardInboundCredentialsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigBlockingFunctionsForwardInboundCredentialsArgs:
     def __init__(__self__, *,
@@ -143,6 +216,24 @@ class ConfigBlockingFunctionsForwardInboundCredentialsArgs:
         pulumi.set(self, "refresh_token", value)
 
 
+if not MYPY:
+    class ConfigBlockingFunctionsTriggerArgsDict(TypedDict):
+        event_type: pulumi.Input[str]
+        """
+        The identifier for this object. Format specified above.
+        """
+        function_uri: pulumi.Input[str]
+        """
+        HTTP URI trigger for the Cloud Function.
+        """
+        update_time: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        When the trigger was changed.
+        """
+elif False:
+    ConfigBlockingFunctionsTriggerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigBlockingFunctionsTriggerArgs:
     def __init__(__self__, *,
@@ -198,6 +289,27 @@ class ConfigBlockingFunctionsTriggerArgs:
         pulumi.set(self, "update_time", value)
 
 
+if not MYPY:
+    class ConfigClientArgsDict(TypedDict):
+        api_key: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        API key that can be used when making requests for this project.
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
+        firebase_subdomain: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        Firebase subdomain.
+        """
+        permissions: NotRequired[pulumi.Input['ConfigClientPermissionsArgsDict']]
+        """
+        Configuration related to restricting a user's ability to affect their account.
+        Structure is documented below.
+        """
+elif False:
+    ConfigClientArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigClientArgs:
     def __init__(__self__, *,
@@ -261,6 +373,19 @@ class ConfigClientArgs:
         pulumi.set(self, "permissions", value)
 
 
+if not MYPY:
+    class ConfigClientPermissionsArgsDict(TypedDict):
+        disabled_user_deletion: NotRequired[pulumi.Input[bool]]
+        """
+        When true, end users cannot delete their account on the associated project through any of our API methods
+        """
+        disabled_user_signup: NotRequired[pulumi.Input[bool]]
+        """
+        When true, end users cannot sign up for a new account on the associated project through any of our API methods
+        """
+elif False:
+    ConfigClientPermissionsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigClientPermissionsArgs:
     def __init__(__self__, *,
@@ -300,6 +425,27 @@ class ConfigClientPermissionsArgs:
         pulumi.set(self, "disabled_user_signup", value)
 
 
+if not MYPY:
+    class ConfigMfaArgsDict(TypedDict):
+        enabled_providers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of usable second factors for this project.
+        Each value may be one of: `PHONE_SMS`.
+        """
+        provider_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigMfaProviderConfigArgsDict']]]]
+        """
+        A list of usable second factors for this project along with their configurations.
+        This field does not support phone based MFA, for that use the 'enabledProviders' field.
+        Structure is documented below.
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        Whether MultiFactor Authentication has been enabled for this project.
+        Possible values are: `DISABLED`, `ENABLED`, `MANDATORY`.
+        """
+elif False:
+    ConfigMfaArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigMfaArgs:
     def __init__(__self__, *,
@@ -363,6 +509,21 @@ class ConfigMfaArgs:
         pulumi.set(self, "state", value)
 
 
+if not MYPY:
+    class ConfigMfaProviderConfigArgsDict(TypedDict):
+        state: NotRequired[pulumi.Input[str]]
+        """
+        Whether MultiFactor Authentication has been enabled for this project.
+        Possible values are: `DISABLED`, `ENABLED`, `MANDATORY`.
+        """
+        totp_provider_config: NotRequired[pulumi.Input['ConfigMfaProviderConfigTotpProviderConfigArgsDict']]
+        """
+        TOTP MFA provider config for this project.
+        Structure is documented below.
+        """
+elif False:
+    ConfigMfaProviderConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigMfaProviderConfigArgs:
     def __init__(__self__, *,
@@ -406,6 +567,15 @@ class ConfigMfaProviderConfigArgs:
         pulumi.set(self, "totp_provider_config", value)
 
 
+if not MYPY:
+    class ConfigMfaProviderConfigTotpProviderConfigArgsDict(TypedDict):
+        adjacent_intervals: NotRequired[pulumi.Input[int]]
+        """
+        The allowed number of adjacent intervals that will be used for verification to avoid clock skew.
+        """
+elif False:
+    ConfigMfaProviderConfigTotpProviderConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigMfaProviderConfigTotpProviderConfigArgs:
     def __init__(__self__, *,
@@ -429,6 +599,16 @@ class ConfigMfaProviderConfigTotpProviderConfigArgs:
         pulumi.set(self, "adjacent_intervals", value)
 
 
+if not MYPY:
+    class ConfigMonitoringArgsDict(TypedDict):
+        request_logging: NotRequired[pulumi.Input['ConfigMonitoringRequestLoggingArgsDict']]
+        """
+        Configuration for logging requests made to this project to Stackdriver Logging
+        Structure is documented below.
+        """
+elif False:
+    ConfigMonitoringArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigMonitoringArgs:
     def __init__(__self__, *,
@@ -454,6 +634,15 @@ class ConfigMonitoringArgs:
         pulumi.set(self, "request_logging", value)
 
 
+if not MYPY:
+    class ConfigMonitoringRequestLoggingArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether logging is enabled for this project or not.
+        """
+elif False:
+    ConfigMonitoringRequestLoggingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigMonitoringRequestLoggingArgs:
     def __init__(__self__, *,
@@ -477,6 +666,21 @@ class ConfigMonitoringRequestLoggingArgs:
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class ConfigMultiTenantArgsDict(TypedDict):
+        allow_tenants: NotRequired[pulumi.Input[bool]]
+        """
+        Whether this project can have tenants or not.
+        """
+        default_tenant_location: NotRequired[pulumi.Input[str]]
+        """
+        The default cloud parent org or folder that the tenant project should be created under.
+        The parent resource name should be in the format of "/", such as "folders/123" or "organizations/456".
+        If the value is not set, the tenant will be created under the same organization or folder as the agent project.
+        """
+elif False:
+    ConfigMultiTenantArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigMultiTenantArgs:
     def __init__(__self__, *,
@@ -520,6 +724,16 @@ class ConfigMultiTenantArgs:
         pulumi.set(self, "default_tenant_location", value)
 
 
+if not MYPY:
+    class ConfigQuotaArgsDict(TypedDict):
+        sign_up_quota_config: NotRequired[pulumi.Input['ConfigQuotaSignUpQuotaConfigArgsDict']]
+        """
+        Quota for the Signup endpoint, if overwritten. Signup quota is measured in sign ups per project per hour per IP.
+        Structure is documented below.
+        """
+elif False:
+    ConfigQuotaArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigQuotaArgs:
     def __init__(__self__, *,
@@ -545,6 +759,23 @@ class ConfigQuotaArgs:
         pulumi.set(self, "sign_up_quota_config", value)
 
 
+if not MYPY:
+    class ConfigQuotaSignUpQuotaConfigArgsDict(TypedDict):
+        quota: NotRequired[pulumi.Input[int]]
+        """
+        A sign up APIs quota that customers can override temporarily.
+        """
+        quota_duration: NotRequired[pulumi.Input[str]]
+        """
+        How long this quota will be active for. It is measurred in seconds, e.g., Example: "9.615s".
+        """
+        start_time: NotRequired[pulumi.Input[str]]
+        """
+        When this quota will take affect.
+        """
+elif False:
+    ConfigQuotaSignUpQuotaConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigQuotaSignUpQuotaConfigArgs:
     def __init__(__self__, *,
@@ -600,6 +831,36 @@ class ConfigQuotaSignUpQuotaConfigArgs:
         pulumi.set(self, "start_time", value)
 
 
+if not MYPY:
+    class ConfigSignInArgsDict(TypedDict):
+        allow_duplicate_emails: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to allow more than one account to have the same email.
+        """
+        anonymous: NotRequired[pulumi.Input['ConfigSignInAnonymousArgsDict']]
+        """
+        Configuration options related to authenticating an anonymous user.
+        Structure is documented below.
+        """
+        email: NotRequired[pulumi.Input['ConfigSignInEmailArgsDict']]
+        """
+        Configuration options related to authenticating a user by their email address.
+        Structure is documented below.
+        """
+        hash_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigSignInHashConfigArgsDict']]]]
+        """
+        (Output)
+        Output only. Hash config information.
+        Structure is documented below.
+        """
+        phone_number: NotRequired[pulumi.Input['ConfigSignInPhoneNumberArgsDict']]
+        """
+        Configuration options related to authenticated a user by their phone number.
+        Structure is documented below.
+        """
+elif False:
+    ConfigSignInArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigSignInArgs:
     def __init__(__self__, *,
@@ -697,6 +958,17 @@ class ConfigSignInArgs:
         pulumi.set(self, "phone_number", value)
 
 
+if not MYPY:
+    class ConfigSignInAnonymousArgsDict(TypedDict):
+        enabled: pulumi.Input[bool]
+        """
+        Whether anonymous user auth is enabled for the project or not.
+
+        <a name="nested_hash_config"></a>The `hash_config` block contains:
+        """
+elif False:
+    ConfigSignInAnonymousArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigSignInAnonymousArgs:
     def __init__(__self__, *,
@@ -723,6 +995,21 @@ class ConfigSignInAnonymousArgs:
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class ConfigSignInEmailArgsDict(TypedDict):
+        enabled: pulumi.Input[bool]
+        """
+        Whether email auth is enabled for the project or not.
+        """
+        password_required: NotRequired[pulumi.Input[bool]]
+        """
+        Whether a password is required for email auth or not. If true, both an email and
+        password must be provided to sign in. If false, a user may sign in via either
+        email/password or email link.
+        """
+elif False:
+    ConfigSignInEmailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigSignInEmailArgs:
     def __init__(__self__, *,
@@ -765,6 +1052,31 @@ class ConfigSignInEmailArgs:
         pulumi.set(self, "password_required", value)
 
 
+if not MYPY:
+    class ConfigSignInHashConfigArgsDict(TypedDict):
+        algorithm: NotRequired[pulumi.Input[str]]
+        """
+        Different password hash algorithms used in Identity Toolkit.
+        """
+        memory_cost: NotRequired[pulumi.Input[int]]
+        """
+        Memory cost for hash calculation. Used by scrypt and other similar password derivation algorithms. See https://tools.ietf.org/html/rfc7914 for explanation of field.
+        """
+        rounds: NotRequired[pulumi.Input[int]]
+        """
+        How many rounds for hash calculation. Used by scrypt and other similar password derivation algorithms.
+        """
+        salt_separator: NotRequired[pulumi.Input[str]]
+        """
+        Non-printable character to be inserted between the salt and plain text password in base64.
+        """
+        signer_key: NotRequired[pulumi.Input[str]]
+        """
+        Signer key in base64.
+        """
+elif False:
+    ConfigSignInHashConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigSignInHashConfigArgs:
     def __init__(__self__, *,
@@ -852,6 +1164,19 @@ class ConfigSignInHashConfigArgs:
         pulumi.set(self, "signer_key", value)
 
 
+if not MYPY:
+    class ConfigSignInPhoneNumberArgsDict(TypedDict):
+        enabled: pulumi.Input[bool]
+        """
+        Whether phone number auth is enabled for the project or not.
+        """
+        test_phone_numbers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A map of <test phone number, fake code> that can be used for phone auth testing.
+        """
+elif False:
+    ConfigSignInPhoneNumberArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigSignInPhoneNumberArgs:
     def __init__(__self__, *,
@@ -890,6 +1215,21 @@ class ConfigSignInPhoneNumberArgs:
         pulumi.set(self, "test_phone_numbers", value)
 
 
+if not MYPY:
+    class ConfigSmsRegionConfigArgsDict(TypedDict):
+        allow_by_default: NotRequired[pulumi.Input['ConfigSmsRegionConfigAllowByDefaultArgsDict']]
+        """
+        A policy of allowing SMS to every region by default and adding disallowed regions to a disallow list.
+        Structure is documented below.
+        """
+        allowlist_only: NotRequired[pulumi.Input['ConfigSmsRegionConfigAllowlistOnlyArgsDict']]
+        """
+        A policy of only allowing regions by explicitly adding them to an allowlist.
+        Structure is documented below.
+        """
+elif False:
+    ConfigSmsRegionConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigSmsRegionConfigArgs:
     def __init__(__self__, *,
@@ -933,6 +1273,15 @@ class ConfigSmsRegionConfigArgs:
         pulumi.set(self, "allowlist_only", value)
 
 
+if not MYPY:
+    class ConfigSmsRegionConfigAllowByDefaultArgsDict(TypedDict):
+        disallowed_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Two letter unicode region codes to disallow as defined by https://cldr.unicode.org/ The full list of these region codes is here: https://github.com/unicode-cldr/cldr-localenames-full/blob/master/main/en/territories.json
+        """
+elif False:
+    ConfigSmsRegionConfigAllowByDefaultArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigSmsRegionConfigAllowByDefaultArgs:
     def __init__(__self__, *,
@@ -956,6 +1305,15 @@ class ConfigSmsRegionConfigAllowByDefaultArgs:
         pulumi.set(self, "disallowed_regions", value)
 
 
+if not MYPY:
+    class ConfigSmsRegionConfigAllowlistOnlyArgsDict(TypedDict):
+        allowed_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Two letter unicode region codes to allow as defined by https://cldr.unicode.org/ The full list of these region codes is here: https://github.com/unicode-cldr/cldr-localenames-full/blob/master/main/en/territories.json
+        """
+elif False:
+    ConfigSmsRegionConfigAllowlistOnlyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ConfigSmsRegionConfigAllowlistOnlyArgs:
     def __init__(__self__, *,
@@ -979,6 +1337,28 @@ class ConfigSmsRegionConfigAllowlistOnlyArgs:
         pulumi.set(self, "allowed_regions", value)
 
 
+if not MYPY:
+    class InboundSamlConfigIdpConfigArgsDict(TypedDict):
+        idp_certificates: pulumi.Input[Sequence[pulumi.Input['InboundSamlConfigIdpConfigIdpCertificateArgsDict']]]
+        """
+        The IdP's certificate data to verify the signature in the SAMLResponse issued by the IDP.
+        Structure is documented below.
+        """
+        idp_entity_id: pulumi.Input[str]
+        """
+        Unique identifier for all SAML entities
+        """
+        sso_url: pulumi.Input[str]
+        """
+        URL to send Authentication request to.
+        """
+        sign_request: NotRequired[pulumi.Input[bool]]
+        """
+        Indicates if outbounding SAMLRequest should be signed.
+        """
+elif False:
+    InboundSamlConfigIdpConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class InboundSamlConfigIdpConfigArgs:
     def __init__(__self__, *,
@@ -1049,6 +1429,15 @@ class InboundSamlConfigIdpConfigArgs:
         pulumi.set(self, "sign_request", value)
 
 
+if not MYPY:
+    class InboundSamlConfigIdpConfigIdpCertificateArgsDict(TypedDict):
+        x509_certificate: NotRequired[pulumi.Input[str]]
+        """
+        The IdP's x509 certificate.
+        """
+elif False:
+    InboundSamlConfigIdpConfigIdpCertificateArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class InboundSamlConfigIdpConfigIdpCertificateArgs:
     def __init__(__self__, *,
@@ -1072,6 +1461,28 @@ class InboundSamlConfigIdpConfigIdpCertificateArgs:
         pulumi.set(self, "x509_certificate", value)
 
 
+if not MYPY:
+    class InboundSamlConfigSpConfigArgsDict(TypedDict):
+        callback_uri: NotRequired[pulumi.Input[str]]
+        """
+        Callback URI where responses from IDP are handled. Must start with `https://`.
+        """
+        sp_certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input['InboundSamlConfigSpConfigSpCertificateArgsDict']]]]
+        """
+        (Output)
+        The IDP's certificate data to verify the signature in the SAMLResponse issued by the IDP.
+        Structure is documented below.
+
+
+        <a name="nested_sp_certificates"></a>The `sp_certificates` block contains:
+        """
+        sp_entity_id: NotRequired[pulumi.Input[str]]
+        """
+        Unique identifier for all SAML entities.
+        """
+elif False:
+    InboundSamlConfigSpConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class InboundSamlConfigSpConfigArgs:
     def __init__(__self__, *,
@@ -1137,6 +1548,15 @@ class InboundSamlConfigSpConfigArgs:
         pulumi.set(self, "sp_entity_id", value)
 
 
+if not MYPY:
+    class InboundSamlConfigSpConfigSpCertificateArgsDict(TypedDict):
+        x509_certificate: NotRequired[pulumi.Input[str]]
+        """
+        The x509 certificate
+        """
+elif False:
+    InboundSamlConfigSpConfigSpCertificateArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class InboundSamlConfigSpConfigSpCertificateArgs:
     def __init__(__self__, *,
@@ -1160,6 +1580,36 @@ class InboundSamlConfigSpConfigSpCertificateArgs:
         pulumi.set(self, "x509_certificate", value)
 
 
+if not MYPY:
+    class ProjectDefaultConfigSignInArgsDict(TypedDict):
+        allow_duplicate_emails: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to allow more than one account to have the same email.
+        """
+        anonymous: NotRequired[pulumi.Input['ProjectDefaultConfigSignInAnonymousArgsDict']]
+        """
+        Configuration options related to authenticating an anonymous user.
+        Structure is documented below.
+        """
+        email: NotRequired[pulumi.Input['ProjectDefaultConfigSignInEmailArgsDict']]
+        """
+        Configuration options related to authenticating a user by their email address.
+        Structure is documented below.
+        """
+        hash_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ProjectDefaultConfigSignInHashConfigArgsDict']]]]
+        """
+        (Output)
+        Output only. Hash config information.
+        Structure is documented below.
+        """
+        phone_number: NotRequired[pulumi.Input['ProjectDefaultConfigSignInPhoneNumberArgsDict']]
+        """
+        Configuration options related to authenticated a user by their phone number.
+        Structure is documented below.
+        """
+elif False:
+    ProjectDefaultConfigSignInArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ProjectDefaultConfigSignInArgs:
     def __init__(__self__, *,
@@ -1257,6 +1707,17 @@ class ProjectDefaultConfigSignInArgs:
         pulumi.set(self, "phone_number", value)
 
 
+if not MYPY:
+    class ProjectDefaultConfigSignInAnonymousArgsDict(TypedDict):
+        enabled: pulumi.Input[bool]
+        """
+        Whether anonymous user auth is enabled for the project or not.
+
+        <a name="nested_hash_config"></a>The `hash_config` block contains:
+        """
+elif False:
+    ProjectDefaultConfigSignInAnonymousArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ProjectDefaultConfigSignInAnonymousArgs:
     def __init__(__self__, *,
@@ -1283,6 +1744,21 @@ class ProjectDefaultConfigSignInAnonymousArgs:
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class ProjectDefaultConfigSignInEmailArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether email auth is enabled for the project or not.
+        """
+        password_required: NotRequired[pulumi.Input[bool]]
+        """
+        Whether a password is required for email auth or not. If true, both an email and
+        password must be provided to sign in. If false, a user may sign in via either
+        email/password or email link.
+        """
+elif False:
+    ProjectDefaultConfigSignInEmailArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ProjectDefaultConfigSignInEmailArgs:
     def __init__(__self__, *,
@@ -1326,6 +1802,31 @@ class ProjectDefaultConfigSignInEmailArgs:
         pulumi.set(self, "password_required", value)
 
 
+if not MYPY:
+    class ProjectDefaultConfigSignInHashConfigArgsDict(TypedDict):
+        algorithm: NotRequired[pulumi.Input[str]]
+        """
+        Different password hash algorithms used in Identity Toolkit.
+        """
+        memory_cost: NotRequired[pulumi.Input[int]]
+        """
+        Memory cost for hash calculation. Used by scrypt and other similar password derivation algorithms. See https://tools.ietf.org/html/rfc7914 for explanation of field.
+        """
+        rounds: NotRequired[pulumi.Input[int]]
+        """
+        How many rounds for hash calculation. Used by scrypt and other similar password derivation algorithms.
+        """
+        salt_separator: NotRequired[pulumi.Input[str]]
+        """
+        Non-printable character to be inserted between the salt and plain text password in base64.
+        """
+        signer_key: NotRequired[pulumi.Input[str]]
+        """
+        Signer key in base64.
+        """
+elif False:
+    ProjectDefaultConfigSignInHashConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ProjectDefaultConfigSignInHashConfigArgs:
     def __init__(__self__, *,
@@ -1413,6 +1914,19 @@ class ProjectDefaultConfigSignInHashConfigArgs:
         pulumi.set(self, "signer_key", value)
 
 
+if not MYPY:
+    class ProjectDefaultConfigSignInPhoneNumberArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether phone number auth is enabled for the project or not.
+        """
+        test_phone_numbers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A map of <test phone number, fake code> that can be used for phone auth testing.
+        """
+elif False:
+    ProjectDefaultConfigSignInPhoneNumberArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ProjectDefaultConfigSignInPhoneNumberArgs:
     def __init__(__self__, *,
@@ -1452,6 +1966,28 @@ class ProjectDefaultConfigSignInPhoneNumberArgs:
         pulumi.set(self, "test_phone_numbers", value)
 
 
+if not MYPY:
+    class TenantInboundSamlConfigIdpConfigArgsDict(TypedDict):
+        idp_certificates: pulumi.Input[Sequence[pulumi.Input['TenantInboundSamlConfigIdpConfigIdpCertificateArgsDict']]]
+        """
+        The IDP's certificate data to verify the signature in the SAMLResponse issued by the IDP.
+        Structure is documented below.
+        """
+        idp_entity_id: pulumi.Input[str]
+        """
+        Unique identifier for all SAML entities
+        """
+        sso_url: pulumi.Input[str]
+        """
+        URL to send Authentication request to.
+        """
+        sign_request: NotRequired[pulumi.Input[bool]]
+        """
+        Indicates if outbounding SAMLRequest should be signed.
+        """
+elif False:
+    TenantInboundSamlConfigIdpConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TenantInboundSamlConfigIdpConfigArgs:
     def __init__(__self__, *,
@@ -1522,6 +2058,15 @@ class TenantInboundSamlConfigIdpConfigArgs:
         pulumi.set(self, "sign_request", value)
 
 
+if not MYPY:
+    class TenantInboundSamlConfigIdpConfigIdpCertificateArgsDict(TypedDict):
+        x509_certificate: NotRequired[pulumi.Input[str]]
+        """
+        The x509 certificate
+        """
+elif False:
+    TenantInboundSamlConfigIdpConfigIdpCertificateArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TenantInboundSamlConfigIdpConfigIdpCertificateArgs:
     def __init__(__self__, *,
@@ -1545,6 +2090,28 @@ class TenantInboundSamlConfigIdpConfigIdpCertificateArgs:
         pulumi.set(self, "x509_certificate", value)
 
 
+if not MYPY:
+    class TenantInboundSamlConfigSpConfigArgsDict(TypedDict):
+        callback_uri: pulumi.Input[str]
+        """
+        Callback URI where responses from IDP are handled. Must start with `https://`.
+        """
+        sp_entity_id: pulumi.Input[str]
+        """
+        Unique identifier for all SAML entities.
+        """
+        sp_certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input['TenantInboundSamlConfigSpConfigSpCertificateArgsDict']]]]
+        """
+        (Output)
+        The IDP's certificate data to verify the signature in the SAMLResponse issued by the IDP.
+        Structure is documented below.
+
+
+        <a name="nested_sp_certificates"></a>The `sp_certificates` block contains:
+        """
+elif False:
+    TenantInboundSamlConfigSpConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TenantInboundSamlConfigSpConfigArgs:
     def __init__(__self__, *,
@@ -1608,6 +2175,15 @@ class TenantInboundSamlConfigSpConfigArgs:
         pulumi.set(self, "sp_certificates", value)
 
 
+if not MYPY:
+    class TenantInboundSamlConfigSpConfigSpCertificateArgsDict(TypedDict):
+        x509_certificate: NotRequired[pulumi.Input[str]]
+        """
+        The x509 certificate
+        """
+elif False:
+    TenantInboundSamlConfigSpConfigSpCertificateArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class TenantInboundSamlConfigSpConfigSpCertificateArgs:
     def __init__(__self__, *,