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

pulumi_gcp/dataproc/_inputs.py

@@ -4,160 +4,329 @@
 
 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__ = [
     'AutoscalingPolicyBasicAlgorithmArgs',
+    'AutoscalingPolicyBasicAlgorithmArgsDict',
     'AutoscalingPolicyBasicAlgorithmYarnConfigArgs',
+    'AutoscalingPolicyBasicAlgorithmYarnConfigArgsDict',
     'AutoscalingPolicyIamBindingConditionArgs',
+    'AutoscalingPolicyIamBindingConditionArgsDict',
     'AutoscalingPolicyIamMemberConditionArgs',
+    'AutoscalingPolicyIamMemberConditionArgsDict',
     'AutoscalingPolicySecondaryWorkerConfigArgs',
+    'AutoscalingPolicySecondaryWorkerConfigArgsDict',
     'AutoscalingPolicyWorkerConfigArgs',
+    'AutoscalingPolicyWorkerConfigArgsDict',
     'ClusterClusterConfigArgs',
+    'ClusterClusterConfigArgsDict',
     'ClusterClusterConfigAutoscalingConfigArgs',
+    'ClusterClusterConfigAutoscalingConfigArgsDict',
     'ClusterClusterConfigAuxiliaryNodeGroupArgs',
+    'ClusterClusterConfigAuxiliaryNodeGroupArgsDict',
     'ClusterClusterConfigAuxiliaryNodeGroupNodeGroupArgs',
+    'ClusterClusterConfigAuxiliaryNodeGroupNodeGroupArgsDict',
     'ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigArgs',
+    'ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigArgsDict',
     'ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigAcceleratorArgs',
+    'ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigAcceleratorArgsDict',
     'ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigDiskConfigArgs',
+    'ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigDiskConfigArgsDict',
     'ClusterClusterConfigDataprocMetricConfigArgs',
+    'ClusterClusterConfigDataprocMetricConfigArgsDict',
     'ClusterClusterConfigDataprocMetricConfigMetricArgs',
+    'ClusterClusterConfigDataprocMetricConfigMetricArgsDict',
     'ClusterClusterConfigEncryptionConfigArgs',
+    'ClusterClusterConfigEncryptionConfigArgsDict',
     'ClusterClusterConfigEndpointConfigArgs',
+    'ClusterClusterConfigEndpointConfigArgsDict',
     'ClusterClusterConfigGceClusterConfigArgs',
+    'ClusterClusterConfigGceClusterConfigArgsDict',
     'ClusterClusterConfigGceClusterConfigNodeGroupAffinityArgs',
+    'ClusterClusterConfigGceClusterConfigNodeGroupAffinityArgsDict',
     'ClusterClusterConfigGceClusterConfigReservationAffinityArgs',
+    'ClusterClusterConfigGceClusterConfigReservationAffinityArgsDict',
     'ClusterClusterConfigGceClusterConfigShieldedInstanceConfigArgs',
+    'ClusterClusterConfigGceClusterConfigShieldedInstanceConfigArgsDict',
     'ClusterClusterConfigInitializationActionArgs',
+    'ClusterClusterConfigInitializationActionArgsDict',
     'ClusterClusterConfigLifecycleConfigArgs',
+    'ClusterClusterConfigLifecycleConfigArgsDict',
     'ClusterClusterConfigMasterConfigArgs',
+    'ClusterClusterConfigMasterConfigArgsDict',
     'ClusterClusterConfigMasterConfigAcceleratorArgs',
+    'ClusterClusterConfigMasterConfigAcceleratorArgsDict',
     'ClusterClusterConfigMasterConfigDiskConfigArgs',
+    'ClusterClusterConfigMasterConfigDiskConfigArgsDict',
     'ClusterClusterConfigMetastoreConfigArgs',
+    'ClusterClusterConfigMetastoreConfigArgsDict',
     'ClusterClusterConfigPreemptibleWorkerConfigArgs',
+    'ClusterClusterConfigPreemptibleWorkerConfigArgsDict',
     'ClusterClusterConfigPreemptibleWorkerConfigDiskConfigArgs',
+    'ClusterClusterConfigPreemptibleWorkerConfigDiskConfigArgsDict',
     'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgs',
+    'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgsDict',
     'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgs',
+    'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgsDict',
     'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgs',
+    'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgsDict',
     'ClusterClusterConfigSecurityConfigArgs',
+    'ClusterClusterConfigSecurityConfigArgsDict',
     'ClusterClusterConfigSecurityConfigKerberosConfigArgs',
+    'ClusterClusterConfigSecurityConfigKerberosConfigArgsDict',
     'ClusterClusterConfigSoftwareConfigArgs',
+    'ClusterClusterConfigSoftwareConfigArgsDict',
     'ClusterClusterConfigWorkerConfigArgs',
+    'ClusterClusterConfigWorkerConfigArgsDict',
     'ClusterClusterConfigWorkerConfigAcceleratorArgs',
+    'ClusterClusterConfigWorkerConfigAcceleratorArgsDict',
     'ClusterClusterConfigWorkerConfigDiskConfigArgs',
+    'ClusterClusterConfigWorkerConfigDiskConfigArgsDict',
     'ClusterIAMBindingConditionArgs',
+    'ClusterIAMBindingConditionArgsDict',
     'ClusterIAMMemberConditionArgs',
+    'ClusterIAMMemberConditionArgsDict',
     'ClusterVirtualClusterConfigArgs',
+    'ClusterVirtualClusterConfigArgsDict',
     'ClusterVirtualClusterConfigAuxiliaryServicesConfigArgs',
+    'ClusterVirtualClusterConfigAuxiliaryServicesConfigArgsDict',
     'ClusterVirtualClusterConfigAuxiliaryServicesConfigMetastoreConfigArgs',
+    'ClusterVirtualClusterConfigAuxiliaryServicesConfigMetastoreConfigArgsDict',
     'ClusterVirtualClusterConfigAuxiliaryServicesConfigSparkHistoryServerConfigArgs',
+    'ClusterVirtualClusterConfigAuxiliaryServicesConfigSparkHistoryServerConfigArgsDict',
     'ClusterVirtualClusterConfigKubernetesClusterConfigArgs',
+    'ClusterVirtualClusterConfigKubernetesClusterConfigArgsDict',
     'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigArgs',
+    'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigArgsDict',
     'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetArgs',
+    'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetArgsDict',
     'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigArgs',
+    'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigArgsDict',
     'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigAutoscalingArgs',
+    'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigAutoscalingArgsDict',
     'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigConfigArgs',
+    'ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigConfigArgsDict',
     'ClusterVirtualClusterConfigKubernetesClusterConfigKubernetesSoftwareConfigArgs',
+    'ClusterVirtualClusterConfigKubernetesClusterConfigKubernetesSoftwareConfigArgsDict',
     'JobHadoopConfigArgs',
+    'JobHadoopConfigArgsDict',
     'JobHadoopConfigLoggingConfigArgs',
+    'JobHadoopConfigLoggingConfigArgsDict',
     'JobHiveConfigArgs',
+    'JobHiveConfigArgsDict',
     'JobIAMBindingConditionArgs',
+    'JobIAMBindingConditionArgsDict',
     'JobIAMMemberConditionArgs',
+    'JobIAMMemberConditionArgsDict',
     'JobPigConfigArgs',
+    'JobPigConfigArgsDict',
     'JobPigConfigLoggingConfigArgs',
+    'JobPigConfigLoggingConfigArgsDict',
     'JobPlacementArgs',
+    'JobPlacementArgsDict',
     'JobPrestoConfigArgs',
+    'JobPrestoConfigArgsDict',
     'JobPrestoConfigLoggingConfigArgs',
+    'JobPrestoConfigLoggingConfigArgsDict',
     'JobPysparkConfigArgs',
+    'JobPysparkConfigArgsDict',
     'JobPysparkConfigLoggingConfigArgs',
+    'JobPysparkConfigLoggingConfigArgsDict',
     'JobReferenceArgs',
+    'JobReferenceArgsDict',
     'JobSchedulingArgs',
+    'JobSchedulingArgsDict',
     'JobSparkConfigArgs',
+    'JobSparkConfigArgsDict',
     'JobSparkConfigLoggingConfigArgs',
+    'JobSparkConfigLoggingConfigArgsDict',
     'JobSparksqlConfigArgs',
+    'JobSparksqlConfigArgsDict',
     'JobSparksqlConfigLoggingConfigArgs',
+    'JobSparksqlConfigLoggingConfigArgsDict',
     'JobStatusArgs',
+    'JobStatusArgsDict',
     'MetastoreFederationBackendMetastoreArgs',
+    'MetastoreFederationBackendMetastoreArgsDict',
     'MetastoreFederationIamBindingConditionArgs',
+    'MetastoreFederationIamBindingConditionArgsDict',
     'MetastoreFederationIamMemberConditionArgs',
+    'MetastoreFederationIamMemberConditionArgsDict',
     'MetastoreServiceEncryptionConfigArgs',
+    'MetastoreServiceEncryptionConfigArgsDict',
     'MetastoreServiceHiveMetastoreConfigArgs',
+    'MetastoreServiceHiveMetastoreConfigArgsDict',
     'MetastoreServiceHiveMetastoreConfigAuxiliaryVersionArgs',
+    'MetastoreServiceHiveMetastoreConfigAuxiliaryVersionArgsDict',
     'MetastoreServiceHiveMetastoreConfigKerberosConfigArgs',
+    'MetastoreServiceHiveMetastoreConfigKerberosConfigArgsDict',
     'MetastoreServiceHiveMetastoreConfigKerberosConfigKeytabArgs',
+    'MetastoreServiceHiveMetastoreConfigKerberosConfigKeytabArgsDict',
     'MetastoreServiceIamBindingConditionArgs',
+    'MetastoreServiceIamBindingConditionArgsDict',
     'MetastoreServiceIamMemberConditionArgs',
+    'MetastoreServiceIamMemberConditionArgsDict',
     'MetastoreServiceMaintenanceWindowArgs',
+    'MetastoreServiceMaintenanceWindowArgsDict',
     'MetastoreServiceMetadataIntegrationArgs',
+    'MetastoreServiceMetadataIntegrationArgsDict',
     'MetastoreServiceMetadataIntegrationDataCatalogConfigArgs',
+    'MetastoreServiceMetadataIntegrationDataCatalogConfigArgsDict',
     'MetastoreServiceNetworkConfigArgs',
+    'MetastoreServiceNetworkConfigArgsDict',
     'MetastoreServiceNetworkConfigConsumerArgs',
+    'MetastoreServiceNetworkConfigConsumerArgsDict',
     'MetastoreServiceScalingConfigArgs',
+    'MetastoreServiceScalingConfigArgsDict',
     'MetastoreServiceScalingConfigAutoscalingConfigArgs',
+    'MetastoreServiceScalingConfigAutoscalingConfigArgsDict',
     'MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs',
+    'MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgsDict',
     'MetastoreServiceScheduledBackupArgs',
+    'MetastoreServiceScheduledBackupArgsDict',
     'MetastoreServiceTelemetryConfigArgs',
+    'MetastoreServiceTelemetryConfigArgsDict',
     'WorkflowTemplateJobArgs',
+    'WorkflowTemplateJobArgsDict',
     'WorkflowTemplateJobHadoopJobArgs',
+    'WorkflowTemplateJobHadoopJobArgsDict',
     'WorkflowTemplateJobHadoopJobLoggingConfigArgs',
+    'WorkflowTemplateJobHadoopJobLoggingConfigArgsDict',
     'WorkflowTemplateJobHiveJobArgs',
+    'WorkflowTemplateJobHiveJobArgsDict',
     'WorkflowTemplateJobHiveJobQueryListArgs',
+    'WorkflowTemplateJobHiveJobQueryListArgsDict',
     'WorkflowTemplateJobPigJobArgs',
+    'WorkflowTemplateJobPigJobArgsDict',
     'WorkflowTemplateJobPigJobLoggingConfigArgs',
+    'WorkflowTemplateJobPigJobLoggingConfigArgsDict',
     'WorkflowTemplateJobPigJobQueryListArgs',
+    'WorkflowTemplateJobPigJobQueryListArgsDict',
     'WorkflowTemplateJobPrestoJobArgs',
+    'WorkflowTemplateJobPrestoJobArgsDict',
     'WorkflowTemplateJobPrestoJobLoggingConfigArgs',
+    'WorkflowTemplateJobPrestoJobLoggingConfigArgsDict',
     'WorkflowTemplateJobPrestoJobQueryListArgs',
+    'WorkflowTemplateJobPrestoJobQueryListArgsDict',
     'WorkflowTemplateJobPysparkJobArgs',
+    'WorkflowTemplateJobPysparkJobArgsDict',
     'WorkflowTemplateJobPysparkJobLoggingConfigArgs',
+    'WorkflowTemplateJobPysparkJobLoggingConfigArgsDict',
     'WorkflowTemplateJobSchedulingArgs',
+    'WorkflowTemplateJobSchedulingArgsDict',
     'WorkflowTemplateJobSparkJobArgs',
+    'WorkflowTemplateJobSparkJobArgsDict',
     'WorkflowTemplateJobSparkJobLoggingConfigArgs',
+    'WorkflowTemplateJobSparkJobLoggingConfigArgsDict',
     'WorkflowTemplateJobSparkRJobArgs',
+    'WorkflowTemplateJobSparkRJobArgsDict',
     'WorkflowTemplateJobSparkRJobLoggingConfigArgs',
+    'WorkflowTemplateJobSparkRJobLoggingConfigArgsDict',
     'WorkflowTemplateJobSparkSqlJobArgs',
+    'WorkflowTemplateJobSparkSqlJobArgsDict',
     'WorkflowTemplateJobSparkSqlJobLoggingConfigArgs',
+    'WorkflowTemplateJobSparkSqlJobLoggingConfigArgsDict',
     'WorkflowTemplateJobSparkSqlJobQueryListArgs',
+    'WorkflowTemplateJobSparkSqlJobQueryListArgsDict',
     'WorkflowTemplateParameterArgs',
+    'WorkflowTemplateParameterArgsDict',
     'WorkflowTemplateParameterValidationArgs',
+    'WorkflowTemplateParameterValidationArgsDict',
     'WorkflowTemplateParameterValidationRegexArgs',
+    'WorkflowTemplateParameterValidationRegexArgsDict',
     'WorkflowTemplateParameterValidationValuesArgs',
+    'WorkflowTemplateParameterValidationValuesArgsDict',
     'WorkflowTemplatePlacementArgs',
+    'WorkflowTemplatePlacementArgsDict',
     'WorkflowTemplatePlacementClusterSelectorArgs',
+    'WorkflowTemplatePlacementClusterSelectorArgsDict',
     'WorkflowTemplatePlacementManagedClusterArgs',
+    'WorkflowTemplatePlacementManagedClusterArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigAutoscalingConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigAutoscalingConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigEncryptionConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigEncryptionConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigEndpointConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigEndpointConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigNodeGroupAffinityArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigNodeGroupAffinityArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigReservationAffinityArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigReservationAffinityArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigShieldedInstanceConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigShieldedInstanceConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigNamespacedGkeDeploymentTargetArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigNamespacedGkeDeploymentTargetArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigInitializationActionArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigInitializationActionArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigLifecycleConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigLifecycleConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigMasterConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigMasterConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigMasterConfigAcceleratorArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigMasterConfigAcceleratorArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigMasterConfigDiskConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigMasterConfigDiskConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigMasterConfigManagedGroupConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigMasterConfigManagedGroupConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigMetastoreConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigMetastoreConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigAcceleratorArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigAcceleratorArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigDiskConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigDiskConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigManagedGroupConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigManagedGroupConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigSecurityConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigSecurityConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigSecurityConfigKerberosConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigSecurityConfigKerberosConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigSoftwareConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigSoftwareConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigWorkerConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigWorkerConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigWorkerConfigAcceleratorArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigWorkerConfigAcceleratorArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigWorkerConfigDiskConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigWorkerConfigDiskConfigArgsDict',
     'WorkflowTemplatePlacementManagedClusterConfigWorkerConfigManagedGroupConfigArgs',
+    'WorkflowTemplatePlacementManagedClusterConfigWorkerConfigManagedGroupConfigArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class AutoscalingPolicyBasicAlgorithmArgsDict(TypedDict):
+        yarn_config: pulumi.Input['AutoscalingPolicyBasicAlgorithmYarnConfigArgsDict']
+        """
+        YARN autoscaling configuration.
+        Structure is documented below.
+        """
+        cooldown_period: NotRequired[pulumi.Input[str]]
+        """
+        Duration between scaling events. A scaling period starts after the
+        update operation from the previous event has completed.
+        Bounds: [2m, 1d]. Default: 2m.
+        """
+elif False:
+    AutoscalingPolicyBasicAlgorithmArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AutoscalingPolicyBasicAlgorithmArgs:
     def __init__(__self__, *,
@@ -202,6 +371,52 @@ class AutoscalingPolicyBasicAlgorithmArgs:
         pulumi.set(self, "cooldown_period", value)
 
 
+if not MYPY:
+    class AutoscalingPolicyBasicAlgorithmYarnConfigArgsDict(TypedDict):
+        graceful_decommission_timeout: pulumi.Input[str]
+        """
+        Timeout for YARN graceful decommissioning of Node Managers. Specifies the
+        duration to wait for jobs to complete before forcefully removing workers
+        (and potentially interrupting jobs). Only applicable to downscaling operations.
+        Bounds: [0s, 1d].
+        """
+        scale_down_factor: pulumi.Input[float]
+        """
+        Fraction of average pending memory in the last cooldown period for which to
+        remove workers. A scale-down factor of 1 will result in scaling down so that there
+        is no available memory remaining after the update (more aggressive scaling).
+        A scale-down factor of 0 disables removing workers, which can be beneficial for
+        autoscaling a single job.
+        Bounds: [0.0, 1.0].
+        """
+        scale_up_factor: pulumi.Input[float]
+        """
+        Fraction of average pending memory in the last cooldown period for which to
+        add workers. A scale-up factor of 1.0 will result in scaling up so that there
+        is no pending memory remaining after the update (more aggressive scaling).
+        A scale-up factor closer to 0 will result in a smaller magnitude of scaling up
+        (less aggressive scaling).
+        Bounds: [0.0, 1.0].
+        """
+        scale_down_min_worker_fraction: NotRequired[pulumi.Input[float]]
+        """
+        Minimum scale-down threshold as a fraction of total cluster size before scaling occurs.
+        For example, in a 20-worker cluster, a threshold of 0.1 means the autoscaler must
+        recommend at least a 2 worker scale-down for the cluster to scale. A threshold of 0
+        means the autoscaler will scale down on any recommended change.
+        Bounds: [0.0, 1.0]. Default: 0.0.
+        """
+        scale_up_min_worker_fraction: NotRequired[pulumi.Input[float]]
+        """
+        Minimum scale-up threshold as a fraction of total cluster size before scaling
+        occurs. For example, in a 20-worker cluster, a threshold of 0.1 means the autoscaler
+        must recommend at least a 2-worker scale-up for the cluster to scale. A threshold of
+        0 means the autoscaler will scale up on any recommended change.
+        Bounds: [0.0, 1.0]. Default: 0.0.
+        """
+elif False:
+    AutoscalingPolicyBasicAlgorithmYarnConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AutoscalingPolicyBasicAlgorithmYarnConfigArgs:
     def __init__(__self__, *,
@@ -328,6 +543,14 @@ class AutoscalingPolicyBasicAlgorithmYarnConfigArgs:
         pulumi.set(self, "scale_up_min_worker_fraction", value)
 
 
+if not MYPY:
+    class AutoscalingPolicyIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    AutoscalingPolicyIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AutoscalingPolicyIamBindingConditionArgs:
     def __init__(__self__, *,
@@ -367,6 +590,14 @@ class AutoscalingPolicyIamBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class AutoscalingPolicyIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    AutoscalingPolicyIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AutoscalingPolicyIamMemberConditionArgs:
     def __init__(__self__, *,
@@ -406,6 +637,36 @@ class AutoscalingPolicyIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class AutoscalingPolicySecondaryWorkerConfigArgsDict(TypedDict):
+        max_instances: NotRequired[pulumi.Input[int]]
+        """
+        Maximum number of instances for this group. Note that by default, clusters will not use
+        secondary workers. Required for secondary workers if the minimum secondary instances is set.
+        Bounds: [minInstances, ). Defaults to 0.
+        """
+        min_instances: NotRequired[pulumi.Input[int]]
+        """
+        Minimum number of instances for this group. Bounds: [0, maxInstances]. Defaults to 0.
+        """
+        weight: NotRequired[pulumi.Input[int]]
+        """
+        Weight for the instance group, which is used to determine the fraction of total workers
+        in the cluster from this instance group. For example, if primary workers have weight 2,
+        and secondary workers have weight 1, the cluster will have approximately 2 primary workers
+        for each secondary worker.
+        The cluster may not reach the specified balance if constrained by min/max bounds or other
+        autoscaling settings. For example, if maxInstances for secondary workers is 0, then only
+        primary workers will be added. The cluster can also be out of balance when created.
+        If weight is not set on any instance group, the cluster will default to equal weight for
+        all groups: the cluster will attempt to maintain an equal number of workers in each group
+        within the configured size bounds for each group. If weight is set for one group only,
+        the cluster will default to zero weight on the unset group. For example if weight is set
+        only on primary workers, the cluster will use primary workers only and no secondary workers.
+        """
+elif False:
+    AutoscalingPolicySecondaryWorkerConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AutoscalingPolicySecondaryWorkerConfigArgs:
     def __init__(__self__, *,
@@ -487,6 +748,34 @@ class AutoscalingPolicySecondaryWorkerConfigArgs:
         pulumi.set(self, "weight", value)
 
 
+if not MYPY:
+    class AutoscalingPolicyWorkerConfigArgsDict(TypedDict):
+        max_instances: pulumi.Input[int]
+        """
+        Maximum number of instances for this group.
+        """
+        min_instances: NotRequired[pulumi.Input[int]]
+        """
+        Minimum number of instances for this group. Bounds: [2, maxInstances]. Defaults to 2.
+        """
+        weight: NotRequired[pulumi.Input[int]]
+        """
+        Weight for the instance group, which is used to determine the fraction of total workers
+        in the cluster from this instance group. For example, if primary workers have weight 2,
+        and secondary workers have weight 1, the cluster will have approximately 2 primary workers
+        for each secondary worker.
+        The cluster may not reach the specified balance if constrained by min/max bounds or other
+        autoscaling settings. For example, if maxInstances for secondary workers is 0, then only
+        primary workers will be added. The cluster can also be out of balance when created.
+        If weight is not set on any instance group, the cluster will default to equal weight for
+        all groups: the cluster will attempt to maintain an equal number of workers in each group
+        within the configured size bounds for each group. If weight is set for one group only,
+        the cluster will default to zero weight on the unset group. For example if weight is set
+        only on primary workers, the cluster will use primary workers only and no secondary workers.
+        """
+elif False:
+    AutoscalingPolicyWorkerConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AutoscalingPolicyWorkerConfigArgs:
     def __init__(__self__, *,
@@ -563,6 +852,108 @@ class AutoscalingPolicyWorkerConfigArgs:
         pulumi.set(self, "weight", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigArgsDict(TypedDict):
+        autoscaling_config: NotRequired[pulumi.Input['ClusterClusterConfigAutoscalingConfigArgsDict']]
+        """
+        The autoscaling policy config associated with the cluster.
+        Note that once set, if `autoscaling_config` is the only field set in `cluster_config`, it can
+        only be removed by setting `policy_uri = ""`, rather than removing the whole block.
+        Structure defined below.
+        """
+        auxiliary_node_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigAuxiliaryNodeGroupArgsDict']]]]
+        """
+        A Dataproc NodeGroup resource is a group of Dataproc cluster nodes that execute an assigned role. 
+        Structure defined below.
+        """
+        bucket: NotRequired[pulumi.Input[str]]
+        """
+        The name of the cloud storage bucket ultimately used to house the staging data
+        for the cluster. If `staging_bucket` is specified, it will contain this value, otherwise
+        it will be the auto generated name.
+        """
+        dataproc_metric_config: NotRequired[pulumi.Input['ClusterClusterConfigDataprocMetricConfigArgsDict']]
+        """
+        The Compute Engine accelerator (GPU) configuration for these instances. Can be specified multiple times.
+        Structure defined below.
+        """
+        encryption_config: NotRequired[pulumi.Input['ClusterClusterConfigEncryptionConfigArgsDict']]
+        """
+        The Customer managed encryption keys settings for the cluster.
+        Structure defined below.
+        """
+        endpoint_config: NotRequired[pulumi.Input['ClusterClusterConfigEndpointConfigArgsDict']]
+        """
+        The config settings for port access on the cluster.
+        Structure defined below.
+        """
+        gce_cluster_config: NotRequired[pulumi.Input['ClusterClusterConfigGceClusterConfigArgsDict']]
+        """
+        Common config settings for resources of Google Compute Engine cluster
+        instances, applicable to all instances in the cluster. Structure defined below.
+        """
+        initialization_actions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigInitializationActionArgsDict']]]]
+        """
+        Commands to execute on each node after config is completed.
+        You can specify multiple versions of these. Structure defined below.
+        """
+        lifecycle_config: NotRequired[pulumi.Input['ClusterClusterConfigLifecycleConfigArgsDict']]
+        """
+        The settings for auto deletion cluster schedule.
+        Structure defined below.
+        """
+        master_config: NotRequired[pulumi.Input['ClusterClusterConfigMasterConfigArgsDict']]
+        """
+        The Google Compute Engine config settings for the master instances
+        in a cluster. Structure defined below.
+        """
+        metastore_config: NotRequired[pulumi.Input['ClusterClusterConfigMetastoreConfigArgsDict']]
+        """
+        The config setting for metastore service with the cluster.
+        Structure defined below.
+        - - -
+        """
+        preemptible_worker_config: NotRequired[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigArgsDict']]
+        """
+        The Google Compute Engine config settings for the additional
+        instances in a cluster. Structure defined below.
+        * **NOTE** : `preemptible_worker_config` is
+        an alias for the api's [secondaryWorkerConfig](https://cloud.google.com/dataproc/docs/reference/rest/v1/ClusterConfig#InstanceGroupConfig). The name doesn't necessarily mean it is preemptible and is named as
+        such for legacy/compatibility reasons.
+        """
+        security_config: NotRequired[pulumi.Input['ClusterClusterConfigSecurityConfigArgsDict']]
+        """
+        Security related configuration. Structure defined below.
+        """
+        software_config: NotRequired[pulumi.Input['ClusterClusterConfigSoftwareConfigArgsDict']]
+        """
+        The config settings for software inside the cluster.
+        Structure defined below.
+        """
+        staging_bucket: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage staging bucket used to stage files,
+        such as Hadoop jars, between client machines and the cluster.
+        Note: If you don't explicitly specify a `staging_bucket`
+        then GCP will auto create / assign one for you. However, you are not guaranteed
+        an auto generated bucket which is solely dedicated to your cluster; it may be shared
+        with other clusters in the same region/zone also choosing to use the auto generation
+        option.
+        """
+        temp_bucket: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage temp bucket used to store ephemeral cluster
+        and jobs data, such as Spark and MapReduce history files.
+        Note: If you don't explicitly specify a `temp_bucket` then GCP will auto create / assign one for you.
+        """
+        worker_config: NotRequired[pulumi.Input['ClusterClusterConfigWorkerConfigArgsDict']]
+        """
+        The Google Compute Engine config settings for the worker instances
+        in a cluster. Structure defined below.
+        """
+elif False:
+    ClusterClusterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigArgs:
     def __init__(__self__, *,
@@ -900,6 +1291,23 @@ class ClusterClusterConfigArgs:
         pulumi.set(self, "worker_config", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigAutoscalingConfigArgsDict(TypedDict):
+        policy_uri: pulumi.Input[str]
+        """
+        The autoscaling policy used by the cluster.
+
+        Only resource names including projectid and location (region) are valid. Examples:
+
+        `https://www.googleapis.com/compute/v1/projects/[projectId]/locations/[dataproc_region]/autoscalingPolicies/[policy_id]`
+        `projects/[projectId]/locations/[dataproc_region]/autoscalingPolicies/[policy_id]`
+        Note that the policy must be in the same project and Cloud Dataproc region.
+
+        - - -
+        """
+elif False:
+    ClusterClusterConfigAutoscalingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigAutoscalingConfigArgs:
     def __init__(__self__, *,
@@ -938,6 +1346,19 @@ class ClusterClusterConfigAutoscalingConfigArgs:
         pulumi.set(self, "policy_uri", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigAuxiliaryNodeGroupArgsDict(TypedDict):
+        node_groups: pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigAuxiliaryNodeGroupNodeGroupArgsDict']]]
+        """
+        Node group configuration.
+        """
+        node_group_id: NotRequired[pulumi.Input[str]]
+        """
+        A node group ID. Generated if not specified. The ID must contain only letters (a-z, A-Z), numbers (0-9), underscores (_), and hyphens (-). Cannot begin or end with underscore or hyphen. Must consist of from 3 to 33 characters.
+        """
+elif False:
+    ClusterClusterConfigAuxiliaryNodeGroupArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigAuxiliaryNodeGroupArgs:
     def __init__(__self__, *,
@@ -976,6 +1397,24 @@ class ClusterClusterConfigAuxiliaryNodeGroupArgs:
         pulumi.set(self, "node_group_id", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupArgsDict(TypedDict):
+        roles: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Node group roles. 
+        One of `"DRIVER"`.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The Node group resource name.
+        """
+        node_group_config: NotRequired[pulumi.Input['ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigArgsDict']]
+        """
+        The node group instance group configuration.
+        """
+elif False:
+    ClusterClusterConfigAuxiliaryNodeGroupNodeGroupArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupArgs:
     def __init__(__self__, *,
@@ -1032,6 +1471,42 @@ class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupArgs:
         pulumi.set(self, "node_group_config", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigArgsDict(TypedDict):
+        accelerators: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigAcceleratorArgsDict']]]]
+        """
+        The Compute Engine accelerator (GPU) configuration for these instances. Can be specified 
+        multiple times.
+        """
+        disk_config: NotRequired[pulumi.Input['ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigDiskConfigArgsDict']]
+        """
+        Disk Config
+        """
+        instance_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of auxiliary node group instance names which have been assigned to the cluster.
+        """
+        machine_type: NotRequired[pulumi.Input[str]]
+        """
+        The name of a Google Compute Engine machine type
+        to create for the node group. If not specified, GCP will default to a predetermined
+        computed value (currently `n1-standard-4`).
+        """
+        min_cpu_platform: NotRequired[pulumi.Input[str]]
+        """
+        The name of a minimum generation of CPU family
+        for the node group. If not specified, GCP will default to a predetermined computed value
+        for each zone. See [the guide](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform)
+        for details about which CPU families are available (and defaulted) for each zone.
+        """
+        num_instances: NotRequired[pulumi.Input[int]]
+        """
+        Specifies the number of master nodes to create.
+        Please set a number greater than 0. Node Group must have at least 1 instance.
+        """
+elif False:
+    ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigArgs:
     def __init__(__self__, *,
@@ -1149,6 +1624,22 @@ class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigArgs:
         pulumi.set(self, "num_instances", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigAcceleratorArgsDict(TypedDict):
+        accelerator_count: pulumi.Input[int]
+        """
+        The number of the accelerator cards of this type exposed to this instance. Often restricted to one of `1`, `2`, `4`, or `8`.
+
+
+        - - -
+        """
+        accelerator_type: pulumi.Input[str]
+        """
+        The short name of the accelerator type to expose to this instance. For example, `nvidia-tesla-k80`.
+        """
+elif False:
+    ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigAcceleratorArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigAcceleratorArgs:
     def __init__(__self__, *,
@@ -1192,6 +1683,33 @@ class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigAcceleratorA
         pulumi.set(self, "accelerator_type", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigDiskConfigArgsDict(TypedDict):
+        boot_disk_size_gb: NotRequired[pulumi.Input[int]]
+        """
+        Size of the primary disk attached to each node, specified
+        in GB. The primary disk contains the boot volume and system libraries, and the
+        smallest allowed disk size is 10GB. GCP will default to a predetermined
+        computed value if not set (currently 500GB). Note: If SSDs are not
+        attached, it also contains the HDFS data blocks and Hadoop working directories.
+        """
+        boot_disk_type: NotRequired[pulumi.Input[str]]
+        """
+        The disk type of the primary disk attached to each node.
+        One of `"pd-ssd"` or `"pd-standard"`. Defaults to `"pd-standard"`.
+        """
+        local_ssd_interface: NotRequired[pulumi.Input[str]]
+        """
+        Interface type of local SSDs (default is "scsi"). Valid values: "scsi" (Small Computer System Interface), "nvme" (Non-Volatile Memory Express).
+        """
+        num_local_ssds: NotRequired[pulumi.Input[int]]
+        """
+        The amount of local SSD disks that will be attached to each master cluster node. 
+        Defaults to 0.
+        """
+elif False:
+    ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigDiskConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigDiskConfigArgs:
     def __init__(__self__, *,
@@ -1275,6 +1793,15 @@ class ClusterClusterConfigAuxiliaryNodeGroupNodeGroupNodeGroupConfigDiskConfigAr
         pulumi.set(self, "num_local_ssds", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigDataprocMetricConfigArgsDict(TypedDict):
+        metrics: pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigDataprocMetricConfigMetricArgsDict']]]
+        """
+        Metrics sources to enable.
+        """
+elif False:
+    ClusterClusterConfigDataprocMetricConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigDataprocMetricConfigArgs:
     def __init__(__self__, *,
@@ -1297,6 +1824,21 @@ class ClusterClusterConfigDataprocMetricConfigArgs:
         pulumi.set(self, "metrics", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigDataprocMetricConfigMetricArgsDict(TypedDict):
+        metric_source: pulumi.Input[str]
+        """
+        A source for the collection of Dataproc OSS metrics (see [available OSS metrics](https://cloud.google.com//dataproc/docs/guides/monitoring#available_oss_metrics)).
+        """
+        metric_overrides: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        One or more [available OSS metrics] (https://cloud.google.com/dataproc/docs/guides/monitoring#available_oss_metrics) to collect for the metric course.
+
+        - - -
+        """
+elif False:
+    ClusterClusterConfigDataprocMetricConfigMetricArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigDataprocMetricConfigMetricArgs:
     def __init__(__self__, *,
@@ -1339,6 +1881,18 @@ class ClusterClusterConfigDataprocMetricConfigMetricArgs:
         pulumi.set(self, "metric_overrides", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigEncryptionConfigArgsDict(TypedDict):
+        kms_key_name: pulumi.Input[str]
+        """
+        The Cloud KMS key name to use for PD disk encryption for
+        all instances in the cluster.
+
+        - - -
+        """
+elif False:
+    ClusterClusterConfigEncryptionConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigEncryptionConfigArgs:
     def __init__(__self__, *,
@@ -1367,6 +1921,21 @@ class ClusterClusterConfigEncryptionConfigArgs:
         pulumi.set(self, "kms_key_name", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigEndpointConfigArgsDict(TypedDict):
+        enable_http_port_access: pulumi.Input[bool]
+        """
+        The flag to enable http access to specific ports
+        on the cluster from external sources (aka Component Gateway). Defaults to false.
+        """
+        http_ports: NotRequired[pulumi.Input[Mapping[str, Any]]]
+        """
+        The map of port descriptions to URLs. Will only be populated if
+        `enable_http_port_access` is true.
+        """
+elif False:
+    ClusterClusterConfigEndpointConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigEndpointConfigArgs:
     def __init__(__self__, *,
@@ -1409,6 +1978,77 @@ class ClusterClusterConfigEndpointConfigArgs:
         pulumi.set(self, "http_ports", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigGceClusterConfigArgsDict(TypedDict):
+        internal_ip_only: NotRequired[pulumi.Input[bool]]
+        """
+        By default, clusters are not restricted to internal IP addresses,
+        and will have ephemeral external IP addresses assigned to each instance. If set to true, all
+        instances in the cluster will only have internal IP addresses. Note: Private Google Access
+        (also known as `privateIpGoogleAccess`) must be enabled on the subnetwork that the cluster
+        will be launched in.
+        """
+        metadata: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A map of the Compute Engine metadata entries to add to all instances
+        (see [Project and instance metadata](https://cloud.google.com/compute/docs/storing-retrieving-metadata#project_and_instance_metadata)).
+        """
+        network: NotRequired[pulumi.Input[str]]
+        """
+        The name or self_link of the Google Compute Engine
+        network to the cluster will be part of. Conflicts with `subnetwork`.
+        If neither is specified, this defaults to the "default" network.
+        """
+        node_group_affinity: NotRequired[pulumi.Input['ClusterClusterConfigGceClusterConfigNodeGroupAffinityArgsDict']]
+        """
+        Node Group Affinity for sole-tenant clusters.
+        """
+        reservation_affinity: NotRequired[pulumi.Input['ClusterClusterConfigGceClusterConfigReservationAffinityArgsDict']]
+        """
+        Reservation Affinity for consuming zonal reservation.
+        """
+        service_account: NotRequired[pulumi.Input[str]]
+        """
+        The service account to be used by the Node VMs.
+        If not specified, the "default" service account is used.
+        """
+        service_account_scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The set of Google API scopes
+        to be made available on all of the node VMs under the `service_account`
+        specified. Both OAuth2 URLs and gcloud
+        short names are supported. To allow full access to all Cloud APIs, use the
+        `cloud-platform` scope. See a complete list of scopes [here](https://cloud.google.com/sdk/gcloud/reference/alpha/compute/instances/set-scopes#--scopes).
+        """
+        shielded_instance_config: NotRequired[pulumi.Input['ClusterClusterConfigGceClusterConfigShieldedInstanceConfigArgsDict']]
+        """
+        Shielded Instance Config for clusters using [Compute Engine Shielded VMs](https://cloud.google.com/security/shielded-cloud/shielded-vm).
+
+        - - -
+        """
+        subnetwork: NotRequired[pulumi.Input[str]]
+        """
+        The name or self_link of the Google Compute Engine
+        subnetwork the cluster will be part of. Conflicts with `network`.
+        """
+        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of instance tags applied to instances in the cluster.
+        Tags are used to identify valid sources or targets for network firewalls.
+        """
+        zone: NotRequired[pulumi.Input[str]]
+        """
+        The GCP zone where your data is stored and used (i.e. where
+        the master and the worker nodes will be created in). If `region` is set to 'global' (default)
+        then `zone` is mandatory, otherwise GCP is able to make use of [Auto Zone Placement](https://cloud.google.com/dataproc/docs/concepts/auto-zone)
+        to determine this automatically for you.
+        Note: This setting additionally determines and restricts
+        which computing resources are available for use with other configs such as
+        `cluster_config.master_config.machine_type` and `cluster_config.worker_config.machine_type`.
+        """
+elif False:
+    ClusterClusterConfigGceClusterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigGceClusterConfigArgs:
     def __init__(__self__, *,
@@ -1636,6 +2276,15 @@ class ClusterClusterConfigGceClusterConfigArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigGceClusterConfigNodeGroupAffinityArgsDict(TypedDict):
+        node_group_uri: pulumi.Input[str]
+        """
+        The URI of a sole-tenant node group resource that the cluster will be created on.
+        """
+elif False:
+    ClusterClusterConfigGceClusterConfigNodeGroupAffinityArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigGceClusterConfigNodeGroupAffinityArgs:
     def __init__(__self__, *,
@@ -1658,6 +2307,23 @@ class ClusterClusterConfigGceClusterConfigNodeGroupAffinityArgs:
         pulumi.set(self, "node_group_uri", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigGceClusterConfigReservationAffinityArgsDict(TypedDict):
+        consume_reservation_type: NotRequired[pulumi.Input[str]]
+        """
+        Corresponds to the type of reservation consumption.
+        """
+        key: NotRequired[pulumi.Input[str]]
+        """
+        Corresponds to the label key of reservation resource.
+        """
+        values: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Corresponds to the label values of reservation resource.
+        """
+elif False:
+    ClusterClusterConfigGceClusterConfigReservationAffinityArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigGceClusterConfigReservationAffinityArgs:
     def __init__(__self__, *,
@@ -1713,6 +2379,25 @@ class ClusterClusterConfigGceClusterConfigReservationAffinityArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigGceClusterConfigShieldedInstanceConfigArgsDict(TypedDict):
+        enable_integrity_monitoring: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether instances have integrity monitoring enabled.
+
+        - - -
+        """
+        enable_secure_boot: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether instances have Secure Boot enabled.
+        """
+        enable_vtpm: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether instances have the [vTPM](https://cloud.google.com/security/shielded-cloud/shielded-vm#vtpm) enabled.
+        """
+elif False:
+    ClusterClusterConfigGceClusterConfigShieldedInstanceConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigGceClusterConfigShieldedInstanceConfigArgs:
     def __init__(__self__, *,
@@ -1772,6 +2457,24 @@ class ClusterClusterConfigGceClusterConfigShieldedInstanceConfigArgs:
         pulumi.set(self, "enable_vtpm", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigInitializationActionArgsDict(TypedDict):
+        script: pulumi.Input[str]
+        """
+        The script to be executed during initialization of the cluster.
+        The script must be a GCS file with a gs:// prefix.
+        """
+        timeout_sec: NotRequired[pulumi.Input[int]]
+        """
+        The maximum duration (in seconds) which `script` is
+        allowed to take to execute its action. GCP will default to a predetermined
+        computed value if not set (currently 300).
+
+        - - -
+        """
+elif False:
+    ClusterClusterConfigInitializationActionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigInitializationActionArgs:
     def __init__(__self__, *,
@@ -1820,6 +2523,29 @@ class ClusterClusterConfigInitializationActionArgs:
         pulumi.set(self, "timeout_sec", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigLifecycleConfigArgsDict(TypedDict):
+        auto_delete_time: NotRequired[pulumi.Input[str]]
+        """
+        The time when cluster will be auto-deleted.
+        A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds.
+        Example: "2014-10-02T15:01:23.045123456Z".
+
+        - - -
+        """
+        idle_delete_ttl: NotRequired[pulumi.Input[str]]
+        """
+        The duration to keep the cluster alive while idling
+        (no jobs running). After this TTL, the cluster will be deleted. Valid range: [10m, 14d].
+        """
+        idle_start_time: NotRequired[pulumi.Input[str]]
+        """
+        Time when the cluster became idle
+        (most recent job finished) and became eligible for deletion due to idleness.
+        """
+elif False:
+    ClusterClusterConfigLifecycleConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigLifecycleConfigArgs:
     def __init__(__self__, *,
@@ -1887,6 +2613,47 @@ class ClusterClusterConfigLifecycleConfigArgs:
         pulumi.set(self, "idle_start_time", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigMasterConfigArgsDict(TypedDict):
+        accelerators: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigMasterConfigAcceleratorArgsDict']]]]
+        """
+        The Compute Engine accelerator (GPU) configuration for these instances. Can be specified multiple times.
+        """
+        disk_config: NotRequired[pulumi.Input['ClusterClusterConfigMasterConfigDiskConfigArgsDict']]
+        """
+        Disk Config
+        """
+        image_uri: NotRequired[pulumi.Input[str]]
+        """
+        The URI for the image to use for this worker.  See [the guide](https://cloud.google.com/dataproc/docs/guides/dataproc-images)
+        for more information.
+        """
+        instance_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of master instance names which
+        have been assigned to the cluster.
+        """
+        machine_type: NotRequired[pulumi.Input[str]]
+        """
+        The name of a Google Compute Engine machine type
+        to create for the master. If not specified, GCP will default to a predetermined
+        computed value (currently `n1-standard-4`).
+        """
+        min_cpu_platform: NotRequired[pulumi.Input[str]]
+        """
+        The name of a minimum generation of CPU family
+        for the master. If not specified, GCP will default to a predetermined computed value
+        for each zone. See [the guide](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform)
+        for details about which CPU families are available (and defaulted) for each zone.
+        """
+        num_instances: NotRequired[pulumi.Input[int]]
+        """
+        Specifies the number of master nodes to create.
+        If not specified, GCP will default to a predetermined computed value (currently 1).
+        """
+elif False:
+    ClusterClusterConfigMasterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigMasterConfigArgs:
     def __init__(__self__, *,
@@ -2022,6 +2789,25 @@ class ClusterClusterConfigMasterConfigArgs:
         pulumi.set(self, "num_instances", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigMasterConfigAcceleratorArgsDict(TypedDict):
+        accelerator_count: pulumi.Input[int]
+        """
+        The number of the accelerator cards of this type exposed to this instance. Often restricted to one of `1`, `2`, `4`, or `8`.
+
+        > The Cloud Dataproc API can return unintuitive error messages when using accelerators; even when you have defined an accelerator, Auto Zone Placement does not exclusively select
+        zones that have that accelerator available. If you get a 400 error that the accelerator can't be found, this is a likely cause. Make sure you check [accelerator availability by zone](https://cloud.google.com/compute/docs/reference/rest/v1/acceleratorTypes/list)
+        if you are trying to use accelerators in a given zone.
+
+        - - -
+        """
+        accelerator_type: pulumi.Input[str]
+        """
+        The short name of the accelerator type to expose to this instance. For example, `nvidia-tesla-k80`.
+        """
+elif False:
+    ClusterClusterConfigMasterConfigAcceleratorArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigMasterConfigAcceleratorArgs:
     def __init__(__self__, *,
@@ -2064,12 +2850,42 @@ class ClusterClusterConfigMasterConfigAcceleratorArgs:
         """
         The short name of the accelerator type to expose to this instance. For example, `nvidia-tesla-k80`.
         """
-        return pulumi.get(self, "accelerator_type")
-
-    @accelerator_type.setter
-    def accelerator_type(self, value: pulumi.Input[str]):
-        pulumi.set(self, "accelerator_type", value)
-
+        return pulumi.get(self, "accelerator_type")
+
+    @accelerator_type.setter
+    def accelerator_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "accelerator_type", value)
+
+
+if not MYPY:
+    class ClusterClusterConfigMasterConfigDiskConfigArgsDict(TypedDict):
+        boot_disk_size_gb: NotRequired[pulumi.Input[int]]
+        """
+        Size of the primary disk attached to each node, specified
+        in GB. The primary disk contains the boot volume and system libraries, and the
+        smallest allowed disk size is 10GB. GCP will default to a predetermined
+        computed value if not set (currently 500GB). Note: If SSDs are not
+        attached, it also contains the HDFS data blocks and Hadoop working directories.
+        """
+        boot_disk_type: NotRequired[pulumi.Input[str]]
+        """
+        The disk type of the primary disk attached to each node.
+        One of `"pd-ssd"` or `"pd-standard"`. Defaults to `"pd-standard"`.
+        """
+        local_ssd_interface: NotRequired[pulumi.Input[str]]
+        """
+        Optional. Interface type of local SSDs (default is "scsi").
+        Valid values: "scsi" (Small Computer System Interface), "nvme" (Non-Volatile
+        Memory Express). See
+        [local SSD performance](https://cloud.google.com/compute/docs/disks/local-ssd#performance).
+        """
+        num_local_ssds: NotRequired[pulumi.Input[int]]
+        """
+        The amount of local SSD disks that will be
+        attached to each master cluster node. Defaults to 0.
+        """
+elif False:
+    ClusterClusterConfigMasterConfigDiskConfigArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ClusterClusterConfigMasterConfigDiskConfigArgs:
@@ -2160,6 +2976,19 @@ class ClusterClusterConfigMasterConfigDiskConfigArgs:
         pulumi.set(self, "num_local_ssds", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigMetastoreConfigArgsDict(TypedDict):
+        dataproc_metastore_service: pulumi.Input[str]
+        """
+        Resource name of an existing Dataproc Metastore service.
+
+        Only resource names including projectid and location (region) are valid. Examples:
+
+        `projects/[projectId]/locations/[dataproc_region]/services/[service-name]`
+        """
+elif False:
+    ClusterClusterConfigMetastoreConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigMetastoreConfigArgs:
     def __init__(__self__, *,
@@ -2190,6 +3019,37 @@ class ClusterClusterConfigMetastoreConfigArgs:
         pulumi.set(self, "dataproc_metastore_service", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigPreemptibleWorkerConfigArgsDict(TypedDict):
+        disk_config: NotRequired[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigDiskConfigArgsDict']]
+        """
+        Disk Config
+        """
+        instance_flexibility_policy: NotRequired[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgsDict']]
+        """
+        Instance flexibility Policy allowing a mixture of VM shapes and provisioning models.
+        """
+        instance_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of preemptible instance names which have been assigned
+        to the cluster.
+        """
+        num_instances: NotRequired[pulumi.Input[int]]
+        """
+        Specifies the number of preemptible nodes to create.
+        Defaults to 0.
+        """
+        preemptibility: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the preemptibility of the secondary workers. The default value is `PREEMPTIBLE`
+        Accepted values are:
+        * PREEMPTIBILITY_UNSPECIFIED
+        * NON_PREEMPTIBLE
+        * PREEMPTIBLE
+        """
+elif False:
+    ClusterClusterConfigPreemptibleWorkerConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigPreemptibleWorkerConfigArgs:
     def __init__(__self__, *,
@@ -2289,6 +3149,32 @@ class ClusterClusterConfigPreemptibleWorkerConfigArgs:
         pulumi.set(self, "preemptibility", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigPreemptibleWorkerConfigDiskConfigArgsDict(TypedDict):
+        boot_disk_size_gb: NotRequired[pulumi.Input[int]]
+        """
+        Size of the primary disk attached to each preemptible worker node, specified
+        in GB. The smallest allowed disk size is 10GB. GCP will default to a predetermined
+        computed value if not set (currently 500GB). Note: If SSDs are not
+        attached, it also contains the HDFS data blocks and Hadoop working directories.
+        """
+        boot_disk_type: NotRequired[pulumi.Input[str]]
+        """
+        The disk type of the primary disk attached to each preemptible worker node.
+        One of `"pd-ssd"` or `"pd-standard"`. Defaults to `"pd-standard"`.
+        """
+        local_ssd_interface: NotRequired[pulumi.Input[str]]
+        """
+        Interface type of local SSDs (default is "scsi"). Valid values: "scsi" (Small Computer System Interface), "nvme" (Non-Volatile Memory Express).
+        """
+        num_local_ssds: NotRequired[pulumi.Input[int]]
+        """
+        The amount of local SSD disks that will be
+        attached to each preemptible worker node. Defaults to 0.
+        """
+elif False:
+    ClusterClusterConfigPreemptibleWorkerConfigDiskConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigPreemptibleWorkerConfigDiskConfigArgs:
     def __init__(__self__, *,
@@ -2370,6 +3256,19 @@ class ClusterClusterConfigPreemptibleWorkerConfigDiskConfigArgs:
         pulumi.set(self, "num_local_ssds", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgsDict(TypedDict):
+        instance_selection_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgsDict']]]]
+        """
+        List of instance selection options that the group will use when creating new VMs.
+        """
+        instance_selection_results: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgsDict']]]]
+        """
+        A list of instance selection results in the group.
+        """
+elif False:
+    ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgs:
     def __init__(__self__, *,
@@ -2409,6 +3308,21 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgs:
         pulumi.set(self, "instance_selection_results", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgsDict(TypedDict):
+        machine_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Full machine-type names, e.g. `"n1-standard-16"`.
+        """
+        rank: NotRequired[pulumi.Input[int]]
+        """
+        Preference of this instance selection. A lower number means higher preference. Dataproc will first try to create a VM based on the machine-type with priority rank and fallback to next rank based on availability. Machine types and instance selections with the same priority have the same preference.
+
+        - - -
+        """
+elif False:
+    ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgs:
     def __init__(__self__, *,
@@ -2452,6 +3366,19 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstan
         pulumi.set(self, "rank", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgsDict(TypedDict):
+        machine_type: NotRequired[pulumi.Input[str]]
+        """
+        Full machine-type names, e.g. "n1-standard-16".
+        """
+        vm_count: NotRequired[pulumi.Input[int]]
+        """
+        Number of VM provisioned with the machine_type.
+        """
+elif False:
+    ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgs:
     def __init__(__self__, *,
@@ -2491,6 +3418,15 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstan
         pulumi.set(self, "vm_count", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigSecurityConfigArgsDict(TypedDict):
+        kerberos_config: pulumi.Input['ClusterClusterConfigSecurityConfigKerberosConfigArgsDict']
+        """
+        Kerberos Configuration
+        """
+elif False:
+    ClusterClusterConfigSecurityConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigSecurityConfigArgs:
     def __init__(__self__, *,
@@ -2513,6 +3449,89 @@ class ClusterClusterConfigSecurityConfigArgs:
         pulumi.set(self, "kerberos_config", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigSecurityConfigKerberosConfigArgsDict(TypedDict):
+        kms_key_uri: pulumi.Input[str]
+        """
+        The URI of the KMS key used to encrypt various sensitive files.
+        """
+        root_principal_password_uri: pulumi.Input[str]
+        """
+        The Cloud Storage URI of a KMS encrypted file
+        containing the root principal password.
+        """
+        cross_realm_trust_admin_server: NotRequired[pulumi.Input[str]]
+        """
+        The admin server (IP or hostname) for the
+        remote trusted realm in a cross realm trust relationship.
+        """
+        cross_realm_trust_kdc: NotRequired[pulumi.Input[str]]
+        """
+        The KDC (IP or hostname) for the
+        remote trusted realm in a cross realm trust relationship.
+        """
+        cross_realm_trust_realm: NotRequired[pulumi.Input[str]]
+        """
+        The remote realm the Dataproc on-cluster KDC will
+        trust, should the user enable cross realm trust.
+        """
+        cross_realm_trust_shared_password_uri: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS
+        encrypted file containing the shared password between the on-cluster Kerberos realm
+        and the remote trusted realm, in a cross realm trust relationship.
+        """
+        enable_kerberos: NotRequired[pulumi.Input[bool]]
+        """
+        Flag to indicate whether to Kerberize the cluster.
+        """
+        kdc_db_key_uri: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing
+        the master key of the KDC database.
+        """
+        key_password_uri: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing
+        the password to the user provided key. For the self-signed certificate, this password
+        is generated by Dataproc.
+        """
+        keystore_password_uri: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing
+        the password to the user provided keystore. For the self-signed certificated, the password
+        is generated by Dataproc.
+        """
+        keystore_uri: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of the keystore file used for SSL encryption.
+        If not provided, Dataproc will provide a self-signed certificate.
+        """
+        realm: NotRequired[pulumi.Input[str]]
+        """
+        The name of the on-cluster Kerberos realm. If not specified, the
+        uppercased domain of hostnames will be the realm.
+        """
+        tgt_lifetime_hours: NotRequired[pulumi.Input[int]]
+        """
+        The lifetime of the ticket granting ticket, in hours.
+        """
+        truststore_password_uri: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file
+        containing the password to the user provided truststore. For the self-signed
+        certificate, this password is generated by Dataproc.
+        """
+        truststore_uri: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of the truststore file used for
+        SSL encryption. If not provided, Dataproc will provide a self-signed certificate.
+
+        - - -
+        """
+elif False:
+    ClusterClusterConfigSecurityConfigKerberosConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigSecurityConfigKerberosConfigArgs:
     def __init__(__self__, *,
@@ -2794,6 +3813,37 @@ class ClusterClusterConfigSecurityConfigKerberosConfigArgs:
         pulumi.set(self, "truststore_uri", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigSoftwareConfigArgsDict(TypedDict):
+        image_version: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Dataproc image version to use
+        for the cluster - this controls the sets of software versions
+        installed onto the nodes when you create clusters. If not specified, defaults to the
+        latest version. For a list of valid versions see
+        [Cloud Dataproc versions](https://cloud.google.com/dataproc/docs/concepts/dataproc-versions)
+        """
+        optional_components: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The set of optional components to activate on the cluster. See [Available Optional Components](https://cloud.google.com/dataproc/docs/concepts/components/overview#available_optional_components).
+
+        - - -
+        """
+        override_properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A list of override and additional properties (key/value pairs)
+        used to modify various aspects of the common configuration files used when creating
+        a cluster. For a list of valid properties please see
+        [Cluster properties](https://cloud.google.com/dataproc/docs/concepts/cluster-properties)
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, Any]]]
+        """
+        A list of the properties used to set the daemon config files.
+        This will include any values supplied by the user via `cluster_config.software_config.override_properties`
+        """
+elif False:
+    ClusterClusterConfigSoftwareConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigSoftwareConfigArgs:
     def __init__(__self__, *,
@@ -2885,6 +3935,56 @@ class ClusterClusterConfigSoftwareConfigArgs:
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigWorkerConfigArgsDict(TypedDict):
+        accelerators: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigWorkerConfigAcceleratorArgsDict']]]]
+        """
+        The Compute Engine accelerator configuration for these instances. Can be specified multiple times.
+        """
+        disk_config: NotRequired[pulumi.Input['ClusterClusterConfigWorkerConfigDiskConfigArgsDict']]
+        """
+        Disk Config
+        """
+        image_uri: NotRequired[pulumi.Input[str]]
+        """
+        The URI for the image to use for this worker.  See [the guide](https://cloud.google.com/dataproc/docs/guides/dataproc-images)
+        for more information.
+        """
+        instance_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of worker instance names which have been assigned
+        to the cluster.
+        """
+        machine_type: NotRequired[pulumi.Input[str]]
+        """
+        The name of a Google Compute Engine machine type
+        to create for the worker nodes. If not specified, GCP will default to a predetermined
+        computed value (currently `n1-standard-4`).
+        """
+        min_cpu_platform: NotRequired[pulumi.Input[str]]
+        """
+        The name of a minimum generation of CPU family
+        for the master. If not specified, GCP will default to a predetermined computed value
+        for each zone. See [the guide](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform)
+        for details about which CPU families are available (and defaulted) for each zone.
+        """
+        min_num_instances: NotRequired[pulumi.Input[int]]
+        """
+        The minimum number of primary worker instances to create.  If `min_num_instances` is set, cluster creation will succeed if the number of primary workers created is at least equal to the `min_num_instances` number.
+        """
+        num_instances: NotRequired[pulumi.Input[int]]
+        """
+        Specifies the number of worker nodes to create.
+        If not specified, GCP will default to a predetermined computed value (currently 2).
+        There is currently a beta feature which allows you to run a
+        [Single Node Cluster](https://cloud.google.com/dataproc/docs/concepts/single-node-clusters).
+        In order to take advantage of this you need to set
+        `"dataproc:dataproc.allow.zero.workers" = "true"` in
+        `cluster_config.software_config.properties`
+        """
+elif False:
+    ClusterClusterConfigWorkerConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigWorkerConfigArgs:
     def __init__(__self__, *,
@@ -3046,6 +4146,25 @@ class ClusterClusterConfigWorkerConfigArgs:
         pulumi.set(self, "num_instances", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigWorkerConfigAcceleratorArgsDict(TypedDict):
+        accelerator_count: pulumi.Input[int]
+        """
+        The number of the accelerator cards of this type exposed to this instance. Often restricted to one of `1`, `2`, `4`, or `8`.
+
+        > The Cloud Dataproc API can return unintuitive error messages when using accelerators; even when you have defined an accelerator, Auto Zone Placement does not exclusively select
+        zones that have that accelerator available. If you get a 400 error that the accelerator can't be found, this is a likely cause. Make sure you check [accelerator availability by zone](https://cloud.google.com/compute/docs/reference/rest/v1/acceleratorTypes/list)
+        if you are trying to use accelerators in a given zone.
+
+        - - -
+        """
+        accelerator_type: pulumi.Input[str]
+        """
+        The short name of the accelerator type to expose to this instance. For example, `nvidia-tesla-k80`.
+        """
+elif False:
+    ClusterClusterConfigWorkerConfigAcceleratorArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigWorkerConfigAcceleratorArgs:
     def __init__(__self__, *,
@@ -3095,6 +4214,32 @@ class ClusterClusterConfigWorkerConfigAcceleratorArgs:
         pulumi.set(self, "accelerator_type", value)
 
 
+if not MYPY:
+    class ClusterClusterConfigWorkerConfigDiskConfigArgsDict(TypedDict):
+        boot_disk_size_gb: NotRequired[pulumi.Input[int]]
+        """
+        Size of the primary disk attached to each worker node, specified
+        in GB. The smallest allowed disk size is 10GB. GCP will default to a predetermined
+        computed value if not set (currently 500GB). Note: If SSDs are not
+        attached, it also contains the HDFS data blocks and Hadoop working directories.
+        """
+        boot_disk_type: NotRequired[pulumi.Input[str]]
+        """
+        The disk type of the primary disk attached to each node.
+        One of `"pd-ssd"` or `"pd-standard"`. Defaults to `"pd-standard"`.
+        """
+        local_ssd_interface: NotRequired[pulumi.Input[str]]
+        """
+        Interface type of local SSDs (default is "scsi"). Valid values: "scsi" (Small Computer System Interface), "nvme" (Non-Volatile Memory Express).
+        """
+        num_local_ssds: NotRequired[pulumi.Input[int]]
+        """
+        The amount of local SSD disks that will be
+        attached to each worker cluster node. Defaults to 0.
+        """
+elif False:
+    ClusterClusterConfigWorkerConfigDiskConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterClusterConfigWorkerConfigDiskConfigArgs:
     def __init__(__self__, *,
@@ -3176,6 +4321,14 @@ class ClusterClusterConfigWorkerConfigDiskConfigArgs:
         pulumi.set(self, "num_local_ssds", value)
 
 
+if not MYPY:
+    class ClusterIAMBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    ClusterIAMBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterIAMBindingConditionArgs:
     def __init__(__self__, *,
@@ -3215,6 +4368,14 @@ class ClusterIAMBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class ClusterIAMMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    ClusterIAMMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterIAMMemberConditionArgs:
     def __init__(__self__, *,
@@ -3254,6 +4415,32 @@ class ClusterIAMMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigArgsDict(TypedDict):
+        auxiliary_services_config: NotRequired[pulumi.Input['ClusterVirtualClusterConfigAuxiliaryServicesConfigArgsDict']]
+        """
+        Configuration of auxiliary services used by this cluster. 
+        Structure defined below.
+        """
+        kubernetes_cluster_config: NotRequired[pulumi.Input['ClusterVirtualClusterConfigKubernetesClusterConfigArgsDict']]
+        """
+        The configuration for running the Dataproc cluster on Kubernetes.
+        Structure defined below.
+        - - -
+        """
+        staging_bucket: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage staging bucket used to stage files,
+        such as Hadoop jars, between client machines and the cluster.
+        Note: If you don't explicitly specify a `staging_bucket`
+        then GCP will auto create / assign one for you. However, you are not guaranteed
+        an auto generated bucket which is solely dedicated to your cluster; it may be shared
+        with other clusters in the same region/zone also choosing to use the auto generation
+        option.
+        """
+elif False:
+    ClusterVirtualClusterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigArgs:
     def __init__(__self__, *,
@@ -3327,6 +4514,19 @@ class ClusterVirtualClusterConfigArgs:
         pulumi.set(self, "staging_bucket", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigAuxiliaryServicesConfigArgsDict(TypedDict):
+        metastore_config: NotRequired[pulumi.Input['ClusterVirtualClusterConfigAuxiliaryServicesConfigMetastoreConfigArgsDict']]
+        """
+        The Hive Metastore configuration for this workload.
+        """
+        spark_history_server_config: NotRequired[pulumi.Input['ClusterVirtualClusterConfigAuxiliaryServicesConfigSparkHistoryServerConfigArgsDict']]
+        """
+        The Spark History Server configuration for the workload.
+        """
+elif False:
+    ClusterVirtualClusterConfigAuxiliaryServicesConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigAuxiliaryServicesConfigArgs:
     def __init__(__self__, *,
@@ -3366,6 +4566,15 @@ class ClusterVirtualClusterConfigAuxiliaryServicesConfigArgs:
         pulumi.set(self, "spark_history_server_config", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigAuxiliaryServicesConfigMetastoreConfigArgsDict(TypedDict):
+        dataproc_metastore_service: NotRequired[pulumi.Input[str]]
+        """
+        Resource name of an existing Dataproc Metastore service.
+        """
+elif False:
+    ClusterVirtualClusterConfigAuxiliaryServicesConfigMetastoreConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigAuxiliaryServicesConfigMetastoreConfigArgs:
     def __init__(__self__, *,
@@ -3389,6 +4598,16 @@ class ClusterVirtualClusterConfigAuxiliaryServicesConfigMetastoreConfigArgs:
         pulumi.set(self, "dataproc_metastore_service", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigAuxiliaryServicesConfigSparkHistoryServerConfigArgsDict(TypedDict):
+        dataproc_cluster: NotRequired[pulumi.Input[str]]
+        """
+        Resource name of an existing Dataproc Cluster to act as a Spark History Server for the workload.
+        - - -
+        """
+elif False:
+    ClusterVirtualClusterConfigAuxiliaryServicesConfigSparkHistoryServerConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigAuxiliaryServicesConfigSparkHistoryServerConfigArgs:
     def __init__(__self__, *,
@@ -3414,6 +4633,26 @@ class ClusterVirtualClusterConfigAuxiliaryServicesConfigSparkHistoryServerConfig
         pulumi.set(self, "dataproc_cluster", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigKubernetesClusterConfigArgsDict(TypedDict):
+        gke_cluster_config: pulumi.Input['ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigArgsDict']
+        """
+        The configuration for running the Dataproc cluster on GKE.
+        """
+        kubernetes_software_config: pulumi.Input['ClusterVirtualClusterConfigKubernetesClusterConfigKubernetesSoftwareConfigArgsDict']
+        """
+        The software configuration for this Dataproc cluster running on Kubernetes.
+        """
+        kubernetes_namespace: NotRequired[pulumi.Input[str]]
+        """
+        A namespace within the Kubernetes cluster to deploy into. 
+        If this namespace does not exist, it is created.
+        If it  exists, Dataproc verifies that another Dataproc VirtualCluster is not installed into it.
+        If not specified, the name of the Dataproc Cluster is used.
+        """
+elif False:
+    ClusterVirtualClusterConfigKubernetesClusterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigKubernetesClusterConfigArgs:
     def __init__(__self__, *,
@@ -3473,6 +4712,22 @@ class ClusterVirtualClusterConfigKubernetesClusterConfigArgs:
         pulumi.set(self, "kubernetes_namespace", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigArgsDict(TypedDict):
+        gke_cluster_target: NotRequired[pulumi.Input[str]]
+        """
+        A target GKE cluster to deploy to. It must be in the same project and region as the Dataproc cluster 
+        (the GKE cluster can be zonal or regional)
+        """
+        node_pool_targets: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetArgsDict']]]]
+        """
+        GKE node pools where workloads will be scheduled. At least one node pool must be assigned the `DEFAULT` 
+        GkeNodePoolTarget.Role. If a GkeNodePoolTarget is not specified, Dataproc constructs a `DEFAULT` GkeNodePoolTarget.
+        Each role can be given to only one GkeNodePoolTarget. All node pools must have the same location settings.
+        """
+elif False:
+    ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigArgs:
     def __init__(__self__, *,
@@ -3518,6 +4773,27 @@ class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigArgs:
         pulumi.set(self, "node_pool_targets", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetArgsDict(TypedDict):
+        node_pool: pulumi.Input[str]
+        """
+        The target GKE node pool.
+        """
+        roles: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        The roles associated with the GKE node pool. 
+        One of `"DEFAULT"`, `"CONTROLLER"`, `"SPARK_DRIVER"` or `"SPARK_EXECUTOR"`.
+        """
+        node_pool_config: NotRequired[pulumi.Input['ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigArgsDict']]
+        """
+        The configuration for the GKE node pool. 
+        If specified, Dataproc attempts to create a node pool with the specified shape.
+        If one with the same name already exists, it is verified against all specified fields.
+        If a field differs, the virtual cluster creation will fail.
+        """
+elif False:
+    ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetArgs:
     def __init__(__self__, *,
@@ -3579,6 +4855,26 @@ class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePool
         pulumi.set(self, "node_pool_config", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigArgsDict(TypedDict):
+        locations: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        The list of Compute Engine zones where node pool nodes associated 
+        with a Dataproc on GKE virtual cluster will be located.
+        - - -
+        """
+        autoscaling: NotRequired[pulumi.Input['ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigAutoscalingArgsDict']]
+        """
+        The autoscaler configuration for this node pool. 
+        The autoscaler is enabled only when a valid configuration is present.
+        """
+        config: NotRequired[pulumi.Input['ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigConfigArgsDict']]
+        """
+        The node pool configuration.
+        """
+elif False:
+    ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigArgs:
     def __init__(__self__, *,
@@ -3639,6 +4935,19 @@ class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePool
         pulumi.set(self, "config", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigAutoscalingArgsDict(TypedDict):
+        max_node_count: NotRequired[pulumi.Input[int]]
+        """
+        The maximum number of nodes in the node pool. Must be >= minNodeCount, and must be > 0.
+        """
+        min_node_count: NotRequired[pulumi.Input[int]]
+        """
+        The minimum number of nodes in the node pool. Must be >= 0 and <= maxNodeCount.
+        """
+elif False:
+    ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigAutoscalingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigAutoscalingArgs:
     def __init__(__self__, *,
@@ -3678,6 +4987,36 @@ class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePool
         pulumi.set(self, "min_node_count", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigConfigArgsDict(TypedDict):
+        local_ssd_count: NotRequired[pulumi.Input[int]]
+        """
+        The number of local SSD disks to attach to the node, 
+        which is limited by the maximum number of disks allowable per zone.
+        """
+        machine_type: NotRequired[pulumi.Input[str]]
+        """
+        The name of a Compute Engine machine type.
+        """
+        min_cpu_platform: NotRequired[pulumi.Input[str]]
+        """
+        Minimum CPU platform to be used by this instance. 
+        The instance may be scheduled on the specified or a newer CPU platform.
+        Specify the friendly names of CPU platforms, such as "Intel Haswell" or "Intel Sandy Bridge".
+        """
+        preemptible: NotRequired[pulumi.Input[bool]]
+        """
+        Whether the nodes are created as preemptible VM instances. 
+        Preemptible nodes cannot be used in a node pool with the CONTROLLER role or in the DEFAULT node pool if the
+        CONTROLLER role is not assigned (the DEFAULT node pool will assume the CONTROLLER role).
+        """
+        spot: NotRequired[pulumi.Input[bool]]
+        """
+        Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
+        """
+elif False:
+    ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePoolTargetNodePoolConfigConfigArgs:
     def __init__(__self__, *,
@@ -3775,6 +5114,22 @@ class ClusterVirtualClusterConfigKubernetesClusterConfigGkeClusterConfigNodePool
         pulumi.set(self, "spot", value)
 
 
+if not MYPY:
+    class ClusterVirtualClusterConfigKubernetesClusterConfigKubernetesSoftwareConfigArgsDict(TypedDict):
+        component_version: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        The components that should be installed in this Dataproc cluster. The key must be a string from the   
+        KubernetesComponent enumeration. The value is the version of the software to be installed. At least one entry must be specified.
+        * **NOTE** : `component_version[SPARK]` is mandatory to set, or the creation of the cluster will fail.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The properties to set on daemon config files. Property keys are specified in prefix:property format, 
+        for example spark:spark.kubernetes.container.image.
+        """
+elif False:
+    ClusterVirtualClusterConfigKubernetesClusterConfigKubernetesSoftwareConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterVirtualClusterConfigKubernetesClusterConfigKubernetesSoftwareConfigArgs:
     def __init__(__self__, *,
@@ -3819,6 +5174,45 @@ class ClusterVirtualClusterConfigKubernetesClusterConfigKubernetesSoftwareConfig
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class JobHadoopConfigArgsDict(TypedDict):
+        archive_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of archives to be extracted in the working directory of .jar, .tar, .tar.gz, .tgz, and .zip.
+        """
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments to pass to the driver. Do not include arguments, such as -libjars or -Dfoo=bar, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        """
+        file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of files to be copied to the working directory of Hadoop drivers and distributed tasks. Useful for naively parallel tasks.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to add to the CLASSPATHs of the Spark driver and tasks.
+        """
+        logging_config: NotRequired[pulumi.Input['JobHadoopConfigLoggingConfigArgsDict']]
+        """
+        The runtime logging config of the job
+        """
+        main_class: NotRequired[pulumi.Input[str]]
+        """
+        The name of the driver's main class. The jar file containing the class must be in the default CLASSPATH or specified in `jar_file_uris`. Conflicts with `main_jar_file_uri`
+        """
+        main_jar_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the jar file containing the main class. Examples: 'gs://foo-bucket/analytics-binaries/extract-useful-metrics-mr.jar' 'hdfs:/tmp/test-samples/custom-wordcount.jar' 'file:///home/usr/lib/hadoop-mapreduce/hadoop-mapreduce-examples.jar'. Conflicts with `main_class`
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure Hadoop. Properties that conflict with values set by the Cloud Dataproc API may be overwritten. Can include properties set in `/etc/hadoop/conf/*-site` and classes in user code..
+
+        * `logging_config.driver_log_levels`- (Required) The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    JobHadoopConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobHadoopConfigArgs:
     def __init__(__self__, *,
@@ -3958,6 +5352,15 @@ class JobHadoopConfigArgs:
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class JobHadoopConfigLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        """
+elif False:
+    JobHadoopConfigLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobHadoopConfigLoggingConfigArgs:
     def __init__(__self__, *,
@@ -3980,6 +5383,37 @@ class JobHadoopConfigLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class JobHiveConfigArgsDict(TypedDict):
+        continue_on_failure: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to continue executing queries if a query fails. The default value is false. Setting to true can be useful when executing independent parallel queries. Defaults to false.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to add to the CLASSPATH of the Hive server and Hadoop MapReduce (MR) tasks. Can contain Hive SerDes and UDFs.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names and values, used to configure Hive. Properties that conflict with values set by the Cloud Dataproc API may be overwritten. Can include properties set in `/etc/hadoop/conf/*-site.xml`, `/etc/hive/conf/hive-site.xml`, and classes in user code..
+        """
+        query_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        HCFS URI of file containing Hive script to execute as the job.
+        Conflicts with `query_list`
+        """
+        query_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of Hive queries or statements to execute as part of the job.
+        Conflicts with `query_file_uri`
+        """
+        script_variables: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Mapping of query variable names to values (equivalent to the Hive command: `SET name="value";`).
+        """
+elif False:
+    JobHiveConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobHiveConfigArgs:
     def __init__(__self__, *,
@@ -4087,6 +5521,14 @@ class JobHiveConfigArgs:
         pulumi.set(self, "script_variables", value)
 
 
+if not MYPY:
+    class JobIAMBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    JobIAMBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobIAMBindingConditionArgs:
     def __init__(__self__, *,
@@ -4126,6 +5568,14 @@ class JobIAMBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class JobIAMMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    JobIAMMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobIAMMemberConditionArgs:
     def __init__(__self__, *,
@@ -4165,6 +5615,43 @@ class JobIAMMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class JobPigConfigArgsDict(TypedDict):
+        continue_on_failure: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to continue executing queries if a query fails. The default value is false. Setting to true can be useful when executing independent parallel queries. Defaults to false.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to add to the CLASSPATH of the Pig Client and Hadoop MapReduce (MR) tasks. Can contain Pig UDFs.
+
+        * `logging_config.driver_log_levels`- (Required) The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+        logging_config: NotRequired[pulumi.Input['JobPigConfigLoggingConfigArgsDict']]
+        """
+        The runtime logging config of the job
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure Pig. Properties that conflict with values set by the Cloud Dataproc API may be overwritten. Can include properties set in `/etc/hadoop/conf/*-site.xml`, `/etc/pig/conf/pig.properties`, and classes in user code.
+        """
+        query_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        HCFS URI of file containing Hive script to execute as the job.
+        Conflicts with `query_list`
+        """
+        query_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of Hive queries or statements to execute as part of the job.
+        Conflicts with `query_file_uri`
+        """
+        script_variables: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Mapping of query variable names to values (equivalent to the Pig command: `name=[value]`).
+        """
+elif False:
+    JobPigConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobPigConfigArgs:
     def __init__(__self__, *,
@@ -4292,6 +5779,15 @@ class JobPigConfigArgs:
         pulumi.set(self, "script_variables", value)
 
 
+if not MYPY:
+    class JobPigConfigLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        """
+elif False:
+    JobPigConfigLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobPigConfigLoggingConfigArgs:
     def __init__(__self__, *,
@@ -4314,6 +5810,19 @@ class JobPigConfigLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class JobPlacementArgsDict(TypedDict):
+        cluster_name: pulumi.Input[str]
+        """
+        The name of the cluster where the job will be submitted
+        """
+        cluster_uuid: NotRequired[pulumi.Input[str]]
+        """
+        Output-only. A cluster UUID generated by the Cloud Dataproc service when the job is submitted
+        """
+elif False:
+    JobPlacementArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobPlacementArgs:
     def __init__(__self__, *,
@@ -4352,6 +5861,43 @@ class JobPlacementArgs:
         pulumi.set(self, "cluster_uuid", value)
 
 
+if not MYPY:
+    class JobPrestoConfigArgsDict(TypedDict):
+        client_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Presto client tags to attach to this query.
+        """
+        continue_on_failure: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to continue executing queries if a query fails. Setting to true can be useful when executing independent parallel queries. Defaults to false.
+        """
+        logging_config: NotRequired[pulumi.Input['JobPrestoConfigLoggingConfigArgsDict']]
+        """
+        The runtime logging config of the job
+        """
+        output_format: NotRequired[pulumi.Input[str]]
+        """
+        The format in which query output will be displayed. See the Presto documentation for supported output formats.
+
+        * `logging_config.driver_log_levels`- (Required) The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values. Used to set Presto session properties Equivalent to using the --session flag in the Presto CLI.
+        """
+        query_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the script that contains SQL queries.
+        Conflicts with `query_list`
+        """
+        query_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of SQL queries or statements to execute as part of the job.
+        Conflicts with `query_file_uri`
+        """
+elif False:
+    JobPrestoConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobPrestoConfigArgs:
     def __init__(__self__, *,
@@ -4479,27 +6025,75 @@ class JobPrestoConfigArgs:
         pulumi.set(self, "query_lists", value)
 
 
+if not MYPY:
+    class JobPrestoConfigLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        """
+elif False:
+    JobPrestoConfigLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobPrestoConfigLoggingConfigArgs:
     def __init__(__self__, *,
                  driver_log_levels: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
         """
-        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] driver_log_levels: Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] driver_log_levels: Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        """
+        pulumi.set(__self__, "driver_log_levels", driver_log_levels)
+
+    @property
+    @pulumi.getter(name="driverLogLevels")
+    def driver_log_levels(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
+        """
+        Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        """
+        return pulumi.get(self, "driver_log_levels")
+
+    @driver_log_levels.setter
+    def driver_log_levels(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
+        pulumi.set(self, "driver_log_levels", value)
+
+
+if not MYPY:
+    class JobPysparkConfigArgsDict(TypedDict):
+        main_python_file_uri: pulumi.Input[str]
+        """
+        The HCFS URI of the main Python file to use as the driver. Must be a .py file.
+        """
+        archive_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of archives to be extracted in the working directory of .jar, .tar, .tar.gz, .tgz, and .zip.
+        """
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments to pass to the driver.
+        """
+        file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of files to be copied to the working directory of Python drivers and distributed tasks. Useful for naively parallel tasks.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
         """
-        pulumi.set(__self__, "driver_log_levels", driver_log_levels)
-
-    @property
-    @pulumi.getter(name="driverLogLevels")
-    def driver_log_levels(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
+        HCFS URIs of jar files to add to the CLASSPATHs of the Python driver and tasks.
         """
-        Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        logging_config: NotRequired[pulumi.Input['JobPysparkConfigLoggingConfigArgsDict']]
         """
-        return pulumi.get(self, "driver_log_levels")
-
-    @driver_log_levels.setter
-    def driver_log_levels(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
-        pulumi.set(self, "driver_log_levels", value)
+        The runtime logging config of the job
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure PySpark. Properties that conflict with values set by the Cloud Dataproc API may be overwritten. Can include properties set in `/etc/spark/conf/spark-defaults.conf` and classes in user code.
 
+        * `logging_config.driver_log_levels`- (Required) The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+        python_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS file URIs of Python files to pass to the PySpark framework. Supported file types: .py, .egg, and .zip.
+        """
+elif False:
+    JobPysparkConfigArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class JobPysparkConfigArgs:
@@ -4639,6 +6233,15 @@ class JobPysparkConfigArgs:
         pulumi.set(self, "python_file_uris", value)
 
 
+if not MYPY:
+    class JobPysparkConfigLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        """
+elif False:
+    JobPysparkConfigLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobPysparkConfigLoggingConfigArgs:
     def __init__(__self__, *,
@@ -4661,6 +6264,15 @@ class JobPysparkConfigLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class JobReferenceArgsDict(TypedDict):
+        job_id: NotRequired[pulumi.Input[str]]
+        """
+        The job ID, which must be unique within the project. The job ID is generated by the server upon job submission or provided by the user as a means to perform retries without creating duplicate jobs
+        """
+elif False:
+    JobReferenceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobReferenceArgs:
     def __init__(__self__, *,
@@ -4684,6 +6296,19 @@ class JobReferenceArgs:
         pulumi.set(self, "job_id", value)
 
 
+if not MYPY:
+    class JobSchedulingArgsDict(TypedDict):
+        max_failures_per_hour: pulumi.Input[int]
+        """
+        Maximum number of times per hour a driver may be restarted as a result of driver exiting with non-zero code before job is reported failed.
+        """
+        max_failures_total: pulumi.Input[int]
+        """
+        Maximum number of times in total a driver may be restarted as a result of driver exiting with non-zero code before job is reported failed.
+        """
+elif False:
+    JobSchedulingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobSchedulingArgs:
     def __init__(__self__, *,
@@ -4721,6 +6346,47 @@ class JobSchedulingArgs:
         pulumi.set(self, "max_failures_total", value)
 
 
+if not MYPY:
+    class JobSparkConfigArgsDict(TypedDict):
+        archive_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of archives to be extracted in the working directory of .jar, .tar, .tar.gz, .tgz, and .zip.
+        """
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments to pass to the driver.
+        """
+        file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of files to be copied to the working directory of Spark drivers and distributed tasks. Useful for naively parallel tasks.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to add to the CLASSPATHs of the Spark driver and tasks.
+        """
+        logging_config: NotRequired[pulumi.Input['JobSparkConfigLoggingConfigArgsDict']]
+        """
+        The runtime logging config of the job
+        """
+        main_class: NotRequired[pulumi.Input[str]]
+        """
+        The class containing the main method of the driver. Must be in a
+        provided jar or jar that is already on the classpath. Conflicts with `main_jar_file_uri`
+        """
+        main_jar_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of jar file containing
+        the driver jar. Conflicts with `main_class`
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure Spark. Properties that conflict with values set by the Cloud Dataproc API may be overwritten. Can include properties set in `/etc/spark/conf/spark-defaults.conf` and classes in user code.
+
+        * `logging_config.driver_log_levels`- (Required) The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    JobSparkConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobSparkConfigArgs:
     def __init__(__self__, *,
@@ -4864,6 +6530,15 @@ class JobSparkConfigArgs:
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class JobSparkConfigLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        """
+elif False:
+    JobSparkConfigLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobSparkConfigLoggingConfigArgs:
     def __init__(__self__, *,
@@ -4886,6 +6561,39 @@ class JobSparkConfigLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class JobSparksqlConfigArgsDict(TypedDict):
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to be added to the Spark CLASSPATH.
+
+        * `logging_config.driver_log_levels`- (Required) The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+        logging_config: NotRequired[pulumi.Input['JobSparksqlConfigLoggingConfigArgsDict']]
+        """
+        The runtime logging config of the job
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure Spark SQL's SparkConf. Properties that conflict with values set by the Cloud Dataproc API may be overwritten.
+        """
+        query_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the script that contains SQL queries.
+        Conflicts with `query_list`
+        """
+        query_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of SQL queries or statements to execute as part of the job.
+        Conflicts with `query_file_uri`
+        """
+        script_variables: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Mapping of query variable names to values (equivalent to the Spark SQL command: `SET name="value";`).
+        """
+elif False:
+    JobSparksqlConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobSparksqlConfigArgs:
     def __init__(__self__, *,
@@ -4997,6 +6705,15 @@ class JobSparksqlConfigArgs:
         pulumi.set(self, "script_variables", value)
 
 
+if not MYPY:
+    class JobSparksqlConfigLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Optional. The per-package log levels for the driver. This may include 'root' package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'.
+        """
+elif False:
+    JobSparksqlConfigLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobSparksqlConfigLoggingConfigArgs:
     def __init__(__self__, *,
@@ -5019,6 +6736,27 @@ class JobSparksqlConfigLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class JobStatusArgsDict(TypedDict):
+        details: NotRequired[pulumi.Input[str]]
+        """
+        Optional job state details, such as an error description if the state is ERROR.
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        A state message specifying the overall job state.
+        """
+        state_start_time: NotRequired[pulumi.Input[str]]
+        """
+        The time when this state was entered.
+        """
+        substate: NotRequired[pulumi.Input[str]]
+        """
+        Additional state information, which includes status reported by the agent.
+        """
+elif False:
+    JobStatusArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class JobStatusArgs:
     def __init__(__self__, *,
@@ -5090,6 +6828,26 @@ class JobStatusArgs:
         pulumi.set(self, "substate", value)
 
 
+if not MYPY:
+    class MetastoreFederationBackendMetastoreArgsDict(TypedDict):
+        metastore_type: pulumi.Input[str]
+        """
+        The type of the backend metastore.
+        Possible values are: `METASTORE_TYPE_UNSPECIFIED`, `DATAPROC_METASTORE`, `BIGQUERY`.
+
+        - - -
+        """
+        name: pulumi.Input[str]
+        """
+        The relative resource name of the metastore that is being federated. The formats of the relative resource names for the currently supported metastores are listed below: Dataplex: projects/{projectId}/locations/{location}/lakes/{lake_id} BigQuery: projects/{projectId} Dataproc Metastore: projects/{projectId}/locations/{location}/services/{serviceId}
+        """
+        rank: pulumi.Input[str]
+        """
+        The identifier for this object. Format specified above.
+        """
+elif False:
+    MetastoreFederationBackendMetastoreArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreFederationBackendMetastoreArgs:
     def __init__(__self__, *,
@@ -5148,6 +6906,14 @@ class MetastoreFederationBackendMetastoreArgs:
         pulumi.set(self, "rank", value)
 
 
+if not MYPY:
+    class MetastoreFederationIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    MetastoreFederationIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreFederationIamBindingConditionArgs:
     def __init__(__self__, *,
@@ -5187,6 +6953,14 @@ class MetastoreFederationIamBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class MetastoreFederationIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    MetastoreFederationIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreFederationIamMemberConditionArgs:
     def __init__(__self__, *,
@@ -5226,6 +7000,16 @@ class MetastoreFederationIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class MetastoreServiceEncryptionConfigArgsDict(TypedDict):
+        kms_key: pulumi.Input[str]
+        """
+        The fully qualified customer provided Cloud KMS key name to use for customer data encryption.
+        Use the following format: `projects/([^/]+)/locations/([^/]+)/keyRings/([^/]+)/cryptoKeys/([^/]+)`
+        """
+elif False:
+    MetastoreServiceEncryptionConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceEncryptionConfigArgs:
     def __init__(__self__, *,
@@ -5250,6 +7034,40 @@ class MetastoreServiceEncryptionConfigArgs:
         pulumi.set(self, "kms_key", value)
 
 
+if not MYPY:
+    class MetastoreServiceHiveMetastoreConfigArgsDict(TypedDict):
+        version: pulumi.Input[str]
+        """
+        The Hive metastore schema version.
+        """
+        auxiliary_versions: NotRequired[pulumi.Input[Sequence[pulumi.Input['MetastoreServiceHiveMetastoreConfigAuxiliaryVersionArgsDict']]]]
+        """
+        A mapping of Hive metastore version to the auxiliary version configuration.
+        When specified, a secondary Hive metastore service is created along with the primary service.
+        All auxiliary versions must be less than the service's primary version.
+        The key is the auxiliary service name and it must match the regular expression a-z?.
+        This means that the first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
+        Structure is documented below.
+        """
+        config_overrides: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of Hive metastore configuration key-value pairs to apply to the Hive metastore (configured in hive-site.xml).
+        The mappings override system defaults (some keys cannot be overridden)
+        """
+        endpoint_protocol: NotRequired[pulumi.Input[str]]
+        """
+        The protocol to use for the metastore service endpoint. If unspecified, defaults to `THRIFT`.
+        Default value is `THRIFT`.
+        Possible values are: `THRIFT`, `GRPC`.
+        """
+        kerberos_config: NotRequired[pulumi.Input['MetastoreServiceHiveMetastoreConfigKerberosConfigArgsDict']]
+        """
+        Information used to configure the Hive metastore service as a service principal in a Kerberos realm.
+        Structure is documented below.
+        """
+elif False:
+    MetastoreServiceHiveMetastoreConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceHiveMetastoreConfigArgs:
     def __init__(__self__, *,
@@ -5354,6 +7172,24 @@ class MetastoreServiceHiveMetastoreConfigArgs:
         pulumi.set(self, "kerberos_config", value)
 
 
+if not MYPY:
+    class MetastoreServiceHiveMetastoreConfigAuxiliaryVersionArgsDict(TypedDict):
+        key: pulumi.Input[str]
+        """
+        The identifier for this object. Format specified above.
+        """
+        version: pulumi.Input[str]
+        """
+        The Hive metastore version of the auxiliary service. It must be less than the primary Hive metastore service's version.
+        """
+        config_overrides: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of Hive metastore configuration key-value pairs to apply to the auxiliary Hive metastore (configured in hive-site.xml) in addition to the primary version's overrides.
+        If keys are present in both the auxiliary version's overrides and the primary version's overrides, the value from the auxiliary version's overrides takes precedence.
+        """
+elif False:
+    MetastoreServiceHiveMetastoreConfigAuxiliaryVersionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceHiveMetastoreConfigAuxiliaryVersionArgs:
     def __init__(__self__, *,
@@ -5409,6 +7245,24 @@ class MetastoreServiceHiveMetastoreConfigAuxiliaryVersionArgs:
         pulumi.set(self, "config_overrides", value)
 
 
+if not MYPY:
+    class MetastoreServiceHiveMetastoreConfigKerberosConfigArgsDict(TypedDict):
+        keytab: pulumi.Input['MetastoreServiceHiveMetastoreConfigKerberosConfigKeytabArgsDict']
+        """
+        A Kerberos keytab file that can be used to authenticate a service principal with a Kerberos Key Distribution Center (KDC).
+        Structure is documented below.
+        """
+        krb5_config_gcs_uri: pulumi.Input[str]
+        """
+        A Cloud Storage URI that specifies the path to a krb5.conf file. It is of the form gs://{bucket_name}/path/to/krb5.conf, although the file does not need to be named krb5.conf explicitly.
+        """
+        principal: pulumi.Input[str]
+        """
+        A Kerberos principal that exists in the both the keytab the KDC to authenticate as. A typical principal is of the form "primary/instance@REALM", but there is no exact format.
+        """
+elif False:
+    MetastoreServiceHiveMetastoreConfigKerberosConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceHiveMetastoreConfigKerberosConfigArgs:
     def __init__(__self__, *,
@@ -5463,6 +7317,16 @@ class MetastoreServiceHiveMetastoreConfigKerberosConfigArgs:
         pulumi.set(self, "principal", value)
 
 
+if not MYPY:
+    class MetastoreServiceHiveMetastoreConfigKerberosConfigKeytabArgsDict(TypedDict):
+        cloud_secret: pulumi.Input[str]
+        """
+        The relative resource name of a Secret Manager secret version, in the following form:
+        "projects/{projectNumber}/secrets/{secret_id}/versions/{version_id}".
+        """
+elif False:
+    MetastoreServiceHiveMetastoreConfigKerberosConfigKeytabArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceHiveMetastoreConfigKerberosConfigKeytabArgs:
     def __init__(__self__, *,
@@ -5487,6 +7351,14 @@ class MetastoreServiceHiveMetastoreConfigKerberosConfigKeytabArgs:
         pulumi.set(self, "cloud_secret", value)
 
 
+if not MYPY:
+    class MetastoreServiceIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    MetastoreServiceIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceIamBindingConditionArgs:
     def __init__(__self__, *,
@@ -5526,6 +7398,14 @@ class MetastoreServiceIamBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class MetastoreServiceIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    MetastoreServiceIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceIamMemberConditionArgs:
     def __init__(__self__, *,
@@ -5565,6 +7445,20 @@ class MetastoreServiceIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class MetastoreServiceMaintenanceWindowArgsDict(TypedDict):
+        day_of_week: pulumi.Input[str]
+        """
+        The day of week, when the window starts.
+        Possible values are: `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`.
+        """
+        hour_of_day: pulumi.Input[int]
+        """
+        The hour of day (0-23) when the window starts.
+        """
+elif False:
+    MetastoreServiceMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceMaintenanceWindowArgs:
     def __init__(__self__, *,
@@ -5604,6 +7498,16 @@ class MetastoreServiceMaintenanceWindowArgs:
         pulumi.set(self, "hour_of_day", value)
 
 
+if not MYPY:
+    class MetastoreServiceMetadataIntegrationArgsDict(TypedDict):
+        data_catalog_config: pulumi.Input['MetastoreServiceMetadataIntegrationDataCatalogConfigArgsDict']
+        """
+        The integration config for the Data Catalog service.
+        Structure is documented below.
+        """
+elif False:
+    MetastoreServiceMetadataIntegrationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceMetadataIntegrationArgs:
     def __init__(__self__, *,
@@ -5628,6 +7532,15 @@ class MetastoreServiceMetadataIntegrationArgs:
         pulumi.set(self, "data_catalog_config", value)
 
 
+if not MYPY:
+    class MetastoreServiceMetadataIntegrationDataCatalogConfigArgsDict(TypedDict):
+        enabled: pulumi.Input[bool]
+        """
+        Defines whether the metastore metadata should be synced to Data Catalog. The default value is to disable syncing metastore metadata to Data Catalog.
+        """
+elif False:
+    MetastoreServiceMetadataIntegrationDataCatalogConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceMetadataIntegrationDataCatalogConfigArgs:
     def __init__(__self__, *,
@@ -5650,6 +7563,20 @@ class MetastoreServiceMetadataIntegrationDataCatalogConfigArgs:
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class MetastoreServiceNetworkConfigArgsDict(TypedDict):
+        consumers: pulumi.Input[Sequence[pulumi.Input['MetastoreServiceNetworkConfigConsumerArgsDict']]]
+        """
+        The consumer-side network configuration for the Dataproc Metastore instance.
+        Structure is documented below.
+        """
+        custom_routes_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Enables custom routes to be imported and exported for the Dataproc Metastore service's peered VPC network.
+        """
+elif False:
+    MetastoreServiceNetworkConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceNetworkConfigArgs:
     def __init__(__self__, *,
@@ -5690,6 +7617,23 @@ class MetastoreServiceNetworkConfigArgs:
         pulumi.set(self, "custom_routes_enabled", value)
 
 
+if not MYPY:
+    class MetastoreServiceNetworkConfigConsumerArgsDict(TypedDict):
+        subnetwork: pulumi.Input[str]
+        """
+        The subnetwork of the customer project from which an IP address is reserved and used as the Dataproc Metastore service's endpoint.
+        It is accessible to hosts in the subnet and to all hosts in a subnet in the same region and same network.
+        There must be at least one IP address available in the subnet's primary range. The subnet is specified in the following form:
+        `projects/{projectNumber}/regions/{region_id}/subnetworks/{subnetwork_id}
+        """
+        endpoint_uri: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The URI of the endpoint used to access the metastore service.
+        """
+elif False:
+    MetastoreServiceNetworkConfigConsumerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceNetworkConfigConsumerArgs:
     def __init__(__self__, *,
@@ -5736,6 +7680,25 @@ class MetastoreServiceNetworkConfigConsumerArgs:
         pulumi.set(self, "endpoint_uri", value)
 
 
+if not MYPY:
+    class MetastoreServiceScalingConfigArgsDict(TypedDict):
+        autoscaling_config: NotRequired[pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigArgsDict']]
+        """
+        Represents the autoscaling configuration of a metastore service.
+        Structure is documented below.
+        """
+        instance_size: NotRequired[pulumi.Input[str]]
+        """
+        Metastore instance sizes.
+        Possible values are: `EXTRA_SMALL`, `SMALL`, `MEDIUM`, `LARGE`, `EXTRA_LARGE`.
+        """
+        scaling_factor: NotRequired[pulumi.Input[float]]
+        """
+        Scaling factor, in increments of 0.1 for values less than 1.0, and increments of 1.0 for values greater than 1.0.
+        """
+elif False:
+    MetastoreServiceScalingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceScalingConfigArgs:
     def __init__(__self__, *,
@@ -5795,6 +7758,20 @@ class MetastoreServiceScalingConfigArgs:
         pulumi.set(self, "scaling_factor", value)
 
 
+if not MYPY:
+    class MetastoreServiceScalingConfigAutoscalingConfigArgsDict(TypedDict):
+        autoscaling_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether autoscaling is enabled. The default value is false.
+        """
+        limit_config: NotRequired[pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgsDict']]
+        """
+        Represents the limit configuration of a metastore service.
+        Structure is documented below.
+        """
+elif False:
+    MetastoreServiceScalingConfigAutoscalingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceScalingConfigAutoscalingConfigArgs:
     def __init__(__self__, *,
@@ -5836,6 +7813,19 @@ class MetastoreServiceScalingConfigAutoscalingConfigArgs:
         pulumi.set(self, "limit_config", value)
 
 
+if not MYPY:
+    class MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgsDict(TypedDict):
+        max_scaling_factor: NotRequired[pulumi.Input[float]]
+        """
+        The maximum scaling factor that the service will autoscale to. The default value is 6.0.
+        """
+        min_scaling_factor: NotRequired[pulumi.Input[float]]
+        """
+        The minimum scaling factor that the service will autoscale to. The default value is 0.1.
+        """
+elif False:
+    MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs:
     def __init__(__self__, *,
@@ -5875,6 +7865,27 @@ class MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs:
         pulumi.set(self, "min_scaling_factor", value)
 
 
+if not MYPY:
+    class MetastoreServiceScheduledBackupArgsDict(TypedDict):
+        backup_location: pulumi.Input[str]
+        """
+        A Cloud Storage URI of a folder, in the format gs://<bucket_name>/<path_inside_bucket>. A sub-folder <backup_folder> containing backup files will be stored below it.
+        """
+        cron_schedule: NotRequired[pulumi.Input[str]]
+        """
+        The scheduled interval in Cron format, see https://en.wikipedia.org/wiki/Cron The default is empty: scheduled backup is not enabled. Must be specified to enable scheduled backups.
+        """
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether the scheduled backup is enabled. The default value is false.
+        """
+        time_zone: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the time zone to be used when interpreting cronSchedule. Must be a time zone name from the time zone database (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones), e.g. America/Los_Angeles or Africa/Abidjan. If left unspecified, the default is UTC.
+        """
+elif False:
+    MetastoreServiceScheduledBackupArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceScheduledBackupArgs:
     def __init__(__self__, *,
@@ -5945,6 +7956,17 @@ class MetastoreServiceScheduledBackupArgs:
         pulumi.set(self, "time_zone", value)
 
 
+if not MYPY:
+    class MetastoreServiceTelemetryConfigArgsDict(TypedDict):
+        log_format: NotRequired[pulumi.Input[str]]
+        """
+        The output format of the Dataproc Metastore service's logs.
+        Default value is `JSON`.
+        Possible values are: `LEGACY`, `JSON`.
+        """
+elif False:
+    MetastoreServiceTelemetryConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetastoreServiceTelemetryConfigArgs:
     def __init__(__self__, *,
@@ -5972,6 +7994,59 @@ class MetastoreServiceTelemetryConfigArgs:
         pulumi.set(self, "log_format", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobArgsDict(TypedDict):
+        step_id: pulumi.Input[str]
+        """
+        Required. The step id. The id must be unique among all jobs within the template. The step id is used as prefix for job id, as job `goog-dataproc-workflow-step-id` label, and in field from other steps. The id must contain only letters (a-z, A-Z), numbers (0-9), underscores (_), and hyphens (-). Cannot begin or end with underscore or hyphen. Must consist of between 3 and 50 characters.
+        """
+        hadoop_job: NotRequired[pulumi.Input['WorkflowTemplateJobHadoopJobArgsDict']]
+        """
+        Job is a Hadoop job.
+        """
+        hive_job: NotRequired[pulumi.Input['WorkflowTemplateJobHiveJobArgsDict']]
+        """
+        Job is a Hive job.
+        """
+        labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The labels to associate with this job. Label keys must be between 1 and 63 characters long, and must conform to the following regular expression: {0,63} No more than 32 labels can be associated with a given job.
+        """
+        pig_job: NotRequired[pulumi.Input['WorkflowTemplateJobPigJobArgsDict']]
+        """
+        Job is a Pig job.
+        """
+        prerequisite_step_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The optional list of prerequisite job step_ids. If not specified, the job will start at the beginning of workflow.
+        """
+        presto_job: NotRequired[pulumi.Input['WorkflowTemplateJobPrestoJobArgsDict']]
+        """
+        Job is a Presto job.
+        """
+        pyspark_job: NotRequired[pulumi.Input['WorkflowTemplateJobPysparkJobArgsDict']]
+        """
+        Job is a PySpark job.
+        """
+        scheduling: NotRequired[pulumi.Input['WorkflowTemplateJobSchedulingArgsDict']]
+        """
+        Job scheduling configuration.
+        """
+        spark_job: NotRequired[pulumi.Input['WorkflowTemplateJobSparkJobArgsDict']]
+        """
+        Job is a Spark job.
+        """
+        spark_r_job: NotRequired[pulumi.Input['WorkflowTemplateJobSparkRJobArgsDict']]
+        """
+        Job is a SparkR job.
+        """
+        spark_sql_job: NotRequired[pulumi.Input['WorkflowTemplateJobSparkSqlJobArgsDict']]
+        """
+        Job is a SparkSql job.
+        """
+elif False:
+    WorkflowTemplateJobArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobArgs:
     def __init__(__self__, *,
@@ -6170,6 +8245,43 @@ class WorkflowTemplateJobArgs:
         pulumi.set(self, "spark_sql_job", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobHadoopJobArgsDict(TypedDict):
+        archive_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of archives to be extracted in the working directory of Hadoop drivers and tasks. Supported file types: .jar, .tar, .tar.gz, .tgz, or .zip.
+        """
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments to pass to the driver. Do not include arguments, such as `-libjars` or `-Dfoo=bar`, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        """
+        file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS (Hadoop Compatible Filesystem) URIs of files to be copied to the working directory of Hadoop drivers and distributed tasks. Useful for naively parallel tasks.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Jar file URIs to add to the CLASSPATHs of the Hadoop driver and tasks.
+        """
+        logging_config: NotRequired[pulumi.Input['WorkflowTemplateJobHadoopJobLoggingConfigArgsDict']]
+        """
+        The runtime log config for job execution.
+        """
+        main_class: NotRequired[pulumi.Input[str]]
+        """
+        The name of the driver's main class. The jar file containing the class must be in the default CLASSPATH or specified in `jar_file_uris`.
+        """
+        main_jar_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the jar file containing the main class. Examples: 'gs://foo-bucket/analytics-binaries/extract-useful-metrics-mr.jar' 'hdfs:/tmp/test-samples/custom-wordcount.jar' 'file:///home/usr/lib/hadoop-mapreduce/hadoop-mapreduce-examples.jar'
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure Hadoop. Properties that conflict with values set by the Dataproc API may be overwritten. Can include properties set in /etc/hadoop/conf/*-site and classes in user code.
+        """
+elif False:
+    WorkflowTemplateJobHadoopJobArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobHadoopJobArgs:
     def __init__(__self__, *,
@@ -6305,6 +8417,15 @@ class WorkflowTemplateJobHadoopJobArgs:
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobHadoopJobLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    WorkflowTemplateJobHadoopJobLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobHadoopJobLoggingConfigArgs:
     def __init__(__self__, *,
@@ -6328,6 +8449,35 @@ class WorkflowTemplateJobHadoopJobLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobHiveJobArgsDict(TypedDict):
+        continue_on_failure: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to continue executing queries if a query fails. The default value is `false`. Setting to `true` can be useful when executing independent parallel queries.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to add to the CLASSPATH of the Hive server and Hadoop MapReduce (MR) tasks. Can contain Hive SerDes and UDFs.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names and values, used to configure Hive. Properties that conflict with values set by the Dataproc API may be overwritten. Can include properties set in /etc/hadoop/conf/*-site.xml, /etc/hive/conf/hive-site.xml, and classes in user code.
+        """
+        query_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the script that contains Hive queries.
+        """
+        query_list: NotRequired[pulumi.Input['WorkflowTemplateJobHiveJobQueryListArgsDict']]
+        """
+        A list of queries.
+        """
+        script_variables: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Mapping of query variable names to values (equivalent to the Hive command: `SET name="value";`).
+        """
+elif False:
+    WorkflowTemplateJobHiveJobArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobHiveJobArgs:
     def __init__(__self__, *,
@@ -6431,6 +8581,15 @@ class WorkflowTemplateJobHiveJobArgs:
         pulumi.set(self, "script_variables", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobHiveJobQueryListArgsDict(TypedDict):
+        queries: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Required. The queries to execute. You do not need to end a query expression with a semicolon. Multiple queries can be specified in one string by separating each with a semicolon. Here is an example of a Dataproc API snippet that uses a QueryList to specify a HiveJob: "hiveJob": { "queryList": { "queries": } }
+        """
+elif False:
+    WorkflowTemplateJobHiveJobQueryListArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobHiveJobQueryListArgs:
     def __init__(__self__, *,
@@ -6453,6 +8612,39 @@ class WorkflowTemplateJobHiveJobQueryListArgs:
         pulumi.set(self, "queries", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobPigJobArgsDict(TypedDict):
+        continue_on_failure: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to continue executing queries if a query fails. The default value is `false`. Setting to `true` can be useful when executing independent parallel queries.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to add to the CLASSPATH of the Pig Client and Hadoop MapReduce (MR) tasks. Can contain Pig UDFs.
+        """
+        logging_config: NotRequired[pulumi.Input['WorkflowTemplateJobPigJobLoggingConfigArgsDict']]
+        """
+        The runtime log config for job execution.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure Pig. Properties that conflict with values set by the Dataproc API may be overwritten. Can include properties set in /etc/hadoop/conf/*-site.xml, /etc/pig/conf/pig.properties, and classes in user code.
+        """
+        query_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the script that contains the Pig queries.
+        """
+        query_list: NotRequired[pulumi.Input['WorkflowTemplateJobPigJobQueryListArgsDict']]
+        """
+        A list of queries.
+        """
+        script_variables: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Mapping of query variable names to values (equivalent to the Pig command: `name=`).
+        """
+elif False:
+    WorkflowTemplateJobPigJobArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobPigJobArgs:
     def __init__(__self__, *,
@@ -6572,6 +8764,15 @@ class WorkflowTemplateJobPigJobArgs:
         pulumi.set(self, "script_variables", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobPigJobLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    WorkflowTemplateJobPigJobLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobPigJobLoggingConfigArgs:
     def __init__(__self__, *,
@@ -6595,6 +8796,15 @@ class WorkflowTemplateJobPigJobLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobPigJobQueryListArgsDict(TypedDict):
+        queries: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Required. The queries to execute. You do not need to end a query expression with a semicolon. Multiple queries can be specified in one string by separating each with a semicolon. Here is an example of a Dataproc API snippet that uses a QueryList to specify a HiveJob: "hiveJob": { "queryList": { "queries": } }
+        """
+elif False:
+    WorkflowTemplateJobPigJobQueryListArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobPigJobQueryListArgs:
     def __init__(__self__, *,
@@ -6617,6 +8827,39 @@ class WorkflowTemplateJobPigJobQueryListArgs:
         pulumi.set(self, "queries", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobPrestoJobArgsDict(TypedDict):
+        client_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Presto client tags to attach to this query
+        """
+        continue_on_failure: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to continue executing queries if a query fails. The default value is `false`. Setting to `true` can be useful when executing independent parallel queries.
+        """
+        logging_config: NotRequired[pulumi.Input['WorkflowTemplateJobPrestoJobLoggingConfigArgsDict']]
+        """
+        The runtime log config for job execution.
+        """
+        output_format: NotRequired[pulumi.Input[str]]
+        """
+        The format in which query output will be displayed. See the Presto documentation for supported output formats
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values. Used to set Presto (https://prestodb.io/docs/current/sql/set-session.html) Equivalent to using the --session flag in the Presto CLI
+        """
+        query_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the script that contains SQL queries.
+        """
+        query_list: NotRequired[pulumi.Input['WorkflowTemplateJobPrestoJobQueryListArgsDict']]
+        """
+        A list of queries.
+        """
+elif False:
+    WorkflowTemplateJobPrestoJobArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobPrestoJobArgs:
     def __init__(__self__, *,
@@ -6736,6 +8979,15 @@ class WorkflowTemplateJobPrestoJobArgs:
         pulumi.set(self, "query_list", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobPrestoJobLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    WorkflowTemplateJobPrestoJobLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobPrestoJobLoggingConfigArgs:
     def __init__(__self__, *,
@@ -6759,6 +9011,15 @@ class WorkflowTemplateJobPrestoJobLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobPrestoJobQueryListArgsDict(TypedDict):
+        queries: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Required. The queries to execute. You do not need to end a query expression with a semicolon. Multiple queries can be specified in one string by separating each with a semicolon. Here is an example of a Dataproc API snippet that uses a QueryList to specify a HiveJob: "hiveJob": { "queryList": { "queries": } }
+        """
+elif False:
+    WorkflowTemplateJobPrestoJobQueryListArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobPrestoJobQueryListArgs:
     def __init__(__self__, *,
@@ -6781,6 +9042,43 @@ class WorkflowTemplateJobPrestoJobQueryListArgs:
         pulumi.set(self, "queries", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobPysparkJobArgsDict(TypedDict):
+        main_python_file_uri: pulumi.Input[str]
+        """
+        Required. The HCFS URI of the main Python file to use as the driver. Must be a .py file.
+        """
+        archive_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and .zip.
+        """
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments to pass to the driver. Do not include arguments, such as `--conf`, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        """
+        file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of files to be placed in the working directory of each executor. Useful for naively parallel tasks.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to add to the CLASSPATHs of the Python driver and tasks.
+        """
+        logging_config: NotRequired[pulumi.Input['WorkflowTemplateJobPysparkJobLoggingConfigArgsDict']]
+        """
+        The runtime log config for job execution.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure PySpark. Properties that conflict with values set by the Dataproc API may be overwritten. Can include properties set in /etc/spark/conf/spark-defaults.conf and classes in user code.
+        """
+        python_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS file URIs of Python files to pass to the PySpark framework. Supported file types: .py, .egg, and .zip.
+        """
+elif False:
+    WorkflowTemplateJobPysparkJobArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobPysparkJobArgs:
     def __init__(__self__, *,
@@ -6915,6 +9213,15 @@ class WorkflowTemplateJobPysparkJobArgs:
         pulumi.set(self, "python_file_uris", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobPysparkJobLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    WorkflowTemplateJobPysparkJobLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobPysparkJobLoggingConfigArgs:
     def __init__(__self__, *,
@@ -6938,6 +9245,19 @@ class WorkflowTemplateJobPysparkJobLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobSchedulingArgsDict(TypedDict):
+        max_failures_per_hour: NotRequired[pulumi.Input[int]]
+        """
+        Maximum number of times per hour a driver may be restarted as a result of driver exiting with non-zero code before job is reported failed. A job may be reported as thrashing if driver exits with non-zero code 4 times within 10 minute window. Maximum value is 10.
+        """
+        max_failures_total: NotRequired[pulumi.Input[int]]
+        """
+        Maximum number of times in total a driver may be restarted as a result of driver exiting with non-zero code before job is reported failed. Maximum value is 240
+        """
+elif False:
+    WorkflowTemplateJobSchedulingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobSchedulingArgs:
     def __init__(__self__, *,
@@ -6977,6 +9297,43 @@ class WorkflowTemplateJobSchedulingArgs:
         pulumi.set(self, "max_failures_total", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobSparkJobArgsDict(TypedDict):
+        archive_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and .zip.
+        """
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments to pass to the driver. Do not include arguments, such as `--conf`, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        """
+        file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of files to be placed in the working directory of each executor. Useful for naively parallel tasks.
+        """
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to add to the CLASSPATHs of the Spark driver and tasks.
+        """
+        logging_config: NotRequired[pulumi.Input['WorkflowTemplateJobSparkJobLoggingConfigArgsDict']]
+        """
+        The runtime log config for job execution.
+        """
+        main_class: NotRequired[pulumi.Input[str]]
+        """
+        The name of the driver's main class. The jar file that contains the class must be in the default CLASSPATH or specified in `jar_file_uris`.
+        """
+        main_jar_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the jar file that contains the main class.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure Spark. Properties that conflict with values set by the Dataproc API may be overwritten. Can include properties set in /etc/spark/conf/spark-defaults.conf and classes in user code.
+        """
+elif False:
+    WorkflowTemplateJobSparkJobArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobSparkJobArgs:
     def __init__(__self__, *,
@@ -7112,28 +9469,66 @@ class WorkflowTemplateJobSparkJobArgs:
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobSparkJobLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    WorkflowTemplateJobSparkJobLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobSparkJobLoggingConfigArgs:
     def __init__(__self__, *,
                  driver_log_levels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
         """
-        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] driver_log_levels: The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] driver_log_levels: The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+        if driver_log_levels is not None:
+            pulumi.set(__self__, "driver_log_levels", driver_log_levels)
+
+    @property
+    @pulumi.getter(name="driverLogLevels")
+    def driver_log_levels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        """
+        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+        return pulumi.get(self, "driver_log_levels")
+
+    @driver_log_levels.setter
+    def driver_log_levels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "driver_log_levels", value)
+
+
+if not MYPY:
+    class WorkflowTemplateJobSparkRJobArgsDict(TypedDict):
+        main_r_file_uri: pulumi.Input[str]
+        """
+        Required. The HCFS URI of the main R file to use as the driver. Must be a .R file.
+        """
+        archive_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and .zip.
+        """
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments to pass to the driver. Do not include arguments, such as `--conf`, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        """
+        file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of files to be placed in the working directory of each executor. Useful for naively parallel tasks.
+        """
+        logging_config: NotRequired[pulumi.Input['WorkflowTemplateJobSparkRJobLoggingConfigArgsDict']]
+        """
+        The runtime log config for job execution.
         """
-        if driver_log_levels is not None:
-            pulumi.set(__self__, "driver_log_levels", driver_log_levels)
-
-    @property
-    @pulumi.getter(name="driverLogLevels")
-    def driver_log_levels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
         """
-        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        A mapping of property names to values, used to configure SparkR. Properties that conflict with values set by the Dataproc API may be overwritten. Can include properties set in /etc/spark/conf/spark-defaults.conf and classes in user code.
         """
-        return pulumi.get(self, "driver_log_levels")
-
-    @driver_log_levels.setter
-    def driver_log_levels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
-        pulumi.set(self, "driver_log_levels", value)
-
+elif False:
+    WorkflowTemplateJobSparkRJobArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class WorkflowTemplateJobSparkRJobArgs:
@@ -7237,6 +9632,15 @@ class WorkflowTemplateJobSparkRJobArgs:
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobSparkRJobLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    WorkflowTemplateJobSparkRJobLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobSparkRJobLoggingConfigArgs:
     def __init__(__self__, *,
@@ -7260,6 +9664,35 @@ class WorkflowTemplateJobSparkRJobLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobSparkSqlJobArgsDict(TypedDict):
+        jar_file_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HCFS URIs of jar files to be added to the Spark CLASSPATH.
+        """
+        logging_config: NotRequired[pulumi.Input['WorkflowTemplateJobSparkSqlJobLoggingConfigArgsDict']]
+        """
+        The runtime log config for job execution.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A mapping of property names to values, used to configure Spark SQL's SparkConf. Properties that conflict with values set by the Dataproc API may be overwritten.
+        """
+        query_file_uri: NotRequired[pulumi.Input[str]]
+        """
+        The HCFS URI of the script that contains SQL queries.
+        """
+        query_list: NotRequired[pulumi.Input['WorkflowTemplateJobSparkSqlJobQueryListArgsDict']]
+        """
+        A list of queries.
+        """
+        script_variables: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Mapping of query variable names to values (equivalent to the Spark SQL command: SET `name="value";`).
+        """
+elif False:
+    WorkflowTemplateJobSparkSqlJobArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobSparkSqlJobArgs:
     def __init__(__self__, *,
@@ -7363,6 +9796,15 @@ class WorkflowTemplateJobSparkSqlJobArgs:
         pulumi.set(self, "script_variables", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobSparkSqlJobLoggingConfigArgsDict(TypedDict):
+        driver_log_levels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The per-package log levels for the driver. This may include "root" package name to configure rootLogger. Examples: 'com.google = FATAL', 'root = INFO', 'org.apache = DEBUG'
+        """
+elif False:
+    WorkflowTemplateJobSparkSqlJobLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobSparkSqlJobLoggingConfigArgs:
     def __init__(__self__, *,
@@ -7386,6 +9828,15 @@ class WorkflowTemplateJobSparkSqlJobLoggingConfigArgs:
         pulumi.set(self, "driver_log_levels", value)
 
 
+if not MYPY:
+    class WorkflowTemplateJobSparkSqlJobQueryListArgsDict(TypedDict):
+        queries: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Required. The queries to execute. You do not need to end a query expression with a semicolon. Multiple queries can be specified in one string by separating each with a semicolon. Here is an example of a Dataproc API snippet that uses a QueryList to specify a HiveJob: "hiveJob": { "queryList": { "queries": } }
+        """
+elif False:
+    WorkflowTemplateJobSparkSqlJobQueryListArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateJobSparkSqlJobQueryListArgs:
     def __init__(__self__, *,
@@ -7408,6 +9859,27 @@ class WorkflowTemplateJobSparkSqlJobQueryListArgs:
         pulumi.set(self, "queries", value)
 
 
+if not MYPY:
+    class WorkflowTemplateParameterArgsDict(TypedDict):
+        fields: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Required. Paths to all fields that the parameter replaces. A field is allowed to appear in at most one parameter's list of field paths. A field path is similar in syntax to a .sparkJob.args
+        """
+        name: pulumi.Input[str]
+        """
+        Required. Parameter name. The parameter name is used as the key, and paired with the parameter value, which are passed to the template when the template is instantiated. The name must contain only capital letters (A-Z), numbers (0-9), and underscores (_), and must not start with a number. The maximum length is 40 characters.
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        Brief description of the parameter. Must not exceed 1024 characters.
+        """
+        validation: NotRequired[pulumi.Input['WorkflowTemplateParameterValidationArgsDict']]
+        """
+        Validation rules to be applied to this parameter's value.
+        """
+elif False:
+    WorkflowTemplateParameterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateParameterArgs:
     def __init__(__self__, *,
@@ -7477,6 +9949,19 @@ class WorkflowTemplateParameterArgs:
         pulumi.set(self, "validation", value)
 
 
+if not MYPY:
+    class WorkflowTemplateParameterValidationArgsDict(TypedDict):
+        regex: NotRequired[pulumi.Input['WorkflowTemplateParameterValidationRegexArgsDict']]
+        """
+        Validation based on regular expressions.
+        """
+        values: NotRequired[pulumi.Input['WorkflowTemplateParameterValidationValuesArgsDict']]
+        """
+        Validation based on a list of allowed values.
+        """
+elif False:
+    WorkflowTemplateParameterValidationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateParameterValidationArgs:
     def __init__(__self__, *,
@@ -7516,6 +10001,15 @@ class WorkflowTemplateParameterValidationArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class WorkflowTemplateParameterValidationRegexArgsDict(TypedDict):
+        regexes: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Required. RE2 regular expressions used to validate the parameter's value. The value must match the regex in its entirety (substring matches are not sufficient).
+        """
+elif False:
+    WorkflowTemplateParameterValidationRegexArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateParameterValidationRegexArgs:
     def __init__(__self__, *,
@@ -7538,6 +10032,15 @@ class WorkflowTemplateParameterValidationRegexArgs:
         pulumi.set(self, "regexes", value)
 
 
+if not MYPY:
+    class WorkflowTemplateParameterValidationValuesArgsDict(TypedDict):
+        values: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Required. List of allowed values for the parameter.
+        """
+elif False:
+    WorkflowTemplateParameterValidationValuesArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplateParameterValidationValuesArgs:
     def __init__(__self__, *,
@@ -7560,6 +10063,19 @@ class WorkflowTemplateParameterValidationValuesArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementArgsDict(TypedDict):
+        cluster_selector: NotRequired[pulumi.Input['WorkflowTemplatePlacementClusterSelectorArgsDict']]
+        """
+        A selector that chooses target cluster for jobs based on metadata. The selector is evaluated at the time each job is submitted.
+        """
+        managed_cluster: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterArgsDict']]
+        """
+        A cluster that is managed by the workflow.
+        """
+elif False:
+    WorkflowTemplatePlacementArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementArgs:
     def __init__(__self__, *,
@@ -7599,6 +10115,19 @@ class WorkflowTemplatePlacementArgs:
         pulumi.set(self, "managed_cluster", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementClusterSelectorArgsDict(TypedDict):
+        cluster_labels: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Required. The cluster labels. Cluster must have all labels to match.
+        """
+        zone: NotRequired[pulumi.Input[str]]
+        """
+        The zone where workflow process executes. This parameter does not affect the selection of the cluster. If unspecified, the zone of the first cluster matching the selector is used.
+        """
+elif False:
+    WorkflowTemplatePlacementClusterSelectorArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementClusterSelectorArgs:
     def __init__(__self__, *,
@@ -7637,6 +10166,23 @@ class WorkflowTemplatePlacementClusterSelectorArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterArgsDict(TypedDict):
+        cluster_name: pulumi.Input[str]
+        """
+        Required. The cluster name prefix. A unique cluster name will be formed by appending a random suffix. The name must contain only lower-case letters (a-z), numbers (0-9), and hyphens (-). Must begin with a letter. Cannot begin or end with hyphen. Must consist of between 2 and 35 characters.
+        """
+        config: pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigArgsDict']
+        """
+        Required. The cluster configuration.
+        """
+        labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The labels to associate with this cluster. Label keys must be between 1 and 63 characters long, and must conform to the following PCRE regular expression: {0,63} No more than 32 labels can be associated with a given cluster.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterArgs:
     def __init__(__self__, *,
@@ -7690,6 +10236,73 @@ class WorkflowTemplatePlacementManagedClusterArgs:
         pulumi.set(self, "labels", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigArgsDict(TypedDict):
+        autoscaling_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigAutoscalingConfigArgsDict']]
+        """
+        Autoscaling config for the policy associated with the cluster. Cluster does not autoscale if this field is unset.
+        """
+        encryption_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigEncryptionConfigArgsDict']]
+        """
+        Encryption settings for the cluster.
+        """
+        endpoint_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigEndpointConfigArgsDict']]
+        """
+        Port/endpoint configuration for this cluster
+        """
+        gce_cluster_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigArgsDict']]
+        """
+        The shared Compute Engine config settings for all instances in a cluster.
+        """
+        gke_cluster_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigArgsDict']]
+        """
+        The Kubernetes Engine config for Dataproc clusters deployed to Kubernetes. Setting this is considered mutually exclusive with Compute Engine-based options such as `gce_cluster_config`, `master_config`, `worker_config`, `secondary_worker_config`, and `autoscaling_config`.
+        """
+        initialization_actions: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigInitializationActionArgsDict']]]]
+        """
+        Commands to execute on each node after config is completed. By default, executables are run on master and all worker nodes. You can test a node's `role` metadata to run an executable on a master or worker node, as shown below using `curl` (you can also use `wget`): ROLE=$(curl -H Metadata-Flavor:Google http://metadata/computeMetadata/v1/instance/attributes/dataproc-role) if ; then ... master specific actions ... else ... worker specific actions ... fi
+        """
+        lifecycle_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigLifecycleConfigArgsDict']]
+        """
+        Lifecycle setting for the cluster.
+        """
+        master_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigMasterConfigArgsDict']]
+        """
+        The Compute Engine config settings for additional worker instances in a cluster.
+        """
+        metastore_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigMetastoreConfigArgsDict']]
+        """
+        Metastore configuration.
+        """
+        secondary_worker_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigArgsDict']]
+        """
+        The Compute Engine config settings for additional worker instances in a cluster.
+        """
+        security_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigSecurityConfigArgsDict']]
+        """
+        Security settings for the cluster.
+        """
+        software_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigSoftwareConfigArgsDict']]
+        """
+        The config settings for software inside the cluster.
+        """
+        staging_bucket: NotRequired[pulumi.Input[str]]
+        """
+        A Cloud Storage bucket used to stage job dependencies, config files, and job driver console output. If you do not specify a staging bucket, Cloud Dataproc will determine a Cloud Storage location (US, ASIA, or EU) for your cluster's staging bucket according to the Compute Engine zone where your cluster is deployed, and then create and manage this project-level, per-location bucket (see (https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/staging-bucket)).
+        """
+        temp_bucket: NotRequired[pulumi.Input[str]]
+        """
+        A Cloud Storage bucket used to store ephemeral cluster and jobs data, such as Spark and MapReduce history files. If you do not specify a temp bucket, Dataproc will determine a Cloud Storage location (US, ASIA, or EU) for your cluster's temp bucket according to the Compute Engine zone where your cluster is deployed, and then create and manage this project-level, per-location bucket. The default bucket has a TTL of 90 days, but you can use any TTL (or none) if you specify a bucket.
+        """
+        worker_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigWorkerConfigArgsDict']]
+        """
+        The Compute Engine config settings for additional worker instances in a cluster.
+
+        - - -
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigArgs:
     def __init__(__self__, *,
@@ -7941,6 +10554,15 @@ class WorkflowTemplatePlacementManagedClusterConfigArgs:
         pulumi.set(self, "worker_config", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigAutoscalingConfigArgsDict(TypedDict):
+        policy: NotRequired[pulumi.Input[str]]
+        """
+        The autoscaling policy used by the cluster. Only resource names including projectid and location (region) are valid. Examples: * `https://www.googleapis.com/compute/v1/projects/` Note that the policy must be in the same project and Dataproc region.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigAutoscalingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigAutoscalingConfigArgs:
     def __init__(__self__, *,
@@ -7964,6 +10586,15 @@ class WorkflowTemplatePlacementManagedClusterConfigAutoscalingConfigArgs:
         pulumi.set(self, "policy", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigEncryptionConfigArgsDict(TypedDict):
+        gce_pd_kms_key_name: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud KMS key name to use for PD disk encryption for all instances in the cluster.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigEncryptionConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigEncryptionConfigArgs:
     def __init__(__self__, *,
@@ -7987,6 +10618,19 @@ class WorkflowTemplatePlacementManagedClusterConfigEncryptionConfigArgs:
         pulumi.set(self, "gce_pd_kms_key_name", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigEndpointConfigArgsDict(TypedDict):
+        enable_http_port_access: NotRequired[pulumi.Input[bool]]
+        """
+        If true, enable http access to specific ports on the cluster from external sources. Defaults to false.
+        """
+        http_ports: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Output only. The map of port descriptions to URLs. Will only be populated if enable_http_port_access is true.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigEndpointConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigEndpointConfigArgs:
     def __init__(__self__, *,
@@ -8026,6 +10670,59 @@ class WorkflowTemplatePlacementManagedClusterConfigEndpointConfigArgs:
         pulumi.set(self, "http_ports", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigArgsDict(TypedDict):
+        internal_ip_only: NotRequired[pulumi.Input[bool]]
+        """
+        If true, all instances in the cluster will only have internal IP addresses. By default, clusters are not restricted to internal IP addresses, and will have ephemeral external IP addresses assigned to each instance. This `internal_ip_only` restriction can only be enabled for subnetwork enabled networks, and all off-cluster dependencies must be configured to be accessible without external IP addresses.
+        """
+        metadata: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The Compute Engine metadata entries to add to all instances (see (https://cloud.google.com/compute/docs/storing-retrieving-metadata#project_and_instance_metadata)).
+        """
+        network: NotRequired[pulumi.Input[str]]
+        """
+        The Compute Engine network to be used for machine communications. Cannot be specified with subnetwork_uri. If neither `network_uri` nor `subnetwork_uri` is specified, the "default" network of the project is used, if it exists. Cannot be a "Custom Subnet Network" (see /regions/global/default` * `default`
+        """
+        node_group_affinity: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigNodeGroupAffinityArgsDict']]
+        """
+        Node Group Affinity for sole-tenant clusters.
+        """
+        private_ipv6_google_access: NotRequired[pulumi.Input[str]]
+        """
+        The type of IPv6 access for a cluster. Possible values: PRIVATE_IPV6_GOOGLE_ACCESS_UNSPECIFIED, INHERIT_FROM_SUBNETWORK, OUTBOUND, BIDIRECTIONAL
+        """
+        reservation_affinity: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigReservationAffinityArgsDict']]
+        """
+        Reservation Affinity for consuming Zonal reservation.
+        """
+        service_account: NotRequired[pulumi.Input[str]]
+        """
+        The (https://cloud.google.com/compute/docs/access/service-accounts#default_service_account) is used.
+        """
+        service_account_scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The URIs of service account scopes to be included in Compute Engine instances. The following base set of scopes is always included: * https://www.googleapis.com/auth/cloud.useraccounts.readonly * https://www.googleapis.com/auth/devstorage.read_write * https://www.googleapis.com/auth/logging.write If no scopes are specified, the following defaults are also provided: * https://www.googleapis.com/auth/bigquery * https://www.googleapis.com/auth/bigtable.admin.table * https://www.googleapis.com/auth/bigtable.data * https://www.googleapis.com/auth/devstorage.full_control
+        """
+        shielded_instance_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigShieldedInstanceConfigArgsDict']]
+        """
+        Shielded Instance Config for clusters using [Compute Engine Shielded VMs](https://cloud.google.com/security/shielded-cloud/shielded-vm). Structure defined below.
+        """
+        subnetwork: NotRequired[pulumi.Input[str]]
+        """
+        The Compute Engine subnetwork to be used for machine communications. Cannot be specified with network_uri. A full URL, partial URI, or short name are valid. Examples: * `https://www.googleapis.com/compute/v1/projects//regions/us-east1/subnetworks/sub0` * `sub0`
+        """
+        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The Compute Engine tags to add to all instances (see (https://cloud.google.com/compute/docs/label-or-tag-resources#tags)).
+        """
+        zone: NotRequired[pulumi.Input[str]]
+        """
+        The zone where the Compute Engine cluster will be located. On a create request, it is required in the "global" region. If omitted in a non-global Dataproc region, the service will pick a zone in the corresponding Compute Engine region. On a get request, zone will always be present. A full URL, partial URI, or short name are valid. Examples: * `https://www.googleapis.com/compute/v1/projects/` * `us-central1-f`
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigArgs:
     def __init__(__self__, *,
@@ -8225,6 +10922,15 @@ class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigArgs:
         pulumi.set(self, "zone", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigNodeGroupAffinityArgsDict(TypedDict):
+        node_group: pulumi.Input[str]
+        """
+        Required. The URI of a sole-tenant /zones/us-central1-a/nodeGroups/node-group-1` * `node-group-1`
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigNodeGroupAffinityArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigNodeGroupAffinityArgs:
     def __init__(__self__, *,
@@ -8247,6 +10953,23 @@ class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigNodeGroupAffi
         pulumi.set(self, "node_group", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigReservationAffinityArgsDict(TypedDict):
+        consume_reservation_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of reservation to consume Possible values: TYPE_UNSPECIFIED, NO_RESERVATION, ANY_RESERVATION, SPECIFIC_RESERVATION
+        """
+        key: NotRequired[pulumi.Input[str]]
+        """
+        Corresponds to the label key of reservation resource.
+        """
+        values: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Corresponds to the label values of reservation resource.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigReservationAffinityArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigReservationAffinityArgs:
     def __init__(__self__, *,
@@ -8302,6 +11025,23 @@ class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigReservationAf
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigShieldedInstanceConfigArgsDict(TypedDict):
+        enable_integrity_monitoring: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether instances have [Integrity Monitoring](https://cloud.google.com/compute/shielded-vm/docs/shielded-vm#integrity-monitoring) enabled.
+        """
+        enable_secure_boot: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether instances have [Secure Boot](https://cloud.google.com/compute/shielded-vm/docs/shielded-vm#secure-boot) enabled.
+        """
+        enable_vtpm: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether instances have the [vTPM](https://cloud.google.com/compute/shielded-vm/docs/shielded-vm#vtpm) enabled.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigShieldedInstanceConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigShieldedInstanceConfigArgs:
     def __init__(__self__, *,
@@ -8357,6 +11097,15 @@ class WorkflowTemplatePlacementManagedClusterConfigGceClusterConfigShieldedInsta
         pulumi.set(self, "enable_vtpm", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigArgsDict(TypedDict):
+        namespaced_gke_deployment_target: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigNamespacedGkeDeploymentTargetArgsDict']]
+        """
+        A target for the deployment.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigArgs:
     def __init__(__self__, *,
@@ -8380,6 +11129,19 @@ class WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigArgs:
         pulumi.set(self, "namespaced_gke_deployment_target", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigNamespacedGkeDeploymentTargetArgsDict(TypedDict):
+        cluster_namespace: NotRequired[pulumi.Input[str]]
+        """
+        A namespace within the GKE cluster to deploy into.
+        """
+        target_gke_cluster: NotRequired[pulumi.Input[str]]
+        """
+        The target GKE cluster to deploy to. Format: 'projects/{project}/locations/{location}/clusters/{cluster_id}'
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigNamespacedGkeDeploymentTargetArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigNamespacedGkeDeploymentTargetArgs:
     def __init__(__self__, *,
@@ -8419,6 +11181,19 @@ class WorkflowTemplatePlacementManagedClusterConfigGkeClusterConfigNamespacedGke
         pulumi.set(self, "target_gke_cluster", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigInitializationActionArgsDict(TypedDict):
+        executable_file: NotRequired[pulumi.Input[str]]
+        """
+        Required. Cloud Storage URI of executable file.
+        """
+        execution_timeout: NotRequired[pulumi.Input[str]]
+        """
+        Amount of time executable has to complete. Default is 10 minutes (see JSON representation of (https://developers.google.com/protocol-buffers/docs/proto3#json)). Cluster creation fails with an explanatory error message (the name of the executable that caused the error and the exceeded timeout period) if the executable is not completed at end of the timeout period.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigInitializationActionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigInitializationActionArgs:
     def __init__(__self__, *,
@@ -8449,14 +11224,35 @@ class WorkflowTemplatePlacementManagedClusterConfigInitializationActionArgs:
     @pulumi.getter(name="executionTimeout")
     def execution_timeout(self) -> Optional[pulumi.Input[str]]:
         """
-        Amount of time executable has to complete. Default is 10 minutes (see JSON representation of (https://developers.google.com/protocol-buffers/docs/proto3#json)). Cluster creation fails with an explanatory error message (the name of the executable that caused the error and the exceeded timeout period) if the executable is not completed at end of the timeout period.
+        Amount of time executable has to complete. Default is 10 minutes (see JSON representation of (https://developers.google.com/protocol-buffers/docs/proto3#json)). Cluster creation fails with an explanatory error message (the name of the executable that caused the error and the exceeded timeout period) if the executable is not completed at end of the timeout period.
+        """
+        return pulumi.get(self, "execution_timeout")
+
+    @execution_timeout.setter
+    def execution_timeout(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "execution_timeout", value)
+
+
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigLifecycleConfigArgsDict(TypedDict):
+        auto_delete_time: NotRequired[pulumi.Input[str]]
+        """
+        The time when cluster will be auto-deleted (see JSON representation of (https://developers.google.com/protocol-buffers/docs/proto3#json)).
+        """
+        auto_delete_ttl: NotRequired[pulumi.Input[str]]
+        """
+        The lifetime duration of cluster. The cluster will be auto-deleted at the end of this period. Minimum value is 10 minutes; maximum value is 14 days (see JSON representation of (https://developers.google.com/protocol-buffers/docs/proto3#json)).
+        """
+        idle_delete_ttl: NotRequired[pulumi.Input[str]]
         """
-        return pulumi.get(self, "execution_timeout")
-
-    @execution_timeout.setter
-    def execution_timeout(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "execution_timeout", value)
-
+        The duration to keep the cluster alive while idling (when no jobs are running). Passing this threshold will cause the cluster to be deleted. Minimum value is 5 minutes; maximum value is 14 days (see JSON representation of (https://developers.google.com/protocol-buffers/docs/proto3#json).
+        """
+        idle_start_time: NotRequired[pulumi.Input[str]]
+        """
+        Output only. The time when cluster became idle (most recent job finished) and became eligible for deletion due to idleness (see JSON representation of (https://developers.google.com/protocol-buffers/docs/proto3#json)).
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigLifecycleConfigArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigLifecycleConfigArgs:
@@ -8529,6 +11325,51 @@ class WorkflowTemplatePlacementManagedClusterConfigLifecycleConfigArgs:
         pulumi.set(self, "idle_start_time", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigMasterConfigArgsDict(TypedDict):
+        accelerators: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigMasterConfigAcceleratorArgsDict']]]]
+        """
+        The Compute Engine accelerator configuration for these instances.
+        """
+        disk_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigMasterConfigDiskConfigArgsDict']]
+        """
+        Disk option config settings.
+        """
+        image: NotRequired[pulumi.Input[str]]
+        """
+        The Compute Engine image resource used for cluster instances. The URI can represent an image or image family. Image examples: * `https://www.googleapis.com/compute/beta/projects/` If the URI is unspecified, it will be inferred from `SoftwareConfig.image_version` or the system default.
+        """
+        instance_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Output only. The list of instance names. Dataproc derives the names from `cluster_name`, `num_instances`, and the instance group.
+        """
+        is_preemptible: NotRequired[pulumi.Input[bool]]
+        """
+        Output only. Specifies that this instance group contains preemptible instances.
+        """
+        machine_type: NotRequired[pulumi.Input[str]]
+        """
+        The Compute Engine machine type used for cluster instances. A full URL, partial URI, or short name are valid. Examples: * `https://www.googleapis.com/compute/v1/projects/(https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/auto-zone#using_auto_zone_placement) feature, you must use the short name of the machine type resource, for example, `n1-standard-2`.
+        """
+        managed_group_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigMasterConfigManagedGroupConfigArgsDict']]]]
+        """
+        Output only. The config for Compute Engine Instance Group Manager that manages this group. This is only used for preemptible instance groups.
+        """
+        min_cpu_platform: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the minimum cpu platform for the Instance Group. See (https://cloud.google.com/dataproc/docs/concepts/compute/dataproc-min-cpu).
+        """
+        num_instances: NotRequired[pulumi.Input[int]]
+        """
+        The number of VM instances in the instance group. For master instance groups, must be set to 1.
+        """
+        preemptibility: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the preemptibility of the instance group. The default value for master and worker groups is `NON_PREEMPTIBLE`. This default cannot be changed. The default value for secondary instances is `PREEMPTIBLE`. Possible values: PREEMPTIBILITY_UNSPECIFIED, NON_PREEMPTIBLE, PREEMPTIBLE
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigMasterConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigMasterConfigArgs:
     def __init__(__self__, *,
@@ -8696,6 +11537,19 @@ class WorkflowTemplatePlacementManagedClusterConfigMasterConfigArgs:
         pulumi.set(self, "preemptibility", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigMasterConfigAcceleratorArgsDict(TypedDict):
+        accelerator_count: NotRequired[pulumi.Input[int]]
+        """
+        The number of the accelerator cards of this type exposed to this instance.
+        """
+        accelerator_type: NotRequired[pulumi.Input[str]]
+        """
+        Full URL, partial URI, or short name of the accelerator type resource to expose to this instance. See (https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/auto-zone#using_auto_zone_placement) feature, you must use the short name of the accelerator type resource, for example, `nvidia-tesla-k80`.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigMasterConfigAcceleratorArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigMasterConfigAcceleratorArgs:
     def __init__(__self__, *,
@@ -8735,6 +11589,23 @@ class WorkflowTemplatePlacementManagedClusterConfigMasterConfigAcceleratorArgs:
         pulumi.set(self, "accelerator_type", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigMasterConfigDiskConfigArgsDict(TypedDict):
+        boot_disk_size_gb: NotRequired[pulumi.Input[int]]
+        """
+        Size in GB of the boot disk (default is 500GB).
+        """
+        boot_disk_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of the boot disk (default is "pd-standard"). Valid values: "pd-ssd" (Persistent Disk Solid State Drive) or "pd-standard" (Persistent Disk Hard Disk Drive).
+        """
+        num_local_ssds: NotRequired[pulumi.Input[int]]
+        """
+        Number of attached SSDs, from 0 to 4 (default is 0). If SSDs are not attached, the boot disk is used to store runtime logs and (https://hadoop.apache.org/docs/r1.2.1/hdfs_user_guide.html) data. If one or more SSDs are attached, this runtime bulk data is spread across them, and the boot disk contains only basic config and installed binaries.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigMasterConfigDiskConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigMasterConfigDiskConfigArgs:
     def __init__(__self__, *,
@@ -8790,6 +11661,19 @@ class WorkflowTemplatePlacementManagedClusterConfigMasterConfigDiskConfigArgs:
         pulumi.set(self, "num_local_ssds", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigMasterConfigManagedGroupConfigArgsDict(TypedDict):
+        instance_group_manager_name: NotRequired[pulumi.Input[str]]
+        """
+        Output only. The name of the Instance Group Manager for this group.
+        """
+        instance_template_name: NotRequired[pulumi.Input[str]]
+        """
+        Output only. The name of the Instance Template used for the Managed Instance Group.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigMasterConfigManagedGroupConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigMasterConfigManagedGroupConfigArgs:
     def __init__(__self__, *,
@@ -8829,6 +11713,15 @@ class WorkflowTemplatePlacementManagedClusterConfigMasterConfigManagedGroupConfi
         pulumi.set(self, "instance_template_name", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigMetastoreConfigArgsDict(TypedDict):
+        dataproc_metastore_service: pulumi.Input[str]
+        """
+        Required. Resource name of an existing Dataproc Metastore service. Example: * `projects/`
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigMetastoreConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigMetastoreConfigArgs:
     def __init__(__self__, *,
@@ -8851,6 +11744,51 @@ class WorkflowTemplatePlacementManagedClusterConfigMetastoreConfigArgs:
         pulumi.set(self, "dataproc_metastore_service", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigArgsDict(TypedDict):
+        accelerators: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigAcceleratorArgsDict']]]]
+        """
+        Optional. The Compute Engine accelerator configuration for these instances.
+        """
+        disk_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigDiskConfigArgsDict']]
+        """
+        Optional. Disk option config settings.
+        """
+        image: NotRequired[pulumi.Input[str]]
+        """
+        Optional. The Compute Engine image resource used for cluster instances. The URI can represent an image or image family. Image examples: * `https://www.googleapis.com/compute/beta/projects/[project_id]/global/images/[image-id]` * `projects/[project_id]/global/images/[image-id]` * `image-id` Image family examples. Dataproc will use the most recent image from the family: * `https://www.googleapis.com/compute/beta/projects/[project_id]/global/images/family/[custom-image-family-name]` * `projects/[project_id]/global/images/family/[custom-image-family-name]` If the URI is unspecified, it will be inferred from `SoftwareConfig.image_version` or the system default.
+        """
+        instance_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Output only. The list of instance names. Dataproc derives the names from `cluster_name`, `num_instances`, and the instance group.
+        """
+        is_preemptible: NotRequired[pulumi.Input[bool]]
+        """
+        Output only. Specifies that this instance group contains preemptible instances.
+        """
+        machine_type: NotRequired[pulumi.Input[str]]
+        """
+        Optional. The Compute Engine machine type used for cluster instances. A full URL, partial URI, or short name are valid. Examples: * `https://www.googleapis.com/compute/v1/projects/[project_id]/zones/us-east1-a/machineTypes/n1-standard-2` * `projects/[project_id]/zones/us-east1-a/machineTypes/n1-standard-2` * `n1-standard-2` **Auto Zone Exception**: If you are using the Dataproc [Auto Zone Placement](https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/auto-zone#using_auto_zone_placement) feature, you must use the short name of the machine type resource, for example, `n1-standard-2`.
+        """
+        managed_group_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigManagedGroupConfigArgsDict']]]]
+        """
+        Output only. The config for Compute Engine Instance Group Manager that manages this group. This is only used for preemptible instance groups.
+        """
+        min_cpu_platform: NotRequired[pulumi.Input[str]]
+        """
+        Optional. Specifies the minimum cpu platform for the Instance Group. See [Dataproc > Minimum CPU Platform](https://cloud.google.com/dataproc/docs/concepts/compute/dataproc-min-cpu).
+        """
+        num_instances: NotRequired[pulumi.Input[int]]
+        """
+        Optional. The number of VM instances in the instance group. For [HA cluster](https://www.terraform.io/dataproc/docs/concepts/configuring-clusters/high-availability) master_config groups, **must be set to 3**. For standard cluster master_config groups, **must be set to 1**.
+        """
+        preemptibility: NotRequired[pulumi.Input[str]]
+        """
+        Optional. Specifies the preemptibility of the instance group. The default value for master and worker groups is `NON_PREEMPTIBLE`. This default cannot be changed. The default value for secondary instances is `PREEMPTIBLE`. Possible values: PREEMPTIBILITY_UNSPECIFIED, NON_PREEMPTIBLE, PREEMPTIBLE
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigArgs:
     def __init__(__self__, *,
@@ -9018,6 +11956,19 @@ class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigArgs:
         pulumi.set(self, "preemptibility", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigAcceleratorArgsDict(TypedDict):
+        accelerator_count: NotRequired[pulumi.Input[int]]
+        """
+        The number of the accelerator cards of this type exposed to this instance.
+        """
+        accelerator_type: NotRequired[pulumi.Input[str]]
+        """
+        Full URL, partial URI, or short name of the accelerator type resource to expose to this instance. See (https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/auto-zone#using_auto_zone_placement) feature, you must use the short name of the accelerator type resource, for example, `nvidia-tesla-k80`.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigAcceleratorArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigAcceleratorArgs:
     def __init__(__self__, *,
@@ -9057,6 +12008,23 @@ class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigAccelera
         pulumi.set(self, "accelerator_type", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigDiskConfigArgsDict(TypedDict):
+        boot_disk_size_gb: NotRequired[pulumi.Input[int]]
+        """
+        Size in GB of the boot disk (default is 500GB).
+        """
+        boot_disk_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of the boot disk (default is "pd-standard"). Valid values: "pd-ssd" (Persistent Disk Solid State Drive) or "pd-standard" (Persistent Disk Hard Disk Drive).
+        """
+        num_local_ssds: NotRequired[pulumi.Input[int]]
+        """
+        Number of attached SSDs, from 0 to 4 (default is 0). If SSDs are not attached, the boot disk is used to store runtime logs and (https://hadoop.apache.org/docs/r1.2.1/hdfs_user_guide.html) data. If one or more SSDs are attached, this runtime bulk data is spread across them, and the boot disk contains only basic config and installed binaries.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigDiskConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigDiskConfigArgs:
     def __init__(__self__, *,
@@ -9112,6 +12080,19 @@ class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigDiskConf
         pulumi.set(self, "num_local_ssds", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigManagedGroupConfigArgsDict(TypedDict):
+        instance_group_manager_name: NotRequired[pulumi.Input[str]]
+        """
+        Output only. The name of the Instance Group Manager for this group.
+        """
+        instance_template_name: NotRequired[pulumi.Input[str]]
+        """
+        Output only. The name of the Instance Template used for the Managed Instance Group.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigManagedGroupConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigManagedGroupConfigArgs:
     def __init__(__self__, *,
@@ -9151,6 +12132,15 @@ class WorkflowTemplatePlacementManagedClusterConfigSecondaryWorkerConfigManagedG
         pulumi.set(self, "instance_template_name", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigSecurityConfigArgsDict(TypedDict):
+        kerberos_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigSecurityConfigKerberosConfigArgsDict']]
+        """
+        Kerberos related configuration.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigSecurityConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigSecurityConfigArgs:
     def __init__(__self__, *,
@@ -9174,6 +12164,71 @@ class WorkflowTemplatePlacementManagedClusterConfigSecurityConfigArgs:
         pulumi.set(self, "kerberos_config", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigSecurityConfigKerberosConfigArgsDict(TypedDict):
+        cross_realm_trust_admin_server: NotRequired[pulumi.Input[str]]
+        """
+        The admin server (IP or hostname) for the remote trusted realm in a cross realm trust relationship.
+        """
+        cross_realm_trust_kdc: NotRequired[pulumi.Input[str]]
+        """
+        The KDC (IP or hostname) for the remote trusted realm in a cross realm trust relationship.
+        """
+        cross_realm_trust_realm: NotRequired[pulumi.Input[str]]
+        """
+        The remote realm the Dataproc on-cluster KDC will trust, should the user enable cross realm trust.
+        """
+        cross_realm_trust_shared_password: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing the shared password between the on-cluster Kerberos realm and the remote trusted realm, in a cross realm trust relationship.
+        """
+        enable_kerberos: NotRequired[pulumi.Input[bool]]
+        """
+        Flag to indicate whether to Kerberize the cluster (default: false). Set this field to true to enable Kerberos on a cluster.
+        """
+        kdc_db_key: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing the master key of the KDC database.
+        """
+        key_password: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing the password to the user provided key. For the self-signed certificate, this password is generated by Dataproc.
+        """
+        keystore: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of the keystore file used for SSL encryption. If not provided, Dataproc will provide a self-signed certificate.
+        """
+        keystore_password: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing the password to the user provided keystore. For the self-signed certificate, this password is generated by Dataproc.
+        """
+        kms_key: NotRequired[pulumi.Input[str]]
+        """
+        The uri of the KMS key used to encrypt various sensitive files.
+        """
+        realm: NotRequired[pulumi.Input[str]]
+        """
+        The name of the on-cluster Kerberos realm. If not specified, the uppercased domain of hostnames will be the realm.
+        """
+        root_principal_password: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing the root principal password.
+        """
+        tgt_lifetime_hours: NotRequired[pulumi.Input[int]]
+        """
+        The lifetime of the ticket granting ticket, in hours. If not specified, or user specifies 0, then default value 10 will be used.
+        """
+        truststore: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of the truststore file used for SSL encryption. If not provided, Dataproc will provide a self-signed certificate.
+        """
+        truststore_password: NotRequired[pulumi.Input[str]]
+        """
+        The Cloud Storage URI of a KMS encrypted file containing the password to the user provided truststore. For the self-signed certificate, this password is generated by Dataproc.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigSecurityConfigKerberosConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigSecurityConfigKerberosConfigArgs:
     def __init__(__self__, *,
@@ -9421,6 +12476,38 @@ class WorkflowTemplatePlacementManagedClusterConfigSecurityConfigKerberosConfigA
         pulumi.set(self, "truststore_password", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigSoftwareConfigArgsDict(TypedDict):
+        image_version: NotRequired[pulumi.Input[str]]
+        """
+        The version of software inside the cluster. It must be one of the supported [Dataproc Versions](https://cloud.google.com/dataproc/docs/concepts/versioning/dataproc-versions#supported_dataproc_versions), such as "1.2" (including a subminor version, such as "1.2.29"), or the ["preview" version](https://cloud.google.com/dataproc/docs/concepts/versioning/dataproc-versions#other_versions). If unspecified, it defaults to the latest Debian version.
+        """
+        optional_components: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The set of components to activate on the cluster.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The properties to set on daemon config files.
+
+        Property keys are specified in `prefix:property` format, for example `core:hadoop.tmp.dir`. The following are supported prefixes and their mappings:
+
+        * capacity-scheduler: `capacity-scheduler.xml`
+        * core: `core-site.xml`
+        * distcp: `distcp-default.xml`
+        * hdfs: `hdfs-site.xml`
+        * hive: `hive-site.xml`
+        * mapred: `mapred-site.xml`
+        * pig: `pig.properties`
+        * spark: `spark-defaults.conf`
+        * yarn: `yarn-site.xml`
+
+
+        For more information, see [Cluster properties](https://cloud.google.com/dataproc/docs/concepts/cluster-properties).
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigSoftwareConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigSoftwareConfigArgs:
     def __init__(__self__, *,
@@ -9506,6 +12593,51 @@ class WorkflowTemplatePlacementManagedClusterConfigSoftwareConfigArgs:
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigArgsDict(TypedDict):
+        accelerators: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigWorkerConfigAcceleratorArgsDict']]]]
+        """
+        Optional. The Compute Engine accelerator configuration for these instances.
+        """
+        disk_config: NotRequired[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigWorkerConfigDiskConfigArgsDict']]
+        """
+        Optional. Disk option config settings.
+        """
+        image: NotRequired[pulumi.Input[str]]
+        """
+        Optional. The Compute Engine image resource used for cluster instances. The URI can represent an image or image family. Image examples: * `https://www.googleapis.com/compute/beta/projects/[project_id]/global/images/[image-id]` * `projects/[project_id]/global/images/[image-id]` * `image-id` Image family examples. Dataproc will use the most recent image from the family: * `https://www.googleapis.com/compute/beta/projects/[project_id]/global/images/family/[custom-image-family-name]` * `projects/[project_id]/global/images/family/[custom-image-family-name]` If the URI is unspecified, it will be inferred from `SoftwareConfig.image_version` or the system default.
+        """
+        instance_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Output only. The list of instance names. Dataproc derives the names from `cluster_name`, `num_instances`, and the instance group.
+        """
+        is_preemptible: NotRequired[pulumi.Input[bool]]
+        """
+        Output only. Specifies that this instance group contains preemptible instances.
+        """
+        machine_type: NotRequired[pulumi.Input[str]]
+        """
+        Optional. The Compute Engine machine type used for cluster instances. A full URL, partial URI, or short name are valid. Examples: * `https://www.googleapis.com/compute/v1/projects/[project_id]/zones/us-east1-a/machineTypes/n1-standard-2` * `projects/[project_id]/zones/us-east1-a/machineTypes/n1-standard-2` * `n1-standard-2` **Auto Zone Exception**: If you are using the Dataproc [Auto Zone Placement](https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/auto-zone#using_auto_zone_placement) feature, you must use the short name of the machine type resource, for example, `n1-standard-2`.
+        """
+        managed_group_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplatePlacementManagedClusterConfigWorkerConfigManagedGroupConfigArgsDict']]]]
+        """
+        Output only. The config for Compute Engine Instance Group Manager that manages this group. This is only used for preemptible instance groups.
+        """
+        min_cpu_platform: NotRequired[pulumi.Input[str]]
+        """
+        Optional. Specifies the minimum cpu platform for the Instance Group. See [Dataproc > Minimum CPU Platform](https://cloud.google.com/dataproc/docs/concepts/compute/dataproc-min-cpu).
+        """
+        num_instances: NotRequired[pulumi.Input[int]]
+        """
+        Optional. The number of VM instances in the instance group. For [HA cluster](https://www.terraform.io/dataproc/docs/concepts/configuring-clusters/high-availability) master_config groups, **must be set to 3**. For standard cluster master_config groups, **must be set to 1**.
+        """
+        preemptibility: NotRequired[pulumi.Input[str]]
+        """
+        Optional. Specifies the preemptibility of the instance group. The default value for master and worker groups is `NON_PREEMPTIBLE`. This default cannot be changed. The default value for secondary instances is `PREEMPTIBLE`. Possible values: PREEMPTIBILITY_UNSPECIFIED, NON_PREEMPTIBLE, PREEMPTIBLE
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigWorkerConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigArgs:
     def __init__(__self__, *,
@@ -9673,6 +12805,19 @@ class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigArgs:
         pulumi.set(self, "preemptibility", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigAcceleratorArgsDict(TypedDict):
+        accelerator_count: NotRequired[pulumi.Input[int]]
+        """
+        The number of the accelerator cards of this type exposed to this instance.
+        """
+        accelerator_type: NotRequired[pulumi.Input[str]]
+        """
+        Full URL, partial URI, or short name of the accelerator type resource to expose to this instance. See (https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/auto-zone#using_auto_zone_placement) feature, you must use the short name of the accelerator type resource, for example, `nvidia-tesla-k80`.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigWorkerConfigAcceleratorArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigAcceleratorArgs:
     def __init__(__self__, *,
@@ -9712,6 +12857,23 @@ class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigAcceleratorArgs:
         pulumi.set(self, "accelerator_type", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigDiskConfigArgsDict(TypedDict):
+        boot_disk_size_gb: NotRequired[pulumi.Input[int]]
+        """
+        Size in GB of the boot disk (default is 500GB).
+        """
+        boot_disk_type: NotRequired[pulumi.Input[str]]
+        """
+        Type of the boot disk (default is "pd-standard"). Valid values: "pd-ssd" (Persistent Disk Solid State Drive) or "pd-standard" (Persistent Disk Hard Disk Drive).
+        """
+        num_local_ssds: NotRequired[pulumi.Input[int]]
+        """
+        Number of attached SSDs, from 0 to 4 (default is 0). If SSDs are not attached, the boot disk is used to store runtime logs and (https://hadoop.apache.org/docs/r1.2.1/hdfs_user_guide.html) data. If one or more SSDs are attached, this runtime bulk data is spread across them, and the boot disk contains only basic config and installed binaries.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigWorkerConfigDiskConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigDiskConfigArgs:
     def __init__(__self__, *,
@@ -9767,6 +12929,19 @@ class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigDiskConfigArgs:
         pulumi.set(self, "num_local_ssds", value)
 
 
+if not MYPY:
+    class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigManagedGroupConfigArgsDict(TypedDict):
+        instance_group_manager_name: NotRequired[pulumi.Input[str]]
+        """
+        Output only. The name of the Instance Group Manager for this group.
+        """
+        instance_template_name: NotRequired[pulumi.Input[str]]
+        """
+        Output only. The name of the Instance Template used for the Managed Instance Group.
+        """
+elif False:
+    WorkflowTemplatePlacementManagedClusterConfigWorkerConfigManagedGroupConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class WorkflowTemplatePlacementManagedClusterConfigWorkerConfigManagedGroupConfigArgs:
     def __init__(__self__, *,