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

pulumi_gcp/clouddomains/_inputs.py

@@ -4,27 +4,78 @@
 
 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__ = [
     'RegistrationContactSettingsArgs',
+    'RegistrationContactSettingsArgsDict',
     'RegistrationContactSettingsAdminContactArgs',
+    'RegistrationContactSettingsAdminContactArgsDict',
     'RegistrationContactSettingsAdminContactPostalAddressArgs',
+    'RegistrationContactSettingsAdminContactPostalAddressArgsDict',
     'RegistrationContactSettingsRegistrantContactArgs',
+    'RegistrationContactSettingsRegistrantContactArgsDict',
     'RegistrationContactSettingsRegistrantContactPostalAddressArgs',
+    'RegistrationContactSettingsRegistrantContactPostalAddressArgsDict',
     'RegistrationContactSettingsTechnicalContactArgs',
+    'RegistrationContactSettingsTechnicalContactArgsDict',
     'RegistrationContactSettingsTechnicalContactPostalAddressArgs',
+    'RegistrationContactSettingsTechnicalContactPostalAddressArgsDict',
     'RegistrationDnsSettingsArgs',
+    'RegistrationDnsSettingsArgsDict',
     'RegistrationDnsSettingsCustomDnsArgs',
+    'RegistrationDnsSettingsCustomDnsArgsDict',
     'RegistrationDnsSettingsCustomDnsDsRecordArgs',
+    'RegistrationDnsSettingsCustomDnsDsRecordArgsDict',
     'RegistrationDnsSettingsGlueRecordArgs',
+    'RegistrationDnsSettingsGlueRecordArgsDict',
     'RegistrationManagementSettingsArgs',
+    'RegistrationManagementSettingsArgsDict',
     'RegistrationYearlyPriceArgs',
+    'RegistrationYearlyPriceArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class RegistrationContactSettingsArgsDict(TypedDict):
+        admin_contact: pulumi.Input['RegistrationContactSettingsAdminContactArgsDict']
+        """
+        Caution: Anyone with access to this email address, phone number, and/or postal address can take control of the domain.
+        Warning: For new Registrations, the registrant receives an email confirmation that they must complete within 15 days to
+        avoid domain suspension.
+        Structure is documented below.
+        """
+        privacy: pulumi.Input[str]
+        """
+        Required. Privacy setting for the contacts associated with the Registration.
+        Values are PUBLIC_CONTACT_DATA, PRIVATE_CONTACT_DATA, and REDACTED_CONTACT_DATA
+        """
+        registrant_contact: pulumi.Input['RegistrationContactSettingsRegistrantContactArgsDict']
+        """
+        Caution: Anyone with access to this email address, phone number, and/or postal address can take control of the domain.
+        Warning: For new Registrations, the registrant receives an email confirmation that they must complete within 15 days to
+        avoid domain suspension.
+        Structure is documented below.
+        """
+        technical_contact: pulumi.Input['RegistrationContactSettingsTechnicalContactArgsDict']
+        """
+        Caution: Anyone with access to this email address, phone number, and/or postal address can take control of the domain.
+        Warning: For new Registrations, the registrant receives an email confirmation that they must complete within 15 days to
+        avoid domain suspension.
+        Structure is documented below.
+        """
+elif False:
+    RegistrationContactSettingsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationContactSettingsArgs:
     def __init__(__self__, *,
@@ -112,6 +163,28 @@ class RegistrationContactSettingsArgs:
         pulumi.set(self, "technical_contact", value)
 
 
+if not MYPY:
+    class RegistrationContactSettingsAdminContactArgsDict(TypedDict):
+        email: pulumi.Input[str]
+        """
+        Required. Email address of the contact.
+        """
+        phone_number: pulumi.Input[str]
+        """
+        Required. Phone number of the contact in international format. For example, "+1-800-555-0123".
+        """
+        postal_address: pulumi.Input['RegistrationContactSettingsAdminContactPostalAddressArgsDict']
+        """
+        Required. Postal address of the contact.
+        Structure is documented below.
+        """
+        fax_number: NotRequired[pulumi.Input[str]]
+        """
+        Fax number of the contact in international format. For example, "+1-800-555-0123".
+        """
+elif False:
+    RegistrationContactSettingsAdminContactArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationContactSettingsAdminContactArgs:
     def __init__(__self__, *,
@@ -182,6 +255,54 @@ class RegistrationContactSettingsAdminContactArgs:
         pulumi.set(self, "fax_number", value)
 
 
+if not MYPY:
+    class RegistrationContactSettingsAdminContactPostalAddressArgsDict(TypedDict):
+        region_code: pulumi.Input[str]
+        """
+        Required. CLDR region code of the country/region of the address. This is never inferred and it is up to the user to
+        ensure the value is correct. See https://cldr.unicode.org/ and
+        https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html for details. Example: "CH" for Switzerland.
+        """
+        address_lines: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Unstructured address lines describing the lower levels of an address.
+        Because values in addressLines do not have type information and may sometimes contain multiple values in a single
+        field (e.g. "Austin, TX"), it is important that the line order is clear. The order of address lines should be
+        "envelope order" for the country/region of the address. In places where this can vary (e.g. Japan), address_language
+        is used to make it explicit (e.g. "ja" for large-to-small ordering and "ja-Latn" or "en" for small-to-large). This way,
+        the most specific line of an address can be selected based on the language.
+        """
+        administrative_area: NotRequired[pulumi.Input[str]]
+        """
+        Highest administrative subdivision which is used for postal addresses of a country or region. For example, this can be a state,
+        a province, an oblast, or a prefecture. Specifically, for Spain this is the province and not the autonomous community
+        (e.g. "Barcelona" and not "Catalonia"). Many countries don't use an administrative area in postal addresses. E.g. in Switzerland
+        this should be left unpopulated.
+        """
+        locality: NotRequired[pulumi.Input[str]]
+        """
+        Generally refers to the city/town portion of the address. Examples: US city, IT comune, UK post town. In regions of the world
+        where localities are not well defined or do not fit into this structure well, leave locality empty and use addressLines.
+        """
+        organization: NotRequired[pulumi.Input[str]]
+        """
+        The name of the organization at the address.
+        """
+        postal_code: NotRequired[pulumi.Input[str]]
+        """
+        Postal code of the address. Not all countries use or require postal codes to be present, but where they are used,
+        they may trigger additional validation with other parts of the address (e.g. state/zip validation in the U.S.A.).
+        """
+        recipients: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The recipient at the address. This field may, under certain circumstances, contain multiline information. For example,
+        it might contain "care of" information.
+
+        - - -
+        """
+elif False:
+    RegistrationContactSettingsAdminContactPostalAddressArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationContactSettingsAdminContactPostalAddressArgs:
     def __init__(__self__, *,
@@ -330,6 +451,28 @@ class RegistrationContactSettingsAdminContactPostalAddressArgs:
         pulumi.set(self, "recipients", value)
 
 
+if not MYPY:
+    class RegistrationContactSettingsRegistrantContactArgsDict(TypedDict):
+        email: pulumi.Input[str]
+        """
+        Required. Email address of the contact.
+        """
+        phone_number: pulumi.Input[str]
+        """
+        Required. Phone number of the contact in international format. For example, "+1-800-555-0123".
+        """
+        postal_address: pulumi.Input['RegistrationContactSettingsRegistrantContactPostalAddressArgsDict']
+        """
+        Required. Postal address of the contact.
+        Structure is documented below.
+        """
+        fax_number: NotRequired[pulumi.Input[str]]
+        """
+        Fax number of the contact in international format. For example, "+1-800-555-0123".
+        """
+elif False:
+    RegistrationContactSettingsRegistrantContactArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationContactSettingsRegistrantContactArgs:
     def __init__(__self__, *,
@@ -400,6 +543,54 @@ class RegistrationContactSettingsRegistrantContactArgs:
         pulumi.set(self, "fax_number", value)
 
 
+if not MYPY:
+    class RegistrationContactSettingsRegistrantContactPostalAddressArgsDict(TypedDict):
+        region_code: pulumi.Input[str]
+        """
+        Required. CLDR region code of the country/region of the address. This is never inferred and it is up to the user to
+        ensure the value is correct. See https://cldr.unicode.org/ and
+        https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html for details. Example: "CH" for Switzerland.
+        """
+        address_lines: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Unstructured address lines describing the lower levels of an address.
+        Because values in addressLines do not have type information and may sometimes contain multiple values in a single
+        field (e.g. "Austin, TX"), it is important that the line order is clear. The order of address lines should be
+        "envelope order" for the country/region of the address. In places where this can vary (e.g. Japan), address_language
+        is used to make it explicit (e.g. "ja" for large-to-small ordering and "ja-Latn" or "en" for small-to-large). This way,
+        the most specific line of an address can be selected based on the language.
+        """
+        administrative_area: NotRequired[pulumi.Input[str]]
+        """
+        Highest administrative subdivision which is used for postal addresses of a country or region. For example, this can be a state,
+        a province, an oblast, or a prefecture. Specifically, for Spain this is the province and not the autonomous community
+        (e.g. "Barcelona" and not "Catalonia"). Many countries don't use an administrative area in postal addresses. E.g. in Switzerland
+        this should be left unpopulated.
+        """
+        locality: NotRequired[pulumi.Input[str]]
+        """
+        Generally refers to the city/town portion of the address. Examples: US city, IT comune, UK post town. In regions of the world
+        where localities are not well defined or do not fit into this structure well, leave locality empty and use addressLines.
+        """
+        organization: NotRequired[pulumi.Input[str]]
+        """
+        The name of the organization at the address.
+        """
+        postal_code: NotRequired[pulumi.Input[str]]
+        """
+        Postal code of the address. Not all countries use or require postal codes to be present, but where they are used,
+        they may trigger additional validation with other parts of the address (e.g. state/zip validation in the U.S.A.).
+        """
+        recipients: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The recipient at the address. This field may, under certain circumstances, contain multiline information. For example,
+        it might contain "care of" information.
+
+        - - -
+        """
+elif False:
+    RegistrationContactSettingsRegistrantContactPostalAddressArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationContactSettingsRegistrantContactPostalAddressArgs:
     def __init__(__self__, *,
@@ -548,6 +739,28 @@ class RegistrationContactSettingsRegistrantContactPostalAddressArgs:
         pulumi.set(self, "recipients", value)
 
 
+if not MYPY:
+    class RegistrationContactSettingsTechnicalContactArgsDict(TypedDict):
+        email: pulumi.Input[str]
+        """
+        Required. Email address of the contact.
+        """
+        phone_number: pulumi.Input[str]
+        """
+        Required. Phone number of the contact in international format. For example, "+1-800-555-0123".
+        """
+        postal_address: pulumi.Input['RegistrationContactSettingsTechnicalContactPostalAddressArgsDict']
+        """
+        Required. Postal address of the contact.
+        Structure is documented below.
+        """
+        fax_number: NotRequired[pulumi.Input[str]]
+        """
+        Fax number of the contact in international format. For example, "+1-800-555-0123".
+        """
+elif False:
+    RegistrationContactSettingsTechnicalContactArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationContactSettingsTechnicalContactArgs:
     def __init__(__self__, *,
@@ -618,6 +831,54 @@ class RegistrationContactSettingsTechnicalContactArgs:
         pulumi.set(self, "fax_number", value)
 
 
+if not MYPY:
+    class RegistrationContactSettingsTechnicalContactPostalAddressArgsDict(TypedDict):
+        region_code: pulumi.Input[str]
+        """
+        Required. CLDR region code of the country/region of the address. This is never inferred and it is up to the user to
+        ensure the value is correct. See https://cldr.unicode.org/ and
+        https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html for details. Example: "CH" for Switzerland.
+        """
+        address_lines: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Unstructured address lines describing the lower levels of an address.
+        Because values in addressLines do not have type information and may sometimes contain multiple values in a single
+        field (e.g. "Austin, TX"), it is important that the line order is clear. The order of address lines should be
+        "envelope order" for the country/region of the address. In places where this can vary (e.g. Japan), address_language
+        is used to make it explicit (e.g. "ja" for large-to-small ordering and "ja-Latn" or "en" for small-to-large). This way,
+        the most specific line of an address can be selected based on the language.
+        """
+        administrative_area: NotRequired[pulumi.Input[str]]
+        """
+        Highest administrative subdivision which is used for postal addresses of a country or region. For example, this can be a state,
+        a province, an oblast, or a prefecture. Specifically, for Spain this is the province and not the autonomous community
+        (e.g. "Barcelona" and not "Catalonia"). Many countries don't use an administrative area in postal addresses. E.g. in Switzerland
+        this should be left unpopulated.
+        """
+        locality: NotRequired[pulumi.Input[str]]
+        """
+        Generally refers to the city/town portion of the address. Examples: US city, IT comune, UK post town. In regions of the world
+        where localities are not well defined or do not fit into this structure well, leave locality empty and use addressLines.
+        """
+        organization: NotRequired[pulumi.Input[str]]
+        """
+        The name of the organization at the address.
+        """
+        postal_code: NotRequired[pulumi.Input[str]]
+        """
+        Postal code of the address. Not all countries use or require postal codes to be present, but where they are used,
+        they may trigger additional validation with other parts of the address (e.g. state/zip validation in the U.S.A.).
+        """
+        recipients: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The recipient at the address. This field may, under certain circumstances, contain multiline information. For example,
+        it might contain "care of" information.
+
+        - - -
+        """
+elif False:
+    RegistrationContactSettingsTechnicalContactPostalAddressArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationContactSettingsTechnicalContactPostalAddressArgs:
     def __init__(__self__, *,
@@ -766,6 +1027,21 @@ class RegistrationContactSettingsTechnicalContactPostalAddressArgs:
         pulumi.set(self, "recipients", value)
 
 
+if not MYPY:
+    class RegistrationDnsSettingsArgsDict(TypedDict):
+        custom_dns: NotRequired[pulumi.Input['RegistrationDnsSettingsCustomDnsArgsDict']]
+        """
+        Configuration for an arbitrary DNS provider.
+        Structure is documented below.
+        """
+        glue_records: NotRequired[pulumi.Input[Sequence[pulumi.Input['RegistrationDnsSettingsGlueRecordArgsDict']]]]
+        """
+        The list of glue records for this Registration. Commonly empty.
+        Structure is documented below.
+        """
+elif False:
+    RegistrationDnsSettingsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationDnsSettingsArgs:
     def __init__(__self__, *,
@@ -809,6 +1085,22 @@ class RegistrationDnsSettingsArgs:
         pulumi.set(self, "glue_records", value)
 
 
+if not MYPY:
+    class RegistrationDnsSettingsCustomDnsArgsDict(TypedDict):
+        name_servers: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Required. A list of name servers that store the DNS zone for this domain. Each name server is a domain
+        name, with Unicode domain names expressed in Punycode format.
+        """
+        ds_records: NotRequired[pulumi.Input[Sequence[pulumi.Input['RegistrationDnsSettingsCustomDnsDsRecordArgsDict']]]]
+        """
+        The list of DS records for this domain, which are used to enable DNSSEC. The domain's DNS provider can provide
+        the values to set here. If this field is empty, DNSSEC is disabled.
+        Structure is documented below.
+        """
+elif False:
+    RegistrationDnsSettingsCustomDnsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationDnsSettingsCustomDnsArgs:
     def __init__(__self__, *,
@@ -853,6 +1145,27 @@ class RegistrationDnsSettingsCustomDnsArgs:
         pulumi.set(self, "ds_records", value)
 
 
+if not MYPY:
+    class RegistrationDnsSettingsCustomDnsDsRecordArgsDict(TypedDict):
+        algorithm: NotRequired[pulumi.Input[str]]
+        """
+        The algorithm used to generate the referenced DNSKEY.
+        """
+        digest: NotRequired[pulumi.Input[str]]
+        """
+        The digest generated from the referenced DNSKEY.
+        """
+        digest_type: NotRequired[pulumi.Input[str]]
+        """
+        The hash function used to generate the digest of the referenced DNSKEY.
+        """
+        key_tag: NotRequired[pulumi.Input[int]]
+        """
+        The key tag of the record. Must be set in range 0 -- 65535.
+        """
+elif False:
+    RegistrationDnsSettingsCustomDnsDsRecordArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationDnsSettingsCustomDnsDsRecordArgs:
     def __init__(__self__, *,
@@ -924,6 +1237,25 @@ class RegistrationDnsSettingsCustomDnsDsRecordArgs:
         pulumi.set(self, "key_tag", value)
 
 
+if not MYPY:
+    class RegistrationDnsSettingsGlueRecordArgsDict(TypedDict):
+        host_name: pulumi.Input[str]
+        """
+        Required. Domain name of the host in Punycode format.
+        """
+        ipv4_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of IPv4 addresses corresponding to this host in the standard decimal format (e.g. 198.51.100.1).
+        At least one of ipv4_address and ipv6_address must be set.
+        """
+        ipv6_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of IPv4 addresses corresponding to this host in the standard decimal format (e.g. 198.51.100.1).
+        At least one of ipv4_address and ipv6_address must be set.
+        """
+elif False:
+    RegistrationDnsSettingsGlueRecordArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationDnsSettingsGlueRecordArgs:
     def __init__(__self__, *,
@@ -982,6 +1314,33 @@ class RegistrationDnsSettingsGlueRecordArgs:
         pulumi.set(self, "ipv6_addresses", value)
 
 
+if not MYPY:
+    class RegistrationManagementSettingsArgsDict(TypedDict):
+        preferred_renewal_method: NotRequired[pulumi.Input[str]]
+        """
+        The desired renewal method for this Registration. The actual renewalMethod is automatically updated to reflect this choice.
+        If unset or equal to RENEWAL_METHOD_UNSPECIFIED, the actual renewalMethod is treated as if it were set to AUTOMATIC_RENEWAL.
+        You cannot use RENEWAL_DISABLED during resource creation, and you can update the renewal status only when the Registration
+        resource has state ACTIVE or SUSPENDED.
+        When preferredRenewalMethod is set to AUTOMATIC_RENEWAL, the actual renewalMethod can be set to RENEWAL_DISABLED in case of
+        problems with the billing account or reported domain abuse. In such cases, check the issues field on the Registration. After
+        the problem is resolved, the renewalMethod is automatically updated to preferredRenewalMethod in a few hours.
+        """
+        renewal_method: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        Output only. The actual renewal method for this Registration. When preferredRenewalMethod is set to AUTOMATIC_RENEWAL,
+        the actual renewalMethod can be equal to RENEWAL_DISABLED—for example, when there are problems with the billing account
+        or reported domain abuse. In such cases, check the issues field on the Registration. After the problem is resolved, the
+        renewalMethod is automatically updated to preferredRenewalMethod in a few hours.
+        """
+        transfer_lock_state: NotRequired[pulumi.Input[str]]
+        """
+        Controls whether the domain can be transferred to another registrar. Values are UNLOCKED or LOCKED.
+        """
+elif False:
+    RegistrationManagementSettingsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationManagementSettingsArgs:
     def __init__(__self__, *,
@@ -1057,6 +1416,19 @@ class RegistrationManagementSettingsArgs:
         pulumi.set(self, "transfer_lock_state", value)
 
 
+if not MYPY:
+    class RegistrationYearlyPriceArgsDict(TypedDict):
+        currency_code: NotRequired[pulumi.Input[str]]
+        """
+        The three-letter currency code defined in ISO 4217.
+        """
+        units: NotRequired[pulumi.Input[str]]
+        """
+        The whole units of the amount. For example if currencyCode is "USD", then 1 unit is one US dollar.
+        """
+elif False:
+    RegistrationYearlyPriceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class RegistrationYearlyPriceArgs:
     def __init__(__self__, *,

pulumi_gcp/clouddomains/outputs.py

@@ -4,9 +4,14 @@
 
 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
 from . import outputs