pulumi-gcp 8.24.0a1743057423__py3-none-any.whl → 8.25.0__py3-none-any.whl

pulumi_gcp/memorystore/outputs.py

@@ -16,34 +16,351 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
+    'InstanceCrossInstanceReplicationConfig',
+    'InstanceCrossInstanceReplicationConfigMembership',
+    'InstanceCrossInstanceReplicationConfigMembershipPrimaryInstance',
+    'InstanceCrossInstanceReplicationConfigMembershipSecondaryInstance',
+    'InstanceCrossInstanceReplicationConfigPrimaryInstance',
+    'InstanceCrossInstanceReplicationConfigSecondaryInstance',
     'InstanceDesiredPscAutoConnection',
+    'InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpoint',
+    'InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnection',
+    'InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionPscConnection',
     'InstanceDiscoveryEndpoint',
     'InstanceEndpoint',
     'InstanceEndpointConnection',
     'InstanceEndpointConnectionPscAutoConnection',
+    'InstanceMaintenancePolicy',
+    'InstanceMaintenancePolicyWeeklyMaintenanceWindow',
+    'InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime',
+    'InstanceMaintenanceSchedule',
     'InstanceNodeConfig',
     'InstancePersistenceConfig',
     'InstancePersistenceConfigAofConfig',
     'InstancePersistenceConfigRdbConfig',
+    'InstancePscAttachmentDetail',
     'InstancePscAutoConnection',
     'InstanceStateInfo',
     'InstanceStateInfoUpdateInfo',
     'InstanceZoneDistributionConfig',
+    'GetInstanceCrossInstanceReplicationConfigResult',
+    'GetInstanceCrossInstanceReplicationConfigMembershipResult',
+    'GetInstanceCrossInstanceReplicationConfigMembershipPrimaryInstanceResult',
+    'GetInstanceCrossInstanceReplicationConfigMembershipSecondaryInstanceResult',
+    'GetInstanceCrossInstanceReplicationConfigPrimaryInstanceResult',
+    'GetInstanceCrossInstanceReplicationConfigSecondaryInstanceResult',
     'GetInstanceDesiredPscAutoConnectionResult',
     'GetInstanceDiscoveryEndpointResult',
     'GetInstanceEndpointResult',
     'GetInstanceEndpointConnectionResult',
     'GetInstanceEndpointConnectionPscAutoConnectionResult',
+    'GetInstanceMaintenancePolicyResult',
+    'GetInstanceMaintenancePolicyWeeklyMaintenanceWindowResult',
+    'GetInstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeResult',
+    'GetInstanceMaintenanceScheduleResult',
     'GetInstanceNodeConfigResult',
     'GetInstancePersistenceConfigResult',
     'GetInstancePersistenceConfigAofConfigResult',
     'GetInstancePersistenceConfigRdbConfigResult',
+    'GetInstancePscAttachmentDetailResult',
     'GetInstancePscAutoConnectionResult',
     'GetInstanceStateInfoResult',
     'GetInstanceStateInfoUpdateInfoResult',
     'GetInstanceZoneDistributionConfigResult',
 ]
 
+@pulumi.output_type
+class InstanceCrossInstanceReplicationConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "instanceRole":
+            suggest = "instance_role"
+        elif key == "primaryInstance":
+            suggest = "primary_instance"
+        elif key == "secondaryInstances":
+            suggest = "secondary_instances"
+        elif key == "updateTime":
+            suggest = "update_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceCrossInstanceReplicationConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceCrossInstanceReplicationConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceCrossInstanceReplicationConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 instance_role: Optional[str] = None,
+                 memberships: Optional[Sequence['outputs.InstanceCrossInstanceReplicationConfigMembership']] = None,
+                 primary_instance: Optional['outputs.InstanceCrossInstanceReplicationConfigPrimaryInstance'] = None,
+                 secondary_instances: Optional[Sequence['outputs.InstanceCrossInstanceReplicationConfigSecondaryInstance']] = None,
+                 update_time: Optional[str] = None):
+        """
+        :param str instance_role: The instance role supports the following values:
+               1. `INSTANCE_ROLE_UNSPECIFIED`: This is an independent instance that has never participated in cross instance replication. It allows both reads and writes.
+               2. `NONE`: This is an independent instance that previously participated in cross instance replication(either as a `PRIMARY` or `SECONDARY` cluster). It allows both reads and writes.
+               3. `PRIMARY`: This instance serves as the replication source for secondary instance that are replicating from it. Any data written to it is automatically replicated to its secondary clusters. It allows both reads and writes.
+               4. `SECONDARY`: This instance replicates data from the primary instance. It allows only reads.
+               Possible values are: `INSTANCE_ROLE_UNSPECIFIED`, `NONE`, `PRIMARY`, `SECONDARY`.
+        :param Sequence['InstanceCrossInstanceReplicationConfigMembershipArgs'] memberships: (Output)
+               An output only view of all the member instance participating in cross instance replication. This field is populated for all the member clusters irrespective of their cluster role.
+               Structure is documented below.
+        :param 'InstanceCrossInstanceReplicationConfigPrimaryInstanceArgs' primary_instance: This field is only set for a secondary instance. Details of the primary instance that is used as the replication source for this secondary instance. This is allowed to be set only for clusters whose cluster role is of type `SECONDARY`.
+               Structure is documented below.
+        :param Sequence['InstanceCrossInstanceReplicationConfigSecondaryInstanceArgs'] secondary_instances: List of secondary instances that are replicating from this primary cluster. This is allowed to be set only for instances whose cluster role is of type `PRIMARY`.
+               Structure is documented below.
+        :param str update_time: (Output)
+               The last time cross instance replication config was updated.
+        """
+        if instance_role is not None:
+            pulumi.set(__self__, "instance_role", instance_role)
+        if memberships is not None:
+            pulumi.set(__self__, "memberships", memberships)
+        if primary_instance is not None:
+            pulumi.set(__self__, "primary_instance", primary_instance)
+        if secondary_instances is not None:
+            pulumi.set(__self__, "secondary_instances", secondary_instances)
+        if update_time is not None:
+            pulumi.set(__self__, "update_time", update_time)
+
+    @property
+    @pulumi.getter(name="instanceRole")
+    def instance_role(self) -> Optional[str]:
+        """
+        The instance role supports the following values:
+        1. `INSTANCE_ROLE_UNSPECIFIED`: This is an independent instance that has never participated in cross instance replication. It allows both reads and writes.
+        2. `NONE`: This is an independent instance that previously participated in cross instance replication(either as a `PRIMARY` or `SECONDARY` cluster). It allows both reads and writes.
+        3. `PRIMARY`: This instance serves as the replication source for secondary instance that are replicating from it. Any data written to it is automatically replicated to its secondary clusters. It allows both reads and writes.
+        4. `SECONDARY`: This instance replicates data from the primary instance. It allows only reads.
+        Possible values are: `INSTANCE_ROLE_UNSPECIFIED`, `NONE`, `PRIMARY`, `SECONDARY`.
+        """
+        return pulumi.get(self, "instance_role")
+
+    @property
+    @pulumi.getter
+    def memberships(self) -> Optional[Sequence['outputs.InstanceCrossInstanceReplicationConfigMembership']]:
+        """
+        (Output)
+        An output only view of all the member instance participating in cross instance replication. This field is populated for all the member clusters irrespective of their cluster role.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "memberships")
+
+    @property
+    @pulumi.getter(name="primaryInstance")
+    def primary_instance(self) -> Optional['outputs.InstanceCrossInstanceReplicationConfigPrimaryInstance']:
+        """
+        This field is only set for a secondary instance. Details of the primary instance that is used as the replication source for this secondary instance. This is allowed to be set only for clusters whose cluster role is of type `SECONDARY`.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "primary_instance")
+
+    @property
+    @pulumi.getter(name="secondaryInstances")
+    def secondary_instances(self) -> Optional[Sequence['outputs.InstanceCrossInstanceReplicationConfigSecondaryInstance']]:
+        """
+        List of secondary instances that are replicating from this primary cluster. This is allowed to be set only for instances whose cluster role is of type `PRIMARY`.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "secondary_instances")
+
+    @property
+    @pulumi.getter(name="updateTime")
+    def update_time(self) -> Optional[str]:
+        """
+        (Output)
+        The last time cross instance replication config was updated.
+        """
+        return pulumi.get(self, "update_time")
+
+
+@pulumi.output_type
+class InstanceCrossInstanceReplicationConfigMembership(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "primaryInstances":
+            suggest = "primary_instances"
+        elif key == "secondaryInstances":
+            suggest = "secondary_instances"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceCrossInstanceReplicationConfigMembership. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceCrossInstanceReplicationConfigMembership.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceCrossInstanceReplicationConfigMembership.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 primary_instances: Optional[Sequence['outputs.InstanceCrossInstanceReplicationConfigMembershipPrimaryInstance']] = None,
+                 secondary_instances: Optional[Sequence['outputs.InstanceCrossInstanceReplicationConfigMembershipSecondaryInstance']] = None):
+        """
+        :param Sequence['InstanceCrossInstanceReplicationConfigMembershipPrimaryInstanceArgs'] primary_instances: Details of the primary instance that is used as the replication source for all the secondary instances.
+        :param Sequence['InstanceCrossInstanceReplicationConfigMembershipSecondaryInstanceArgs'] secondary_instances: List of secondary instances that are replicating from the primary instance.
+        """
+        if primary_instances is not None:
+            pulumi.set(__self__, "primary_instances", primary_instances)
+        if secondary_instances is not None:
+            pulumi.set(__self__, "secondary_instances", secondary_instances)
+
+    @property
+    @pulumi.getter(name="primaryInstances")
+    def primary_instances(self) -> Optional[Sequence['outputs.InstanceCrossInstanceReplicationConfigMembershipPrimaryInstance']]:
+        """
+        Details of the primary instance that is used as the replication source for all the secondary instances.
+        """
+        return pulumi.get(self, "primary_instances")
+
+    @property
+    @pulumi.getter(name="secondaryInstances")
+    def secondary_instances(self) -> Optional[Sequence['outputs.InstanceCrossInstanceReplicationConfigMembershipSecondaryInstance']]:
+        """
+        List of secondary instances that are replicating from the primary instance.
+        """
+        return pulumi.get(self, "secondary_instances")
+
+
+@pulumi.output_type
+class InstanceCrossInstanceReplicationConfigMembershipPrimaryInstance(dict):
+    def __init__(__self__, *,
+                 instance: Optional[str] = None,
+                 uid: Optional[str] = None):
+        """
+        :param str instance: The full resource path of the primary instance in the format: projects/{project}/locations/{region}/instances/{instance-id}
+        :param str uid: (Output)
+               The unique id of the primary instance.
+        """
+        if instance is not None:
+            pulumi.set(__self__, "instance", instance)
+        if uid is not None:
+            pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def instance(self) -> Optional[str]:
+        """
+        The full resource path of the primary instance in the format: projects/{project}/locations/{region}/instances/{instance-id}
+        """
+        return pulumi.get(self, "instance")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> Optional[str]:
+        """
+        (Output)
+        The unique id of the primary instance.
+        """
+        return pulumi.get(self, "uid")
+
+
+@pulumi.output_type
+class InstanceCrossInstanceReplicationConfigMembershipSecondaryInstance(dict):
+    def __init__(__self__, *,
+                 instance: Optional[str] = None,
+                 uid: Optional[str] = None):
+        """
+        :param str instance: The full resource path of the secondary instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        :param str uid: Output only. System assigned, unique identifier for the instance.
+        """
+        if instance is not None:
+            pulumi.set(__self__, "instance", instance)
+        if uid is not None:
+            pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def instance(self) -> Optional[str]:
+        """
+        The full resource path of the secondary instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        """
+        return pulumi.get(self, "instance")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> Optional[str]:
+        """
+        Output only. System assigned, unique identifier for the instance.
+        """
+        return pulumi.get(self, "uid")
+
+
+@pulumi.output_type
+class InstanceCrossInstanceReplicationConfigPrimaryInstance(dict):
+    def __init__(__self__, *,
+                 instance: Optional[str] = None,
+                 uid: Optional[str] = None):
+        """
+        :param str instance: The full resource path of the primary instance in the format: projects/{project}/locations/{region}/instances/{instance-id}
+        :param str uid: (Output)
+               The unique id of the primary instance.
+        """
+        if instance is not None:
+            pulumi.set(__self__, "instance", instance)
+        if uid is not None:
+            pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def instance(self) -> Optional[str]:
+        """
+        The full resource path of the primary instance in the format: projects/{project}/locations/{region}/instances/{instance-id}
+        """
+        return pulumi.get(self, "instance")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> Optional[str]:
+        """
+        (Output)
+        The unique id of the primary instance.
+        """
+        return pulumi.get(self, "uid")
+
+
+@pulumi.output_type
+class InstanceCrossInstanceReplicationConfigSecondaryInstance(dict):
+    def __init__(__self__, *,
+                 instance: Optional[str] = None,
+                 uid: Optional[str] = None):
+        """
+        :param str instance: (Output)
+               The full resource path of the secondary instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        :param str uid: (Output)
+               The unique id of the secondary instance.
+        """
+        if instance is not None:
+            pulumi.set(__self__, "instance", instance)
+        if uid is not None:
+            pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def instance(self) -> Optional[str]:
+        """
+        (Output)
+        The full resource path of the secondary instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        """
+        return pulumi.get(self, "instance")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> Optional[str]:
+        """
+        (Output)
+        The unique id of the secondary instance.
+        """
+        return pulumi.get(self, "uid")
+
+
 @pulumi.output_type
 class InstanceDesiredPscAutoConnection(dict):
     @staticmethod
@@ -96,6 +413,218 @@ class InstanceDesiredPscAutoConnection(dict):
         return pulumi.get(self, "project_id")
 
 
+@pulumi.output_type
+class InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpoint(dict):
+    def __init__(__self__, *,
+                 connections: Optional[Sequence['outputs.InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnection']] = None):
+        """
+        :param Sequence['InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionArgs'] connections: Structure is documented below.
+        """
+        if connections is not None:
+            pulumi.set(__self__, "connections", connections)
+
+    @property
+    @pulumi.getter
+    def connections(self) -> Optional[Sequence['outputs.InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnection']]:
+        """
+        Structure is documented below.
+        """
+        return pulumi.get(self, "connections")
+
+
+@pulumi.output_type
+class InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnection(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "pscConnection":
+            suggest = "psc_connection"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnection. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnection.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnection.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 psc_connection: Optional['outputs.InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionPscConnection'] = None):
+        """
+        :param 'InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionPscConnectionArgs' psc_connection: Detailed information of a PSC connection that is created by the customer
+               who owns the cluster.
+               Structure is documented below.
+        """
+        if psc_connection is not None:
+            pulumi.set(__self__, "psc_connection", psc_connection)
+
+    @property
+    @pulumi.getter(name="pscConnection")
+    def psc_connection(self) -> Optional['outputs.InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionPscConnection']:
+        """
+        Detailed information of a PSC connection that is created by the customer
+        who owns the cluster.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_connection")
+
+
+@pulumi.output_type
+class InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionPscConnection(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "forwardingRule":
+            suggest = "forwarding_rule"
+        elif key == "ipAddress":
+            suggest = "ip_address"
+        elif key == "pscConnectionId":
+            suggest = "psc_connection_id"
+        elif key == "serviceAttachment":
+            suggest = "service_attachment"
+        elif key == "connectionType":
+            suggest = "connection_type"
+        elif key == "projectId":
+            suggest = "project_id"
+        elif key == "pscConnectionStatus":
+            suggest = "psc_connection_status"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionPscConnection. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionPscConnection.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceDesiredUserCreatedEndpointsDesiredUserCreatedEndpointConnectionPscConnection.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 forwarding_rule: str,
+                 ip_address: str,
+                 network: str,
+                 psc_connection_id: str,
+                 service_attachment: str,
+                 connection_type: Optional[str] = None,
+                 project_id: Optional[str] = None,
+                 psc_connection_status: Optional[str] = None):
+        """
+        :param str forwarding_rule: The URI of the consumer side forwarding rule.
+               Format:
+               projects/{project}/regions/{region}/forwardingRules/{forwarding_rule}
+        :param str ip_address: The IP allocated on the consumer network for the PSC forwarding rule.
+        :param str network: The consumer network where the IP address resides, in the form of
+               projects/{project_id}/global/networks/{network_id}.
+        :param str psc_connection_id: The PSC connection id of the forwarding rule connected to the
+               service attachment.
+        :param str service_attachment: The service attachment which is the target of the PSC connection, in the form of projects/{project-id}/regions/{region}/serviceAttachments/{service-attachment-id}.
+        :param str connection_type: (Output)
+               Output Only. Type of a PSC Connection.
+               Possible values:
+               CONNECTION_TYPE_DISCOVERY
+               CONNECTION_TYPE_PRIMARY
+               CONNECTION_TYPE_READER
+        :param str project_id: The consumer project_id where the forwarding rule is created from.
+        :param str psc_connection_status: (Output)
+               Output Only. The status of the PSC connection: whether a connection exists and ACTIVE or it no longer exists.
+               Possible values:
+               ACTIVE
+               NOT_FOUND
+        """
+        pulumi.set(__self__, "forwarding_rule", forwarding_rule)
+        pulumi.set(__self__, "ip_address", ip_address)
+        pulumi.set(__self__, "network", network)
+        pulumi.set(__self__, "psc_connection_id", psc_connection_id)
+        pulumi.set(__self__, "service_attachment", service_attachment)
+        if connection_type is not None:
+            pulumi.set(__self__, "connection_type", connection_type)
+        if project_id is not None:
+            pulumi.set(__self__, "project_id", project_id)
+        if psc_connection_status is not None:
+            pulumi.set(__self__, "psc_connection_status", psc_connection_status)
+
+    @property
+    @pulumi.getter(name="forwardingRule")
+    def forwarding_rule(self) -> str:
+        """
+        The URI of the consumer side forwarding rule.
+        Format:
+        projects/{project}/regions/{region}/forwardingRules/{forwarding_rule}
+        """
+        return pulumi.get(self, "forwarding_rule")
+
+    @property
+    @pulumi.getter(name="ipAddress")
+    def ip_address(self) -> str:
+        """
+        The IP allocated on the consumer network for the PSC forwarding rule.
+        """
+        return pulumi.get(self, "ip_address")
+
+    @property
+    @pulumi.getter
+    def network(self) -> str:
+        """
+        The consumer network where the IP address resides, in the form of
+        projects/{project_id}/global/networks/{network_id}.
+        """
+        return pulumi.get(self, "network")
+
+    @property
+    @pulumi.getter(name="pscConnectionId")
+    def psc_connection_id(self) -> str:
+        """
+        The PSC connection id of the forwarding rule connected to the
+        service attachment.
+        """
+        return pulumi.get(self, "psc_connection_id")
+
+    @property
+    @pulumi.getter(name="serviceAttachment")
+    def service_attachment(self) -> str:
+        """
+        The service attachment which is the target of the PSC connection, in the form of projects/{project-id}/regions/{region}/serviceAttachments/{service-attachment-id}.
+        """
+        return pulumi.get(self, "service_attachment")
+
+    @property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> Optional[str]:
+        """
+        (Output)
+        Output Only. Type of a PSC Connection.
+        Possible values:
+        CONNECTION_TYPE_DISCOVERY
+        CONNECTION_TYPE_PRIMARY
+        CONNECTION_TYPE_READER
+        """
+        return pulumi.get(self, "connection_type")
+
+    @property
+    @pulumi.getter(name="projectId")
+    def project_id(self) -> Optional[str]:
+        """
+        The consumer project_id where the forwarding rule is created from.
+        """
+        return pulumi.get(self, "project_id")
+
+    @property
+    @pulumi.getter(name="pscConnectionStatus")
+    def psc_connection_status(self) -> Optional[str]:
+        """
+        (Output)
+        Output Only. The status of the PSC connection: whether a connection exists and ACTIVE or it no longer exists.
+        Possible values:
+        ACTIVE
+        NOT_FOUND
+        """
+        return pulumi.get(self, "psc_connection_status")
+
+
 @pulumi.output_type
 class InstanceDiscoveryEndpoint(dict):
     def __init__(__self__, *,
@@ -368,6 +897,317 @@ class InstanceEndpointConnectionPscAutoConnection(dict):
         return pulumi.get(self, "service_attachment")
 
 
+@pulumi.output_type
+class InstanceMaintenancePolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "createTime":
+            suggest = "create_time"
+        elif key == "updateTime":
+            suggest = "update_time"
+        elif key == "weeklyMaintenanceWindows":
+            suggest = "weekly_maintenance_windows"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceMaintenancePolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceMaintenancePolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceMaintenancePolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 create_time: Optional[str] = None,
+                 update_time: Optional[str] = None,
+                 weekly_maintenance_windows: Optional[Sequence['outputs.InstanceMaintenancePolicyWeeklyMaintenanceWindow']] = None):
+        """
+        :param str create_time: (Output)
+               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 update_time: (Output)
+               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['InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs'] 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.
+               Structure is documented below.
+        """
+        if create_time is not None:
+            pulumi.set(__self__, "create_time", create_time)
+        if update_time is not None:
+            pulumi.set(__self__, "update_time", update_time)
+        if weekly_maintenance_windows is not None:
+            pulumi.set(__self__, "weekly_maintenance_windows", weekly_maintenance_windows)
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> Optional[str]:
+        """
+        (Output)
+        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(name="updateTime")
+    def update_time(self) -> Optional[str]:
+        """
+        (Output)
+        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) -> Optional[Sequence['outputs.InstanceMaintenancePolicyWeeklyMaintenanceWindow']]:
+        """
+        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.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "weekly_maintenance_windows")
+
+
+@pulumi.output_type
+class InstanceMaintenancePolicyWeeklyMaintenanceWindow(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "startTime":
+            suggest = "start_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceMaintenancePolicyWeeklyMaintenanceWindow. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceMaintenancePolicyWeeklyMaintenanceWindow.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceMaintenancePolicyWeeklyMaintenanceWindow.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 day: str,
+                 start_time: 'outputs.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime',
+                 duration: Optional[str] = None):
+        """
+        :param str day: 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 are: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`.
+        :param 'InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs' start_time: Start time of the window in UTC time.
+               Structure is documented below.
+        :param str duration: (Output)
+               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".
+        """
+        pulumi.set(__self__, "day", day)
+        pulumi.set(__self__, "start_time", start_time)
+        if duration is not None:
+            pulumi.set(__self__, "duration", duration)
+
+    @property
+    @pulumi.getter
+    def day(self) -> str:
+        """
+        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 are: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`.
+        """
+        return pulumi.get(self, "day")
+
+    @property
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> 'outputs.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime':
+        """
+        Start time of the window in UTC time.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "start_time")
+
+    @property
+    @pulumi.getter
+    def duration(self) -> Optional[str]:
+        """
+        (Output)
+        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")
+
+
+@pulumi.output_type
+class InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime(dict):
+    def __init__(__self__, *,
+                 hours: Optional[int] = None,
+                 minutes: Optional[int] = None,
+                 nanos: Optional[int] = None,
+                 seconds: Optional[int] = None):
+        """
+        :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.
+        """
+        if hours is not None:
+            pulumi.set(__self__, "hours", hours)
+        if minutes is not None:
+            pulumi.set(__self__, "minutes", minutes)
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+        if seconds is not None:
+            pulumi.set(__self__, "seconds", seconds)
+
+    @property
+    @pulumi.getter
+    def hours(self) -> Optional[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) -> Optional[int]:
+        """
+        Minutes of hour of day. Must be from 0 to 59.
+        """
+        return pulumi.get(self, "minutes")
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[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) -> Optional[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")
+
+
+@pulumi.output_type
+class InstanceMaintenanceSchedule(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "endTime":
+            suggest = "end_time"
+        elif key == "scheduleDeadlineTime":
+            suggest = "schedule_deadline_time"
+        elif key == "startTime":
+            suggest = "start_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceMaintenanceSchedule. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceMaintenanceSchedule.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceMaintenanceSchedule.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 end_time: Optional[str] = None,
+                 schedule_deadline_time: Optional[str] = None,
+                 start_time: Optional[str] = None):
+        """
+        :param str end_time: (Output)
+               The end time of any upcoming scheduled maintenance for this cluster.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+               resolution and up to nine fractional digits.
+        :param str schedule_deadline_time: (Output)
+               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)
+               The start time of any upcoming scheduled maintenance for this cluster.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+               resolution and up to nine fractional digits.
+        """
+        if end_time is not None:
+            pulumi.set(__self__, "end_time", end_time)
+        if schedule_deadline_time is not None:
+            pulumi.set(__self__, "schedule_deadline_time", schedule_deadline_time)
+        if start_time is not None:
+            pulumi.set(__self__, "start_time", start_time)
+
+    @property
+    @pulumi.getter(name="endTime")
+    def end_time(self) -> Optional[str]:
+        """
+        (Output)
+        The end time of any upcoming scheduled maintenance for this cluster.
+        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) -> Optional[str]:
+        """
+        (Output)
+        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) -> Optional[str]:
+        """
+        (Output)
+        The start time of any upcoming scheduled maintenance for this cluster.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+        resolution and up to nine fractional digits.
+        """
+        return pulumi.get(self, "start_time")
+
+
 @pulumi.output_type
 class InstanceNodeConfig(dict):
     @staticmethod
@@ -567,27 +1407,89 @@ class InstancePersistenceConfigRdbConfig(dict):
             pulumi.set(__self__, "rdb_snapshot_start_time", rdb_snapshot_start_time)
 
     @property
-    @pulumi.getter(name="rdbSnapshotPeriod")
-    def rdb_snapshot_period(self) -> Optional[str]:
+    @pulumi.getter(name="rdbSnapshotPeriod")
+    def rdb_snapshot_period(self) -> Optional[str]:
+        """
+        Optional. Period between RDB snapshots.
+        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) -> Optional[str]:
+        """
+        Optional. 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.
+        """
+        return pulumi.get(self, "rdb_snapshot_start_time")
+
+
+@pulumi.output_type
+class InstancePscAttachmentDetail(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "connectionType":
+            suggest = "connection_type"
+        elif key == "serviceAttachment":
+            suggest = "service_attachment"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstancePscAttachmentDetail. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstancePscAttachmentDetail.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstancePscAttachmentDetail.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 connection_type: Optional[str] = None,
+                 service_attachment: Optional[str] = None):
+        """
+        :param str connection_type: (Output)
+               Output Only. Type of a PSC Connection.
+               Possible values:
+               CONNECTION_TYPE_DISCOVERY
+               CONNECTION_TYPE_PRIMARY
+               CONNECTION_TYPE_READER
+        :param str service_attachment: (Output)
+               Output only. The service attachment which is the target of the PSC connection, in the form of projects/{project-id}/regions/{region}/serviceAttachments/{service-attachment-id}.
+        """
+        if connection_type is not None:
+            pulumi.set(__self__, "connection_type", connection_type)
+        if service_attachment is not None:
+            pulumi.set(__self__, "service_attachment", service_attachment)
+
+    @property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> Optional[str]:
         """
-        Optional. Period between RDB snapshots.
+        (Output)
+        Output Only. Type of a PSC Connection.
         Possible values:
-        ONE_HOUR
-        SIX_HOURS
-        TWELVE_HOURS
-        TWENTY_FOUR_HOURS
+        CONNECTION_TYPE_DISCOVERY
+        CONNECTION_TYPE_PRIMARY
+        CONNECTION_TYPE_READER
         """
-        return pulumi.get(self, "rdb_snapshot_period")
+        return pulumi.get(self, "connection_type")
 
     @property
-    @pulumi.getter(name="rdbSnapshotStartTime")
-    def rdb_snapshot_start_time(self) -> Optional[str]:
+    @pulumi.getter(name="serviceAttachment")
+    def service_attachment(self) -> Optional[str]:
         """
-        Optional. 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.
+        (Output)
+        Output only. The service attachment which is the target of the PSC connection, in the form of projects/{project-id}/regions/{region}/serviceAttachments/{service-attachment-id}.
         """
-        return pulumi.get(self, "rdb_snapshot_start_time")
+        return pulumi.get(self, "service_attachment")
 
 
 @pulumi.output_type
@@ -819,7 +1721,11 @@ class InstanceStateInfoUpdateInfo(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "targetReplicaCount":
+        if key == "targetEngineVersion":
+            suggest = "target_engine_version"
+        elif key == "targetNodeType":
+            suggest = "target_node_type"
+        elif key == "targetReplicaCount":
             suggest = "target_replica_count"
         elif key == "targetShardCount":
             suggest = "target_shard_count"
@@ -836,19 +1742,47 @@ class InstanceStateInfoUpdateInfo(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 target_engine_version: Optional[str] = None,
+                 target_node_type: Optional[str] = None,
                  target_replica_count: Optional[int] = None,
                  target_shard_count: Optional[int] = None):
         """
+        :param str target_engine_version: (Output)
+               Output only. Target engine version for the instance.
+        :param str target_node_type: (Output)
+               Output only. Target node type for the instance.
         :param int target_replica_count: (Output)
                Output only. Target number of replica nodes per shard for the instance.
         :param int target_shard_count: (Output)
                Output only. Target number of shards for the instance.
         """
+        if target_engine_version is not None:
+            pulumi.set(__self__, "target_engine_version", target_engine_version)
+        if target_node_type is not None:
+            pulumi.set(__self__, "target_node_type", target_node_type)
         if target_replica_count is not None:
             pulumi.set(__self__, "target_replica_count", target_replica_count)
         if target_shard_count is not None:
             pulumi.set(__self__, "target_shard_count", target_shard_count)
 
+    @property
+    @pulumi.getter(name="targetEngineVersion")
+    def target_engine_version(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. Target engine version for the instance.
+        """
+        return pulumi.get(self, "target_engine_version")
+
+    @property
+    @pulumi.getter(name="targetNodeType")
+    def target_node_type(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. Target node type for the instance.
+        """
+        return pulumi.get(self, "target_node_type")
+
     @property
     @pulumi.getter(name="targetReplicaCount")
     def target_replica_count(self) -> Optional[int]:
@@ -909,6 +1843,221 @@ class InstanceZoneDistributionConfig(dict):
         return pulumi.get(self, "zone")
 
 
+@pulumi.output_type
+class GetInstanceCrossInstanceReplicationConfigResult(dict):
+    def __init__(__self__, *,
+                 instance_role: str,
+                 memberships: Sequence['outputs.GetInstanceCrossInstanceReplicationConfigMembershipResult'],
+                 primary_instances: Sequence['outputs.GetInstanceCrossInstanceReplicationConfigPrimaryInstanceResult'],
+                 secondary_instances: Sequence['outputs.GetInstanceCrossInstanceReplicationConfigSecondaryInstanceResult'],
+                 update_time: str):
+        """
+        :param str instance_role: The instance role supports the following values:
+               1. 'INSTANCE_ROLE_UNSPECIFIED': This is an independent instance that has never participated in cross instance replication. It allows both reads and writes.
+               2. 'NONE': This is an independent instance that previously participated in cross instance replication(either as a 'PRIMARY' or 'SECONDARY' cluster). It allows both reads and writes.
+               3. 'PRIMARY': This instance serves as the replication source for secondary instance that are replicating from it. Any data written to it is automatically replicated to its secondary clusters. It allows both reads and writes.
+               4. 'SECONDARY': This instance replicates data from the primary instance. It allows only reads. Possible values: ["INSTANCE_ROLE_UNSPECIFIED", "NONE", "PRIMARY", "SECONDARY"]
+        :param Sequence['GetInstanceCrossInstanceReplicationConfigMembershipArgs'] memberships: An output only view of all the member instance participating in cross instance replication. This field is populated for all the member clusters irrespective of their cluster role.
+        :param Sequence['GetInstanceCrossInstanceReplicationConfigPrimaryInstanceArgs'] primary_instances: This field is only set for a secondary instance. Details of the primary instance that is used as the replication source for this secondary instance. This is allowed to be set only for clusters whose cluster role is of type 'SECONDARY'.
+        :param Sequence['GetInstanceCrossInstanceReplicationConfigSecondaryInstanceArgs'] secondary_instances: List of secondary instances that are replicating from this primary cluster. This is allowed to be set only for instances whose cluster role is of type 'PRIMARY'.
+        :param str update_time: The last time cross instance replication config was updated.
+        """
+        pulumi.set(__self__, "instance_role", instance_role)
+        pulumi.set(__self__, "memberships", memberships)
+        pulumi.set(__self__, "primary_instances", primary_instances)
+        pulumi.set(__self__, "secondary_instances", secondary_instances)
+        pulumi.set(__self__, "update_time", update_time)
+
+    @property
+    @pulumi.getter(name="instanceRole")
+    def instance_role(self) -> str:
+        """
+        The instance role supports the following values:
+        1. 'INSTANCE_ROLE_UNSPECIFIED': This is an independent instance that has never participated in cross instance replication. It allows both reads and writes.
+        2. 'NONE': This is an independent instance that previously participated in cross instance replication(either as a 'PRIMARY' or 'SECONDARY' cluster). It allows both reads and writes.
+        3. 'PRIMARY': This instance serves as the replication source for secondary instance that are replicating from it. Any data written to it is automatically replicated to its secondary clusters. It allows both reads and writes.
+        4. 'SECONDARY': This instance replicates data from the primary instance. It allows only reads. Possible values: ["INSTANCE_ROLE_UNSPECIFIED", "NONE", "PRIMARY", "SECONDARY"]
+        """
+        return pulumi.get(self, "instance_role")
+
+    @property
+    @pulumi.getter
+    def memberships(self) -> Sequence['outputs.GetInstanceCrossInstanceReplicationConfigMembershipResult']:
+        """
+        An output only view of all the member instance participating in cross instance replication. This field is populated for all the member clusters irrespective of their cluster role.
+        """
+        return pulumi.get(self, "memberships")
+
+    @property
+    @pulumi.getter(name="primaryInstances")
+    def primary_instances(self) -> Sequence['outputs.GetInstanceCrossInstanceReplicationConfigPrimaryInstanceResult']:
+        """
+        This field is only set for a secondary instance. Details of the primary instance that is used as the replication source for this secondary instance. This is allowed to be set only for clusters whose cluster role is of type 'SECONDARY'.
+        """
+        return pulumi.get(self, "primary_instances")
+
+    @property
+    @pulumi.getter(name="secondaryInstances")
+    def secondary_instances(self) -> Sequence['outputs.GetInstanceCrossInstanceReplicationConfigSecondaryInstanceResult']:
+        """
+        List of secondary instances that are replicating from this primary cluster. This is allowed to be set only for instances whose cluster role is of type 'PRIMARY'.
+        """
+        return pulumi.get(self, "secondary_instances")
+
+    @property
+    @pulumi.getter(name="updateTime")
+    def update_time(self) -> str:
+        """
+        The last time cross instance replication config was updated.
+        """
+        return pulumi.get(self, "update_time")
+
+
+@pulumi.output_type
+class GetInstanceCrossInstanceReplicationConfigMembershipResult(dict):
+    def __init__(__self__, *,
+                 primary_instances: Sequence['outputs.GetInstanceCrossInstanceReplicationConfigMembershipPrimaryInstanceResult'],
+                 secondary_instances: Sequence['outputs.GetInstanceCrossInstanceReplicationConfigMembershipSecondaryInstanceResult']):
+        """
+        :param Sequence['GetInstanceCrossInstanceReplicationConfigMembershipPrimaryInstanceArgs'] primary_instances: Details of the primary instance that is used as the replication source for all the secondary instances.
+        :param Sequence['GetInstanceCrossInstanceReplicationConfigMembershipSecondaryInstanceArgs'] secondary_instances: List of secondary instances that are replicating from the primary instance.
+        """
+        pulumi.set(__self__, "primary_instances", primary_instances)
+        pulumi.set(__self__, "secondary_instances", secondary_instances)
+
+    @property
+    @pulumi.getter(name="primaryInstances")
+    def primary_instances(self) -> Sequence['outputs.GetInstanceCrossInstanceReplicationConfigMembershipPrimaryInstanceResult']:
+        """
+        Details of the primary instance that is used as the replication source for all the secondary instances.
+        """
+        return pulumi.get(self, "primary_instances")
+
+    @property
+    @pulumi.getter(name="secondaryInstances")
+    def secondary_instances(self) -> Sequence['outputs.GetInstanceCrossInstanceReplicationConfigMembershipSecondaryInstanceResult']:
+        """
+        List of secondary instances that are replicating from the primary instance.
+        """
+        return pulumi.get(self, "secondary_instances")
+
+
+@pulumi.output_type
+class GetInstanceCrossInstanceReplicationConfigMembershipPrimaryInstanceResult(dict):
+    def __init__(__self__, *,
+                 instance: str,
+                 uid: str):
+        """
+        :param str instance: The full resource path of the primary instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        :param str uid: The unique id of the primary instance.
+        """
+        pulumi.set(__self__, "instance", instance)
+        pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def instance(self) -> str:
+        """
+        The full resource path of the primary instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        """
+        return pulumi.get(self, "instance")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> str:
+        """
+        The unique id of the primary instance.
+        """
+        return pulumi.get(self, "uid")
+
+
+@pulumi.output_type
+class GetInstanceCrossInstanceReplicationConfigMembershipSecondaryInstanceResult(dict):
+    def __init__(__self__, *,
+                 instance: str,
+                 uid: str):
+        """
+        :param str instance: The full resource path of the secondary instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        :param str uid: The unique id of the secondary instance.
+        """
+        pulumi.set(__self__, "instance", instance)
+        pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def instance(self) -> str:
+        """
+        The full resource path of the secondary instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        """
+        return pulumi.get(self, "instance")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> str:
+        """
+        The unique id of the secondary instance.
+        """
+        return pulumi.get(self, "uid")
+
+
+@pulumi.output_type
+class GetInstanceCrossInstanceReplicationConfigPrimaryInstanceResult(dict):
+    def __init__(__self__, *,
+                 instance: str,
+                 uid: str):
+        """
+        :param str instance: The full resource path of the primary instance in the format: projects/{project}/locations/{region}/instances/{instance-id}
+        :param str uid: The unique id of the primary instance.
+        """
+        pulumi.set(__self__, "instance", instance)
+        pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def instance(self) -> str:
+        """
+        The full resource path of the primary instance in the format: projects/{project}/locations/{region}/instances/{instance-id}
+        """
+        return pulumi.get(self, "instance")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> str:
+        """
+        The unique id of the primary instance.
+        """
+        return pulumi.get(self, "uid")
+
+
+@pulumi.output_type
+class GetInstanceCrossInstanceReplicationConfigSecondaryInstanceResult(dict):
+    def __init__(__self__, *,
+                 instance: str,
+                 uid: str):
+        """
+        :param str instance: The full resource path of the Nth instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        :param str uid: The unique id of the Nth instance.
+        """
+        pulumi.set(__self__, "instance", instance)
+        pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def instance(self) -> str:
+        """
+        The full resource path of the Nth instance in the format: projects/{project}/locations/{region}/instance/{instance-id}
+        """
+        return pulumi.get(self, "instance")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> str:
+        """
+        The unique id of the Nth instance.
+        """
+        return pulumi.get(self, "uid")
+
+
 @pulumi.output_type
 class GetInstanceDesiredPscAutoConnectionResult(dict):
     def __init__(__self__, *,
@@ -1131,6 +2280,231 @@ class GetInstanceEndpointConnectionPscAutoConnectionResult(dict):
         return pulumi.get(self, "service_attachment")
 
 
+@pulumi.output_type
+class GetInstanceMaintenancePolicyResult(dict):
+    def __init__(__self__, *,
+                 create_time: str,
+                 update_time: str,
+                 weekly_maintenance_windows: Sequence['outputs.GetInstanceMaintenancePolicyWeeklyMaintenanceWindowResult']):
+        """
+        :param str create_time: 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 update_time: 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__, "update_time", update_time)
+        pulumi.set(__self__, "weekly_maintenance_windows", weekly_maintenance_windows)
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
+        """
+        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(name="updateTime")
+    def update_time(self) -> str:
+        """
+        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")
+
+
+@pulumi.output_type
+class GetInstanceMaintenancePolicyWeeklyMaintenanceWindowResult(dict):
+    def __init__(__self__, *,
+                 day: str,
+                 duration: str,
+                 start_times: Sequence['outputs.GetInstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeResult']):
+        """
+        :param str day: 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: 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: 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)
+
+    @property
+    @pulumi.getter
+    def day(self) -> str:
+        """
+        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:
+        """
+        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']:
+        """
+        Start time of the window in UTC time.
+        """
+        return pulumi.get(self, "start_times")
+
+
+@pulumi.output_type
+class GetInstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeResult(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. 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)
+        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. 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")
+
+
+@pulumi.output_type
+class GetInstanceMaintenanceScheduleResult(dict):
+    def __init__(__self__, *,
+                 end_time: str,
+                 schedule_deadline_time: str,
+                 start_time: str):
+        """
+        :param str end_time: The end time of any upcoming scheduled maintenance for this cluster.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+               resolution and up to nine fractional digits.
+        :param str schedule_deadline_time: 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: The start time of any upcoming scheduled maintenance for this cluster.
+               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)
+
+    @property
+    @pulumi.getter(name="endTime")
+    def end_time(self) -> str:
+        """
+        The end time of any upcoming scheduled maintenance for this cluster.
+        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:
+        """
+        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:
+        """
+        The start time of any upcoming scheduled maintenance for this cluster.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond
+        resolution and up to nine fractional digits.
+        """
+        return pulumi.get(self, "start_time")
+
+
 @pulumi.output_type
 class GetInstanceNodeConfigResult(dict):
     def __init__(__self__, *,
@@ -1266,6 +2640,35 @@ class GetInstancePersistenceConfigRdbConfigResult(dict):
         return pulumi.get(self, "rdb_snapshot_start_time")
 
 
+@pulumi.output_type
+class GetInstancePscAttachmentDetailResult(dict):
+    def __init__(__self__, *,
+                 connection_type: str,
+                 service_attachment: str):
+        """
+        :param str connection_type: Service attachment URI which your self-created PscConnection should use as target.
+        :param str service_attachment: Service attachment URI which your self-created PscConnection should use as target.
+        """
+        pulumi.set(__self__, "connection_type", connection_type)
+        pulumi.set(__self__, "service_attachment", service_attachment)
+
+    @property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> str:
+        """
+        Service attachment URI which your self-created PscConnection should use as target.
+        """
+        return pulumi.get(self, "connection_type")
+
+    @property
+    @pulumi.getter(name="serviceAttachment")
+    def service_attachment(self) -> str:
+        """
+        Service attachment URI which your self-created PscConnection should use as target.
+        """
+        return pulumi.get(self, "service_attachment")
+
+
 @pulumi.output_type
 class GetInstancePscAutoConnectionResult(dict):
     def __init__(__self__, *,
@@ -1415,15 +2818,37 @@ class GetInstanceStateInfoResult(dict):
 @pulumi.output_type
 class GetInstanceStateInfoUpdateInfoResult(dict):
     def __init__(__self__, *,
+                 target_engine_version: str,
+                 target_node_type: str,
                  target_replica_count: int,
                  target_shard_count: int):
         """
+        :param str target_engine_version: Output only. Target engine version for the instance.
+        :param str target_node_type: Output only. Target node type for the instance.
         :param int target_replica_count: Output only. Target number of replica nodes per shard for the instance.
         :param int target_shard_count: Output only. Target number of shards for the instance.
         """
+        pulumi.set(__self__, "target_engine_version", target_engine_version)
+        pulumi.set(__self__, "target_node_type", target_node_type)
         pulumi.set(__self__, "target_replica_count", target_replica_count)
         pulumi.set(__self__, "target_shard_count", target_shard_count)
 
+    @property
+    @pulumi.getter(name="targetEngineVersion")
+    def target_engine_version(self) -> str:
+        """
+        Output only. Target engine version for the instance.
+        """
+        return pulumi.get(self, "target_engine_version")
+
+    @property
+    @pulumi.getter(name="targetNodeType")
+    def target_node_type(self) -> str:
+        """
+        Output only. Target node type for the instance.
+        """
+        return pulumi.get(self, "target_node_type")
+
     @property
     @pulumi.getter(name="targetReplicaCount")
     def target_replica_count(self) -> int: