pulumi-gcp 7.39.0a1726207510__py3-none-any.whl → 8.0.0a1__py3-none-any.whl

pulumi_gcp/identityplatform/outputs.py

@@ -41,11 +41,6 @@ __all__ = [
     'InboundSamlConfigIdpConfigIdpCertificate',
     'InboundSamlConfigSpConfig',
     'InboundSamlConfigSpConfigSpCertificate',
-    'ProjectDefaultConfigSignIn',
-    'ProjectDefaultConfigSignInAnonymous',
-    'ProjectDefaultConfigSignInEmail',
-    'ProjectDefaultConfigSignInHashConfig',
-    'ProjectDefaultConfigSignInPhoneNumber',
     'TenantInboundSamlConfigIdpConfig',
     'TenantInboundSamlConfigIdpConfigIdpCertificate',
     'TenantInboundSamlConfigSpConfig',
@@ -1375,314 +1370,6 @@ class InboundSamlConfigSpConfigSpCertificate(dict):
         return pulumi.get(self, "x509_certificate")
 
 
-@pulumi.output_type
-class ProjectDefaultConfigSignIn(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "allowDuplicateEmails":
-            suggest = "allow_duplicate_emails"
-        elif key == "hashConfigs":
-            suggest = "hash_configs"
-        elif key == "phoneNumber":
-            suggest = "phone_number"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ProjectDefaultConfigSignIn. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ProjectDefaultConfigSignIn.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ProjectDefaultConfigSignIn.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 allow_duplicate_emails: Optional[bool] = None,
-                 anonymous: Optional['outputs.ProjectDefaultConfigSignInAnonymous'] = None,
-                 email: Optional['outputs.ProjectDefaultConfigSignInEmail'] = None,
-                 hash_configs: Optional[Sequence['outputs.ProjectDefaultConfigSignInHashConfig']] = None,
-                 phone_number: Optional['outputs.ProjectDefaultConfigSignInPhoneNumber'] = None):
-        """
-        :param bool allow_duplicate_emails: Whether to allow more than one account to have the same email.
-        :param 'ProjectDefaultConfigSignInAnonymousArgs' anonymous: Configuration options related to authenticating an anonymous user.
-               Structure is documented below.
-        :param 'ProjectDefaultConfigSignInEmailArgs' email: Configuration options related to authenticating a user by their email address.
-               Structure is documented below.
-        :param Sequence['ProjectDefaultConfigSignInHashConfigArgs'] hash_configs: (Output)
-               Output only. Hash config information.
-               Structure is documented below.
-        :param 'ProjectDefaultConfigSignInPhoneNumberArgs' phone_number: Configuration options related to authenticated a user by their phone number.
-               Structure is documented below.
-        """
-        if allow_duplicate_emails is not None:
-            pulumi.set(__self__, "allow_duplicate_emails", allow_duplicate_emails)
-        if anonymous is not None:
-            pulumi.set(__self__, "anonymous", anonymous)
-        if email is not None:
-            pulumi.set(__self__, "email", email)
-        if hash_configs is not None:
-            pulumi.set(__self__, "hash_configs", hash_configs)
-        if phone_number is not None:
-            pulumi.set(__self__, "phone_number", phone_number)
-
-    @property
-    @pulumi.getter(name="allowDuplicateEmails")
-    def allow_duplicate_emails(self) -> Optional[bool]:
-        """
-        Whether to allow more than one account to have the same email.
-        """
-        return pulumi.get(self, "allow_duplicate_emails")
-
-    @property
-    @pulumi.getter
-    def anonymous(self) -> Optional['outputs.ProjectDefaultConfigSignInAnonymous']:
-        """
-        Configuration options related to authenticating an anonymous user.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "anonymous")
-
-    @property
-    @pulumi.getter
-    def email(self) -> Optional['outputs.ProjectDefaultConfigSignInEmail']:
-        """
-        Configuration options related to authenticating a user by their email address.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "email")
-
-    @property
-    @pulumi.getter(name="hashConfigs")
-    def hash_configs(self) -> Optional[Sequence['outputs.ProjectDefaultConfigSignInHashConfig']]:
-        """
-        (Output)
-        Output only. Hash config information.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "hash_configs")
-
-    @property
-    @pulumi.getter(name="phoneNumber")
-    def phone_number(self) -> Optional['outputs.ProjectDefaultConfigSignInPhoneNumber']:
-        """
-        Configuration options related to authenticated a user by their phone number.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "phone_number")
-
-
-@pulumi.output_type
-class ProjectDefaultConfigSignInAnonymous(dict):
-    def __init__(__self__, *,
-                 enabled: bool):
-        """
-        :param bool enabled: Whether anonymous user auth is enabled for the project or not.
-               
-               <a name="nested_hash_config"></a>The `hash_config` block contains:
-        """
-        pulumi.set(__self__, "enabled", enabled)
-
-    @property
-    @pulumi.getter
-    def enabled(self) -> bool:
-        """
-        Whether anonymous user auth is enabled for the project or not.
-
-        <a name="nested_hash_config"></a>The `hash_config` block contains:
-        """
-        return pulumi.get(self, "enabled")
-
-
-@pulumi.output_type
-class ProjectDefaultConfigSignInEmail(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "passwordRequired":
-            suggest = "password_required"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ProjectDefaultConfigSignInEmail. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ProjectDefaultConfigSignInEmail.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ProjectDefaultConfigSignInEmail.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 enabled: Optional[bool] = None,
-                 password_required: Optional[bool] = None):
-        """
-        :param bool enabled: Whether email auth is enabled for the project or not.
-        :param bool password_required: 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.
-        """
-        if enabled is not None:
-            pulumi.set(__self__, "enabled", enabled)
-        if password_required is not None:
-            pulumi.set(__self__, "password_required", password_required)
-
-    @property
-    @pulumi.getter
-    def enabled(self) -> Optional[bool]:
-        """
-        Whether email auth is enabled for the project or not.
-        """
-        return pulumi.get(self, "enabled")
-
-    @property
-    @pulumi.getter(name="passwordRequired")
-    def password_required(self) -> Optional[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.
-        """
-        return pulumi.get(self, "password_required")
-
-
-@pulumi.output_type
-class ProjectDefaultConfigSignInHashConfig(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "memoryCost":
-            suggest = "memory_cost"
-        elif key == "saltSeparator":
-            suggest = "salt_separator"
-        elif key == "signerKey":
-            suggest = "signer_key"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ProjectDefaultConfigSignInHashConfig. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ProjectDefaultConfigSignInHashConfig.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ProjectDefaultConfigSignInHashConfig.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 algorithm: Optional[str] = None,
-                 memory_cost: Optional[int] = None,
-                 rounds: Optional[int] = None,
-                 salt_separator: Optional[str] = None,
-                 signer_key: Optional[str] = None):
-        """
-        :param str algorithm: Different password hash algorithms used in Identity Toolkit.
-        :param int memory_cost: 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.
-        :param int rounds: How many rounds for hash calculation. Used by scrypt and other similar password derivation algorithms.
-        :param str salt_separator: Non-printable character to be inserted between the salt and plain text password in base64.
-        :param str signer_key: Signer key in base64.
-        """
-        if algorithm is not None:
-            pulumi.set(__self__, "algorithm", algorithm)
-        if memory_cost is not None:
-            pulumi.set(__self__, "memory_cost", memory_cost)
-        if rounds is not None:
-            pulumi.set(__self__, "rounds", rounds)
-        if salt_separator is not None:
-            pulumi.set(__self__, "salt_separator", salt_separator)
-        if signer_key is not None:
-            pulumi.set(__self__, "signer_key", signer_key)
-
-    @property
-    @pulumi.getter
-    def algorithm(self) -> Optional[str]:
-        """
-        Different password hash algorithms used in Identity Toolkit.
-        """
-        return pulumi.get(self, "algorithm")
-
-    @property
-    @pulumi.getter(name="memoryCost")
-    def memory_cost(self) -> Optional[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.
-        """
-        return pulumi.get(self, "memory_cost")
-
-    @property
-    @pulumi.getter
-    def rounds(self) -> Optional[int]:
-        """
-        How many rounds for hash calculation. Used by scrypt and other similar password derivation algorithms.
-        """
-        return pulumi.get(self, "rounds")
-
-    @property
-    @pulumi.getter(name="saltSeparator")
-    def salt_separator(self) -> Optional[str]:
-        """
-        Non-printable character to be inserted between the salt and plain text password in base64.
-        """
-        return pulumi.get(self, "salt_separator")
-
-    @property
-    @pulumi.getter(name="signerKey")
-    def signer_key(self) -> Optional[str]:
-        """
-        Signer key in base64.
-        """
-        return pulumi.get(self, "signer_key")
-
-
-@pulumi.output_type
-class ProjectDefaultConfigSignInPhoneNumber(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "testPhoneNumbers":
-            suggest = "test_phone_numbers"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ProjectDefaultConfigSignInPhoneNumber. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ProjectDefaultConfigSignInPhoneNumber.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ProjectDefaultConfigSignInPhoneNumber.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 enabled: Optional[bool] = None,
-                 test_phone_numbers: Optional[Mapping[str, str]] = None):
-        """
-        :param bool enabled: Whether phone number auth is enabled for the project or not.
-        :param Mapping[str, str] test_phone_numbers: A map of <test phone number, fake code> that can be used for phone auth testing.
-        """
-        if enabled is not None:
-            pulumi.set(__self__, "enabled", enabled)
-        if test_phone_numbers is not None:
-            pulumi.set(__self__, "test_phone_numbers", test_phone_numbers)
-
-    @property
-    @pulumi.getter
-    def enabled(self) -> Optional[bool]:
-        """
-        Whether phone number auth is enabled for the project or not.
-        """
-        return pulumi.get(self, "enabled")
-
-    @property
-    @pulumi.getter(name="testPhoneNumbers")
-    def test_phone_numbers(self) -> Optional[Mapping[str, str]]:
-        """
-        A map of <test phone number, fake code> that can be used for phone auth testing.
-        """
-        return pulumi.get(self, "test_phone_numbers")
-
-
 @pulumi.output_type
 class TenantInboundSamlConfigIdpConfig(dict):
     @staticmethod

pulumi_gcp/integrationconnectors/managed_zone.py

@@ -381,7 +381,8 @@ class ManagedZone(pulumi.CustomResource):
             project_id="tf-test_34535",
             name="tf-test_22375",
             org_id="123456789",
-            billing_account="000000-0000000-0000000-000000")
+            billing_account="000000-0000000-0000000-000000",
+            deletion_policy="DELETE")
         test_project = gcp.organizations.get_project()
         dns_peer_binding = gcp.projects.IAMMember("dns_peer_binding",
             project=target_project.project_id,
@@ -491,7 +492,8 @@ class ManagedZone(pulumi.CustomResource):
             project_id="tf-test_34535",
             name="tf-test_22375",
             org_id="123456789",
-            billing_account="000000-0000000-0000000-000000")
+            billing_account="000000-0000000-0000000-000000",
+            deletion_policy="DELETE")
         test_project = gcp.organizations.get_project()
         dns_peer_binding = gcp.projects.IAMMember("dns_peer_binding",
             project=target_project.project_id,

pulumi_gcp/kms/__init__.py

@@ -12,8 +12,12 @@ from .crypto_key_iam_member import *
 from .crypto_key_iam_policy import *
 from .crypto_key_version import *
 from .ekm_connection import *
+from .ekm_connection_iam_binding import *
+from .ekm_connection_iam_member import *
+from .ekm_connection_iam_policy import *
 from .get_crypto_key_iam_policy import *
 from .get_crypto_keys import *
+from .get_ekm_connection_iam_policy import *
 from .get_key_ring_iam_policy import *
 from .get_key_rings import *
 from .get_kms_crypto_key import *

pulumi_gcp/kms/_inputs.py

@@ -33,6 +33,10 @@ __all__ = [
     'CryptoKeyVersionExternalProtectionLevelOptionsArgsDict',
     'CryptoKeyVersionTemplateArgs',
     'CryptoKeyVersionTemplateArgsDict',
+    'EkmConnectionIamBindingConditionArgs',
+    'EkmConnectionIamBindingConditionArgsDict',
+    'EkmConnectionIamMemberConditionArgs',
+    'EkmConnectionIamMemberConditionArgsDict',
     'EkmConnectionServiceResolverArgs',
     'EkmConnectionServiceResolverArgsDict',
     'EkmConnectionServiceResolverServerCertificateArgs',
@@ -644,6 +648,132 @@ class CryptoKeyVersionTemplateArgs:
         pulumi.set(self, "protection_level", value)
 
 
+if not MYPY:
+    class EkmConnectionIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        title: pulumi.Input[str]
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    EkmConnectionIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EkmConnectionIamBindingConditionArgs:
+    def __init__(__self__, *,
+                 expression: pulumi.Input[str],
+                 title: pulumi.Input[str],
+                 description: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
+        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> pulumi.Input[str]:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: pulumi.Input[str]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def title(self) -> pulumi.Input[str]:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @title.setter
+    def title(self, value: pulumi.Input[str]):
+        pulumi.set(self, "title", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+
+if not MYPY:
+    class EkmConnectionIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        title: pulumi.Input[str]
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    EkmConnectionIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EkmConnectionIamMemberConditionArgs:
+    def __init__(__self__, *,
+                 expression: pulumi.Input[str],
+                 title: pulumi.Input[str],
+                 description: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
+        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> pulumi.Input[str]:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: pulumi.Input[str]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def title(self) -> pulumi.Input[str]:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @title.setter
+    def title(self, value: pulumi.Input[str]):
+        pulumi.set(self, "title", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+
 if not MYPY:
     class EkmConnectionServiceResolverArgsDict(TypedDict):
         hostname: pulumi.Input[str]

pulumi_gcp/kms/autokey_config.py

@@ -136,13 +136,15 @@ class AutokeyConfig(pulumi.CustomResource):
         # Create Folder in GCP Organization
         autokms_folder = gcp.organizations.Folder("autokms_folder",
             display_name="my-folder",
-            parent="organizations/123456789")
+            parent="organizations/123456789",
+            deletion_protection=False)
         # Create the key project
         key_project = gcp.organizations.Project("key_project",
             project_id="key-proj",
             name="key-proj",
             folder_id=autokms_folder.folder_id,
             billing_account="000000-0000000-0000000-000000",
+            deletion_policy="DELETE",
             opts = pulumi.ResourceOptions(depends_on=[autokms_folder]))
         # Enable the Cloud KMS API
         kms_api_service = gcp.projects.Service("kms_api_service",
@@ -224,13 +226,15 @@ class AutokeyConfig(pulumi.CustomResource):
         # Create Folder in GCP Organization
         autokms_folder = gcp.organizations.Folder("autokms_folder",
             display_name="my-folder",
-            parent="organizations/123456789")
+            parent="organizations/123456789",
+            deletion_protection=False)
         # Create the key project
         key_project = gcp.organizations.Project("key_project",
             project_id="key-proj",
             name="key-proj",
             folder_id=autokms_folder.folder_id,
             billing_account="000000-0000000-0000000-000000",
+            deletion_policy="DELETE",
             opts = pulumi.ResourceOptions(depends_on=[autokms_folder]))
         # Enable the Cloud KMS API
         kms_api_service = gcp.projects.Service("kms_api_service",