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

pulumi_gcp/gkebackup/_inputs.py

@@ -4,128 +4,47 @@
 
 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__ = [
     'BackupPlanBackupConfigArgs',
-    'BackupPlanBackupConfigArgsDict',
     'BackupPlanBackupConfigEncryptionKeyArgs',
-    'BackupPlanBackupConfigEncryptionKeyArgsDict',
     'BackupPlanBackupConfigSelectedApplicationsArgs',
-    'BackupPlanBackupConfigSelectedApplicationsArgsDict',
     'BackupPlanBackupConfigSelectedApplicationsNamespacedNameArgs',
-    'BackupPlanBackupConfigSelectedApplicationsNamespacedNameArgsDict',
     'BackupPlanBackupConfigSelectedNamespacesArgs',
-    'BackupPlanBackupConfigSelectedNamespacesArgsDict',
     'BackupPlanBackupScheduleArgs',
-    'BackupPlanBackupScheduleArgsDict',
     'BackupPlanBackupScheduleRpoConfigArgs',
-    'BackupPlanBackupScheduleRpoConfigArgsDict',
     'BackupPlanBackupScheduleRpoConfigExclusionWindowArgs',
-    'BackupPlanBackupScheduleRpoConfigExclusionWindowArgsDict',
     'BackupPlanBackupScheduleRpoConfigExclusionWindowDaysOfWeekArgs',
-    'BackupPlanBackupScheduleRpoConfigExclusionWindowDaysOfWeekArgsDict',
     'BackupPlanBackupScheduleRpoConfigExclusionWindowSingleOccurrenceDateArgs',
-    'BackupPlanBackupScheduleRpoConfigExclusionWindowSingleOccurrenceDateArgsDict',
     'BackupPlanBackupScheduleRpoConfigExclusionWindowStartTimeArgs',
-    'BackupPlanBackupScheduleRpoConfigExclusionWindowStartTimeArgsDict',
     'BackupPlanIamBindingConditionArgs',
-    'BackupPlanIamBindingConditionArgsDict',
     'BackupPlanIamMemberConditionArgs',
-    'BackupPlanIamMemberConditionArgsDict',
     'BackupPlanRetentionPolicyArgs',
-    'BackupPlanRetentionPolicyArgsDict',
     'RestorePlanIamBindingConditionArgs',
-    'RestorePlanIamBindingConditionArgsDict',
     'RestorePlanIamMemberConditionArgs',
-    'RestorePlanIamMemberConditionArgsDict',
     'RestorePlanRestoreConfigArgs',
-    'RestorePlanRestoreConfigArgsDict',
     'RestorePlanRestoreConfigClusterResourceRestoreScopeArgs',
-    'RestorePlanRestoreConfigClusterResourceRestoreScopeArgsDict',
     'RestorePlanRestoreConfigClusterResourceRestoreScopeExcludedGroupKindArgs',
-    'RestorePlanRestoreConfigClusterResourceRestoreScopeExcludedGroupKindArgsDict',
     'RestorePlanRestoreConfigClusterResourceRestoreScopeSelectedGroupKindArgs',
-    'RestorePlanRestoreConfigClusterResourceRestoreScopeSelectedGroupKindArgsDict',
     'RestorePlanRestoreConfigExcludedNamespacesArgs',
-    'RestorePlanRestoreConfigExcludedNamespacesArgsDict',
     'RestorePlanRestoreConfigRestoreOrderArgs',
-    'RestorePlanRestoreConfigRestoreOrderArgsDict',
     'RestorePlanRestoreConfigRestoreOrderGroupKindDependencyArgs',
-    'RestorePlanRestoreConfigRestoreOrderGroupKindDependencyArgsDict',
     'RestorePlanRestoreConfigRestoreOrderGroupKindDependencyRequiringArgs',
-    'RestorePlanRestoreConfigRestoreOrderGroupKindDependencyRequiringArgsDict',
     'RestorePlanRestoreConfigRestoreOrderGroupKindDependencySatisfyingArgs',
-    'RestorePlanRestoreConfigRestoreOrderGroupKindDependencySatisfyingArgsDict',
     'RestorePlanRestoreConfigSelectedApplicationsArgs',
-    'RestorePlanRestoreConfigSelectedApplicationsArgsDict',
     'RestorePlanRestoreConfigSelectedApplicationsNamespacedNameArgs',
-    'RestorePlanRestoreConfigSelectedApplicationsNamespacedNameArgsDict',
     'RestorePlanRestoreConfigSelectedNamespacesArgs',
-    'RestorePlanRestoreConfigSelectedNamespacesArgsDict',
     'RestorePlanRestoreConfigTransformationRuleArgs',
-    'RestorePlanRestoreConfigTransformationRuleArgsDict',
     'RestorePlanRestoreConfigTransformationRuleFieldActionArgs',
-    'RestorePlanRestoreConfigTransformationRuleFieldActionArgsDict',
     'RestorePlanRestoreConfigTransformationRuleResourceFilterArgs',
-    'RestorePlanRestoreConfigTransformationRuleResourceFilterArgsDict',
     'RestorePlanRestoreConfigTransformationRuleResourceFilterGroupKindArgs',
-    'RestorePlanRestoreConfigTransformationRuleResourceFilterGroupKindArgsDict',
     'RestorePlanRestoreConfigVolumeDataRestorePolicyBindingArgs',
-    'RestorePlanRestoreConfigVolumeDataRestorePolicyBindingArgsDict',
 ]
 
-MYPY = False
-
-if not MYPY:
-    class BackupPlanBackupConfigArgsDict(TypedDict):
-        all_namespaces: NotRequired[pulumi.Input[bool]]
-        """
-        If True, include all namespaced resources.
-        """
-        encryption_key: NotRequired[pulumi.Input['BackupPlanBackupConfigEncryptionKeyArgsDict']]
-        """
-        This defines a customer managed encryption key that will be used to encrypt the "config"
-        portion (the Kubernetes resources) of Backups created via this plan.
-        Structure is documented below.
-        """
-        include_secrets: NotRequired[pulumi.Input[bool]]
-        """
-        This flag specifies whether Kubernetes Secret resources should be included
-        when they fall into the scope of Backups.
-        """
-        include_volume_data: NotRequired[pulumi.Input[bool]]
-        """
-        This flag specifies whether volume data should be backed up when PVCs are
-        included in the scope of a Backup.
-        """
-        permissive_mode: NotRequired[pulumi.Input[bool]]
-        """
-        This flag specifies whether Backups will not fail when
-        Backup for GKE detects Kubernetes configuration that is
-        non-standard or requires additional setup to restore.
-        """
-        selected_applications: NotRequired[pulumi.Input['BackupPlanBackupConfigSelectedApplicationsArgsDict']]
-        """
-        A list of namespaced Kubernetes Resources.
-        Structure is documented below.
-        """
-        selected_namespaces: NotRequired[pulumi.Input['BackupPlanBackupConfigSelectedNamespacesArgsDict']]
-        """
-        If set, include just the resources in the listed namespaces.
-        Structure is documented below.
-        """
-elif False:
-    BackupPlanBackupConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupConfigArgs:
     def __init__(__self__, *,
@@ -261,15 +180,6 @@ class BackupPlanBackupConfigArgs:
         pulumi.set(self, "selected_namespaces", value)
 
 
-if not MYPY:
-    class BackupPlanBackupConfigEncryptionKeyArgsDict(TypedDict):
-        gcp_kms_encryption_key: pulumi.Input[str]
-        """
-        Google Cloud KMS encryption key. Format: projects/*/locations/*/keyRings/*/cryptoKeys/*
-        """
-elif False:
-    BackupPlanBackupConfigEncryptionKeyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupConfigEncryptionKeyArgs:
     def __init__(__self__, *,
@@ -292,16 +202,6 @@ class BackupPlanBackupConfigEncryptionKeyArgs:
         pulumi.set(self, "gcp_kms_encryption_key", value)
 
 
-if not MYPY:
-    class BackupPlanBackupConfigSelectedApplicationsArgsDict(TypedDict):
-        namespaced_names: pulumi.Input[Sequence[pulumi.Input['BackupPlanBackupConfigSelectedApplicationsNamespacedNameArgsDict']]]
-        """
-        A list of namespaced Kubernetes resources.
-        Structure is documented below.
-        """
-elif False:
-    BackupPlanBackupConfigSelectedApplicationsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupConfigSelectedApplicationsArgs:
     def __init__(__self__, *,
@@ -326,19 +226,6 @@ class BackupPlanBackupConfigSelectedApplicationsArgs:
         pulumi.set(self, "namespaced_names", value)
 
 
-if not MYPY:
-    class BackupPlanBackupConfigSelectedApplicationsNamespacedNameArgsDict(TypedDict):
-        name: pulumi.Input[str]
-        """
-        The name of a Kubernetes Resource.
-        """
-        namespace: pulumi.Input[str]
-        """
-        The namespace of a Kubernetes Resource.
-        """
-elif False:
-    BackupPlanBackupConfigSelectedApplicationsNamespacedNameArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupConfigSelectedApplicationsNamespacedNameArgs:
     def __init__(__self__, *,
@@ -376,15 +263,6 @@ class BackupPlanBackupConfigSelectedApplicationsNamespacedNameArgs:
         pulumi.set(self, "namespace", value)
 
 
-if not MYPY:
-    class BackupPlanBackupConfigSelectedNamespacesArgsDict(TypedDict):
-        namespaces: pulumi.Input[Sequence[pulumi.Input[str]]]
-        """
-        A list of Kubernetes Namespaces.
-        """
-elif False:
-    BackupPlanBackupConfigSelectedNamespacesArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupConfigSelectedNamespacesArgs:
     def __init__(__self__, *,
@@ -407,30 +285,6 @@ class BackupPlanBackupConfigSelectedNamespacesArgs:
         pulumi.set(self, "namespaces", value)
 
 
-if not MYPY:
-    class BackupPlanBackupScheduleArgsDict(TypedDict):
-        cron_schedule: NotRequired[pulumi.Input[str]]
-        """
-        A standard cron string that defines a repeating schedule for
-        creating Backups via this BackupPlan.
-        This is mutually exclusive with the rpoConfig field since at most one
-        schedule can be defined for a BackupPlan.
-        If this is defined, then backupRetainDays must also be defined.
-        """
-        paused: NotRequired[pulumi.Input[bool]]
-        """
-        This flag denotes whether automatic Backup creation is paused for this BackupPlan.
-        """
-        rpo_config: NotRequired[pulumi.Input['BackupPlanBackupScheduleRpoConfigArgsDict']]
-        """
-        Defines the RPO schedule configuration for this BackupPlan. This is mutually
-        exclusive with the cronSchedule field since at most one schedule can be defined
-        for a BackupPLan. If this is defined, then backupRetainDays must also be defined.
-        Structure is documented below.
-        """
-elif False:
-    BackupPlanBackupScheduleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupScheduleArgs:
     def __init__(__self__, *,
@@ -500,28 +354,6 @@ class BackupPlanBackupScheduleArgs:
         pulumi.set(self, "rpo_config", value)
 
 
-if not MYPY:
-    class BackupPlanBackupScheduleRpoConfigArgsDict(TypedDict):
-        target_rpo_minutes: pulumi.Input[int]
-        """
-        Defines the target RPO for the BackupPlan in minutes, which means the target
-        maximum data loss in time that is acceptable for this BackupPlan. This must be
-        at least 60, i.e., 1 hour, and at most 86400, i.e., 60 days.
-        """
-        exclusion_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input['BackupPlanBackupScheduleRpoConfigExclusionWindowArgsDict']]]]
-        """
-        User specified time windows during which backup can NOT happen for this BackupPlan.
-        Backups should start and finish outside of any given exclusion window. Note: backup
-        jobs will be scheduled to start and finish outside the duration of the window as
-        much as possible, but running jobs will not get canceled when it runs into the window.
-        All the time and date values in exclusionWindows entry in the API are in UTC. We
-        only allow <=1 recurrence (daily or weekly) exclusion window for a BackupPlan while no
-        restriction on number of single occurrence windows.
-        Structure is documented below.
-        """
-elif False:
-    BackupPlanBackupScheduleRpoConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupScheduleRpoConfigArgs:
     def __init__(__self__, *,
@@ -578,45 +410,6 @@ class BackupPlanBackupScheduleRpoConfigArgs:
         pulumi.set(self, "exclusion_windows", value)
 
 
-if not MYPY:
-    class BackupPlanBackupScheduleRpoConfigExclusionWindowArgsDict(TypedDict):
-        duration: pulumi.Input[str]
-        """
-        Specifies duration of the window in seconds with up to nine fractional digits,
-        terminated by 's'. Example: "3.5s". Restrictions for duration based on the
-        recurrence type to allow some time for backup to happen:
-        - single_occurrence_date:  no restriction
-        - daily window: duration < 24 hours
-        - weekly window:
-        - days of week includes all seven days of a week: duration < 24 hours
-        - all other weekly window: duration < 168 hours (i.e., 24 * 7 hours)
-        """
-        start_time: pulumi.Input['BackupPlanBackupScheduleRpoConfigExclusionWindowStartTimeArgsDict']
-        """
-        Specifies the start time of the window using time of the day in UTC.
-        Structure is documented below.
-        """
-        daily: NotRequired[pulumi.Input[bool]]
-        """
-        The exclusion window occurs every day if set to "True".
-        Specifying this field to "False" is an error.
-        Only one of singleOccurrenceDate, daily and daysOfWeek may be set.
-        """
-        days_of_week: NotRequired[pulumi.Input['BackupPlanBackupScheduleRpoConfigExclusionWindowDaysOfWeekArgsDict']]
-        """
-        The exclusion window occurs on these days of each week in UTC.
-        Only one of singleOccurrenceDate, daily and daysOfWeek may be set.
-        Structure is documented below.
-        """
-        single_occurrence_date: NotRequired[pulumi.Input['BackupPlanBackupScheduleRpoConfigExclusionWindowSingleOccurrenceDateArgsDict']]
-        """
-        No recurrence. The exclusion window occurs only once and on this date in UTC.
-        Only one of singleOccurrenceDate, daily and daysOfWeek may be set.
-        Structure is documented below.
-        """
-elif False:
-    BackupPlanBackupScheduleRpoConfigExclusionWindowArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupScheduleRpoConfigExclusionWindowArgs:
     def __init__(__self__, *,
@@ -730,16 +523,6 @@ class BackupPlanBackupScheduleRpoConfigExclusionWindowArgs:
         pulumi.set(self, "single_occurrence_date", value)
 
 
-if not MYPY:
-    class BackupPlanBackupScheduleRpoConfigExclusionWindowDaysOfWeekArgsDict(TypedDict):
-        days_of_weeks: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        A list of days of week.
-        Each value may be one of: `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`.
-        """
-elif False:
-    BackupPlanBackupScheduleRpoConfigExclusionWindowDaysOfWeekArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupScheduleRpoConfigExclusionWindowDaysOfWeekArgs:
     def __init__(__self__, *,
@@ -765,23 +548,6 @@ class BackupPlanBackupScheduleRpoConfigExclusionWindowDaysOfWeekArgs:
         pulumi.set(self, "days_of_weeks", value)
 
 
-if not MYPY:
-    class BackupPlanBackupScheduleRpoConfigExclusionWindowSingleOccurrenceDateArgsDict(TypedDict):
-        day: NotRequired[pulumi.Input[int]]
-        """
-        Day of a month.
-        """
-        month: NotRequired[pulumi.Input[int]]
-        """
-        Month of a year.
-        """
-        year: NotRequired[pulumi.Input[int]]
-        """
-        Year of the date.
-        """
-elif False:
-    BackupPlanBackupScheduleRpoConfigExclusionWindowSingleOccurrenceDateArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupScheduleRpoConfigExclusionWindowSingleOccurrenceDateArgs:
     def __init__(__self__, *,
@@ -837,27 +603,6 @@ class BackupPlanBackupScheduleRpoConfigExclusionWindowSingleOccurrenceDateArgs:
         pulumi.set(self, "year", value)
 
 
-if not MYPY:
-    class BackupPlanBackupScheduleRpoConfigExclusionWindowStartTimeArgsDict(TypedDict):
-        hours: NotRequired[pulumi.Input[int]]
-        """
-        Hours of day in 24 hour format.
-        """
-        minutes: NotRequired[pulumi.Input[int]]
-        """
-        Minutes of hour of day.
-        """
-        nanos: NotRequired[pulumi.Input[int]]
-        """
-        Fractions of seconds in nanoseconds.
-        """
-        seconds: NotRequired[pulumi.Input[int]]
-        """
-        Seconds of minutes of the time.
-        """
-elif False:
-    BackupPlanBackupScheduleRpoConfigExclusionWindowStartTimeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanBackupScheduleRpoConfigExclusionWindowStartTimeArgs:
     def __init__(__self__, *,
@@ -929,14 +674,6 @@ class BackupPlanBackupScheduleRpoConfigExclusionWindowStartTimeArgs:
         pulumi.set(self, "seconds", value)
 
 
-if not MYPY:
-    class BackupPlanIamBindingConditionArgsDict(TypedDict):
-        expression: pulumi.Input[str]
-        title: pulumi.Input[str]
-        description: NotRequired[pulumi.Input[str]]
-elif False:
-    BackupPlanIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanIamBindingConditionArgs:
     def __init__(__self__, *,
@@ -976,14 +713,6 @@ class BackupPlanIamBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
-if not MYPY:
-    class BackupPlanIamMemberConditionArgsDict(TypedDict):
-        expression: pulumi.Input[str]
-        title: pulumi.Input[str]
-        description: NotRequired[pulumi.Input[str]]
-elif False:
-    BackupPlanIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanIamMemberConditionArgs:
     def __init__(__self__, *,
@@ -1023,41 +752,6 @@ class BackupPlanIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
-if not MYPY:
-    class BackupPlanRetentionPolicyArgsDict(TypedDict):
-        backup_delete_lock_days: NotRequired[pulumi.Input[int]]
-        """
-        Minimum age for a Backup created via this BackupPlan (in days).
-        Must be an integer value between 0-90 (inclusive).
-        A Backup created under this BackupPlan will not be deletable
-        until it reaches Backup's (create time + backup_delete_lock_days).
-        Updating this field of a BackupPlan does not affect existing Backups.
-        Backups created after a successful update will inherit this new value.
-        """
-        backup_retain_days: NotRequired[pulumi.Input[int]]
-        """
-        The default maximum age of a Backup created via this BackupPlan.
-        This field MUST be an integer value >= 0 and <= 365. If specified,
-        a Backup created under this BackupPlan will be automatically deleted
-        after its age reaches (createTime + backupRetainDays).
-        If not specified, Backups created under this BackupPlan will NOT be
-        subject to automatic deletion. Updating this field does NOT affect
-        existing Backups under it. Backups created AFTER a successful update
-        will automatically pick up the new value.
-        NOTE: backupRetainDays must be >= backupDeleteLockDays.
-        If cronSchedule is defined, then this must be <= 360 * the creation interval.
-        If rpo_config is defined, then this must be
-        <= 360 * targetRpoMinutes/(1440minutes/day)
-        """
-        locked: NotRequired[pulumi.Input[bool]]
-        """
-        This flag denotes whether the retention policy of this BackupPlan is locked.
-        If set to True, no further update is allowed on this policy, including
-        the locked field itself.
-        """
-elif False:
-    BackupPlanRetentionPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class BackupPlanRetentionPolicyArgs:
     def __init__(__self__, *,
@@ -1149,14 +843,6 @@ class BackupPlanRetentionPolicyArgs:
         pulumi.set(self, "locked", value)
 
 
-if not MYPY:
-    class RestorePlanIamBindingConditionArgsDict(TypedDict):
-        expression: pulumi.Input[str]
-        title: pulumi.Input[str]
-        description: NotRequired[pulumi.Input[str]]
-elif False:
-    RestorePlanIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanIamBindingConditionArgs:
     def __init__(__self__, *,
@@ -1196,14 +882,6 @@ class RestorePlanIamBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
-if not MYPY:
-    class RestorePlanIamMemberConditionArgsDict(TypedDict):
-        expression: pulumi.Input[str]
-        title: pulumi.Input[str]
-        description: NotRequired[pulumi.Input[str]]
-elif False:
-    RestorePlanIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanIamMemberConditionArgs:
     def __init__(__self__, *,
@@ -1243,96 +921,6 @@ class RestorePlanIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigArgsDict(TypedDict):
-        all_namespaces: NotRequired[pulumi.Input[bool]]
-        """
-        If True, restore all namespaced resources in the Backup.
-        Setting this field to False will result in an error.
-        """
-        cluster_resource_conflict_policy: NotRequired[pulumi.Input[str]]
-        """
-        Defines the behavior for handling the situation where cluster-scoped resources
-        being restored already exist in the target cluster.
-        This MUST be set to a value other than `CLUSTER_RESOURCE_CONFLICT_POLICY_UNSPECIFIED`
-        if `clusterResourceRestoreScope` is anyting other than `noGroupKinds`.
-        See https://cloud.google.com/kubernetes-engine/docs/add-on/backup-for-gke/reference/rest/v1/RestoreConfig#clusterresourceconflictpolicy
-        for more information on each policy option.
-        Possible values are: `USE_EXISTING_VERSION`, `USE_BACKUP_VERSION`.
-        """
-        cluster_resource_restore_scope: NotRequired[pulumi.Input['RestorePlanRestoreConfigClusterResourceRestoreScopeArgsDict']]
-        """
-        Identifies the cluster-scoped resources to restore from the Backup.
-        Structure is documented below.
-        """
-        excluded_namespaces: NotRequired[pulumi.Input['RestorePlanRestoreConfigExcludedNamespacesArgsDict']]
-        """
-        A list of selected namespaces excluded from restoration.
-        All namespaces except those in this list will be restored.
-        Structure is documented below.
-        """
-        namespaced_resource_restore_mode: NotRequired[pulumi.Input[str]]
-        """
-        Defines the behavior for handling the situation where sets of namespaced resources
-        being restored already exist in the target cluster.
-        This MUST be set to a value other than `NAMESPACED_RESOURCE_RESTORE_MODE_UNSPECIFIED`
-        if the `namespacedResourceRestoreScope` is anything other than `noNamespaces`.
-        See https://cloud.google.com/kubernetes-engine/docs/add-on/backup-for-gke/reference/rest/v1/RestoreConfig#namespacedresourcerestoremode
-        for more information on each mode.
-        Possible values are: `DELETE_AND_RESTORE`, `FAIL_ON_CONFLICT`, `MERGE_SKIP_ON_CONFLICT`, `MERGE_REPLACE_VOLUME_ON_CONFLICT`, `MERGE_REPLACE_ON_CONFLICT`.
-        """
-        no_namespaces: NotRequired[pulumi.Input[bool]]
-        """
-        Do not restore any namespaced resources if set to "True".
-        Specifying this field to "False" is not allowed.
-        """
-        restore_order: NotRequired[pulumi.Input['RestorePlanRestoreConfigRestoreOrderArgsDict']]
-        """
-        It contains custom ordering to use on a Restore.
-        Structure is documented below.
-        """
-        selected_applications: NotRequired[pulumi.Input['RestorePlanRestoreConfigSelectedApplicationsArgsDict']]
-        """
-        A list of selected ProtectedApplications to restore.
-        The listed ProtectedApplications and all the resources
-        to which they refer will be restored.
-        Structure is documented below.
-        """
-        selected_namespaces: NotRequired[pulumi.Input['RestorePlanRestoreConfigSelectedNamespacesArgsDict']]
-        """
-        A list of selected namespaces to restore from the Backup.
-        The listed Namespaces and all resources contained in them will be restored.
-        Structure is documented below.
-        """
-        transformation_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['RestorePlanRestoreConfigTransformationRuleArgsDict']]]]
-        """
-        A list of transformation rules to be applied against Kubernetes
-        resources as they are selected for restoration from a Backup.
-        Rules are executed in order defined - this order matters,
-        as changes made by a rule may impact the filtering logic of subsequent
-        rules. An empty list means no transformation will occur.
-        Structure is documented below.
-        """
-        volume_data_restore_policy: NotRequired[pulumi.Input[str]]
-        """
-        Specifies the mechanism to be used to restore volume data.
-        This should be set to a value other than `NAMESPACED_RESOURCE_RESTORE_MODE_UNSPECIFIED`
-        if the `namespacedResourceRestoreScope` is anything other than `noNamespaces`.
-        If not specified, it will be treated as `NO_VOLUME_DATA_RESTORATION`.
-        See https://cloud.google.com/kubernetes-engine/docs/add-on/backup-for-gke/reference/rest/v1/RestoreConfig#VolumeDataRestorePolicy
-        for more information on each policy option.
-        Possible values are: `RESTORE_VOLUME_DATA_FROM_BACKUP`, `REUSE_VOLUME_HANDLE_FROM_BACKUP`, `NO_VOLUME_DATA_RESTORATION`.
-        """
-        volume_data_restore_policy_bindings: NotRequired[pulumi.Input[Sequence[pulumi.Input['RestorePlanRestoreConfigVolumeDataRestorePolicyBindingArgsDict']]]]
-        """
-        A table that binds volumes by their scope to a restore policy. Bindings
-        must have a unique scope. Any volumes not scoped in the bindings are
-        subject to the policy defined in volume_data_restore_policy.
-        Structure is documented below.
-        """
-elif False:
-    RestorePlanRestoreConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigArgs:
     def __init__(__self__, *,
@@ -1606,36 +1194,6 @@ class RestorePlanRestoreConfigArgs:
         pulumi.set(self, "volume_data_restore_policy_bindings", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigClusterResourceRestoreScopeArgsDict(TypedDict):
-        all_group_kinds: NotRequired[pulumi.Input[bool]]
-        """
-        If True, all valid cluster-scoped resources will be restored.
-        Mutually exclusive to any other field in `clusterResourceRestoreScope`.
-        """
-        excluded_group_kinds: NotRequired[pulumi.Input[Sequence[pulumi.Input['RestorePlanRestoreConfigClusterResourceRestoreScopeExcludedGroupKindArgsDict']]]]
-        """
-        A list of cluster-scoped resource group kinds to NOT restore from the backup.
-        If specified, all valid cluster-scoped resources will be restored except
-        for those specified in the list.
-        Mutually exclusive to any other field in `clusterResourceRestoreScope`.
-        Structure is documented below.
-        """
-        no_group_kinds: NotRequired[pulumi.Input[bool]]
-        """
-        If True, no cluster-scoped resources will be restored.
-        Mutually exclusive to any other field in `clusterResourceRestoreScope`.
-        """
-        selected_group_kinds: NotRequired[pulumi.Input[Sequence[pulumi.Input['RestorePlanRestoreConfigClusterResourceRestoreScopeSelectedGroupKindArgsDict']]]]
-        """
-        A list of cluster-scoped resource group kinds to restore from the backup.
-        If specified, only the selected resources will be restored.
-        Mutually exclusive to any other field in the `clusterResourceRestoreScope`.
-        Structure is documented below.
-        """
-elif False:
-    RestorePlanRestoreConfigClusterResourceRestoreScopeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigClusterResourceRestoreScopeArgs:
     def __init__(__self__, *,
@@ -1725,22 +1283,6 @@ class RestorePlanRestoreConfigClusterResourceRestoreScopeArgs:
         pulumi.set(self, "selected_group_kinds", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigClusterResourceRestoreScopeExcludedGroupKindArgsDict(TypedDict):
-        resource_group: NotRequired[pulumi.Input[str]]
-        """
-        API Group string of a Kubernetes resource, e.g.
-        "apiextensions.k8s.io", "storage.k8s.io", etc.
-        Use empty string for core group.
-        """
-        resource_kind: NotRequired[pulumi.Input[str]]
-        """
-        Kind of a Kubernetes resource, e.g.
-        "CustomResourceDefinition", "StorageClass", etc.
-        """
-elif False:
-    RestorePlanRestoreConfigClusterResourceRestoreScopeExcludedGroupKindArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigClusterResourceRestoreScopeExcludedGroupKindArgs:
     def __init__(__self__, *,
@@ -1786,22 +1328,6 @@ class RestorePlanRestoreConfigClusterResourceRestoreScopeExcludedGroupKindArgs:
         pulumi.set(self, "resource_kind", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigClusterResourceRestoreScopeSelectedGroupKindArgsDict(TypedDict):
-        resource_group: NotRequired[pulumi.Input[str]]
-        """
-        API Group string of a Kubernetes resource, e.g.
-        "apiextensions.k8s.io", "storage.k8s.io", etc.
-        Use empty string for core group.
-        """
-        resource_kind: NotRequired[pulumi.Input[str]]
-        """
-        Kind of a Kubernetes resource, e.g.
-        "CustomResourceDefinition", "StorageClass", etc.
-        """
-elif False:
-    RestorePlanRestoreConfigClusterResourceRestoreScopeSelectedGroupKindArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigClusterResourceRestoreScopeSelectedGroupKindArgs:
     def __init__(__self__, *,
@@ -1847,15 +1373,6 @@ class RestorePlanRestoreConfigClusterResourceRestoreScopeSelectedGroupKindArgs:
         pulumi.set(self, "resource_kind", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigExcludedNamespacesArgsDict(TypedDict):
-        namespaces: pulumi.Input[Sequence[pulumi.Input[str]]]
-        """
-        A list of Kubernetes Namespaces.
-        """
-elif False:
-    RestorePlanRestoreConfigExcludedNamespacesArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigExcludedNamespacesArgs:
     def __init__(__self__, *,
@@ -1878,18 +1395,6 @@ class RestorePlanRestoreConfigExcludedNamespacesArgs:
         pulumi.set(self, "namespaces", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigRestoreOrderArgsDict(TypedDict):
-        group_kind_dependencies: pulumi.Input[Sequence[pulumi.Input['RestorePlanRestoreConfigRestoreOrderGroupKindDependencyArgsDict']]]
-        """
-        A list of group kind dependency pairs
-        that is used by Backup for GKE to
-        generate a group kind restore order.
-        Structure is documented below.
-        """
-elif False:
-    RestorePlanRestoreConfigRestoreOrderArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigRestoreOrderArgs:
     def __init__(__self__, *,
@@ -1918,23 +1423,6 @@ class RestorePlanRestoreConfigRestoreOrderArgs:
         pulumi.set(self, "group_kind_dependencies", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigRestoreOrderGroupKindDependencyArgsDict(TypedDict):
-        requiring: pulumi.Input['RestorePlanRestoreConfigRestoreOrderGroupKindDependencyRequiringArgsDict']
-        """
-        The requiring group kind requires that the satisfying
-        group kind be restored first.
-        Structure is documented below.
-        """
-        satisfying: pulumi.Input['RestorePlanRestoreConfigRestoreOrderGroupKindDependencySatisfyingArgsDict']
-        """
-        The satisfying group kind must be restored first
-        in order to satisfy the dependency.
-        Structure is documented below.
-        """
-elif False:
-    RestorePlanRestoreConfigRestoreOrderGroupKindDependencyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigRestoreOrderGroupKindDependencyArgs:
     def __init__(__self__, *,
@@ -1980,24 +1468,6 @@ class RestorePlanRestoreConfigRestoreOrderGroupKindDependencyArgs:
         pulumi.set(self, "satisfying", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigRestoreOrderGroupKindDependencyRequiringArgsDict(TypedDict):
-        resource_group: NotRequired[pulumi.Input[str]]
-        """
-        API Group of a Kubernetes resource, e.g.
-        "apiextensions.k8s.io", "storage.k8s.io", etc.
-        Use empty string for core group.
-        """
-        resource_kind: NotRequired[pulumi.Input[str]]
-        """
-        Kind of a Kubernetes resource, e.g.
-        "CustomResourceDefinition", "StorageClass", etc.
-
-        - - -
-        """
-elif False:
-    RestorePlanRestoreConfigRestoreOrderGroupKindDependencyRequiringArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigRestoreOrderGroupKindDependencyRequiringArgs:
     def __init__(__self__, *,
@@ -2047,22 +1517,6 @@ class RestorePlanRestoreConfigRestoreOrderGroupKindDependencyRequiringArgs:
         pulumi.set(self, "resource_kind", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigRestoreOrderGroupKindDependencySatisfyingArgsDict(TypedDict):
-        resource_group: NotRequired[pulumi.Input[str]]
-        """
-        API Group of a Kubernetes resource, e.g.
-        "apiextensions.k8s.io", "storage.k8s.io", etc.
-        Use empty string for core group.
-        """
-        resource_kind: NotRequired[pulumi.Input[str]]
-        """
-        Kind of a Kubernetes resource, e.g.
-        "CustomResourceDefinition", "StorageClass", etc.
-        """
-elif False:
-    RestorePlanRestoreConfigRestoreOrderGroupKindDependencySatisfyingArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigRestoreOrderGroupKindDependencySatisfyingArgs:
     def __init__(__self__, *,
@@ -2108,16 +1562,6 @@ class RestorePlanRestoreConfigRestoreOrderGroupKindDependencySatisfyingArgs:
         pulumi.set(self, "resource_kind", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigSelectedApplicationsArgsDict(TypedDict):
-        namespaced_names: pulumi.Input[Sequence[pulumi.Input['RestorePlanRestoreConfigSelectedApplicationsNamespacedNameArgsDict']]]
-        """
-        A list of namespaced Kubernetes resources.
-        Structure is documented below.
-        """
-elif False:
-    RestorePlanRestoreConfigSelectedApplicationsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigSelectedApplicationsArgs:
     def __init__(__self__, *,
@@ -2142,19 +1586,6 @@ class RestorePlanRestoreConfigSelectedApplicationsArgs:
         pulumi.set(self, "namespaced_names", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigSelectedApplicationsNamespacedNameArgsDict(TypedDict):
-        name: pulumi.Input[str]
-        """
-        The name of a Kubernetes Resource.
-        """
-        namespace: pulumi.Input[str]
-        """
-        The namespace of a Kubernetes Resource.
-        """
-elif False:
-    RestorePlanRestoreConfigSelectedApplicationsNamespacedNameArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigSelectedApplicationsNamespacedNameArgs:
     def __init__(__self__, *,
@@ -2192,15 +1623,6 @@ class RestorePlanRestoreConfigSelectedApplicationsNamespacedNameArgs:
         pulumi.set(self, "namespace", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigSelectedNamespacesArgsDict(TypedDict):
-        namespaces: pulumi.Input[Sequence[pulumi.Input[str]]]
-        """
-        A list of Kubernetes Namespaces.
-        """
-elif False:
-    RestorePlanRestoreConfigSelectedNamespacesArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigSelectedNamespacesArgs:
     def __init__(__self__, *,
@@ -2223,32 +1645,6 @@ class RestorePlanRestoreConfigSelectedNamespacesArgs:
         pulumi.set(self, "namespaces", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigTransformationRuleArgsDict(TypedDict):
-        field_actions: pulumi.Input[Sequence[pulumi.Input['RestorePlanRestoreConfigTransformationRuleFieldActionArgsDict']]]
-        """
-        A list of transformation rule actions to take against candidate
-        resources. Actions are executed in order defined - this order
-        matters, as they could potentially interfere with each other and
-        the first operation could affect the outcome of the second operation.
-        Structure is documented below.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        The description is a user specified string description
-        of the transformation rule.
-        """
-        resource_filter: NotRequired[pulumi.Input['RestorePlanRestoreConfigTransformationRuleResourceFilterArgsDict']]
-        """
-        This field is used to specify a set of fields that should be used to
-        determine which resources in backup should be acted upon by the
-        supplied transformation rule actions, and this will ensure that only
-        specific resources are affected by transformation rule actions.
-        Structure is documented below.
-        """
-elif False:
-    RestorePlanRestoreConfigTransformationRuleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigTransformationRuleArgs:
     def __init__(__self__, *,
@@ -2321,31 +1717,6 @@ class RestorePlanRestoreConfigTransformationRuleArgs:
         pulumi.set(self, "resource_filter", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigTransformationRuleFieldActionArgsDict(TypedDict):
-        op: pulumi.Input[str]
-        """
-        Specifies the operation to perform.
-        Possible values are: `REMOVE`, `MOVE`, `COPY`, `ADD`, `TEST`, `REPLACE`.
-        """
-        from_path: NotRequired[pulumi.Input[str]]
-        """
-        A string containing a JSON Pointer value that references the
-        location in the target document to move the value from.
-        """
-        path: NotRequired[pulumi.Input[str]]
-        """
-        A string containing a JSON-Pointer value that references a
-        location within the target document where the operation is performed.
-        """
-        value: NotRequired[pulumi.Input[str]]
-        """
-        A string that specifies the desired value in string format
-        to use for transformation.
-        """
-elif False:
-    RestorePlanRestoreConfigTransformationRuleFieldActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigTransformationRuleFieldActionArgs:
     def __init__(__self__, *,
@@ -2424,37 +1795,6 @@ class RestorePlanRestoreConfigTransformationRuleFieldActionArgs:
         pulumi.set(self, "value", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigTransformationRuleResourceFilterArgsDict(TypedDict):
-        group_kinds: NotRequired[pulumi.Input[Sequence[pulumi.Input['RestorePlanRestoreConfigTransformationRuleResourceFilterGroupKindArgsDict']]]]
-        """
-        (Filtering parameter) Any resource subject to transformation must
-        belong to one of the listed "types". If this field is not provided,
-        no type filtering will be performed
-        (all resources of all types matching previous filtering parameters
-        will be candidates for transformation).
-        Structure is documented below.
-        """
-        json_path: NotRequired[pulumi.Input[str]]
-        """
-        This is a JSONPath expression that matches specific fields of
-        candidate resources and it operates as a filtering parameter
-        (resources that are not matched with this expression will not
-        be candidates for transformation).
-        """
-        namespaces: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        (Filtering parameter) Any resource subject to transformation must
-        be contained within one of the listed Kubernetes Namespace in the
-        Backup. If this field is not provided, no namespace filtering will
-        be performed (all resources in all Namespaces, including all
-        cluster-scoped resources, will be candidates for transformation).
-        To mix cluster-scoped and namespaced resources in the same rule,
-        use an empty string ("") as one of the target namespaces.
-        """
-elif False:
-    RestorePlanRestoreConfigTransformationRuleResourceFilterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigTransformationRuleResourceFilterArgs:
     def __init__(__self__, *,
@@ -2538,22 +1878,6 @@ class RestorePlanRestoreConfigTransformationRuleResourceFilterArgs:
         pulumi.set(self, "namespaces", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigTransformationRuleResourceFilterGroupKindArgsDict(TypedDict):
-        resource_group: NotRequired[pulumi.Input[str]]
-        """
-        API Group string of a Kubernetes resource, e.g.
-        "apiextensions.k8s.io", "storage.k8s.io", etc.
-        Use empty string for core group.
-        """
-        resource_kind: NotRequired[pulumi.Input[str]]
-        """
-        Kind of a Kubernetes resource, e.g.
-        "CustomResourceDefinition", "StorageClass", etc.
-        """
-elif False:
-    RestorePlanRestoreConfigTransformationRuleResourceFilterGroupKindArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigTransformationRuleResourceFilterGroupKindArgs:
     def __init__(__self__, *,
@@ -2599,24 +1923,6 @@ class RestorePlanRestoreConfigTransformationRuleResourceFilterGroupKindArgs:
         pulumi.set(self, "resource_kind", value)
 
 
-if not MYPY:
-    class RestorePlanRestoreConfigVolumeDataRestorePolicyBindingArgsDict(TypedDict):
-        policy: pulumi.Input[str]
-        """
-        Specifies the mechanism to be used to restore this volume data.
-        See https://cloud.google.com/kubernetes-engine/docs/add-on/backup-for-gke/reference/rest/v1/RestoreConfig#VolumeDataRestorePolicy
-        for more information on each policy option.
-        Possible values are: `RESTORE_VOLUME_DATA_FROM_BACKUP`, `REUSE_VOLUME_HANDLE_FROM_BACKUP`, `NO_VOLUME_DATA_RESTORATION`.
-        """
-        volume_type: pulumi.Input[str]
-        """
-        The volume type, as determined by the PVC's
-        bound PV, to apply the policy to.
-        Possible values are: `GCE_PERSISTENT_DISK`.
-        """
-elif False:
-    RestorePlanRestoreConfigVolumeDataRestorePolicyBindingArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class RestorePlanRestoreConfigVolumeDataRestorePolicyBindingArgs:
     def __init__(__self__, *,