pulumi-gcp 8.11.0a1734348982__py3-none-any.whl → 8.12.0__py3-none-any.whl

pulumi_gcp/dataproc/outputs.py

@@ -28,6 +28,7 @@ __all__ = [
     'BatchEnvironmentConfigPeripheralsConfigSparkHistoryServerConfig',
     'BatchPysparkBatch',
     'BatchRuntimeConfig',
+    'BatchRuntimeConfigAutotuningConfig',
     'BatchRuntimeInfo',
     'BatchRuntimeInfoApproximateUsage',
     'BatchRuntimeInfoCurrentUsage',
@@ -47,6 +48,7 @@ __all__ = [
     'ClusterClusterConfigEncryptionConfig',
     'ClusterClusterConfigEndpointConfig',
     'ClusterClusterConfigGceClusterConfig',
+    'ClusterClusterConfigGceClusterConfigConfidentialInstanceConfig',
     'ClusterClusterConfigGceClusterConfigNodeGroupAffinity',
     'ClusterClusterConfigGceClusterConfigReservationAffinity',
     'ClusterClusterConfigGceClusterConfigShieldedInstanceConfig',
@@ -61,6 +63,7 @@ __all__ = [
     'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicy',
     'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionList',
     'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResult',
+    'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMix',
     'ClusterClusterConfigSecurityConfig',
     'ClusterClusterConfigSecurityConfigKerberosConfig',
     'ClusterClusterConfigSoftwareConfig',
@@ -1008,7 +1011,9 @@ class BatchRuntimeConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "containerImage":
+        if key == "autotuningConfig":
+            suggest = "autotuning_config"
+        elif key == "containerImage":
             suggest = "container_image"
         elif key == "effectiveProperties":
             suggest = "effective_properties"
@@ -1025,17 +1030,26 @@ class BatchRuntimeConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 autotuning_config: Optional['outputs.BatchRuntimeConfigAutotuningConfig'] = None,
+                 cohort: Optional[str] = None,
                  container_image: Optional[str] = None,
                  effective_properties: Optional[Mapping[str, str]] = None,
                  properties: Optional[Mapping[str, str]] = None,
                  version: Optional[str] = None):
         """
+        :param 'BatchRuntimeConfigAutotuningConfigArgs' autotuning_config: Optional. Autotuning configuration of the workload.
+               Structure is documented below.
+        :param str cohort: Optional. Cohort identifier. Identifies families of the workloads having the same shape, e.g. daily ETL jobs.
         :param str container_image: Optional custom container image for the job runtime environment. If not specified, a default container image will be used.
         :param Mapping[str, str] effective_properties: (Output)
                A mapping of property names to values, which are used to configure workload execution.
         :param Mapping[str, str] properties: A mapping of property names to values, which are used to configure workload execution.
         :param str version: Version of the batch runtime.
         """
+        if autotuning_config is not None:
+            pulumi.set(__self__, "autotuning_config", autotuning_config)
+        if cohort is not None:
+            pulumi.set(__self__, "cohort", cohort)
         if container_image is not None:
             pulumi.set(__self__, "container_image", container_image)
         if effective_properties is not None:
@@ -1045,6 +1059,23 @@ class BatchRuntimeConfig(dict):
         if version is not None:
             pulumi.set(__self__, "version", version)
 
+    @property
+    @pulumi.getter(name="autotuningConfig")
+    def autotuning_config(self) -> Optional['outputs.BatchRuntimeConfigAutotuningConfig']:
+        """
+        Optional. Autotuning configuration of the workload.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "autotuning_config")
+
+    @property
+    @pulumi.getter
+    def cohort(self) -> Optional[str]:
+        """
+        Optional. Cohort identifier. Identifies families of the workloads having the same shape, e.g. daily ETL jobs.
+        """
+        return pulumi.get(self, "cohort")
+
     @property
     @pulumi.getter(name="containerImage")
     def container_image(self) -> Optional[str]:
@@ -1079,6 +1110,27 @@ class BatchRuntimeConfig(dict):
         return pulumi.get(self, "version")
 
 
+@pulumi.output_type
+class BatchRuntimeConfigAutotuningConfig(dict):
+    def __init__(__self__, *,
+                 scenarios: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] scenarios: Optional. Scenarios for which tunings are applied.
+               Each value may be one of: `SCALING`, `BROADCAST_HASH_JOIN`, `MEMORY`.
+        """
+        if scenarios is not None:
+            pulumi.set(__self__, "scenarios", scenarios)
+
+    @property
+    @pulumi.getter
+    def scenarios(self) -> Optional[Sequence[str]]:
+        """
+        Optional. Scenarios for which tunings are applied.
+        Each value may be one of: `SCALING`, `BROADCAST_HASH_JOIN`, `MEMORY`.
+        """
+        return pulumi.get(self, "scenarios")
+
+
 @pulumi.output_type
 class BatchRuntimeInfo(dict):
     @staticmethod
@@ -2634,7 +2686,9 @@ class ClusterClusterConfigGceClusterConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "internalIpOnly":
+        if key == "confidentialInstanceConfig":
+            suggest = "confidential_instance_config"
+        elif key == "internalIpOnly":
             suggest = "internal_ip_only"
         elif key == "nodeGroupAffinity":
             suggest = "node_group_affinity"
@@ -2659,6 +2713,7 @@ class ClusterClusterConfigGceClusterConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 confidential_instance_config: Optional['outputs.ClusterClusterConfigGceClusterConfigConfidentialInstanceConfig'] = None,
                  internal_ip_only: Optional[bool] = None,
                  metadata: Optional[Mapping[str, str]] = None,
                  network: Optional[str] = None,
@@ -2671,6 +2726,7 @@ class ClusterClusterConfigGceClusterConfig(dict):
                  tags: Optional[Sequence[str]] = None,
                  zone: Optional[str] = None):
         """
+        :param 'ClusterClusterConfigGceClusterConfigConfidentialInstanceConfigArgs' confidential_instance_config: Confidential Instance Config for clusters using [Confidential VMs](https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/confidential-compute)
         :param bool internal_ip_only: 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
@@ -2705,6 +2761,8 @@ class ClusterClusterConfigGceClusterConfig(dict):
                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`.
         """
+        if confidential_instance_config is not None:
+            pulumi.set(__self__, "confidential_instance_config", confidential_instance_config)
         if internal_ip_only is not None:
             pulumi.set(__self__, "internal_ip_only", internal_ip_only)
         if metadata is not None:
@@ -2728,6 +2786,14 @@ class ClusterClusterConfigGceClusterConfig(dict):
         if zone is not None:
             pulumi.set(__self__, "zone", zone)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceConfig")
+    def confidential_instance_config(self) -> Optional['outputs.ClusterClusterConfigGceClusterConfigConfidentialInstanceConfig']:
+        """
+        Confidential Instance Config for clusters using [Confidential VMs](https://cloud.google.com/dataproc/docs/concepts/configuring-clusters/confidential-compute)
+        """
+        return pulumi.get(self, "confidential_instance_config")
+
     @property
     @pulumi.getter(name="internalIpOnly")
     def internal_ip_only(self) -> Optional[bool]:
@@ -2839,6 +2905,42 @@ class ClusterClusterConfigGceClusterConfig(dict):
         return pulumi.get(self, "zone")
 
 
+@pulumi.output_type
+class ClusterClusterConfigGceClusterConfigConfidentialInstanceConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "enableConfidentialCompute":
+            suggest = "enable_confidential_compute"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterClusterConfigGceClusterConfigConfidentialInstanceConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterClusterConfigGceClusterConfigConfidentialInstanceConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterClusterConfigGceClusterConfigConfidentialInstanceConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enable_confidential_compute: Optional[bool] = None):
+        """
+        :param bool enable_confidential_compute: Defines whether the instance should have confidential compute enabled.
+        """
+        if enable_confidential_compute is not None:
+            pulumi.set(__self__, "enable_confidential_compute", enable_confidential_compute)
+
+    @property
+    @pulumi.getter(name="enableConfidentialCompute")
+    def enable_confidential_compute(self) -> Optional[bool]:
+        """
+        Defines whether the instance should have confidential compute enabled.
+        """
+        return pulumi.get(self, "enable_confidential_compute")
+
+
 @pulumi.output_type
 class ClusterClusterConfigGceClusterConfigNodeGroupAffinity(dict):
     @staticmethod
@@ -3667,6 +3769,8 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicy(dict)
             suggest = "instance_selection_lists"
         elif key == "instanceSelectionResults":
             suggest = "instance_selection_results"
+        elif key == "provisioningModelMix":
+            suggest = "provisioning_model_mix"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicy. Access the value via the '{suggest}' property getter instead.")
@@ -3681,15 +3785,19 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicy(dict)
 
     def __init__(__self__, *,
                  instance_selection_lists: Optional[Sequence['outputs.ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionList']] = None,
-                 instance_selection_results: Optional[Sequence['outputs.ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResult']] = None):
+                 instance_selection_results: Optional[Sequence['outputs.ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResult']] = None,
+                 provisioning_model_mix: Optional['outputs.ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMix'] = None):
         """
         :param Sequence['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgs'] instance_selection_lists: List of instance selection options that the group will use when creating new VMs.
         :param Sequence['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgs'] instance_selection_results: A list of instance selection results in the group.
+        :param 'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgs' provisioning_model_mix: Defines how Dataproc should create VMs with a mixture of provisioning models.
         """
         if instance_selection_lists is not None:
             pulumi.set(__self__, "instance_selection_lists", instance_selection_lists)
         if instance_selection_results is not None:
             pulumi.set(__self__, "instance_selection_results", instance_selection_results)
+        if provisioning_model_mix is not None:
+            pulumi.set(__self__, "provisioning_model_mix", provisioning_model_mix)
 
     @property
     @pulumi.getter(name="instanceSelectionLists")
@@ -3707,6 +3815,14 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicy(dict)
         """
         return pulumi.get(self, "instance_selection_results")
 
+    @property
+    @pulumi.getter(name="provisioningModelMix")
+    def provisioning_model_mix(self) -> Optional['outputs.ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMix']:
+        """
+        Defines how Dataproc should create VMs with a mixture of provisioning models.
+        """
+        return pulumi.get(self, "provisioning_model_mix")
+
 
 @pulumi.output_type
 class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionList(dict):
@@ -3810,6 +3926,56 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstan
         return pulumi.get(self, "vm_count")
 
 
+@pulumi.output_type
+class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMix(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "standardCapacityBase":
+            suggest = "standard_capacity_base"
+        elif key == "standardCapacityPercentAboveBase":
+            suggest = "standard_capacity_percent_above_base"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMix. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMix.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMix.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 standard_capacity_base: Optional[int] = None,
+                 standard_capacity_percent_above_base: Optional[int] = None):
+        """
+        :param int standard_capacity_base: The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need.
+        :param int standard_capacity_percent_above_base: The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs.
+        """
+        if standard_capacity_base is not None:
+            pulumi.set(__self__, "standard_capacity_base", standard_capacity_base)
+        if standard_capacity_percent_above_base is not None:
+            pulumi.set(__self__, "standard_capacity_percent_above_base", standard_capacity_percent_above_base)
+
+    @property
+    @pulumi.getter(name="standardCapacityBase")
+    def standard_capacity_base(self) -> Optional[int]:
+        """
+        The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need.
+        """
+        return pulumi.get(self, "standard_capacity_base")
+
+    @property
+    @pulumi.getter(name="standardCapacityPercentAboveBase")
+    def standard_capacity_percent_above_base(self) -> Optional[int]:
+        """
+        The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs.
+        """
+        return pulumi.get(self, "standard_capacity_percent_above_base")
+
+
 @pulumi.output_type
 class ClusterClusterConfigSecurityConfig(dict):
     @staticmethod

pulumi_gcp/diagflow/_inputs.py

@@ -1400,7 +1400,7 @@ if not MYPY:
         """
         use_timeout_based_endpointing: NotRequired[pulumi.Input[bool]]
         """
-        Use timeout based endpointing, interpreting endpointer sensitivy as seconds of timeout value.
+        Use timeout based endpointing, interpreting endpointer sensitivity as seconds of timeout value.
         """
 elif False:
     CxFlowAdvancedSettingsSpeechSettingsArgsDict: TypeAlias = Mapping[str, Any]
@@ -1418,7 +1418,7 @@ class CxFlowAdvancedSettingsSpeechSettingsArgs:
                An object containing a list of **"key": value** pairs. Example: **{ "name": "wrench", "mass": "1.3kg", "count": "3" }**.
         :param pulumi.Input[str] no_speech_timeout: Timeout before detecting no speech.
                A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
-        :param pulumi.Input[bool] use_timeout_based_endpointing: Use timeout based endpointing, interpreting endpointer sensitivy as seconds of timeout value.
+        :param pulumi.Input[bool] use_timeout_based_endpointing: Use timeout based endpointing, interpreting endpointer sensitivity as seconds of timeout value.
         """
         if endpointer_sensitivity is not None:
             pulumi.set(__self__, "endpointer_sensitivity", endpointer_sensitivity)
@@ -1471,7 +1471,7 @@ class CxFlowAdvancedSettingsSpeechSettingsArgs:
     @pulumi.getter(name="useTimeoutBasedEndpointing")
     def use_timeout_based_endpointing(self) -> Optional[pulumi.Input[bool]]:
         """
-        Use timeout based endpointing, interpreting endpointer sensitivy as seconds of timeout value.
+        Use timeout based endpointing, interpreting endpointer sensitivity as seconds of timeout value.
         """
         return pulumi.get(self, "use_timeout_based_endpointing")
 

pulumi_gcp/diagflow/outputs.py

@@ -1069,7 +1069,7 @@ class CxFlowAdvancedSettingsSpeechSettings(dict):
                An object containing a list of **"key": value** pairs. Example: **{ "name": "wrench", "mass": "1.3kg", "count": "3" }**.
         :param str no_speech_timeout: Timeout before detecting no speech.
                A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
-        :param bool use_timeout_based_endpointing: Use timeout based endpointing, interpreting endpointer sensitivy as seconds of timeout value.
+        :param bool use_timeout_based_endpointing: Use timeout based endpointing, interpreting endpointer sensitivity as seconds of timeout value.
         """
         if endpointer_sensitivity is not None:
             pulumi.set(__self__, "endpointer_sensitivity", endpointer_sensitivity)
@@ -1110,7 +1110,7 @@ class CxFlowAdvancedSettingsSpeechSettings(dict):
     @pulumi.getter(name="useTimeoutBasedEndpointing")
     def use_timeout_based_endpointing(self) -> Optional[bool]:
         """
-        Use timeout based endpointing, interpreting endpointer sensitivy as seconds of timeout value.
+        Use timeout based endpointing, interpreting endpointer sensitivity as seconds of timeout value.
         """
         return pulumi.get(self, "use_timeout_based_endpointing")
 

pulumi_gcp/discoveryengine/search_engine.py

@@ -42,7 +42,7 @@ class SearchEngineArgs:
         :param pulumi.Input['SearchEngineCommonConfigArgs'] common_config: Common config spec that specifies the metadata of the engine.
         :param pulumi.Input[str] industry_vertical: The industry vertical that the engine registers. The restriction of the Engine industry vertical is based on DataStore:
                If unspecified, default to GENERIC. Vertical on Engine has to match vertical of the DataStore liniked to the engine.
-               Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA"]
+               Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA", "HEALTHCARE_FHIR"]
         """
         pulumi.set(__self__, "collection_id", collection_id)
         pulumi.set(__self__, "data_store_ids", data_store_ids)
@@ -148,7 +148,7 @@ class SearchEngineArgs:
         """
         The industry vertical that the engine registers. The restriction of the Engine industry vertical is based on DataStore:
         If unspecified, default to GENERIC. Vertical on Engine has to match vertical of the DataStore liniked to the engine.
-        Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA"]
+        Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA", "HEALTHCARE_FHIR"]
         """
         return pulumi.get(self, "industry_vertical")
 
@@ -191,7 +191,7 @@ class _SearchEngineState:
         :param pulumi.Input[str] engine_id: Unique ID to use for Search Engine App.
         :param pulumi.Input[str] industry_vertical: The industry vertical that the engine registers. The restriction of the Engine industry vertical is based on DataStore:
                If unspecified, default to GENERIC. Vertical on Engine has to match vertical of the DataStore liniked to the engine.
-               Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA"]
+               Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA", "HEALTHCARE_FHIR"]
         :param pulumi.Input[str] location: Location.
         :param pulumi.Input[str] name: The unique full resource name of the search engine. Values are of the format
                `projects/{project}/locations/{location}/collections/{collection_id}/engines/{engine_id}`.
@@ -304,7 +304,7 @@ class _SearchEngineState:
         """
         The industry vertical that the engine registers. The restriction of the Engine industry vertical is based on DataStore:
         If unspecified, default to GENERIC. Vertical on Engine has to match vertical of the DataStore liniked to the engine.
-        Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA"]
+        Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA", "HEALTHCARE_FHIR"]
         """
         return pulumi.get(self, "industry_vertical")
 
@@ -456,7 +456,7 @@ class SearchEngine(pulumi.CustomResource):
         :param pulumi.Input[str] engine_id: Unique ID to use for Search Engine App.
         :param pulumi.Input[str] industry_vertical: The industry vertical that the engine registers. The restriction of the Engine industry vertical is based on DataStore:
                If unspecified, default to GENERIC. Vertical on Engine has to match vertical of the DataStore liniked to the engine.
-               Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA"]
+               Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA", "HEALTHCARE_FHIR"]
         :param pulumi.Input[str] location: Location.
         :param pulumi.Input[Union['SearchEngineSearchEngineConfigArgs', 'SearchEngineSearchEngineConfigArgsDict']] search_engine_config: Configurations for a Search Engine.
                Structure is documented below.
@@ -619,7 +619,7 @@ class SearchEngine(pulumi.CustomResource):
         :param pulumi.Input[str] engine_id: Unique ID to use for Search Engine App.
         :param pulumi.Input[str] industry_vertical: The industry vertical that the engine registers. The restriction of the Engine industry vertical is based on DataStore:
                If unspecified, default to GENERIC. Vertical on Engine has to match vertical of the DataStore liniked to the engine.
-               Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA"]
+               Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA", "HEALTHCARE_FHIR"]
         :param pulumi.Input[str] location: Location.
         :param pulumi.Input[str] name: The unique full resource name of the search engine. Values are of the format
                `projects/{project}/locations/{location}/collections/{collection_id}/engines/{engine_id}`.
@@ -701,7 +701,7 @@ class SearchEngine(pulumi.CustomResource):
         """
         The industry vertical that the engine registers. The restriction of the Engine industry vertical is based on DataStore:
         If unspecified, default to GENERIC. Vertical on Engine has to match vertical of the DataStore liniked to the engine.
-        Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA"]
+        Default value: "GENERIC" Possible values: ["GENERIC", "MEDIA", "HEALTHCARE_FHIR"]
         """
         return pulumi.get(self, "industry_vertical")
 

pulumi_gcp/firebase/_inputs.py

@@ -55,6 +55,8 @@ __all__ = [
     'HostingCustomDomainRequiredDnsUpdateDiscoveredRecordArgsDict',
     'HostingVersionConfigArgs',
     'HostingVersionConfigArgsDict',
+    'HostingVersionConfigHeaderArgs',
+    'HostingVersionConfigHeaderArgsDict',
     'HostingVersionConfigRedirectArgs',
     'HostingVersionConfigRedirectArgsDict',
     'HostingVersionConfigRewriteArgs',
@@ -1694,6 +1696,12 @@ class HostingCustomDomainRequiredDnsUpdateDiscoveredRecordArgs:
 
 if not MYPY:
     class HostingVersionConfigArgsDict(TypedDict):
+        headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigHeaderArgsDict']]]]
+        """
+        An array of objects, where each object specifies a URL pattern that, if matched to the request URL path,
+        triggers Hosting to apply the specified custom response headers.
+        Structure is documented below.
+        """
         redirects: NotRequired[pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigRedirectArgsDict']]]]
         """
         An array of objects (called redirect rules), where each rule specifies a URL pattern that, if matched to the request URL path,
@@ -1712,9 +1720,13 @@ elif False:
 @pulumi.input_type
 class HostingVersionConfigArgs:
     def __init__(__self__, *,
+                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigHeaderArgs']]]] = None,
                  redirects: Optional[pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigRedirectArgs']]]] = None,
                  rewrites: Optional[pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigRewriteArgs']]]] = None):
         """
+        :param pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigHeaderArgs']]] headers: An array of objects, where each object specifies a URL pattern that, if matched to the request URL path,
+               triggers Hosting to apply the specified custom response headers.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigRedirectArgs']]] redirects: An array of objects (called redirect rules), where each rule specifies a URL pattern that, if matched to the request URL path,
                triggers Hosting to respond with a redirect to the specified destination path.
                Structure is documented below.
@@ -1722,11 +1734,27 @@ class HostingVersionConfigArgs:
                request URL path, triggers Hosting to respond as if the service were given the specified destination URL.
                Structure is documented below.
         """
+        if headers is not None:
+            pulumi.set(__self__, "headers", headers)
         if redirects is not None:
             pulumi.set(__self__, "redirects", redirects)
         if rewrites is not None:
             pulumi.set(__self__, "rewrites", rewrites)
 
+    @property
+    @pulumi.getter
+    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigHeaderArgs']]]]:
+        """
+        An array of objects, where each object specifies a URL pattern that, if matched to the request URL path,
+        triggers Hosting to apply the specified custom response headers.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "headers")
+
+    @headers.setter
+    def headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigHeaderArgs']]]]):
+        pulumi.set(self, "headers", value)
+
     @property
     @pulumi.getter
     def redirects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HostingVersionConfigRedirectArgs']]]]:
@@ -1756,6 +1784,77 @@ class HostingVersionConfigArgs:
         pulumi.set(self, "rewrites", value)
 
 
+if not MYPY:
+    class HostingVersionConfigHeaderArgsDict(TypedDict):
+        headers: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        The additional headers to add to the response. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
+        """
+        glob: NotRequired[pulumi.Input[str]]
+        """
+        The user-supplied glob to match against the request URL path.
+        """
+        regex: NotRequired[pulumi.Input[str]]
+        """
+        The user-supplied RE2 regular expression to match against the request URL path.
+        """
+elif False:
+    HostingVersionConfigHeaderArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class HostingVersionConfigHeaderArgs:
+    def __init__(__self__, *,
+                 headers: pulumi.Input[Mapping[str, pulumi.Input[str]]],
+                 glob: Optional[pulumi.Input[str]] = None,
+                 regex: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] headers: The additional headers to add to the response. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
+        :param pulumi.Input[str] glob: The user-supplied glob to match against the request URL path.
+        :param pulumi.Input[str] regex: The user-supplied RE2 regular expression to match against the request URL path.
+        """
+        pulumi.set(__self__, "headers", headers)
+        if glob is not None:
+            pulumi.set(__self__, "glob", glob)
+        if regex is not None:
+            pulumi.set(__self__, "regex", regex)
+
+    @property
+    @pulumi.getter
+    def headers(self) -> pulumi.Input[Mapping[str, pulumi.Input[str]]]:
+        """
+        The additional headers to add to the response. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
+        """
+        return pulumi.get(self, "headers")
+
+    @headers.setter
+    def headers(self, value: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
+        pulumi.set(self, "headers", value)
+
+    @property
+    @pulumi.getter
+    def glob(self) -> Optional[pulumi.Input[str]]:
+        """
+        The user-supplied glob to match against the request URL path.
+        """
+        return pulumi.get(self, "glob")
+
+    @glob.setter
+    def glob(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "glob", value)
+
+    @property
+    @pulumi.getter
+    def regex(self) -> Optional[pulumi.Input[str]]:
+        """
+        The user-supplied RE2 regular expression to match against the request URL path.
+        """
+        return pulumi.get(self, "regex")
+
+    @regex.setter
+    def regex(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "regex", value)
+
+
 if not MYPY:
     class HostingVersionConfigRedirectArgsDict(TypedDict):
         location: pulumi.Input[str]

pulumi_gcp/firebase/database_instance.py

@@ -333,6 +333,7 @@ class DatabaseInstance(pulumi.CustomResource):
         ```python
         import pulumi
         import pulumi_gcp as gcp
+        import pulumi_time as time
 
         default = gcp.organizations.Project("default",
             project_id="rtdb-project",
@@ -342,16 +343,24 @@ class DatabaseInstance(pulumi.CustomResource):
             labels={
                 "firebase": "enabled",
             })
-        default_project = gcp.firebase.Project("default", project=default.project_id)
+        firebase = gcp.projects.Service("firebase",
+            project=default.project_id,
+            service="firebase.googleapis.com",
+            disable_on_destroy=False)
+        default_project = gcp.firebase.Project("default", project=default.project_id,
+        opts = pulumi.ResourceOptions(depends_on=[firebase]))
         firebase_database = gcp.projects.Service("firebase_database",
             project=default_project.project,
-            service="firebasedatabase.googleapis.com")
+            service="firebasedatabase.googleapis.com",
+            disable_on_destroy=False)
+        wait60_seconds = time.index.Sleep("wait_60_seconds", create_duration=60s,
+        opts = pulumi.ResourceOptions(depends_on=[firebase_database]))
         default_database_instance = gcp.firebase.DatabaseInstance("default",
             project=default_project.project,
             region="us-central1",
             instance_id="rtdb-project-default-rtdb",
             type="DEFAULT_DATABASE",
-            opts = pulumi.ResourceOptions(depends_on=[firebase_database]))
+            opts = pulumi.ResourceOptions(depends_on=[wait60_seconds]))
         ```
 
         ## Import
@@ -441,6 +450,7 @@ class DatabaseInstance(pulumi.CustomResource):
         ```python
         import pulumi
         import pulumi_gcp as gcp
+        import pulumi_time as time
 
         default = gcp.organizations.Project("default",
             project_id="rtdb-project",
@@ -450,16 +460,24 @@ class DatabaseInstance(pulumi.CustomResource):
             labels={
                 "firebase": "enabled",
             })
-        default_project = gcp.firebase.Project("default", project=default.project_id)
+        firebase = gcp.projects.Service("firebase",
+            project=default.project_id,
+            service="firebase.googleapis.com",
+            disable_on_destroy=False)
+        default_project = gcp.firebase.Project("default", project=default.project_id,
+        opts = pulumi.ResourceOptions(depends_on=[firebase]))
         firebase_database = gcp.projects.Service("firebase_database",
             project=default_project.project,
-            service="firebasedatabase.googleapis.com")
+            service="firebasedatabase.googleapis.com",
+            disable_on_destroy=False)
+        wait60_seconds = time.index.Sleep("wait_60_seconds", create_duration=60s,
+        opts = pulumi.ResourceOptions(depends_on=[firebase_database]))
         default_database_instance = gcp.firebase.DatabaseInstance("default",
             project=default_project.project,
             region="us-central1",
             instance_id="rtdb-project-default-rtdb",
             type="DEFAULT_DATABASE",
-            opts = pulumi.ResourceOptions(depends_on=[firebase_database]))
+            opts = pulumi.ResourceOptions(depends_on=[wait60_seconds]))
         ```
 
         ## Import