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

pulumi_gcp/redis/_inputs.py

@@ -4,68 +4,28 @@
 
 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__ = [
     'ClusterDiscoveryEndpointArgs',
-    'ClusterDiscoveryEndpointArgsDict',
     'ClusterDiscoveryEndpointPscConfigArgs',
-    'ClusterDiscoveryEndpointPscConfigArgsDict',
     'ClusterPscConfigArgs',
-    'ClusterPscConfigArgsDict',
     'ClusterPscConnectionArgs',
-    'ClusterPscConnectionArgsDict',
     'ClusterStateInfoArgs',
-    'ClusterStateInfoArgsDict',
     'ClusterStateInfoUpdateInfoArgs',
-    'ClusterStateInfoUpdateInfoArgsDict',
     'ClusterZoneDistributionConfigArgs',
-    'ClusterZoneDistributionConfigArgsDict',
     'InstanceMaintenancePolicyArgs',
-    'InstanceMaintenancePolicyArgsDict',
     'InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs',
-    'InstanceMaintenancePolicyWeeklyMaintenanceWindowArgsDict',
     'InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs',
-    'InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgsDict',
     'InstanceMaintenanceScheduleArgs',
-    'InstanceMaintenanceScheduleArgsDict',
     'InstanceNodeArgs',
-    'InstanceNodeArgsDict',
     'InstancePersistenceConfigArgs',
-    'InstancePersistenceConfigArgsDict',
     'InstanceServerCaCertArgs',
-    'InstanceServerCaCertArgsDict',
 ]
 
-MYPY = False
-
-if not MYPY:
-    class ClusterDiscoveryEndpointArgsDict(TypedDict):
-        address: NotRequired[pulumi.Input[str]]
-        """
-        Output only. The IP allocated on the consumer network for the PSC forwarding rule.
-        """
-        port: NotRequired[pulumi.Input[int]]
-        """
-        Output only. The port number of the exposed Redis endpoint.
-        """
-        psc_config: NotRequired[pulumi.Input['ClusterDiscoveryEndpointPscConfigArgsDict']]
-        """
-        Output only. Customer configuration for where the endpoint
-        is created and accessed from.
-        Structure is documented below.
-        """
-elif False:
-    ClusterDiscoveryEndpointArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ClusterDiscoveryEndpointArgs:
     def __init__(__self__, *,
@@ -125,15 +85,6 @@ class ClusterDiscoveryEndpointArgs:
         pulumi.set(self, "psc_config", value)
 
 
-if not MYPY:
-    class ClusterDiscoveryEndpointPscConfigArgsDict(TypedDict):
-        network: NotRequired[pulumi.Input[str]]
-        """
-        The consumer network where the IP address resides, in the form of projects/{projectId}/global/networks/{network_id}.
-        """
-elif False:
-    ClusterDiscoveryEndpointPscConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ClusterDiscoveryEndpointPscConfigArgs:
     def __init__(__self__, *,
@@ -157,19 +108,6 @@ class ClusterDiscoveryEndpointPscConfigArgs:
         pulumi.set(self, "network", value)
 
 
-if not MYPY:
-    class ClusterPscConfigArgsDict(TypedDict):
-        network: pulumi.Input[str]
-        """
-        Required. The consumer network where the network address of
-        the discovery endpoint will be reserved, in the form of
-        projects/{network_project_id_or_number}/global/networks/{network_id}.
-
-        - - -
-        """
-elif False:
-    ClusterPscConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ClusterPscConfigArgs:
     def __init__(__self__, *,
@@ -200,31 +138,6 @@ class ClusterPscConfigArgs:
         pulumi.set(self, "network", value)
 
 
-if not MYPY:
-    class ClusterPscConnectionArgsDict(TypedDict):
-        address: NotRequired[pulumi.Input[str]]
-        """
-        Output only. The IP allocated on the consumer network for the PSC forwarding rule.
-        """
-        forwarding_rule: NotRequired[pulumi.Input[str]]
-        """
-        Output only. The URI of the consumer side forwarding rule. Example: projects/{projectNumOrId}/regions/us-east1/forwardingRules/{resourceId}.
-        """
-        network: NotRequired[pulumi.Input[str]]
-        """
-        The consumer network where the IP address resides, in the form of projects/{projectId}/global/networks/{network_id}.
-        """
-        project_id: NotRequired[pulumi.Input[str]]
-        """
-        Output only. The consumer projectId where the forwarding rule is created from.
-        """
-        psc_connection_id: NotRequired[pulumi.Input[str]]
-        """
-        Output only. The PSC connection id of the forwarding rule connected to the service attachment.
-        """
-elif False:
-    ClusterPscConnectionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ClusterPscConnectionArgs:
     def __init__(__self__, *,
@@ -312,16 +225,6 @@ class ClusterPscConnectionArgs:
         pulumi.set(self, "psc_connection_id", value)
 
 
-if not MYPY:
-    class ClusterStateInfoArgsDict(TypedDict):
-        update_info: NotRequired[pulumi.Input['ClusterStateInfoUpdateInfoArgsDict']]
-        """
-        A nested object resource
-        Structure is documented below.
-        """
-elif False:
-    ClusterStateInfoArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ClusterStateInfoArgs:
     def __init__(__self__, *,
@@ -347,19 +250,6 @@ class ClusterStateInfoArgs:
         pulumi.set(self, "update_info", value)
 
 
-if not MYPY:
-    class ClusterStateInfoUpdateInfoArgsDict(TypedDict):
-        target_replica_count: NotRequired[pulumi.Input[int]]
-        """
-        Target number of replica nodes per shard.
-        """
-        target_shard_count: NotRequired[pulumi.Input[int]]
-        """
-        Target number of shards for redis cluster.
-        """
-elif False:
-    ClusterStateInfoUpdateInfoArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ClusterStateInfoUpdateInfoArgs:
     def __init__(__self__, *,
@@ -399,21 +289,6 @@ class ClusterStateInfoUpdateInfoArgs:
         pulumi.set(self, "target_shard_count", value)
 
 
-if not MYPY:
-    class ClusterZoneDistributionConfigArgsDict(TypedDict):
-        mode: NotRequired[pulumi.Input[str]]
-        """
-        Immutable. The mode for zone distribution for Memorystore Redis cluster.
-        If not provided, MULTI_ZONE will be used as default
-        Possible values are: `MULTI_ZONE`, `SINGLE_ZONE`.
-        """
-        zone: NotRequired[pulumi.Input[str]]
-        """
-        Immutable. The zone for single zone Memorystore Redis cluster.
-        """
-elif False:
-    ClusterZoneDistributionConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ClusterZoneDistributionConfigArgs:
     def __init__(__self__, *,
@@ -457,38 +332,6 @@ class ClusterZoneDistributionConfigArgs:
         pulumi.set(self, "zone", value)
 
 
-if not MYPY:
-    class InstanceMaintenancePolicyArgsDict(TypedDict):
-        create_time: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Output only. The time when the policy was created.
-        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
-        resolution and up to nine fractional digits.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        Optional. Description of what this policy is for.
-        Create/Update methods return INVALID_ARGUMENT if the
-        length is greater than 512.
-        """
-        update_time: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Output only. The time when the policy was last updated.
-        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
-        resolution and up to nine fractional digits.
-        """
-        weekly_maintenance_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceMaintenancePolicyWeeklyMaintenanceWindowArgsDict']]]]
-        """
-        Optional. Maintenance window that is applied to resources covered by this policy.
-        Minimum 1. For the current version, the maximum number
-        of weekly_window is expected to be one.
-        Structure is documented below.
-        """
-elif False:
-    InstanceMaintenancePolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class InstanceMaintenancePolicyArgs:
     def __init__(__self__, *,
@@ -582,37 +425,6 @@ class InstanceMaintenancePolicyArgs:
         pulumi.set(self, "weekly_maintenance_windows", value)
 
 
-if not MYPY:
-    class InstanceMaintenancePolicyWeeklyMaintenanceWindowArgsDict(TypedDict):
-        day: pulumi.Input[str]
-        """
-        Required. The day of week that maintenance updates occur.
-        - DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
-        - MONDAY: Monday
-        - TUESDAY: Tuesday
-        - WEDNESDAY: Wednesday
-        - THURSDAY: Thursday
-        - FRIDAY: Friday
-        - SATURDAY: Saturday
-        - SUNDAY: Sunday
-        Possible values are: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`.
-        """
-        start_time: pulumi.Input['InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgsDict']
-        """
-        Required. Start time of the window in UTC time.
-        Structure is documented below.
-        """
-        duration: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Output only. Duration of the maintenance window.
-        The current window is fixed at 1 hour.
-        A duration in seconds with up to nine fractional digits,
-        terminated by 's'. Example: "3.5s".
-        """
-elif False:
-    InstanceMaintenancePolicyWeeklyMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs:
     def __init__(__self__, *,
@@ -694,29 +506,6 @@ class InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs:
         pulumi.set(self, "duration", value)
 
 
-if not MYPY:
-    class InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgsDict(TypedDict):
-        hours: NotRequired[pulumi.Input[int]]
-        """
-        Hours of day in 24 hour format. Should be from 0 to 23.
-        An API may choose to allow the value "24:00:00" for scenarios like business closing time.
-        """
-        minutes: NotRequired[pulumi.Input[int]]
-        """
-        Minutes of hour of day. Must be from 0 to 59.
-        """
-        nanos: NotRequired[pulumi.Input[int]]
-        """
-        Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
-        """
-        seconds: NotRequired[pulumi.Input[int]]
-        """
-        Seconds of minutes of the time. Must normally be from 0 to 59.
-        An API may allow the value 60 if it allows leap-seconds.
-        """
-elif False:
-    InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs:
     def __init__(__self__, *,
@@ -792,33 +581,6 @@ class InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs:
         pulumi.set(self, "seconds", value)
 
 
-if not MYPY:
-    class InstanceMaintenanceScheduleArgsDict(TypedDict):
-        end_time: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Output only. The end time of any upcoming scheduled maintenance for this instance.
-        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
-        resolution and up to nine fractional digits.
-        """
-        schedule_deadline_time: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Output only. The deadline that the maintenance schedule start time
-        can not go beyond, including reschedule.
-        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
-        resolution and up to nine fractional digits.
-        """
-        start_time: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Output only. The start time of any upcoming scheduled maintenance for this instance.
-        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
-        resolution and up to nine fractional digits.
-        """
-elif False:
-    InstanceMaintenanceScheduleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class InstanceMaintenanceScheduleArgs:
     def __init__(__self__, *,
@@ -894,21 +656,6 @@ class InstanceMaintenanceScheduleArgs:
         pulumi.set(self, "start_time", value)
 
 
-if not MYPY:
-    class InstanceNodeArgsDict(TypedDict):
-        id: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Node identifying string. e.g. 'node-0', 'node-1'
-        """
-        zone: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Location of the node.
-        """
-elif False:
-    InstanceNodeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class InstanceNodeArgs:
     def __init__(__self__, *,
@@ -952,44 +699,6 @@ class InstanceNodeArgs:
         pulumi.set(self, "zone", value)
 
 
-if not MYPY:
-    class InstancePersistenceConfigArgsDict(TypedDict):
-        persistence_mode: NotRequired[pulumi.Input[str]]
-        """
-        Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.
-        - DISABLED: 	Persistence is disabled for the instance, and any existing snapshots are deleted.
-        - RDB: RDB based Persistence is enabled.
-        Possible values are: `DISABLED`, `RDB`.
-        """
-        rdb_next_snapshot_time: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Output only. The next time that a snapshot attempt is scheduled to occur.
-        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
-        to nine fractional digits.
-        Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
-        """
-        rdb_snapshot_period: NotRequired[pulumi.Input[str]]
-        """
-        Optional. Available snapshot periods for scheduling.
-        - ONE_HOUR:	Snapshot every 1 hour.
-        - SIX_HOURS:	Snapshot every 6 hours.
-        - TWELVE_HOURS:	Snapshot every 12 hours.
-        - TWENTY_FOUR_HOURS:	Snapshot every 24 hours.
-        Possible values are: `ONE_HOUR`, `SIX_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`.
-        """
-        rdb_snapshot_start_time: NotRequired[pulumi.Input[str]]
-        """
-        Optional. Date and time that the first snapshot was/will be attempted,
-        and to which future snapshots will be aligned. If not provided,
-        the current time will be used.
-        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution
-        and up to nine fractional digits.
-        Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
-        """
-elif False:
-    InstancePersistenceConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class InstancePersistenceConfigArgs:
     def __init__(__self__, *,
@@ -1095,36 +804,6 @@ class InstancePersistenceConfigArgs:
         pulumi.set(self, "rdb_snapshot_start_time", value)
 
 
-if not MYPY:
-    class InstanceServerCaCertArgsDict(TypedDict):
-        cert: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        The certificate data in PEM format.
-        """
-        create_time: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        The time when the certificate was created.
-        """
-        expire_time: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        The time when the certificate expires.
-        """
-        serial_number: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Serial number, as extracted from the certificate.
-        """
-        sha1_fingerprint: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Sha1 Fingerprint of the certificate.
-        """
-elif False:
-    InstanceServerCaCertArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class InstanceServerCaCertArgs:
     def __init__(__self__, *,