pulumi-gcp 7.8.0a1706805960__py3-none-any.whl → 7.8.0a1706829616__py3-none-any.whl

pulumi_gcp/redis/outputs.py

@@ -915,6 +915,20 @@ class GetInstanceMaintenancePolicyResult(dict):
                  description: str,
                  update_time: str,
                  weekly_maintenance_windows: Sequence['outputs.GetInstanceMaintenancePolicyWeeklyMaintenanceWindowResult']):
+        """
+        :param str create_time: Output only. The time when the policy was created.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+               resolution and up to nine fractional digits.
+        :param str description: Optional. Description of what this policy is for.
+               Create/Update methods return INVALID_ARGUMENT if the
+               length is greater than 512.
+        :param str update_time: Output only. The time when the policy was last updated.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+               resolution and up to nine fractional digits.
+        :param Sequence['GetInstanceMaintenancePolicyWeeklyMaintenanceWindowArgs'] weekly_maintenance_windows: Optional. Maintenance window that is applied to resources covered by this policy.
+               Minimum 1. For the current version, the maximum number
+               of weekly_window is expected to be one.
+        """
         pulumi.set(__self__, "create_time", create_time)
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "update_time", update_time)
@@ -923,21 +937,41 @@ class GetInstanceMaintenancePolicyResult(dict):
     @property
     @pulumi.getter(name="createTime")
     def create_time(self) -> str:
+        """
+        Output only. The time when the policy was created.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+        resolution and up to nine fractional digits.
+        """
         return pulumi.get(self, "create_time")
 
     @property
     @pulumi.getter
     def description(self) -> str:
+        """
+        Optional. Description of what this policy is for.
+        Create/Update methods return INVALID_ARGUMENT if the
+        length is greater than 512.
+        """
         return pulumi.get(self, "description")
 
     @property
     @pulumi.getter(name="updateTime")
     def update_time(self) -> str:
+        """
+        Output only. The time when the policy was last updated.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+        resolution and up to nine fractional digits.
+        """
         return pulumi.get(self, "update_time")
 
     @property
     @pulumi.getter(name="weeklyMaintenanceWindows")
     def weekly_maintenance_windows(self) -> Sequence['outputs.GetInstanceMaintenancePolicyWeeklyMaintenanceWindowResult']:
+        """
+        Optional. Maintenance window that is applied to resources covered by this policy.
+        Minimum 1. For the current version, the maximum number
+        of weekly_window is expected to be one.
+        """
         return pulumi.get(self, "weekly_maintenance_windows")
 
 
@@ -947,6 +981,23 @@ class GetInstanceMaintenancePolicyWeeklyMaintenanceWindowResult(dict):
                  day: str,
                  duration: str,
                  start_times: Sequence['outputs.GetInstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeResult']):
+        """
+        :param str day: Required. The day of week that maintenance updates occur.
+               
+               - DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
+               - MONDAY: Monday
+               - TUESDAY: Tuesday
+               - WEDNESDAY: Wednesday
+               - THURSDAY: Thursday
+               - FRIDAY: Friday
+               - SATURDAY: Saturday
+               - SUNDAY: Sunday Possible values: ["DAY_OF_WEEK_UNSPECIFIED", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]
+        :param str duration: Output only. Duration of the maintenance window.
+               The current window is fixed at 1 hour.
+               A duration in seconds with up to nine fractional digits,
+               terminated by 's'. Example: "3.5s".
+        :param Sequence['GetInstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs'] start_times: Required. Start time of the window in UTC time.
+        """
         pulumi.set(__self__, "day", day)
         pulumi.set(__self__, "duration", duration)
         pulumi.set(__self__, "start_times", start_times)
@@ -954,16 +1005,37 @@ class GetInstanceMaintenancePolicyWeeklyMaintenanceWindowResult(dict):
     @property
     @pulumi.getter
     def day(self) -> str:
+        """
+        Required. The day of week that maintenance updates occur.
+
+        - DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
+        - MONDAY: Monday
+        - TUESDAY: Tuesday
+        - WEDNESDAY: Wednesday
+        - THURSDAY: Thursday
+        - FRIDAY: Friday
+        - SATURDAY: Saturday
+        - SUNDAY: Sunday Possible values: ["DAY_OF_WEEK_UNSPECIFIED", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]
+        """
         return pulumi.get(self, "day")
 
     @property
     @pulumi.getter
     def duration(self) -> str:
+        """
+        Output only. Duration of the maintenance window.
+        The current window is fixed at 1 hour.
+        A duration in seconds with up to nine fractional digits,
+        terminated by 's'. Example: "3.5s".
+        """
         return pulumi.get(self, "duration")
 
     @property
     @pulumi.getter(name="startTimes")
     def start_times(self) -> Sequence['outputs.GetInstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeResult']:
+        """
+        Required. Start time of the window in UTC time.
+        """
         return pulumi.get(self, "start_times")
 
 
@@ -974,6 +1046,14 @@ class GetInstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeResult(dict):
                  minutes: int,
                  nanos: int,
                  seconds: int):
+        """
+        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23.
+               An API may choose to allow the value "24:00:00" for scenarios like business closing time.
+        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
+        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
+        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59.
+               An API may allow the value 60 if it allows leap-seconds.
+        """
         pulumi.set(__self__, "hours", hours)
         pulumi.set(__self__, "minutes", minutes)
         pulumi.set(__self__, "nanos", nanos)
@@ -982,21 +1062,35 @@ class GetInstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeResult(dict):
     @property
     @pulumi.getter
     def hours(self) -> int:
+        """
+        Hours of day in 24 hour format. Should be from 0 to 23.
+        An API may choose to allow the value "24:00:00" for scenarios like business closing time.
+        """
         return pulumi.get(self, "hours")
 
     @property
     @pulumi.getter
     def minutes(self) -> int:
+        """
+        Minutes of hour of day. Must be from 0 to 59.
+        """
         return pulumi.get(self, "minutes")
 
     @property
     @pulumi.getter
     def nanos(self) -> int:
+        """
+        Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
+        """
         return pulumi.get(self, "nanos")
 
     @property
     @pulumi.getter
     def seconds(self) -> int:
+        """
+        Seconds of minutes of the time. Must normally be from 0 to 59.
+        An API may allow the value 60 if it allows leap-seconds.
+        """
         return pulumi.get(self, "seconds")
 
 
@@ -1006,6 +1100,18 @@ class GetInstanceMaintenanceScheduleResult(dict):
                  end_time: str,
                  schedule_deadline_time: str,
                  start_time: str):
+        """
+        :param str end_time: Output only. The end time of any upcoming scheduled maintenance for this instance.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+               resolution and up to nine fractional digits.
+        :param str schedule_deadline_time: Output only. The deadline that the maintenance schedule start time
+               can not go beyond, including reschedule.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+               resolution and up to nine fractional digits.
+        :param str start_time: Output only. The start time of any upcoming scheduled maintenance for this instance.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+               resolution and up to nine fractional digits.
+        """
         pulumi.set(__self__, "end_time", end_time)
         pulumi.set(__self__, "schedule_deadline_time", schedule_deadline_time)
         pulumi.set(__self__, "start_time", start_time)
@@ -1013,16 +1119,32 @@ class GetInstanceMaintenanceScheduleResult(dict):
     @property
     @pulumi.getter(name="endTime")
     def end_time(self) -> str:
+        """
+        Output only. The end time of any upcoming scheduled maintenance for this instance.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+        resolution and up to nine fractional digits.
+        """
         return pulumi.get(self, "end_time")
 
     @property
     @pulumi.getter(name="scheduleDeadlineTime")
     def schedule_deadline_time(self) -> str:
+        """
+        Output only. The deadline that the maintenance schedule start time
+        can not go beyond, including reschedule.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+        resolution and up to nine fractional digits.
+        """
         return pulumi.get(self, "schedule_deadline_time")
 
     @property
     @pulumi.getter(name="startTime")
     def start_time(self) -> str:
+        """
+        Output only. The start time of any upcoming scheduled maintenance for this instance.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+        resolution and up to nine fractional digits.
+        """
         return pulumi.get(self, "start_time")
 
 
@@ -1031,17 +1153,27 @@ class GetInstanceNodeResult(dict):
     def __init__(__self__, *,
                  id: str,
                  zone: str):
+        """
+        :param str id: Node identifying string. e.g. 'node-0', 'node-1'
+        :param str zone: Location of the node.
+        """
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "zone", zone)
 
     @property
     @pulumi.getter
     def id(self) -> str:
+        """
+        Node identifying string. e.g. 'node-0', 'node-1'
+        """
         return pulumi.get(self, "id")
 
     @property
     @pulumi.getter
     def zone(self) -> str:
+        """
+        Location of the node.
+        """
         return pulumi.get(self, "zone")
 
 
@@ -1052,6 +1184,28 @@ class GetInstancePersistenceConfigResult(dict):
                  rdb_next_snapshot_time: str,
                  rdb_snapshot_period: str,
                  rdb_snapshot_start_time: str):
+        """
+        :param str persistence_mode: Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.
+               
+               - DISABLED: 	Persistence is disabled for the instance, and any existing snapshots are deleted.
+               - RDB: RDB based Persistence is enabled. Possible values: ["DISABLED", "RDB"]
+        :param str rdb_next_snapshot_time: Output only. The next time that a snapshot attempt is scheduled to occur.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
+               to nine fractional digits.
+               Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        :param str rdb_snapshot_period: Optional. Available snapshot periods for scheduling.
+               
+               - ONE_HOUR:	Snapshot every 1 hour.
+               - SIX_HOURS:	Snapshot every 6 hours.
+               - TWELVE_HOURS:	Snapshot every 12 hours.
+               - TWENTY_FOUR_HOURS:	Snapshot every 24 hours. Possible values: ["ONE_HOUR", "SIX_HOURS", "TWELVE_HOURS", "TWENTY_FOUR_HOURS"]
+        :param str rdb_snapshot_start_time: Optional. Date and time that the first snapshot was/will be attempted,
+               and to which future snapshots will be aligned. If not provided,
+               the current time will be used.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution
+               and up to nine fractional digits.
+               Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        """
         pulumi.set(__self__, "persistence_mode", persistence_mode)
         pulumi.set(__self__, "rdb_next_snapshot_time", rdb_next_snapshot_time)
         pulumi.set(__self__, "rdb_snapshot_period", rdb_snapshot_period)
@@ -1060,21 +1214,49 @@ class GetInstancePersistenceConfigResult(dict):
     @property
     @pulumi.getter(name="persistenceMode")
     def persistence_mode(self) -> str:
+        """
+        Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.
+
+        - DISABLED: 	Persistence is disabled for the instance, and any existing snapshots are deleted.
+        - RDB: RDB based Persistence is enabled. Possible values: ["DISABLED", "RDB"]
+        """
         return pulumi.get(self, "persistence_mode")
 
     @property
     @pulumi.getter(name="rdbNextSnapshotTime")
     def rdb_next_snapshot_time(self) -> str:
+        """
+        Output only. The next time that a snapshot attempt is scheduled to occur.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
+        to nine fractional digits.
+        Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        """
         return pulumi.get(self, "rdb_next_snapshot_time")
 
     @property
     @pulumi.getter(name="rdbSnapshotPeriod")
     def rdb_snapshot_period(self) -> str:
+        """
+        Optional. Available snapshot periods for scheduling.
+
+        - ONE_HOUR:	Snapshot every 1 hour.
+        - SIX_HOURS:	Snapshot every 6 hours.
+        - TWELVE_HOURS:	Snapshot every 12 hours.
+        - TWENTY_FOUR_HOURS:	Snapshot every 24 hours. Possible values: ["ONE_HOUR", "SIX_HOURS", "TWELVE_HOURS", "TWENTY_FOUR_HOURS"]
+        """
         return pulumi.get(self, "rdb_snapshot_period")
 
     @property
     @pulumi.getter(name="rdbSnapshotStartTime")
     def rdb_snapshot_start_time(self) -> str:
+        """
+        Optional. Date and time that the first snapshot was/will be attempted,
+        and to which future snapshots will be aligned. If not provided,
+        the current time will be used.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution
+        and up to nine fractional digits.
+        Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        """
         return pulumi.get(self, "rdb_snapshot_start_time")
 
 
@@ -1086,6 +1268,13 @@ class GetInstanceServerCaCertResult(dict):
                  expire_time: str,
                  serial_number: str,
                  sha1_fingerprint: str):
+        """
+        :param str cert: The certificate data in PEM format.
+        :param str create_time: The time when the certificate was created.
+        :param str expire_time: The time when the certificate expires.
+        :param str serial_number: Serial number, as extracted from the certificate.
+        :param str sha1_fingerprint: Sha1 Fingerprint of the certificate.
+        """
         pulumi.set(__self__, "cert", cert)
         pulumi.set(__self__, "create_time", create_time)
         pulumi.set(__self__, "expire_time", expire_time)
@@ -1095,26 +1284,41 @@ class GetInstanceServerCaCertResult(dict):
     @property
     @pulumi.getter
     def cert(self) -> str:
+        """
+        The certificate data in PEM format.
+        """
         return pulumi.get(self, "cert")
 
     @property
     @pulumi.getter(name="createTime")
     def create_time(self) -> str:
+        """
+        The time when the certificate was created.
+        """
         return pulumi.get(self, "create_time")
 
     @property
     @pulumi.getter(name="expireTime")
     def expire_time(self) -> str:
+        """
+        The time when the certificate expires.
+        """
         return pulumi.get(self, "expire_time")
 
     @property
     @pulumi.getter(name="serialNumber")
     def serial_number(self) -> str:
+        """
+        Serial number, as extracted from the certificate.
+        """
         return pulumi.get(self, "serial_number")
 
     @property
     @pulumi.getter(name="sha1Fingerprint")
     def sha1_fingerprint(self) -> str:
+        """
+        Sha1 Fingerprint of the certificate.
+        """
         return pulumi.get(self, "sha1_fingerprint")
 
 

pulumi_gcp/secretmanager/outputs.py

@@ -414,17 +414,27 @@ class GetSecretReplicationResult(dict):
     def __init__(__self__, *,
                  autos: Sequence['outputs.GetSecretReplicationAutoResult'],
                  user_manageds: Sequence['outputs.GetSecretReplicationUserManagedResult']):
+        """
+        :param Sequence['GetSecretReplicationAutoArgs'] autos: The Secret will automatically be replicated without any restrictions.
+        :param Sequence['GetSecretReplicationUserManagedArgs'] user_manageds: The Secret will be replicated to the regions specified by the user.
+        """
         pulumi.set(__self__, "autos", autos)
         pulumi.set(__self__, "user_manageds", user_manageds)
 
     @property
     @pulumi.getter
     def autos(self) -> Sequence['outputs.GetSecretReplicationAutoResult']:
+        """
+        The Secret will automatically be replicated without any restrictions.
+        """
         return pulumi.get(self, "autos")
 
     @property
     @pulumi.getter(name="userManageds")
     def user_manageds(self) -> Sequence['outputs.GetSecretReplicationUserManagedResult']:
+        """
+        The Secret will be replicated to the regions specified by the user.
+        """
         return pulumi.get(self, "user_manageds")
 
 
@@ -432,11 +442,21 @@ class GetSecretReplicationResult(dict):
 class GetSecretReplicationAutoResult(dict):
     def __init__(__self__, *,
                  customer_managed_encryptions: Sequence['outputs.GetSecretReplicationAutoCustomerManagedEncryptionResult']):
+        """
+        :param Sequence['GetSecretReplicationAutoCustomerManagedEncryptionArgs'] customer_managed_encryptions: The customer-managed encryption configuration of the Secret.
+               If no configuration is provided, Google-managed default
+               encryption is used.
+        """
         pulumi.set(__self__, "customer_managed_encryptions", customer_managed_encryptions)
 
     @property
     @pulumi.getter(name="customerManagedEncryptions")
     def customer_managed_encryptions(self) -> Sequence['outputs.GetSecretReplicationAutoCustomerManagedEncryptionResult']:
+        """
+        The customer-managed encryption configuration of the Secret.
+        If no configuration is provided, Google-managed default
+        encryption is used.
+        """
         return pulumi.get(self, "customer_managed_encryptions")
 
 
@@ -444,11 +464,17 @@ class GetSecretReplicationAutoResult(dict):
 class GetSecretReplicationAutoCustomerManagedEncryptionResult(dict):
     def __init__(__self__, *,
                  kms_key_name: str):
+        """
+        :param str kms_key_name: The resource name of the Cloud KMS CryptoKey used to encrypt secret payloads.
+        """
         pulumi.set(__self__, "kms_key_name", kms_key_name)
 
     @property
     @pulumi.getter(name="kmsKeyName")
     def kms_key_name(self) -> str:
+        """
+        The resource name of the Cloud KMS CryptoKey used to encrypt secret payloads.
+        """
         return pulumi.get(self, "kms_key_name")
 
 
@@ -456,11 +482,17 @@ class GetSecretReplicationAutoCustomerManagedEncryptionResult(dict):
 class GetSecretReplicationUserManagedResult(dict):
     def __init__(__self__, *,
                  replicas: Sequence['outputs.GetSecretReplicationUserManagedReplicaResult']):
+        """
+        :param Sequence['GetSecretReplicationUserManagedReplicaArgs'] replicas: The list of Replicas for this Secret. Cannot be empty.
+        """
         pulumi.set(__self__, "replicas", replicas)
 
     @property
     @pulumi.getter
     def replicas(self) -> Sequence['outputs.GetSecretReplicationUserManagedReplicaResult']:
+        """
+        The list of Replicas for this Secret. Cannot be empty.
+        """
         return pulumi.get(self, "replicas")
 
 
@@ -469,17 +501,27 @@ class GetSecretReplicationUserManagedReplicaResult(dict):
     def __init__(__self__, *,
                  customer_managed_encryptions: Sequence['outputs.GetSecretReplicationUserManagedReplicaCustomerManagedEncryptionResult'],
                  location: str):
+        """
+        :param Sequence['GetSecretReplicationUserManagedReplicaCustomerManagedEncryptionArgs'] customer_managed_encryptions: Customer Managed Encryption for the secret.
+        :param str location: The canonical IDs of the location to replicate data. For example: "us-east1".
+        """
         pulumi.set(__self__, "customer_managed_encryptions", customer_managed_encryptions)
         pulumi.set(__self__, "location", location)
 
     @property
     @pulumi.getter(name="customerManagedEncryptions")
     def customer_managed_encryptions(self) -> Sequence['outputs.GetSecretReplicationUserManagedReplicaCustomerManagedEncryptionResult']:
+        """
+        Customer Managed Encryption for the secret.
+        """
         return pulumi.get(self, "customer_managed_encryptions")
 
     @property
     @pulumi.getter
     def location(self) -> str:
+        """
+        The canonical IDs of the location to replicate data. For example: "us-east1".
+        """
         return pulumi.get(self, "location")
 
 
@@ -487,11 +529,17 @@ class GetSecretReplicationUserManagedReplicaResult(dict):
 class GetSecretReplicationUserManagedReplicaCustomerManagedEncryptionResult(dict):
     def __init__(__self__, *,
                  kms_key_name: str):
+        """
+        :param str kms_key_name: Describes the Cloud KMS encryption key that will be used to protect destination secret.
+        """
         pulumi.set(__self__, "kms_key_name", kms_key_name)
 
     @property
     @pulumi.getter(name="kmsKeyName")
     def kms_key_name(self) -> str:
+        """
+        Describes the Cloud KMS encryption key that will be used to protect destination secret.
+        """
         return pulumi.get(self, "kms_key_name")
 
 
@@ -500,17 +548,31 @@ class GetSecretRotationResult(dict):
     def __init__(__self__, *,
                  next_rotation_time: str,
                  rotation_period: str):
+        """
+        :param str next_rotation_time: Timestamp in UTC at which the Secret is scheduled to rotate.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        :param str rotation_period: The Duration between rotation notifications. Must be in seconds and at least 3600s (1h) and at most 3153600000s (100 years).
+               If rotationPeriod is set, 'next_rotation_time' must be set. 'next_rotation_time' will be advanced by this period when the service automatically sends rotation notifications.
+        """
         pulumi.set(__self__, "next_rotation_time", next_rotation_time)
         pulumi.set(__self__, "rotation_period", rotation_period)
 
     @property
     @pulumi.getter(name="nextRotationTime")
     def next_rotation_time(self) -> str:
+        """
+        Timestamp in UTC at which the Secret is scheduled to rotate.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        """
         return pulumi.get(self, "next_rotation_time")
 
     @property
     @pulumi.getter(name="rotationPeriod")
     def rotation_period(self) -> str:
+        """
+        The Duration between rotation notifications. Must be in seconds and at least 3600s (1h) and at most 3153600000s (100 years).
+        If rotationPeriod is set, 'next_rotation_time' must be set. 'next_rotation_time' will be advanced by this period when the service automatically sends rotation notifications.
+        """
         return pulumi.get(self, "rotation_period")
 
 
@@ -518,11 +580,19 @@ class GetSecretRotationResult(dict):
 class GetSecretTopicResult(dict):
     def __init__(__self__, *,
                  name: str):
+        """
+        :param str name: The resource name of the Pub/Sub topic that will be published to, in the following format: projects/*/topics/*.
+               For publication to succeed, the Secret Manager Service Agent service account must have pubsub.publisher permissions on the topic.
+        """
         pulumi.set(__self__, "name", name)
 
     @property
     @pulumi.getter
     def name(self) -> str:
+        """
+        The resource name of the Pub/Sub topic that will be published to, in the following format: projects/*/topics/*.
+        For publication to succeed, the Secret Manager Service Agent service account must have pubsub.publisher permissions on the topic.
+        """
         return pulumi.get(self, "name")
 
 
@@ -551,12 +621,18 @@ class GetSecretsSecretResult(dict):
         :param Mapping[str, str] labels: The labels assigned to this Secret.
         :param str name: The resource name of the Pub/Sub topic that will be published to.
         :param str project: The ID of the project.
+        :param Mapping[str, str] pulumi_labels: The combination of labels configured directly on the resource
+                and default labels configured on the provider.
         :param Sequence['GetSecretsSecretReplicationArgs'] replications: The replication policy of the secret data attached to the Secret.
                Structure is documented below.
         :param Sequence['GetSecretsSecretRotationArgs'] rotations: The rotation time and period for a Secret.
                Structure is documented below.
+        :param str secret_id: This must be unique within the project.
         :param Sequence['GetSecretsSecretTopicArgs'] topics: A list of up to 10 Pub/Sub topics to which messages are published when control plane operations are called on the secret or its versions.
                Structure is documented below.
+        :param str ttl: The TTL for the Secret.
+               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+               Only one of 'ttl' or 'expire_time' can be provided.
         :param Mapping[str, str] version_aliases: Mapping from version alias to version name.
         """
         pulumi.set(__self__, "annotations", annotations)
@@ -636,6 +712,10 @@ class GetSecretsSecretResult(dict):
     @property
     @pulumi.getter(name="pulumiLabels")
     def pulumi_labels(self) -> Mapping[str, str]:
+        """
+        The combination of labels configured directly on the resource
+         and default labels configured on the provider.
+        """
         return pulumi.get(self, "pulumi_labels")
 
     @property
@@ -659,6 +739,9 @@ class GetSecretsSecretResult(dict):
     @property
     @pulumi.getter(name="secretId")
     def secret_id(self) -> str:
+        """
+        This must be unique within the project.
+        """
         return pulumi.get(self, "secret_id")
 
     @property
@@ -673,6 +756,11 @@ class GetSecretsSecretResult(dict):
     @property
     @pulumi.getter
     def ttl(self) -> str:
+        """
+        The TTL for the Secret.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        Only one of 'ttl' or 'expire_time' can be provided.
+        """
         return pulumi.get(self, "ttl")
 
     @property

pulumi_gcp/sourcerepo/outputs.py

@@ -148,6 +148,15 @@ class GetRepositoryPubsubConfigResult(dict):
                  message_format: str,
                  service_account_email: str,
                  topic: str):
+        """
+        :param str message_format: The format of the Cloud Pub/Sub messages.
+               - PROTOBUF: The message payload is a serialized protocol buffer of SourceRepoEvent.
+               - JSON: The message payload is a JSON string of SourceRepoEvent. Possible values: ["PROTOBUF", "JSON"]
+        :param str service_account_email: Email address of the service account used for publishing Cloud Pub/Sub messages.
+               This service account needs to be in the same project as the PubsubConfig. When added,
+               the caller needs to have iam.serviceAccounts.actAs permission on this service account.
+               If unspecified, it defaults to the compute engine default service account.
+        """
         pulumi.set(__self__, "message_format", message_format)
         pulumi.set(__self__, "service_account_email", service_account_email)
         pulumi.set(__self__, "topic", topic)
@@ -155,11 +164,22 @@ class GetRepositoryPubsubConfigResult(dict):
     @property
     @pulumi.getter(name="messageFormat")
     def message_format(self) -> str:
+        """
+        The format of the Cloud Pub/Sub messages.
+        - PROTOBUF: The message payload is a serialized protocol buffer of SourceRepoEvent.
+        - JSON: The message payload is a JSON string of SourceRepoEvent. Possible values: ["PROTOBUF", "JSON"]
+        """
         return pulumi.get(self, "message_format")
 
     @property
     @pulumi.getter(name="serviceAccountEmail")
     def service_account_email(self) -> str:
+        """
+        Email address of the service account used for publishing Cloud Pub/Sub messages.
+        This service account needs to be in the same project as the PubsubConfig. When added,
+        the caller needs to have iam.serviceAccounts.actAs permission on this service account.
+        If unspecified, it defaults to the compute engine default service account.
+        """
         return pulumi.get(self, "service_account_email")
 
     @property