pulumi-gcp 8.20.0a1739946722__py3-none-any.whl → 8.20.1a1741108673__py3-none-any.whl

pulumi_gcp/alloydb/outputs.py

@@ -52,6 +52,39 @@ __all__ = [
     'InstancePscInstanceConfig',
     'InstanceQueryInsightsConfig',
     'InstanceReadPoolConfig',
+    'GetClusterAutomatedBackupPolicyResult',
+    'GetClusterAutomatedBackupPolicyEncryptionConfigResult',
+    'GetClusterAutomatedBackupPolicyQuantityBasedRetentionResult',
+    'GetClusterAutomatedBackupPolicyTimeBasedRetentionResult',
+    'GetClusterAutomatedBackupPolicyWeeklyScheduleResult',
+    'GetClusterAutomatedBackupPolicyWeeklyScheduleStartTimeResult',
+    'GetClusterBackupSourceResult',
+    'GetClusterContinuousBackupConfigResult',
+    'GetClusterContinuousBackupConfigEncryptionConfigResult',
+    'GetClusterContinuousBackupInfoResult',
+    'GetClusterContinuousBackupInfoEncryptionInfoResult',
+    'GetClusterEncryptionConfigResult',
+    'GetClusterEncryptionInfoResult',
+    'GetClusterInitialUserResult',
+    'GetClusterMaintenanceUpdatePolicyResult',
+    'GetClusterMaintenanceUpdatePolicyMaintenanceWindowResult',
+    'GetClusterMaintenanceUpdatePolicyMaintenanceWindowStartTimeResult',
+    'GetClusterMigrationSourceResult',
+    'GetClusterNetworkConfigResult',
+    'GetClusterPscConfigResult',
+    'GetClusterRestoreBackupSourceResult',
+    'GetClusterRestoreContinuousBackupSourceResult',
+    'GetClusterSecondaryConfigResult',
+    'GetClusterTrialMetadataResult',
+    'GetInstanceClientConnectionConfigResult',
+    'GetInstanceClientConnectionConfigSslConfigResult',
+    'GetInstanceMachineConfigResult',
+    'GetInstanceNetworkConfigResult',
+    'GetInstanceNetworkConfigAuthorizedExternalNetworkResult',
+    'GetInstanceObservabilityConfigResult',
+    'GetInstancePscInstanceConfigResult',
+    'GetInstanceQueryInsightsConfigResult',
+    'GetInstanceReadPoolConfigResult',
     'GetLocationsLocationResult',
     'GetSupportedDatabaseFlagsSupportedDatabaseFlagResult',
     'GetSupportedDatabaseFlagsSupportedDatabaseFlagIntegerRestrictionsResult',
@@ -1991,6 +2024,1133 @@ class InstanceReadPoolConfig(dict):
         return pulumi.get(self, "node_count")
 
 
+@pulumi.output_type
+class GetClusterAutomatedBackupPolicyResult(dict):
+    def __init__(__self__, *,
+                 backup_window: str,
+                 enabled: bool,
+                 encryption_configs: Sequence['outputs.GetClusterAutomatedBackupPolicyEncryptionConfigResult'],
+                 labels: Mapping[str, str],
+                 location: str,
+                 quantity_based_retentions: Sequence['outputs.GetClusterAutomatedBackupPolicyQuantityBasedRetentionResult'],
+                 time_based_retentions: Sequence['outputs.GetClusterAutomatedBackupPolicyTimeBasedRetentionResult'],
+                 weekly_schedules: Sequence['outputs.GetClusterAutomatedBackupPolicyWeeklyScheduleResult']):
+        """
+        :param str backup_window: The length of the time window during which a backup can be taken. If a backup does not succeed within this time window, it will be canceled and considered failed.
+               
+               The backup window must be at least 5 minutes long. There is no upper bound on the window. If not set, it will default to 1 hour.
+               
+               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        :param bool enabled: Whether automated backups are enabled.
+        :param Sequence['GetClusterAutomatedBackupPolicyEncryptionConfigArgs'] encryption_configs: EncryptionConfig describes the encryption config of a cluster or a backup that is encrypted with a CMEK (customer-managed encryption key).
+        :param Mapping[str, str] labels: Labels to apply to backups created using this configuration.
+        :param str location: (optional)
+               The canonical id of the location.If it is not provided, the provider project is used. For example: us-east1.
+        :param Sequence['GetClusterAutomatedBackupPolicyQuantityBasedRetentionArgs'] quantity_based_retentions: Quantity-based Backup retention policy to retain recent backups. Conflicts with 'time_based_retention', both can't be set together.
+        :param Sequence['GetClusterAutomatedBackupPolicyTimeBasedRetentionArgs'] time_based_retentions: Time-based Backup retention policy. Conflicts with 'quantity_based_retention', both can't be set together.
+        :param Sequence['GetClusterAutomatedBackupPolicyWeeklyScheduleArgs'] weekly_schedules: Weekly schedule for the Backup.
+        """
+        pulumi.set(__self__, "backup_window", backup_window)
+        pulumi.set(__self__, "enabled", enabled)
+        pulumi.set(__self__, "encryption_configs", encryption_configs)
+        pulumi.set(__self__, "labels", labels)
+        pulumi.set(__self__, "location", location)
+        pulumi.set(__self__, "quantity_based_retentions", quantity_based_retentions)
+        pulumi.set(__self__, "time_based_retentions", time_based_retentions)
+        pulumi.set(__self__, "weekly_schedules", weekly_schedules)
+
+    @property
+    @pulumi.getter(name="backupWindow")
+    def backup_window(self) -> str:
+        """
+        The length of the time window during which a backup can be taken. If a backup does not succeed within this time window, it will be canceled and considered failed.
+
+        The backup window must be at least 5 minutes long. There is no upper bound on the window. If not set, it will default to 1 hour.
+
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        """
+        return pulumi.get(self, "backup_window")
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        Whether automated backups are enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="encryptionConfigs")
+    def encryption_configs(self) -> Sequence['outputs.GetClusterAutomatedBackupPolicyEncryptionConfigResult']:
+        """
+        EncryptionConfig describes the encryption config of a cluster or a backup that is encrypted with a CMEK (customer-managed encryption key).
+        """
+        return pulumi.get(self, "encryption_configs")
+
+    @property
+    @pulumi.getter
+    def labels(self) -> Mapping[str, str]:
+        """
+        Labels to apply to backups created using this configuration.
+        """
+        return pulumi.get(self, "labels")
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        (optional)
+        The canonical id of the location.If it is not provided, the provider project is used. For example: us-east1.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter(name="quantityBasedRetentions")
+    def quantity_based_retentions(self) -> Sequence['outputs.GetClusterAutomatedBackupPolicyQuantityBasedRetentionResult']:
+        """
+        Quantity-based Backup retention policy to retain recent backups. Conflicts with 'time_based_retention', both can't be set together.
+        """
+        return pulumi.get(self, "quantity_based_retentions")
+
+    @property
+    @pulumi.getter(name="timeBasedRetentions")
+    def time_based_retentions(self) -> Sequence['outputs.GetClusterAutomatedBackupPolicyTimeBasedRetentionResult']:
+        """
+        Time-based Backup retention policy. Conflicts with 'quantity_based_retention', both can't be set together.
+        """
+        return pulumi.get(self, "time_based_retentions")
+
+    @property
+    @pulumi.getter(name="weeklySchedules")
+    def weekly_schedules(self) -> Sequence['outputs.GetClusterAutomatedBackupPolicyWeeklyScheduleResult']:
+        """
+        Weekly schedule for the Backup.
+        """
+        return pulumi.get(self, "weekly_schedules")
+
+
+@pulumi.output_type
+class GetClusterAutomatedBackupPolicyEncryptionConfigResult(dict):
+    def __init__(__self__, *,
+                 kms_key_name: str):
+        """
+        :param str kms_key_name: The fully-qualified resource name of the KMS key. Each Cloud KMS key is regionalized and has the following format: projects/[PROJECT]/locations/[REGION]/keyRings/[RING]/cryptoKeys/[KEY_NAME].
+        """
+        pulumi.set(__self__, "kms_key_name", kms_key_name)
+
+    @property
+    @pulumi.getter(name="kmsKeyName")
+    def kms_key_name(self) -> str:
+        """
+        The fully-qualified resource name of the KMS key. Each Cloud KMS key is regionalized and has the following format: projects/[PROJECT]/locations/[REGION]/keyRings/[RING]/cryptoKeys/[KEY_NAME].
+        """
+        return pulumi.get(self, "kms_key_name")
+
+
+@pulumi.output_type
+class GetClusterAutomatedBackupPolicyQuantityBasedRetentionResult(dict):
+    def __init__(__self__, *,
+                 count: int):
+        """
+        :param int count: The number of backups to retain.
+        """
+        pulumi.set(__self__, "count", count)
+
+    @property
+    @pulumi.getter
+    def count(self) -> int:
+        """
+        The number of backups to retain.
+        """
+        return pulumi.get(self, "count")
+
+
+@pulumi.output_type
+class GetClusterAutomatedBackupPolicyTimeBasedRetentionResult(dict):
+    def __init__(__self__, *,
+                 retention_period: str):
+        """
+        :param str retention_period: The retention period.
+               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        """
+        pulumi.set(__self__, "retention_period", retention_period)
+
+    @property
+    @pulumi.getter(name="retentionPeriod")
+    def retention_period(self) -> str:
+        """
+        The retention period.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        """
+        return pulumi.get(self, "retention_period")
+
+
+@pulumi.output_type
+class GetClusterAutomatedBackupPolicyWeeklyScheduleResult(dict):
+    def __init__(__self__, *,
+                 days_of_weeks: Sequence[str],
+                 start_times: Sequence['outputs.GetClusterAutomatedBackupPolicyWeeklyScheduleStartTimeResult']):
+        """
+        :param Sequence[str] days_of_weeks: The days of the week to perform a backup. At least one day of the week must be provided. Possible values: ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]
+        :param Sequence['GetClusterAutomatedBackupPolicyWeeklyScheduleStartTimeArgs'] start_times: The times during the day to start a backup. At least one start time must be provided. The start times are assumed to be in UTC and to be an exact hour (e.g., 04:00:00).
+        """
+        pulumi.set(__self__, "days_of_weeks", days_of_weeks)
+        pulumi.set(__self__, "start_times", start_times)
+
+    @property
+    @pulumi.getter(name="daysOfWeeks")
+    def days_of_weeks(self) -> Sequence[str]:
+        """
+        The days of the week to perform a backup. At least one day of the week must be provided. Possible values: ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]
+        """
+        return pulumi.get(self, "days_of_weeks")
+
+    @property
+    @pulumi.getter(name="startTimes")
+    def start_times(self) -> Sequence['outputs.GetClusterAutomatedBackupPolicyWeeklyScheduleStartTimeResult']:
+        """
+        The times during the day to start a backup. At least one start time must be provided. The start times are assumed to be in UTC and to be an exact hour (e.g., 04:00:00).
+        """
+        return pulumi.get(self, "start_times")
+
+
+@pulumi.output_type
+class GetClusterAutomatedBackupPolicyWeeklyScheduleStartTimeResult(dict):
+    def __init__(__self__, *,
+                 hours: int,
+                 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. Currently, only the value 0 is supported.
+        :param int nanos: Fractions of seconds in nanoseconds. Currently, only the value 0 is supported.
+        :param int seconds: Seconds of minutes of the time. Currently, only the value 0 is supported.
+        """
+        pulumi.set(__self__, "hours", hours)
+        pulumi.set(__self__, "minutes", minutes)
+        pulumi.set(__self__, "nanos", nanos)
+        pulumi.set(__self__, "seconds", seconds)
+
+    @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. Currently, only the value 0 is supported.
+        """
+        return pulumi.get(self, "minutes")
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> int:
+        """
+        Fractions of seconds in nanoseconds. Currently, only the value 0 is supported.
+        """
+        return pulumi.get(self, "nanos")
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> int:
+        """
+        Seconds of minutes of the time. Currently, only the value 0 is supported.
+        """
+        return pulumi.get(self, "seconds")
+
+
+@pulumi.output_type
+class GetClusterBackupSourceResult(dict):
+    def __init__(__self__, *,
+                 backup_name: str):
+        """
+        :param str backup_name: The name of the backup resource.
+        """
+        pulumi.set(__self__, "backup_name", backup_name)
+
+    @property
+    @pulumi.getter(name="backupName")
+    def backup_name(self) -> str:
+        """
+        The name of the backup resource.
+        """
+        return pulumi.get(self, "backup_name")
+
+
+@pulumi.output_type
+class GetClusterContinuousBackupConfigResult(dict):
+    def __init__(__self__, *,
+                 enabled: bool,
+                 encryption_configs: Sequence['outputs.GetClusterContinuousBackupConfigEncryptionConfigResult'],
+                 recovery_window_days: int):
+        """
+        :param bool enabled: Whether continuous backup recovery is enabled. If not set, defaults to true.
+        :param Sequence['GetClusterContinuousBackupConfigEncryptionConfigArgs'] encryption_configs: EncryptionConfig describes the encryption config of a cluster or a backup that is encrypted with a CMEK (customer-managed encryption key).
+        :param int recovery_window_days: The numbers of days that are eligible to restore from using PITR. To support the entire recovery window, backups and logs are retained for one day more than the recovery window.
+               
+               If not set, defaults to 14 days.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        pulumi.set(__self__, "encryption_configs", encryption_configs)
+        pulumi.set(__self__, "recovery_window_days", recovery_window_days)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        Whether continuous backup recovery is enabled. If not set, defaults to true.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="encryptionConfigs")
+    def encryption_configs(self) -> Sequence['outputs.GetClusterContinuousBackupConfigEncryptionConfigResult']:
+        """
+        EncryptionConfig describes the encryption config of a cluster or a backup that is encrypted with a CMEK (customer-managed encryption key).
+        """
+        return pulumi.get(self, "encryption_configs")
+
+    @property
+    @pulumi.getter(name="recoveryWindowDays")
+    def recovery_window_days(self) -> int:
+        """
+        The numbers of days that are eligible to restore from using PITR. To support the entire recovery window, backups and logs are retained for one day more than the recovery window.
+
+        If not set, defaults to 14 days.
+        """
+        return pulumi.get(self, "recovery_window_days")
+
+
+@pulumi.output_type
+class GetClusterContinuousBackupConfigEncryptionConfigResult(dict):
+    def __init__(__self__, *,
+                 kms_key_name: str):
+        """
+        :param str kms_key_name: The fully-qualified resource name of the KMS key. Each Cloud KMS key is regionalized and has the following format: projects/[PROJECT]/locations/[REGION]/keyRings/[RING]/cryptoKeys/[KEY_NAME].
+        """
+        pulumi.set(__self__, "kms_key_name", kms_key_name)
+
+    @property
+    @pulumi.getter(name="kmsKeyName")
+    def kms_key_name(self) -> str:
+        """
+        The fully-qualified resource name of the KMS key. Each Cloud KMS key is regionalized and has the following format: projects/[PROJECT]/locations/[REGION]/keyRings/[RING]/cryptoKeys/[KEY_NAME].
+        """
+        return pulumi.get(self, "kms_key_name")
+
+
+@pulumi.output_type
+class GetClusterContinuousBackupInfoResult(dict):
+    def __init__(__self__, *,
+                 earliest_restorable_time: str,
+                 enabled_time: str,
+                 encryption_infos: Sequence['outputs.GetClusterContinuousBackupInfoEncryptionInfoResult'],
+                 schedules: Sequence[str]):
+        """
+        :param str earliest_restorable_time: The earliest restorable time that can be restored to. Output only field.
+        :param str enabled_time: When ContinuousBackup was most recently enabled. Set to null if ContinuousBackup is not enabled.
+        :param Sequence['GetClusterContinuousBackupInfoEncryptionInfoArgs'] encryption_infos: Output only. The encryption information for the WALs and backups required for ContinuousBackup.
+        :param Sequence[str] schedules: Days of the week on which a continuous backup is taken. Output only field. Ignored if passed into the request.
+        """
+        pulumi.set(__self__, "earliest_restorable_time", earliest_restorable_time)
+        pulumi.set(__self__, "enabled_time", enabled_time)
+        pulumi.set(__self__, "encryption_infos", encryption_infos)
+        pulumi.set(__self__, "schedules", schedules)
+
+    @property
+    @pulumi.getter(name="earliestRestorableTime")
+    def earliest_restorable_time(self) -> str:
+        """
+        The earliest restorable time that can be restored to. Output only field.
+        """
+        return pulumi.get(self, "earliest_restorable_time")
+
+    @property
+    @pulumi.getter(name="enabledTime")
+    def enabled_time(self) -> str:
+        """
+        When ContinuousBackup was most recently enabled. Set to null if ContinuousBackup is not enabled.
+        """
+        return pulumi.get(self, "enabled_time")
+
+    @property
+    @pulumi.getter(name="encryptionInfos")
+    def encryption_infos(self) -> Sequence['outputs.GetClusterContinuousBackupInfoEncryptionInfoResult']:
+        """
+        Output only. The encryption information for the WALs and backups required for ContinuousBackup.
+        """
+        return pulumi.get(self, "encryption_infos")
+
+    @property
+    @pulumi.getter
+    def schedules(self) -> Sequence[str]:
+        """
+        Days of the week on which a continuous backup is taken. Output only field. Ignored if passed into the request.
+        """
+        return pulumi.get(self, "schedules")
+
+
+@pulumi.output_type
+class GetClusterContinuousBackupInfoEncryptionInfoResult(dict):
+    def __init__(__self__, *,
+                 encryption_type: str,
+                 kms_key_versions: Sequence[str]):
+        """
+        :param str encryption_type: Output only. Type of encryption.
+        :param Sequence[str] kms_key_versions: Output only. Cloud KMS key versions that are being used to protect the database or the backup.
+        """
+        pulumi.set(__self__, "encryption_type", encryption_type)
+        pulumi.set(__self__, "kms_key_versions", kms_key_versions)
+
+    @property
+    @pulumi.getter(name="encryptionType")
+    def encryption_type(self) -> str:
+        """
+        Output only. Type of encryption.
+        """
+        return pulumi.get(self, "encryption_type")
+
+    @property
+    @pulumi.getter(name="kmsKeyVersions")
+    def kms_key_versions(self) -> Sequence[str]:
+        """
+        Output only. Cloud KMS key versions that are being used to protect the database or the backup.
+        """
+        return pulumi.get(self, "kms_key_versions")
+
+
+@pulumi.output_type
+class GetClusterEncryptionConfigResult(dict):
+    def __init__(__self__, *,
+                 kms_key_name: str):
+        """
+        :param str kms_key_name: The fully-qualified resource name of the KMS key. Each Cloud KMS key is regionalized and has the following format: projects/[PROJECT]/locations/[REGION]/keyRings/[RING]/cryptoKeys/[KEY_NAME].
+        """
+        pulumi.set(__self__, "kms_key_name", kms_key_name)
+
+    @property
+    @pulumi.getter(name="kmsKeyName")
+    def kms_key_name(self) -> str:
+        """
+        The fully-qualified resource name of the KMS key. Each Cloud KMS key is regionalized and has the following format: projects/[PROJECT]/locations/[REGION]/keyRings/[RING]/cryptoKeys/[KEY_NAME].
+        """
+        return pulumi.get(self, "kms_key_name")
+
+
+@pulumi.output_type
+class GetClusterEncryptionInfoResult(dict):
+    def __init__(__self__, *,
+                 encryption_type: str,
+                 kms_key_versions: Sequence[str]):
+        """
+        :param str encryption_type: Output only. Type of encryption.
+        :param Sequence[str] kms_key_versions: Output only. Cloud KMS key versions that are being used to protect the database or the backup.
+        """
+        pulumi.set(__self__, "encryption_type", encryption_type)
+        pulumi.set(__self__, "kms_key_versions", kms_key_versions)
+
+    @property
+    @pulumi.getter(name="encryptionType")
+    def encryption_type(self) -> str:
+        """
+        Output only. Type of encryption.
+        """
+        return pulumi.get(self, "encryption_type")
+
+    @property
+    @pulumi.getter(name="kmsKeyVersions")
+    def kms_key_versions(self) -> Sequence[str]:
+        """
+        Output only. Cloud KMS key versions that are being used to protect the database or the backup.
+        """
+        return pulumi.get(self, "kms_key_versions")
+
+
+@pulumi.output_type
+class GetClusterInitialUserResult(dict):
+    def __init__(__self__, *,
+                 password: str,
+                 user: str):
+        """
+        :param str password: The initial password for the user.
+        :param str user: The database username.
+        """
+        pulumi.set(__self__, "password", password)
+        pulumi.set(__self__, "user", user)
+
+    @property
+    @pulumi.getter
+    def password(self) -> str:
+        """
+        The initial password for the user.
+        """
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter
+    def user(self) -> str:
+        """
+        The database username.
+        """
+        return pulumi.get(self, "user")
+
+
+@pulumi.output_type
+class GetClusterMaintenanceUpdatePolicyResult(dict):
+    def __init__(__self__, *,
+                 maintenance_windows: Sequence['outputs.GetClusterMaintenanceUpdatePolicyMaintenanceWindowResult']):
+        """
+        :param Sequence['GetClusterMaintenanceUpdatePolicyMaintenanceWindowArgs'] maintenance_windows: Preferred windows to perform maintenance. Currently limited to 1.
+        """
+        pulumi.set(__self__, "maintenance_windows", maintenance_windows)
+
+    @property
+    @pulumi.getter(name="maintenanceWindows")
+    def maintenance_windows(self) -> Sequence['outputs.GetClusterMaintenanceUpdatePolicyMaintenanceWindowResult']:
+        """
+        Preferred windows to perform maintenance. Currently limited to 1.
+        """
+        return pulumi.get(self, "maintenance_windows")
+
+
+@pulumi.output_type
+class GetClusterMaintenanceUpdatePolicyMaintenanceWindowResult(dict):
+    def __init__(__self__, *,
+                 day: str,
+                 start_times: Sequence['outputs.GetClusterMaintenanceUpdatePolicyMaintenanceWindowStartTimeResult']):
+        """
+        :param str day: Preferred day of the week for maintenance, e.g. MONDAY, TUESDAY, etc. Possible values: ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]
+        :param Sequence['GetClusterMaintenanceUpdatePolicyMaintenanceWindowStartTimeArgs'] start_times: Preferred time to start the maintenance operation on the specified day. Maintenance will start within 1 hour of this time.
+        """
+        pulumi.set(__self__, "day", day)
+        pulumi.set(__self__, "start_times", start_times)
+
+    @property
+    @pulumi.getter
+    def day(self) -> str:
+        """
+        Preferred day of the week for maintenance, e.g. MONDAY, TUESDAY, etc. Possible values: ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]
+        """
+        return pulumi.get(self, "day")
+
+    @property
+    @pulumi.getter(name="startTimes")
+    def start_times(self) -> Sequence['outputs.GetClusterMaintenanceUpdatePolicyMaintenanceWindowStartTimeResult']:
+        """
+        Preferred time to start the maintenance operation on the specified day. Maintenance will start within 1 hour of this time.
+        """
+        return pulumi.get(self, "start_times")
+
+
+@pulumi.output_type
+class GetClusterMaintenanceUpdatePolicyMaintenanceWindowStartTimeResult(dict):
+    def __init__(__self__, *,
+                 hours: int,
+                 minutes: int,
+                 nanos: int,
+                 seconds: int):
+        """
+        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23.
+        :param int minutes: Minutes of hour of day. Currently, only the value 0 is supported.
+        :param int nanos: Fractions of seconds in nanoseconds. Currently, only the value 0 is supported.
+        :param int seconds: Seconds of minutes of the time. Currently, only the value 0 is supported.
+        """
+        pulumi.set(__self__, "hours", hours)
+        pulumi.set(__self__, "minutes", minutes)
+        pulumi.set(__self__, "nanos", nanos)
+        pulumi.set(__self__, "seconds", seconds)
+
+    @property
+    @pulumi.getter
+    def hours(self) -> int:
+        """
+        Hours of day in 24 hour format. Should be from 0 to 23.
+        """
+        return pulumi.get(self, "hours")
+
+    @property
+    @pulumi.getter
+    def minutes(self) -> int:
+        """
+        Minutes of hour of day. Currently, only the value 0 is supported.
+        """
+        return pulumi.get(self, "minutes")
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> int:
+        """
+        Fractions of seconds in nanoseconds. Currently, only the value 0 is supported.
+        """
+        return pulumi.get(self, "nanos")
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> int:
+        """
+        Seconds of minutes of the time. Currently, only the value 0 is supported.
+        """
+        return pulumi.get(self, "seconds")
+
+
+@pulumi.output_type
+class GetClusterMigrationSourceResult(dict):
+    def __init__(__self__, *,
+                 host_port: str,
+                 reference_id: str,
+                 source_type: str):
+        """
+        :param str host_port: The host and port of the on-premises instance in host:port format
+        :param str reference_id: Place holder for the external source identifier(e.g DMS job name) that created the cluster.
+        :param str source_type: Type of migration source.
+        """
+        pulumi.set(__self__, "host_port", host_port)
+        pulumi.set(__self__, "reference_id", reference_id)
+        pulumi.set(__self__, "source_type", source_type)
+
+    @property
+    @pulumi.getter(name="hostPort")
+    def host_port(self) -> str:
+        """
+        The host and port of the on-premises instance in host:port format
+        """
+        return pulumi.get(self, "host_port")
+
+    @property
+    @pulumi.getter(name="referenceId")
+    def reference_id(self) -> str:
+        """
+        Place holder for the external source identifier(e.g DMS job name) that created the cluster.
+        """
+        return pulumi.get(self, "reference_id")
+
+    @property
+    @pulumi.getter(name="sourceType")
+    def source_type(self) -> str:
+        """
+        Type of migration source.
+        """
+        return pulumi.get(self, "source_type")
+
+
+@pulumi.output_type
+class GetClusterNetworkConfigResult(dict):
+    def __init__(__self__, *,
+                 allocated_ip_range: str,
+                 network: str):
+        """
+        :param str allocated_ip_range: The name of the allocated IP range for the private IP AlloyDB cluster. For example: "google-managed-services-default".
+               If set, the instance IPs for this cluster will be created in the allocated range.
+        :param str network: The resource link for the VPC network in which cluster resources are created and from which they are accessible via Private IP. The network must belong to the same project as the cluster.
+               It is specified in the form: "projects/{projectNumber}/global/networks/{network_id}".
+        """
+        pulumi.set(__self__, "allocated_ip_range", allocated_ip_range)
+        pulumi.set(__self__, "network", network)
+
+    @property
+    @pulumi.getter(name="allocatedIpRange")
+    def allocated_ip_range(self) -> str:
+        """
+        The name of the allocated IP range for the private IP AlloyDB cluster. For example: "google-managed-services-default".
+        If set, the instance IPs for this cluster will be created in the allocated range.
+        """
+        return pulumi.get(self, "allocated_ip_range")
+
+    @property
+    @pulumi.getter
+    def network(self) -> str:
+        """
+        The resource link for the VPC network in which cluster resources are created and from which they are accessible via Private IP. The network must belong to the same project as the cluster.
+        It is specified in the form: "projects/{projectNumber}/global/networks/{network_id}".
+        """
+        return pulumi.get(self, "network")
+
+
+@pulumi.output_type
+class GetClusterPscConfigResult(dict):
+    def __init__(__self__, *,
+                 psc_enabled: bool):
+        """
+        :param bool psc_enabled: Create an instance that allows connections from Private Service Connect endpoints to the instance.
+        """
+        pulumi.set(__self__, "psc_enabled", psc_enabled)
+
+    @property
+    @pulumi.getter(name="pscEnabled")
+    def psc_enabled(self) -> bool:
+        """
+        Create an instance that allows connections from Private Service Connect endpoints to the instance.
+        """
+        return pulumi.get(self, "psc_enabled")
+
+
+@pulumi.output_type
+class GetClusterRestoreBackupSourceResult(dict):
+    def __init__(__self__, *,
+                 backup_name: str):
+        """
+        :param str backup_name: The name of the backup that this cluster is restored from.
+        """
+        pulumi.set(__self__, "backup_name", backup_name)
+
+    @property
+    @pulumi.getter(name="backupName")
+    def backup_name(self) -> str:
+        """
+        The name of the backup that this cluster is restored from.
+        """
+        return pulumi.get(self, "backup_name")
+
+
+@pulumi.output_type
+class GetClusterRestoreContinuousBackupSourceResult(dict):
+    def __init__(__self__, *,
+                 cluster: str,
+                 point_in_time: str):
+        """
+        :param str cluster: The name of the source cluster that this cluster is restored from.
+        :param str point_in_time: The point in time that this cluster is restored to, in RFC 3339 format.
+        """
+        pulumi.set(__self__, "cluster", cluster)
+        pulumi.set(__self__, "point_in_time", point_in_time)
+
+    @property
+    @pulumi.getter
+    def cluster(self) -> str:
+        """
+        The name of the source cluster that this cluster is restored from.
+        """
+        return pulumi.get(self, "cluster")
+
+    @property
+    @pulumi.getter(name="pointInTime")
+    def point_in_time(self) -> str:
+        """
+        The point in time that this cluster is restored to, in RFC 3339 format.
+        """
+        return pulumi.get(self, "point_in_time")
+
+
+@pulumi.output_type
+class GetClusterSecondaryConfigResult(dict):
+    def __init__(__self__, *,
+                 primary_cluster_name: str):
+        """
+        :param str primary_cluster_name: Name of the primary cluster must be in the format
+               'projects/{project}/locations/{location}/clusters/{cluster_id}'
+        """
+        pulumi.set(__self__, "primary_cluster_name", primary_cluster_name)
+
+    @property
+    @pulumi.getter(name="primaryClusterName")
+    def primary_cluster_name(self) -> str:
+        """
+        Name of the primary cluster must be in the format
+        'projects/{project}/locations/{location}/clusters/{cluster_id}'
+        """
+        return pulumi.get(self, "primary_cluster_name")
+
+
+@pulumi.output_type
+class GetClusterTrialMetadataResult(dict):
+    def __init__(__self__, *,
+                 end_time: str,
+                 grace_end_time: str,
+                 start_time: str,
+                 upgrade_time: str):
+        """
+        :param str end_time: End time of the trial cluster.
+        :param str grace_end_time: Grace end time of the trial cluster.
+        :param str start_time: Start time of the trial cluster.
+        :param str upgrade_time: Upgrade time of the trial cluster to standard cluster.
+        """
+        pulumi.set(__self__, "end_time", end_time)
+        pulumi.set(__self__, "grace_end_time", grace_end_time)
+        pulumi.set(__self__, "start_time", start_time)
+        pulumi.set(__self__, "upgrade_time", upgrade_time)
+
+    @property
+    @pulumi.getter(name="endTime")
+    def end_time(self) -> str:
+        """
+        End time of the trial cluster.
+        """
+        return pulumi.get(self, "end_time")
+
+    @property
+    @pulumi.getter(name="graceEndTime")
+    def grace_end_time(self) -> str:
+        """
+        Grace end time of the trial cluster.
+        """
+        return pulumi.get(self, "grace_end_time")
+
+    @property
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> str:
+        """
+        Start time of the trial cluster.
+        """
+        return pulumi.get(self, "start_time")
+
+    @property
+    @pulumi.getter(name="upgradeTime")
+    def upgrade_time(self) -> str:
+        """
+        Upgrade time of the trial cluster to standard cluster.
+        """
+        return pulumi.get(self, "upgrade_time")
+
+
+@pulumi.output_type
+class GetInstanceClientConnectionConfigResult(dict):
+    def __init__(__self__, *,
+                 require_connectors: bool,
+                 ssl_configs: Sequence['outputs.GetInstanceClientConnectionConfigSslConfigResult']):
+        """
+        :param bool require_connectors: Configuration to enforce connectors only (ex: AuthProxy) connections to the database.
+        :param Sequence['GetInstanceClientConnectionConfigSslConfigArgs'] ssl_configs: SSL config option for this instance.
+        """
+        pulumi.set(__self__, "require_connectors", require_connectors)
+        pulumi.set(__self__, "ssl_configs", ssl_configs)
+
+    @property
+    @pulumi.getter(name="requireConnectors")
+    def require_connectors(self) -> bool:
+        """
+        Configuration to enforce connectors only (ex: AuthProxy) connections to the database.
+        """
+        return pulumi.get(self, "require_connectors")
+
+    @property
+    @pulumi.getter(name="sslConfigs")
+    def ssl_configs(self) -> Sequence['outputs.GetInstanceClientConnectionConfigSslConfigResult']:
+        """
+        SSL config option for this instance.
+        """
+        return pulumi.get(self, "ssl_configs")
+
+
+@pulumi.output_type
+class GetInstanceClientConnectionConfigSslConfigResult(dict):
+    def __init__(__self__, *,
+                 ssl_mode: str):
+        """
+        :param str ssl_mode: SSL mode. Specifies client-server SSL/TLS connection behavior. Possible values: ["ENCRYPTED_ONLY", "ALLOW_UNENCRYPTED_AND_ENCRYPTED"]
+        """
+        pulumi.set(__self__, "ssl_mode", ssl_mode)
+
+    @property
+    @pulumi.getter(name="sslMode")
+    def ssl_mode(self) -> str:
+        """
+        SSL mode. Specifies client-server SSL/TLS connection behavior. Possible values: ["ENCRYPTED_ONLY", "ALLOW_UNENCRYPTED_AND_ENCRYPTED"]
+        """
+        return pulumi.get(self, "ssl_mode")
+
+
+@pulumi.output_type
+class GetInstanceMachineConfigResult(dict):
+    def __init__(__self__, *,
+                 cpu_count: int):
+        """
+        :param int cpu_count: The number of CPU's in the VM instance.
+        """
+        pulumi.set(__self__, "cpu_count", cpu_count)
+
+    @property
+    @pulumi.getter(name="cpuCount")
+    def cpu_count(self) -> int:
+        """
+        The number of CPU's in the VM instance.
+        """
+        return pulumi.get(self, "cpu_count")
+
+
+@pulumi.output_type
+class GetInstanceNetworkConfigResult(dict):
+    def __init__(__self__, *,
+                 authorized_external_networks: Sequence['outputs.GetInstanceNetworkConfigAuthorizedExternalNetworkResult'],
+                 enable_outbound_public_ip: bool,
+                 enable_public_ip: bool):
+        """
+        :param Sequence['GetInstanceNetworkConfigAuthorizedExternalNetworkArgs'] authorized_external_networks: A list of external networks authorized to access this instance. This
+               field is only allowed to be set when 'enable_public_ip' is set to
+               true.
+        :param bool enable_outbound_public_ip: Enabling outbound public ip for the instance.
+        :param bool enable_public_ip: Enabling public ip for the instance. If a user wishes to disable this,
+               please also clear the list of the authorized external networks set on
+               the same instance.
+        """
+        pulumi.set(__self__, "authorized_external_networks", authorized_external_networks)
+        pulumi.set(__self__, "enable_outbound_public_ip", enable_outbound_public_ip)
+        pulumi.set(__self__, "enable_public_ip", enable_public_ip)
+
+    @property
+    @pulumi.getter(name="authorizedExternalNetworks")
+    def authorized_external_networks(self) -> Sequence['outputs.GetInstanceNetworkConfigAuthorizedExternalNetworkResult']:
+        """
+        A list of external networks authorized to access this instance. This
+        field is only allowed to be set when 'enable_public_ip' is set to
+        true.
+        """
+        return pulumi.get(self, "authorized_external_networks")
+
+    @property
+    @pulumi.getter(name="enableOutboundPublicIp")
+    def enable_outbound_public_ip(self) -> bool:
+        """
+        Enabling outbound public ip for the instance.
+        """
+        return pulumi.get(self, "enable_outbound_public_ip")
+
+    @property
+    @pulumi.getter(name="enablePublicIp")
+    def enable_public_ip(self) -> bool:
+        """
+        Enabling public ip for the instance. If a user wishes to disable this,
+        please also clear the list of the authorized external networks set on
+        the same instance.
+        """
+        return pulumi.get(self, "enable_public_ip")
+
+
+@pulumi.output_type
+class GetInstanceNetworkConfigAuthorizedExternalNetworkResult(dict):
+    def __init__(__self__, *,
+                 cidr_range: str):
+        """
+        :param str cidr_range: CIDR range for one authorized network of the instance.
+        """
+        pulumi.set(__self__, "cidr_range", cidr_range)
+
+    @property
+    @pulumi.getter(name="cidrRange")
+    def cidr_range(self) -> str:
+        """
+        CIDR range for one authorized network of the instance.
+        """
+        return pulumi.get(self, "cidr_range")
+
+
+@pulumi.output_type
+class GetInstanceObservabilityConfigResult(dict):
+    def __init__(__self__, *,
+                 enabled: bool,
+                 max_query_string_length: int,
+                 preserve_comments: bool,
+                 query_plans_per_minute: int,
+                 record_application_tags: bool,
+                 track_active_queries: bool,
+                 track_wait_event_types: bool,
+                 track_wait_events: bool):
+        """
+        :param bool enabled: Observability feature status for an instance.
+        :param int max_query_string_length: Query string length. The default value is 10240. Any integer between 1024 and 100000 is considered valid.
+        :param bool preserve_comments: Preserve comments in the query string.
+        :param int query_plans_per_minute: Number of query execution plans captured by Insights per minute for all queries combined. The default value is 5. Any integer between 0 and 200 is considered valid.
+        :param bool record_application_tags: Record application tags for an instance. This flag is turned "on" by default.
+        :param bool track_active_queries: Track actively running queries. If not set, default value is "off".
+        :param bool track_wait_event_types: Record wait event types during query execution for an instance.
+        :param bool track_wait_events: Record wait events during query execution for an instance.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        pulumi.set(__self__, "max_query_string_length", max_query_string_length)
+        pulumi.set(__self__, "preserve_comments", preserve_comments)
+        pulumi.set(__self__, "query_plans_per_minute", query_plans_per_minute)
+        pulumi.set(__self__, "record_application_tags", record_application_tags)
+        pulumi.set(__self__, "track_active_queries", track_active_queries)
+        pulumi.set(__self__, "track_wait_event_types", track_wait_event_types)
+        pulumi.set(__self__, "track_wait_events", track_wait_events)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        Observability feature status for an instance.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="maxQueryStringLength")
+    def max_query_string_length(self) -> int:
+        """
+        Query string length. The default value is 10240. Any integer between 1024 and 100000 is considered valid.
+        """
+        return pulumi.get(self, "max_query_string_length")
+
+    @property
+    @pulumi.getter(name="preserveComments")
+    def preserve_comments(self) -> bool:
+        """
+        Preserve comments in the query string.
+        """
+        return pulumi.get(self, "preserve_comments")
+
+    @property
+    @pulumi.getter(name="queryPlansPerMinute")
+    def query_plans_per_minute(self) -> int:
+        """
+        Number of query execution plans captured by Insights per minute for all queries combined. The default value is 5. Any integer between 0 and 200 is considered valid.
+        """
+        return pulumi.get(self, "query_plans_per_minute")
+
+    @property
+    @pulumi.getter(name="recordApplicationTags")
+    def record_application_tags(self) -> bool:
+        """
+        Record application tags for an instance. This flag is turned "on" by default.
+        """
+        return pulumi.get(self, "record_application_tags")
+
+    @property
+    @pulumi.getter(name="trackActiveQueries")
+    def track_active_queries(self) -> bool:
+        """
+        Track actively running queries. If not set, default value is "off".
+        """
+        return pulumi.get(self, "track_active_queries")
+
+    @property
+    @pulumi.getter(name="trackWaitEventTypes")
+    def track_wait_event_types(self) -> bool:
+        """
+        Record wait event types during query execution for an instance.
+        """
+        return pulumi.get(self, "track_wait_event_types")
+
+    @property
+    @pulumi.getter(name="trackWaitEvents")
+    def track_wait_events(self) -> bool:
+        """
+        Record wait events during query execution for an instance.
+        """
+        return pulumi.get(self, "track_wait_events")
+
+
+@pulumi.output_type
+class GetInstancePscInstanceConfigResult(dict):
+    def __init__(__self__, *,
+                 allowed_consumer_projects: Sequence[str],
+                 psc_dns_name: str,
+                 service_attachment_link: str):
+        """
+        :param Sequence[str] allowed_consumer_projects: List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
+               These should be specified as project numbers only.
+        :param str psc_dns_name: The DNS name of the instance for PSC connectivity.
+               Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
+        :param str service_attachment_link: The service attachment created when Private Service Connect (PSC) is enabled for the instance.
+               The name of the resource will be in the format of
+               'projects/<alloydb-tenant-project-number>/regions/<region-name>/serviceAttachments/<service-attachment-name>'
+        """
+        pulumi.set(__self__, "allowed_consumer_projects", allowed_consumer_projects)
+        pulumi.set(__self__, "psc_dns_name", psc_dns_name)
+        pulumi.set(__self__, "service_attachment_link", service_attachment_link)
+
+    @property
+    @pulumi.getter(name="allowedConsumerProjects")
+    def allowed_consumer_projects(self) -> Sequence[str]:
+        """
+        List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
+        These should be specified as project numbers only.
+        """
+        return pulumi.get(self, "allowed_consumer_projects")
+
+    @property
+    @pulumi.getter(name="pscDnsName")
+    def psc_dns_name(self) -> str:
+        """
+        The DNS name of the instance for PSC connectivity.
+        Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
+        """
+        return pulumi.get(self, "psc_dns_name")
+
+    @property
+    @pulumi.getter(name="serviceAttachmentLink")
+    def service_attachment_link(self) -> str:
+        """
+        The service attachment created when Private Service Connect (PSC) is enabled for the instance.
+        The name of the resource will be in the format of
+        'projects/<alloydb-tenant-project-number>/regions/<region-name>/serviceAttachments/<service-attachment-name>'
+        """
+        return pulumi.get(self, "service_attachment_link")
+
+
+@pulumi.output_type
+class GetInstanceQueryInsightsConfigResult(dict):
+    def __init__(__self__, *,
+                 query_plans_per_minute: int,
+                 query_string_length: int,
+                 record_application_tags: bool,
+                 record_client_address: bool):
+        """
+        :param int query_plans_per_minute: Number of query execution plans captured by Insights per minute for all queries combined. The default value is 5. Any integer between 0 and 20 is considered valid.
+        :param int query_string_length: Query string length. The default value is 1024. Any integer between 256 and 4500 is considered valid.
+        :param bool record_application_tags: Record application tags for an instance. This flag is turned "on" by default.
+        :param bool record_client_address: Record client address for an instance. Client address is PII information. This flag is turned "on" by default.
+        """
+        pulumi.set(__self__, "query_plans_per_minute", query_plans_per_minute)
+        pulumi.set(__self__, "query_string_length", query_string_length)
+        pulumi.set(__self__, "record_application_tags", record_application_tags)
+        pulumi.set(__self__, "record_client_address", record_client_address)
+
+    @property
+    @pulumi.getter(name="queryPlansPerMinute")
+    def query_plans_per_minute(self) -> int:
+        """
+        Number of query execution plans captured by Insights per minute for all queries combined. The default value is 5. Any integer between 0 and 20 is considered valid.
+        """
+        return pulumi.get(self, "query_plans_per_minute")
+
+    @property
+    @pulumi.getter(name="queryStringLength")
+    def query_string_length(self) -> int:
+        """
+        Query string length. The default value is 1024. Any integer between 256 and 4500 is considered valid.
+        """
+        return pulumi.get(self, "query_string_length")
+
+    @property
+    @pulumi.getter(name="recordApplicationTags")
+    def record_application_tags(self) -> bool:
+        """
+        Record application tags for an instance. This flag is turned "on" by default.
+        """
+        return pulumi.get(self, "record_application_tags")
+
+    @property
+    @pulumi.getter(name="recordClientAddress")
+    def record_client_address(self) -> bool:
+        """
+        Record client address for an instance. Client address is PII information. This flag is turned "on" by default.
+        """
+        return pulumi.get(self, "record_client_address")
+
+
+@pulumi.output_type
+class GetInstanceReadPoolConfigResult(dict):
+    def __init__(__self__, *,
+                 node_count: int):
+        """
+        :param int node_count: Read capacity, i.e. number of nodes in a read pool instance.
+        """
+        pulumi.set(__self__, "node_count", node_count)
+
+    @property
+    @pulumi.getter(name="nodeCount")
+    def node_count(self) -> int:
+        """
+        Read capacity, i.e. number of nodes in a read pool instance.
+        """
+        return pulumi.get(self, "node_count")
+
+
 @pulumi.output_type
 class GetLocationsLocationResult(dict):
     def __init__(__self__, *,