pulumi-gcp 7.29.0a1719416802__py3-none-any.whl → 7.30.0__py3-none-any.whl

pulumi_gcp/gkebackup/_inputs.py

@@ -4,47 +4,128 @@
 
 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__, *,
@@ -180,6 +261,15 @@ 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__, *,
@@ -202,6 +292,16 @@ 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__, *,
@@ -226,6 +326,19 @@ 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__, *,
@@ -263,6 +376,15 @@ 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__, *,
@@ -285,6 +407,30 @@ 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__, *,
@@ -354,6 +500,28 @@ 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__, *,
@@ -410,6 +578,45 @@ 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__, *,
@@ -523,6 +730,16 @@ 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__, *,
@@ -548,6 +765,23 @@ 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__, *,
@@ -603,6 +837,27 @@ 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__, *,
@@ -674,6 +929,14 @@ 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__, *,
@@ -713,6 +976,14 @@ 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__, *,
@@ -752,6 +1023,41 @@ 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__, *,
@@ -843,6 +1149,14 @@ 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__, *,
@@ -882,6 +1196,14 @@ 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__, *,
@@ -921,6 +1243,96 @@ 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__, *,
@@ -1194,6 +1606,36 @@ 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__, *,
@@ -1283,6 +1725,22 @@ 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__, *,
@@ -1328,6 +1786,22 @@ 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__, *,
@@ -1373,6 +1847,15 @@ 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__, *,
@@ -1395,6 +1878,18 @@ 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__, *,
@@ -1423,6 +1918,23 @@ 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__, *,
@@ -1468,6 +1980,24 @@ 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__, *,
@@ -1517,6 +2047,22 @@ 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__, *,
@@ -1562,6 +2108,16 @@ 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__, *,
@@ -1586,6 +2142,19 @@ 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__, *,
@@ -1623,6 +2192,15 @@ 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__, *,
@@ -1645,6 +2223,32 @@ 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__, *,
@@ -1717,6 +2321,31 @@ 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__, *,
@@ -1795,6 +2424,37 @@ 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__, *,
@@ -1878,6 +2538,22 @@ 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__, *,
@@ -1923,6 +2599,24 @@ 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__, *,