pulumi-gcp 7.29.0a1719364094__py3-none-any.whl → 7.29.0a1719416802__py3-none-any.whl

pulumi_gcp/dataproc/outputs.py

@@ -97,6 +97,8 @@ __all__ = [
     'MetastoreServiceNetworkConfig',
     'MetastoreServiceNetworkConfigConsumer',
     'MetastoreServiceScalingConfig',
+    'MetastoreServiceScalingConfigAutoscalingConfig',
+    'MetastoreServiceScalingConfigAutoscalingConfigLimitConfig',
     'MetastoreServiceScheduledBackup',
     'MetastoreServiceTelemetryConfig',
     'WorkflowTemplateJob',
@@ -166,6 +168,8 @@ __all__ = [
     'GetMetastoreServiceNetworkConfigResult',
     'GetMetastoreServiceNetworkConfigConsumerResult',
     'GetMetastoreServiceScalingConfigResult',
+    'GetMetastoreServiceScalingConfigAutoscalingConfigResult',
+    'GetMetastoreServiceScalingConfigAutoscalingConfigLimitConfigResult',
     'GetMetastoreServiceScheduledBackupResult',
     'GetMetastoreServiceTelemetryConfigResult',
 ]
@@ -6099,7 +6103,9 @@ class MetastoreServiceScalingConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "instanceSize":
+        if key == "autoscalingConfig":
+            suggest = "autoscaling_config"
+        elif key == "instanceSize":
             suggest = "instance_size"
         elif key == "scalingFactor":
             suggest = "scaling_factor"
@@ -6116,18 +6122,32 @@ class MetastoreServiceScalingConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 autoscaling_config: Optional['outputs.MetastoreServiceScalingConfigAutoscalingConfig'] = None,
                  instance_size: Optional[str] = None,
                  scaling_factor: Optional[float] = None):
         """
+        :param 'MetastoreServiceScalingConfigAutoscalingConfigArgs' autoscaling_config: Represents the autoscaling configuration of a metastore service.
+               Structure is documented below.
         :param str instance_size: Metastore instance sizes.
                Possible values are: `EXTRA_SMALL`, `SMALL`, `MEDIUM`, `LARGE`, `EXTRA_LARGE`.
         :param float scaling_factor: Scaling factor, in increments of 0.1 for values less than 1.0, and increments of 1.0 for values greater than 1.0.
         """
+        if autoscaling_config is not None:
+            pulumi.set(__self__, "autoscaling_config", autoscaling_config)
         if instance_size is not None:
             pulumi.set(__self__, "instance_size", instance_size)
         if scaling_factor is not None:
             pulumi.set(__self__, "scaling_factor", scaling_factor)
 
+    @property
+    @pulumi.getter(name="autoscalingConfig")
+    def autoscaling_config(self) -> Optional['outputs.MetastoreServiceScalingConfigAutoscalingConfig']:
+        """
+        Represents the autoscaling configuration of a metastore service.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "autoscaling_config")
+
     @property
     @pulumi.getter(name="instanceSize")
     def instance_size(self) -> Optional[str]:
@@ -6146,6 +6166,108 @@ class MetastoreServiceScalingConfig(dict):
         return pulumi.get(self, "scaling_factor")
 
 
+@pulumi.output_type
+class MetastoreServiceScalingConfigAutoscalingConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "autoscalingEnabled":
+            suggest = "autoscaling_enabled"
+        elif key == "limitConfig":
+            suggest = "limit_config"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MetastoreServiceScalingConfigAutoscalingConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MetastoreServiceScalingConfigAutoscalingConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MetastoreServiceScalingConfigAutoscalingConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 autoscaling_enabled: Optional[bool] = None,
+                 limit_config: Optional['outputs.MetastoreServiceScalingConfigAutoscalingConfigLimitConfig'] = None):
+        """
+        :param bool autoscaling_enabled: Defines whether autoscaling is enabled. The default value is false.
+        :param 'MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs' limit_config: Represents the limit configuration of a metastore service.
+               Structure is documented below.
+        """
+        if autoscaling_enabled is not None:
+            pulumi.set(__self__, "autoscaling_enabled", autoscaling_enabled)
+        if limit_config is not None:
+            pulumi.set(__self__, "limit_config", limit_config)
+
+    @property
+    @pulumi.getter(name="autoscalingEnabled")
+    def autoscaling_enabled(self) -> Optional[bool]:
+        """
+        Defines whether autoscaling is enabled. The default value is false.
+        """
+        return pulumi.get(self, "autoscaling_enabled")
+
+    @property
+    @pulumi.getter(name="limitConfig")
+    def limit_config(self) -> Optional['outputs.MetastoreServiceScalingConfigAutoscalingConfigLimitConfig']:
+        """
+        Represents the limit configuration of a metastore service.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "limit_config")
+
+
+@pulumi.output_type
+class MetastoreServiceScalingConfigAutoscalingConfigLimitConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxScalingFactor":
+            suggest = "max_scaling_factor"
+        elif key == "minScalingFactor":
+            suggest = "min_scaling_factor"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MetastoreServiceScalingConfigAutoscalingConfigLimitConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MetastoreServiceScalingConfigAutoscalingConfigLimitConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MetastoreServiceScalingConfigAutoscalingConfigLimitConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_scaling_factor: Optional[float] = None,
+                 min_scaling_factor: Optional[float] = None):
+        """
+        :param float max_scaling_factor: The maximum scaling factor that the service will autoscale to. The default value is 6.0.
+        :param float min_scaling_factor: The minimum scaling factor that the service will autoscale to. The default value is 0.1.
+        """
+        if max_scaling_factor is not None:
+            pulumi.set(__self__, "max_scaling_factor", max_scaling_factor)
+        if min_scaling_factor is not None:
+            pulumi.set(__self__, "min_scaling_factor", min_scaling_factor)
+
+    @property
+    @pulumi.getter(name="maxScalingFactor")
+    def max_scaling_factor(self) -> Optional[float]:
+        """
+        The maximum scaling factor that the service will autoscale to. The default value is 6.0.
+        """
+        return pulumi.get(self, "max_scaling_factor")
+
+    @property
+    @pulumi.getter(name="minScalingFactor")
+    def min_scaling_factor(self) -> Optional[float]:
+        """
+        The minimum scaling factor that the service will autoscale to. The default value is 0.1.
+        """
+        return pulumi.get(self, "min_scaling_factor")
+
+
 @pulumi.output_type
 class MetastoreServiceScheduledBackup(dict):
     @staticmethod
@@ -10596,15 +10718,26 @@ class GetMetastoreServiceNetworkConfigConsumerResult(dict):
 @pulumi.output_type
 class GetMetastoreServiceScalingConfigResult(dict):
     def __init__(__self__, *,
+                 autoscaling_configs: Sequence['outputs.GetMetastoreServiceScalingConfigAutoscalingConfigResult'],
                  instance_size: str,
                  scaling_factor: float):
         """
+        :param Sequence['GetMetastoreServiceScalingConfigAutoscalingConfigArgs'] autoscaling_configs: Represents the autoscaling configuration of a metastore service.
         :param str instance_size: Metastore instance sizes. Possible values: ["EXTRA_SMALL", "SMALL", "MEDIUM", "LARGE", "EXTRA_LARGE"]
         :param float scaling_factor: Scaling factor, in increments of 0.1 for values less than 1.0, and increments of 1.0 for values greater than 1.0.
         """
+        pulumi.set(__self__, "autoscaling_configs", autoscaling_configs)
         pulumi.set(__self__, "instance_size", instance_size)
         pulumi.set(__self__, "scaling_factor", scaling_factor)
 
+    @property
+    @pulumi.getter(name="autoscalingConfigs")
+    def autoscaling_configs(self) -> Sequence['outputs.GetMetastoreServiceScalingConfigAutoscalingConfigResult']:
+        """
+        Represents the autoscaling configuration of a metastore service.
+        """
+        return pulumi.get(self, "autoscaling_configs")
+
     @property
     @pulumi.getter(name="instanceSize")
     def instance_size(self) -> str:
@@ -10622,6 +10755,64 @@ class GetMetastoreServiceScalingConfigResult(dict):
         return pulumi.get(self, "scaling_factor")
 
 
+@pulumi.output_type
+class GetMetastoreServiceScalingConfigAutoscalingConfigResult(dict):
+    def __init__(__self__, *,
+                 autoscaling_enabled: bool,
+                 limit_configs: Sequence['outputs.GetMetastoreServiceScalingConfigAutoscalingConfigLimitConfigResult']):
+        """
+        :param bool autoscaling_enabled: Defines whether autoscaling is enabled. The default value is false.
+        :param Sequence['GetMetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs'] limit_configs: Represents the limit configuration of a metastore service.
+        """
+        pulumi.set(__self__, "autoscaling_enabled", autoscaling_enabled)
+        pulumi.set(__self__, "limit_configs", limit_configs)
+
+    @property
+    @pulumi.getter(name="autoscalingEnabled")
+    def autoscaling_enabled(self) -> bool:
+        """
+        Defines whether autoscaling is enabled. The default value is false.
+        """
+        return pulumi.get(self, "autoscaling_enabled")
+
+    @property
+    @pulumi.getter(name="limitConfigs")
+    def limit_configs(self) -> Sequence['outputs.GetMetastoreServiceScalingConfigAutoscalingConfigLimitConfigResult']:
+        """
+        Represents the limit configuration of a metastore service.
+        """
+        return pulumi.get(self, "limit_configs")
+
+
+@pulumi.output_type
+class GetMetastoreServiceScalingConfigAutoscalingConfigLimitConfigResult(dict):
+    def __init__(__self__, *,
+                 max_scaling_factor: float,
+                 min_scaling_factor: float):
+        """
+        :param float max_scaling_factor: The maximum scaling factor that the service will autoscale to. The default value is 6.0.
+        :param float min_scaling_factor: The minimum scaling factor that the service will autoscale to. The default value is 0.1.
+        """
+        pulumi.set(__self__, "max_scaling_factor", max_scaling_factor)
+        pulumi.set(__self__, "min_scaling_factor", min_scaling_factor)
+
+    @property
+    @pulumi.getter(name="maxScalingFactor")
+    def max_scaling_factor(self) -> float:
+        """
+        The maximum scaling factor that the service will autoscale to. The default value is 6.0.
+        """
+        return pulumi.get(self, "max_scaling_factor")
+
+    @property
+    @pulumi.getter(name="minScalingFactor")
+    def min_scaling_factor(self) -> float:
+        """
+        The minimum scaling factor that the service will autoscale to. The default value is 0.1.
+        """
+        return pulumi.get(self, "min_scaling_factor")
+
+
 @pulumi.output_type
 class GetMetastoreServiceScheduledBackupResult(dict):
     def __init__(__self__, *,

pulumi_gcp/gkehub/_inputs.py

@@ -3153,7 +3153,7 @@ class FleetDefaultClusterConfigSecurityPostureConfigArgs:
                  vulnerability_mode: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] mode: Sets which mode to use for Security Posture features.
-               Possible values are: `DISABLED`, `BASIC`.
+               Possible values are: `DISABLED`, `BASIC`, `ENTERPRISE`.
         :param pulumi.Input[str] vulnerability_mode: Sets which mode to use for vulnerability scanning.
                Possible values are: `VULNERABILITY_DISABLED`, `VULNERABILITY_BASIC`, `VULNERABILITY_ENTERPRISE`.
         """
@@ -3167,7 +3167,7 @@ class FleetDefaultClusterConfigSecurityPostureConfigArgs:
     def mode(self) -> Optional[pulumi.Input[str]]:
         """
         Sets which mode to use for Security Posture features.
-        Possible values are: `DISABLED`, `BASIC`.
+        Possible values are: `DISABLED`, `BASIC`, `ENTERPRISE`.
         """
         return pulumi.get(self, "mode")
 

pulumi_gcp/gkehub/outputs.py

@@ -3147,7 +3147,7 @@ class FleetDefaultClusterConfigSecurityPostureConfig(dict):
                  vulnerability_mode: Optional[str] = None):
         """
         :param str mode: Sets which mode to use for Security Posture features.
-               Possible values are: `DISABLED`, `BASIC`.
+               Possible values are: `DISABLED`, `BASIC`, `ENTERPRISE`.
         :param str vulnerability_mode: Sets which mode to use for vulnerability scanning.
                Possible values are: `VULNERABILITY_DISABLED`, `VULNERABILITY_BASIC`, `VULNERABILITY_ENTERPRISE`.
         """
@@ -3161,7 +3161,7 @@ class FleetDefaultClusterConfigSecurityPostureConfig(dict):
     def mode(self) -> Optional[str]:
         """
         Sets which mode to use for Security Posture features.
-        Possible values are: `DISABLED`, `BASIC`.
+        Possible values are: `DISABLED`, `BASIC`, `ENTERPRISE`.
         """
         return pulumi.get(self, "mode")
 

pulumi_gcp/pubsub/_inputs.py

@@ -291,6 +291,7 @@ class SubscriptionBigqueryConfigArgs:
     def __init__(__self__, *,
                  table: pulumi.Input[str],
                  drop_unknown_fields: Optional[pulumi.Input[bool]] = None,
+                 service_account_email: Optional[pulumi.Input[str]] = None,
                  use_table_schema: Optional[pulumi.Input[bool]] = None,
                  use_topic_schema: Optional[pulumi.Input[bool]] = None,
                  write_metadata: Optional[pulumi.Input[bool]] = None):
@@ -299,6 +300,9 @@ class SubscriptionBigqueryConfigArgs:
         :param pulumi.Input[bool] drop_unknown_fields: When true and use_topic_schema or use_table_schema is true, any fields that are a part of the topic schema or message schema that
                are not part of the BigQuery table schema are dropped when writing to BigQuery. Otherwise, the schemas must be kept in sync
                and any messages with extra fields are not written and remain in the subscription's backlog.
+        :param pulumi.Input[str] service_account_email: The service account to use to write to BigQuery. If not specified, the Pub/Sub
+               [service agent](https://cloud.google.com/iam/docs/service-agents),
+               service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
         :param pulumi.Input[bool] use_table_schema: When true, use the BigQuery table's schema as the columns to write to in BigQuery. Messages
                must be published in JSON format. Only one of use_topic_schema and use_table_schema can be set.
         :param pulumi.Input[bool] use_topic_schema: When true, use the topic's schema as the columns to write to in BigQuery, if it exists.
@@ -309,6 +313,8 @@ class SubscriptionBigqueryConfigArgs:
         pulumi.set(__self__, "table", table)
         if drop_unknown_fields is not None:
             pulumi.set(__self__, "drop_unknown_fields", drop_unknown_fields)
+        if service_account_email is not None:
+            pulumi.set(__self__, "service_account_email", service_account_email)
         if use_table_schema is not None:
             pulumi.set(__self__, "use_table_schema", use_table_schema)
         if use_topic_schema is not None:
@@ -342,6 +348,20 @@ class SubscriptionBigqueryConfigArgs:
     def drop_unknown_fields(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "drop_unknown_fields", value)
 
+    @property
+    @pulumi.getter(name="serviceAccountEmail")
+    def service_account_email(self) -> Optional[pulumi.Input[str]]:
+        """
+        The service account to use to write to BigQuery. If not specified, the Pub/Sub
+        [service agent](https://cloud.google.com/iam/docs/service-agents),
+        service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
+        """
+        return pulumi.get(self, "service_account_email")
+
+    @service_account_email.setter
+    def service_account_email(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_account_email", value)
+
     @property
     @pulumi.getter(name="useTableSchema")
     def use_table_schema(self) -> Optional[pulumi.Input[bool]]:
@@ -392,6 +412,7 @@ class SubscriptionCloudStorageConfigArgs:
                  filename_suffix: Optional[pulumi.Input[str]] = None,
                  max_bytes: Optional[pulumi.Input[int]] = None,
                  max_duration: Optional[pulumi.Input[str]] = None,
+                 service_account_email: Optional[pulumi.Input[str]] = None,
                  state: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] bucket: User-provided name for the Cloud Storage bucket. The bucket must be created by the user. The bucket name must be without any prefix like "gs://".
@@ -405,6 +426,9 @@ class SubscriptionCloudStorageConfigArgs:
         :param pulumi.Input[str] max_duration: The maximum duration that can elapse before a new Cloud Storage file is created. Min 1 minute, max 10 minutes, default 5 minutes.
                May not exceed the subscription's acknowledgement deadline.
                A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
+        :param pulumi.Input[str] service_account_email: The service account to use to write to Cloud Storage. If not specified, the Pub/Sub
+               [service agent](https://cloud.google.com/iam/docs/service-agents),
+               service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
         :param pulumi.Input[str] state: (Output)
                An output-only field that indicates whether or not the subscription can receive messages.
         """
@@ -421,6 +445,8 @@ class SubscriptionCloudStorageConfigArgs:
             pulumi.set(__self__, "max_bytes", max_bytes)
         if max_duration is not None:
             pulumi.set(__self__, "max_duration", max_duration)
+        if service_account_email is not None:
+            pulumi.set(__self__, "service_account_email", service_account_email)
         if state is not None:
             pulumi.set(__self__, "state", state)
 
@@ -512,6 +538,20 @@ class SubscriptionCloudStorageConfigArgs:
     def max_duration(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "max_duration", value)
 
+    @property
+    @pulumi.getter(name="serviceAccountEmail")
+    def service_account_email(self) -> Optional[pulumi.Input[str]]:
+        """
+        The service account to use to write to Cloud Storage. If not specified, the Pub/Sub
+        [service agent](https://cloud.google.com/iam/docs/service-agents),
+        service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
+        """
+        return pulumi.get(self, "service_account_email")
+
+    @service_account_email.setter
+    def service_account_email(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_account_email", value)
+
     @property
     @pulumi.getter
     def state(self) -> Optional[pulumi.Input[str]]:

pulumi_gcp/pubsub/outputs.py

@@ -321,6 +321,8 @@ class SubscriptionBigqueryConfig(dict):
         suggest = None
         if key == "dropUnknownFields":
             suggest = "drop_unknown_fields"
+        elif key == "serviceAccountEmail":
+            suggest = "service_account_email"
         elif key == "useTableSchema":
             suggest = "use_table_schema"
         elif key == "useTopicSchema":
@@ -342,6 +344,7 @@ class SubscriptionBigqueryConfig(dict):
     def __init__(__self__, *,
                  table: str,
                  drop_unknown_fields: Optional[bool] = None,
+                 service_account_email: Optional[str] = None,
                  use_table_schema: Optional[bool] = None,
                  use_topic_schema: Optional[bool] = None,
                  write_metadata: Optional[bool] = None):
@@ -350,6 +353,9 @@ class SubscriptionBigqueryConfig(dict):
         :param bool drop_unknown_fields: When true and use_topic_schema or use_table_schema is true, any fields that are a part of the topic schema or message schema that
                are not part of the BigQuery table schema are dropped when writing to BigQuery. Otherwise, the schemas must be kept in sync
                and any messages with extra fields are not written and remain in the subscription's backlog.
+        :param str service_account_email: The service account to use to write to BigQuery. If not specified, the Pub/Sub
+               [service agent](https://cloud.google.com/iam/docs/service-agents),
+               service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
         :param bool use_table_schema: When true, use the BigQuery table's schema as the columns to write to in BigQuery. Messages
                must be published in JSON format. Only one of use_topic_schema and use_table_schema can be set.
         :param bool use_topic_schema: When true, use the topic's schema as the columns to write to in BigQuery, if it exists.
@@ -360,6 +366,8 @@ class SubscriptionBigqueryConfig(dict):
         pulumi.set(__self__, "table", table)
         if drop_unknown_fields is not None:
             pulumi.set(__self__, "drop_unknown_fields", drop_unknown_fields)
+        if service_account_email is not None:
+            pulumi.set(__self__, "service_account_email", service_account_email)
         if use_table_schema is not None:
             pulumi.set(__self__, "use_table_schema", use_table_schema)
         if use_topic_schema is not None:
@@ -385,6 +393,16 @@ class SubscriptionBigqueryConfig(dict):
         """
         return pulumi.get(self, "drop_unknown_fields")
 
+    @property
+    @pulumi.getter(name="serviceAccountEmail")
+    def service_account_email(self) -> Optional[str]:
+        """
+        The service account to use to write to BigQuery. If not specified, the Pub/Sub
+        [service agent](https://cloud.google.com/iam/docs/service-agents),
+        service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
+        """
+        return pulumi.get(self, "service_account_email")
+
     @property
     @pulumi.getter(name="useTableSchema")
     def use_table_schema(self) -> Optional[bool]:
@@ -430,6 +448,8 @@ class SubscriptionCloudStorageConfig(dict):
             suggest = "max_bytes"
         elif key == "maxDuration":
             suggest = "max_duration"
+        elif key == "serviceAccountEmail":
+            suggest = "service_account_email"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in SubscriptionCloudStorageConfig. Access the value via the '{suggest}' property getter instead.")
@@ -450,6 +470,7 @@ class SubscriptionCloudStorageConfig(dict):
                  filename_suffix: Optional[str] = None,
                  max_bytes: Optional[int] = None,
                  max_duration: Optional[str] = None,
+                 service_account_email: Optional[str] = None,
                  state: Optional[str] = None):
         """
         :param str bucket: User-provided name for the Cloud Storage bucket. The bucket must be created by the user. The bucket name must be without any prefix like "gs://".
@@ -463,6 +484,9 @@ class SubscriptionCloudStorageConfig(dict):
         :param str max_duration: The maximum duration that can elapse before a new Cloud Storage file is created. Min 1 minute, max 10 minutes, default 5 minutes.
                May not exceed the subscription's acknowledgement deadline.
                A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
+        :param str service_account_email: The service account to use to write to Cloud Storage. If not specified, the Pub/Sub
+               [service agent](https://cloud.google.com/iam/docs/service-agents),
+               service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
         :param str state: (Output)
                An output-only field that indicates whether or not the subscription can receive messages.
         """
@@ -479,6 +503,8 @@ class SubscriptionCloudStorageConfig(dict):
             pulumi.set(__self__, "max_bytes", max_bytes)
         if max_duration is not None:
             pulumi.set(__self__, "max_duration", max_duration)
+        if service_account_email is not None:
+            pulumi.set(__self__, "service_account_email", service_account_email)
         if state is not None:
             pulumi.set(__self__, "state", state)
 
@@ -542,6 +568,16 @@ class SubscriptionCloudStorageConfig(dict):
         """
         return pulumi.get(self, "max_duration")
 
+    @property
+    @pulumi.getter(name="serviceAccountEmail")
+    def service_account_email(self) -> Optional[str]:
+        """
+        The service account to use to write to Cloud Storage. If not specified, the Pub/Sub
+        [service agent](https://cloud.google.com/iam/docs/service-agents),
+        service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
+        """
+        return pulumi.get(self, "service_account_email")
+
     @property
     @pulumi.getter
     def state(self) -> Optional[str]:
@@ -1294,6 +1330,7 @@ class TopicSchemaSettings(dict):
 class GetSubscriptionBigqueryConfigResult(dict):
     def __init__(__self__, *,
                  drop_unknown_fields: bool,
+                 service_account_email: str,
                  table: str,
                  use_table_schema: bool,
                  use_topic_schema: bool,
@@ -1302,6 +1339,9 @@ class GetSubscriptionBigqueryConfigResult(dict):
         :param bool drop_unknown_fields: When true and use_topic_schema or use_table_schema is true, any fields that are a part of the topic schema or message schema that
                are not part of the BigQuery table schema are dropped when writing to BigQuery. Otherwise, the schemas must be kept in sync
                and any messages with extra fields are not written and remain in the subscription's backlog.
+        :param str service_account_email: The service account to use to write to BigQuery. If not specified, the Pub/Sub
+               [service agent](https://cloud.google.com/iam/docs/service-agents),
+               service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
         :param str table: The name of the table to which to write data, of the form {projectId}:{datasetId}.{tableId}
         :param bool use_table_schema: When true, use the BigQuery table's schema as the columns to write to in BigQuery. Messages
                must be published in JSON format. Only one of use_topic_schema and use_table_schema can be set.
@@ -1311,6 +1351,7 @@ class GetSubscriptionBigqueryConfigResult(dict):
                The subscription name, messageId, and publishTime fields are put in their own columns while all other message properties (other than data) are written to a JSON object in the attributes column.
         """
         pulumi.set(__self__, "drop_unknown_fields", drop_unknown_fields)
+        pulumi.set(__self__, "service_account_email", service_account_email)
         pulumi.set(__self__, "table", table)
         pulumi.set(__self__, "use_table_schema", use_table_schema)
         pulumi.set(__self__, "use_topic_schema", use_topic_schema)
@@ -1326,6 +1367,16 @@ class GetSubscriptionBigqueryConfigResult(dict):
         """
         return pulumi.get(self, "drop_unknown_fields")
 
+    @property
+    @pulumi.getter(name="serviceAccountEmail")
+    def service_account_email(self) -> str:
+        """
+        The service account to use to write to BigQuery. If not specified, the Pub/Sub
+        [service agent](https://cloud.google.com/iam/docs/service-agents),
+        service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
+        """
+        return pulumi.get(self, "service_account_email")
+
     @property
     @pulumi.getter
     def table(self) -> str:
@@ -1372,6 +1423,7 @@ class GetSubscriptionCloudStorageConfigResult(dict):
                  filename_suffix: str,
                  max_bytes: int,
                  max_duration: str,
+                 service_account_email: str,
                  state: str):
         """
         :param Sequence['GetSubscriptionCloudStorageConfigAvroConfigArgs'] avro_configs: If set, message data will be written to Cloud Storage in Avro format.
@@ -1384,6 +1436,9 @@ class GetSubscriptionCloudStorageConfigResult(dict):
         :param str max_duration: The maximum duration that can elapse before a new Cloud Storage file is created. Min 1 minute, max 10 minutes, default 5 minutes.
                May not exceed the subscription's acknowledgement deadline.
                A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
+        :param str service_account_email: The service account to use to write to Cloud Storage. If not specified, the Pub/Sub
+               [service agent](https://cloud.google.com/iam/docs/service-agents),
+               service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
         :param str state: An output-only field that indicates whether or not the subscription can receive messages.
         """
         pulumi.set(__self__, "avro_configs", avro_configs)
@@ -1393,6 +1448,7 @@ class GetSubscriptionCloudStorageConfigResult(dict):
         pulumi.set(__self__, "filename_suffix", filename_suffix)
         pulumi.set(__self__, "max_bytes", max_bytes)
         pulumi.set(__self__, "max_duration", max_duration)
+        pulumi.set(__self__, "service_account_email", service_account_email)
         pulumi.set(__self__, "state", state)
 
     @property
@@ -1454,6 +1510,16 @@ class GetSubscriptionCloudStorageConfigResult(dict):
         """
         return pulumi.get(self, "max_duration")
 
+    @property
+    @pulumi.getter(name="serviceAccountEmail")
+    def service_account_email(self) -> str:
+        """
+        The service account to use to write to Cloud Storage. If not specified, the Pub/Sub
+        [service agent](https://cloud.google.com/iam/docs/service-agents),
+        service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
+        """
+        return pulumi.get(self, "service_account_email")
+
     @property
     @pulumi.getter
     def state(self) -> str: