database

type Client struct {
	// contains filtered or unexported fields
}

type CreateDatabaseCatalogRequest struct {
	Catalog *DatabaseCatalog
}

type CreateDatabaseInstanceRequest struct {
	// Instance to create.
	DatabaseInstance *DatabaseInstance
}

type CreateDatabaseInstanceRoleRequest struct {
	InstanceName         *string
	DatabaseInstanceRole *DatabaseInstanceRole
	DatabaseInstanceName *string
}

type CreateDatabaseInstanceWaiter struct {
	// contains filtered or unexported fields
}

type CreateDatabaseTableRequest struct {
	Table *DatabaseTable
}

type CreateSyncedDatabaseTableRequest struct {
	SyncedTable *SyncedDatabaseTable
}

type CustomTag struct {
	// The key of the custom tag.
	Key *string
	// The value of the custom tag.
	Value *string
}

type DatabaseCatalog struct {
	// The name of the catalog in UC.
	Name *string `fieldmask:"name"`
	// The name of the DatabaseInstance housing the database.
	DatabaseInstanceName *string `fieldmask:"database_instance_name"`
	// The name of the database (in an instance) associated with the catalog.
	DatabaseName              *string `fieldmask:"database_name"`
	Uid                       *string `fieldmask:"uid"`
	CreateDatabaseIfNotExists *bool   `fieldmask:"create_database_if_not_exists"`
}

type DatabaseCredential struct {
	Token          *string
	ExpirationTime *types.Time
}

type DatabaseInstance struct {
	// An immutable UUID identifier for the instance.
	Uid *string `fieldmask:"uid"`
	// The name of the instance. This is the unique identifier for the instance.
	Name *string `fieldmask:"name"`
	// The email of the creator of the instance.
	Creator *string `fieldmask:"creator"`
	// The DNS endpoint to connect to the instance for read+write access.
	ReadWriteDns *string `fieldmask:"read_write_dns"`
	// The timestamp when the instance was created.
	CreationTime *types.Time `fieldmask:"creation_time"`
	// The current state of the instance.
	State DatabaseInstance_State `fieldmask:"state"`
	// The version of Postgres running on the instance.
	PgVersion *string `fieldmask:"pg_version"`
	// The sku of the instance. Valid values are "CU_1", "CU_2", "CU_4", "CU_8".
	Capacity *string `fieldmask:"capacity"`
	// Deprecated. The sku of the instance; this field will always match the value
	// of capacity. This is an output only field that contains the value computed
	// from the input field combined with server side defaults. Use the field
	// without the effective_ prefix to set the value.
	EffectiveCapacity *string `fieldmask:"effective_capacity"`
	// Whether to stop the instance. An input only param, see effective_stopped for
	// the output.
	Stopped *bool `fieldmask:"stopped"`
	// Whether the instance is stopped. This is an output only field that contains
	// the value computed from the input field combined with server side defaults.
	// Use the field without the effective_ prefix to set the value.
	EffectiveStopped *bool `fieldmask:"effective_stopped"`
	// The number of nodes in the instance, composed of 1 primary and 0 or more
	// secondaries. Defaults to 1 primary and 0 secondaries. This field is input
	// only, see effective_node_count for the output.
	NodeCount *int `fieldmask:"node_count"`
	// The number of nodes in the instance, composed of 1 primary and 0 or more
	// secondaries. Defaults to 1 primary and 0 secondaries. This is an output only
	// field that contains the value computed from the input field combined with
	// server side defaults. Use the field without the effective_ prefix to set the
	// value.
	EffectiveNodeCount *int `fieldmask:"effective_node_count"`
	// Whether to enable secondaries to serve read-only traffic. Defaults to false.
	EnableReadableSecondaries *bool `fieldmask:"enable_readable_secondaries"`
	// Whether secondaries serving read-only traffic are enabled. Defaults to false.
	// This is an output only field that contains the value computed from the input
	// field combined with server side defaults. Use the field without the
	// effective_ prefix to set the value.
	EffectiveEnableReadableSecondaries *bool `fieldmask:"effective_enable_readable_secondaries"`
	// The DNS endpoint to connect to the instance for read only access. This is
	// only available if enable_readable_secondaries is true.
	ReadOnlyDns *string `fieldmask:"read_only_dns"`
	// The retention window for the instance. This is the time window in days for
	// which the historical data is retained. The default value is 7 days. Valid
	// values are 2 to 35 days.
	RetentionWindowInDays *int `fieldmask:"retention_window_in_days"`
	// The retention window for the instance. This is the time window in days for
	// which the historical data is retained. This is an output only field that
	// contains the value computed from the input field combined with server side
	// defaults. Use the field without the effective_ prefix to set the value.
	EffectiveRetentionWindowInDays *int `fieldmask:"effective_retention_window_in_days"`
	// The ref of the parent instance. This is only available if the instance is
	// child instance. Input: For specifying the parent instance to create a child
	// instance. Optional. Output: Only populated if provided as input to create a
	// child instance.
	ParentInstanceRef *DatabaseInstanceRef `fieldmask:"parent_instance_ref"`
	// The refs of the child instances. This is only available if the instance is
	// parent instance.
	ChildInstanceRefs []DatabaseInstanceRef `fieldmask:"child_instance_refs"`
	// Whether to enable PG native password login on the instance. Defaults to
	// false.
	EnablePgNativeLogin *bool `fieldmask:"enable_pg_native_login"`
	// Whether the instance has PG native password login enabled. This is an output
	// only field that contains the value computed from the input field combined
	// with server side defaults. Use the field without the effective_ prefix to set
	// the value.
	EffectiveEnablePgNativeLogin *bool `fieldmask:"effective_enable_pg_native_login"`
	// The desired usage policy to associate with the instance.
	UsagePolicyId *string `fieldmask:"usage_policy_id"`
	// The policy that is applied to the instance. This is an output only field that
	// contains the value computed from the input field combined with server side
	// defaults. Use the field without the effective_ prefix to set the value.
	EffectiveUsagePolicyId *string `fieldmask:"effective_usage_policy_id"`
	// Custom tags associated with the instance. This field is only included on
	// create and update responses.
	CustomTags []CustomTag `fieldmask:"custom_tags"`
	// The recorded custom tags associated with the instance. This is an output only
	// field that contains the value computed from the input field combined with
	// server side defaults. Use the field without the effective_ prefix to set the
	// value.
	EffectiveCustomTags []CustomTag `fieldmask:"effective_custom_tags"`
}

type DatabaseInstanceRef struct {
	// Id of the ref database instance.
	Uid *string `fieldmask:"uid"`
	// Name of the ref database instance.
	Name *string `fieldmask:"name"`
	// User-specified WAL LSN of the ref database instance.
	//
	// Input: For specifying the WAL LSN to create a child instance. Optional.
	// Output: Only populated if provided as input to create a child instance.
	Lsn *string `fieldmask:"lsn"`
	// For a parent ref instance, this is the LSN on the parent instance from which
	// the instance was created. For a child ref instance, this is the LSN on the
	// instance from which the child instance was created. This is an output only
	// field that contains the value computed from the input field combined with
	// server side defaults. Use the field without the effective_ prefix to set the
	// value.
	EffectiveLsn *string `fieldmask:"effective_lsn"`
	// Branch time of the ref database instance. For a parent ref instance, this is
	// the point in time on the parent instance from which the instance was created.
	// For a child ref instance, this is the point in time on the instance from
	// which the child instance was created. Input: For specifying the point in time
	// to create a child instance. Optional. Output: Only populated if provided as
	// input to create a child instance.
	BranchTime *types.Time `fieldmask:"branch_time"`
}

type DatabaseInstanceRole struct {
	// The name of the role. This is the unique identifier for the role in an
	// instance.
	Name *string
	// The type of the role.
	IdentityType DatabaseInstanceRole_IdentityType
	// An enum value for a standard role that this role is a member of.
	MembershipRole DatabaseInstanceRole_MembershipRole
	// The desired API-exposed Postgres role attribute to associate with the role.
	// Optional.
	Attributes *DatabaseInstanceRole_Attributes
	// The attributes that are applied to the role. This is an output only field
	// that contains the value computed from the input field combined with server
	// side defaults. Use the field without the effective_ prefix to set the value.
	EffectiveAttributes *DatabaseInstanceRole_Attributes
	InstanceName        *string
}

type DatabaseInstanceRole_Attributes struct {
	Createdb   *bool
	Createrole *bool
	Bypassrls  *bool
}

type DatabaseInstanceRole_IdentityType string

type DatabaseInstanceRole_MembershipRole string

type DatabaseInstance_State string

type DatabaseTable struct {
	// Full three-part (catalog, schema, table) name of the table.
	Name *string
	// Name of the target database instance. This is required when creating database
	// tables in standard catalogs. This is optional when creating database tables
	// in registered catalogs. If this field is specified when creating database
	// tables in registered catalogs, the database instance name MUST match that of
	// the registered catalog (or the request will be rejected).
	DatabaseInstanceName *string
	// Target Postgres database object (logical database) name for this table.
	//
	// When creating a table in a standard catalog, this field is required. In this
	// scenario, specifying this field will allow targeting an arbitrary postgres
	// database.
	//
	// Registration of database tables via /database/tables is currently only
	// supported in standard catalogs.
	LogicalDatabaseName *string
}

type DeleteDatabaseCatalogRequest struct {
	Name *string
}

type DeleteDatabaseInstanceRequest struct {
	// Name of the instance to delete.
	Name *string
	// By default, an instance cannot be deleted if it has descendant instances
	// created via PITR. If this flag is specified as true, all descendent instances
	// will be deleted as well.
	Force *bool
	// Deprecated. Omitting the field or setting it to true will result in the field
	// being hard deleted. Setting a value of false will throw a bad request.
	Purge *bool
}

type DeleteDatabaseInstanceRoleRequest struct {
	InstanceName    *string
	Name            *string
	ReassignOwnedTo *string
	// This is the AIP standard name for the equivalent of Postgres' `IF EXISTS`
	// option
	AllowMissing *bool
}

type DeleteDatabaseTableRequest struct {
	Name *string
}

type DeleteSyncedDatabaseTableRequest struct {
	Name *string
	// Optional. When set to true, the actual PostgreSQL table will be dropped from
	// the database.
	PurgeData *bool
}

type DeltaTableSyncInfo struct {
	// The Delta Lake commit version that was last successfully synced.
	DeltaCommitVersion *int64 `fieldmask:"delta_commit_version"`
	// The timestamp when the above Delta version was committed in the source Delta
	// table. Note: This is the Delta commit time, not the time the data was written
	// to the synced table.
	DeltaCommitTimestamp *types.Time `fieldmask:"delta_commit_timestamp"`
}

type FindDatabaseInstanceByUidRequest struct {
	// UID of the cluster to get.
	Uid *string
}

type GenerateDatabaseCredentialRequest struct {
	RequestId *string
	// Instances to request a credential for. At least one of instance_names or
	// claims must be specified.
	InstanceNames []string
	// A set of UC permissions to add to the credential. We verify that the caller
	// has the necessary permissions in UC and include a reference in the token.
	// Postgres uses that token to give the connecting user additional grants to the
	// Postgres resources that correspond to the UC resources. The UC resources need
	// to be something that have a Postgres counterpart. For example, a synced table
	// or a table in a UC database catalog.
	Claims []RequestedClaims
}

type GetDatabaseCatalogRequest struct {
	Name *string
}

type GetDatabaseInstanceRequest struct {
	// Name of the cluster to get.
	Name *string
}

type GetDatabaseInstanceRoleRequest struct {
	InstanceName *string
	Name         *string
}

type GetDatabaseTableRequest struct {
	Name *string
}

type GetSyncedDatabaseTableRequest struct {
	Name *string
}

type ListDatabaseCatalogsRequest struct {
	// Name of the instance to get database catalogs for.
	InstanceName *string
	// Pagination token to go to the next page of synced database tables. Requests
	// first page if absent.
	PageToken *string
	// Upper bound for items returned.
	PageSize *int
}

type ListDatabaseCatalogsResponse struct {
	DatabaseCatalogs []DatabaseCatalog
	// Pagination token to request the next page of database catalogs.
	NextPageToken *string
}

type ListDatabaseInstanceRolesRequest struct {
	InstanceName *string
	// Pagination token to go to the next page of Database Instances. Requests first
	// page if absent.
	PageToken *string
	// Upper bound for items returned.
	PageSize *int
}

type ListDatabaseInstanceRolesResponse struct {
	// List of database instance roles.
	DatabaseInstanceRoles []DatabaseInstanceRole
	// Pagination token to request the next page of instances.
	NextPageToken *string
}

type ListDatabaseInstancesRequest struct {
	// Pagination token to go to the next page of Database Instances. Requests first
	// page if absent.
	PageToken *string
	// Upper bound for items returned. The maximum value is 100.
	PageSize *int
}

type ListDatabaseInstancesResponse struct {
	// List of instances.
	DatabaseInstances []DatabaseInstance
	// Pagination token to request the next page of instances.
	NextPageToken *string
}

type ListSyncedDatabaseTablesRequest struct {
	// Name of the instance to get synced tables for.
	InstanceName *string
	// Pagination token to go to the next page of synced database tables. Requests
	// first page if absent.
	PageToken *string
	// Upper bound for items returned.
	PageSize *int
}

type ListSyncedDatabaseTablesResponse struct {
	SyncedTables []SyncedDatabaseTable
	// Pagination token to request the next page of synced tables.
	NextPageToken *string
}

type NewPipelineSpec struct {
	// This field needs to be specified if the destination catalog is a managed
	// postgres catalog.
	//
	// UC catalog for the pipeline to store intermediate files (checkpoints, event
	// logs etc). This needs to be a standard catalog where the user has permissions
	// to create Delta tables.
	StorageCatalog *string `fieldmask:"storage_catalog"`
	// This field needs to be specified if the destination catalog is a managed
	// postgres catalog.
	//
	// UC schema for the pipeline to store intermediate files (checkpoints, event
	// logs etc). This needs to be in the standard catalog where the user has
	// permissions to create Delta tables.
	StorageSchema *string `fieldmask:"storage_schema"`
	// Budget policy to set on the newly created pipeline.
	BudgetPolicyId *string `fieldmask:"budget_policy_id"`
}

type ProvisioningInfo struct {
}

type ProvisioningInfo_State string

type ProvisioningPhase string

type RequestedClaims struct {
	PermissionSet RequestedClaims_PermissionSet
	Resources     []RequestedResource
}

type RequestedClaims_PermissionSet string

type RequestedResource struct {
	// Might add UC_SCHEMA & UC_CATALOG later
	ResourceName isRequestedResource_ResourceName
}

type RequestedResource_ResourceName_TableName struct {
	TableName string
}

type RequestedResource_ResourceName_UnspecifiedResourceName struct {
	UnspecifiedResourceName string
}

type SyncedDatabaseTable struct {
	// Full three-part (catalog, schema, table) name of the table.
	Name *string `fieldmask:"name"`
	// Name of the target database instance. This is required when creating synced
	// database tables in standard catalogs. This is optional when creating synced
	// database tables in registered catalogs. If this field is specified when
	// creating synced database tables in registered catalogs, the database instance
	// name MUST match that of the registered catalog (or the request will be
	// rejected).
	DatabaseInstanceName *string `fieldmask:"database_instance_name"`
	// The name of the database instance that this table is registered to. This
	// field is always returned, and for tables inside database catalogs is inferred
	// database instance associated with the catalog. This is an output only field
	// that contains the value computed from the input field combined with server
	// side defaults. Use the field without the effective_ prefix to set the value.
	EffectiveDatabaseInstanceName *string `fieldmask:"effective_database_instance_name"`
	// Target Postgres database object (logical database) name for this table.
	//
	// When creating a synced table in a registered Postgres catalog, the target
	// Postgres database name is inferred to be that of the registered catalog. If
	// this field is specified in this scenario, the Postgres database name MUST
	// match that of the registered catalog (or the request will be rejected).
	//
	// When creating a synced table in a standard catalog, this field is required.
	// In this scenario, specifying this field will allow targeting an arbitrary
	// postgres database. Note that this has implications for the
	// `create_database_objects_is_missing` field in `spec`.
	LogicalDatabaseName *string `fieldmask:"logical_database_name"`
	// The name of the logical database that this table is registered to. This is an
	// output only field that contains the value computed from the input field
	// combined with server side defaults. Use the field without the effective_
	// prefix to set the value.
	EffectiveLogicalDatabaseName *string          `fieldmask:"effective_logical_database_name"`
	Spec                         *SyncedTableSpec `fieldmask:"spec"`
	// The provisioning state of the synced table entity in Unity Catalog. This is
	// distinct from the state of the data synchronization pipeline (i.e. the table
	// may be in "ACTIVE" but the pipeline may be in "PROVISIONING" as it runs
	// asynchronously).
	UnityCatalogProvisioningState ProvisioningInfo_State `fieldmask:"unity_catalog_provisioning_state"`
	// Synced Table data synchronization status
	DataSynchronizationStatus *SyncedTableStatus `fieldmask:"data_synchronization_status"`
}

type SyncedTableContinuousUpdateStatus struct {
	// The last source table Delta version that was successfully synced to the
	// synced table.
	LastProcessedCommitVersion *int64 `fieldmask:"last_processed_commit_version"`
	// The end timestamp of the last time any data was synchronized from the source
	// table to the synced table. This is when the data is available in the synced
	// table.
	Timestamp *types.Time `fieldmask:"timestamp"`
	// Progress of the initial data synchronization.
	InitialPipelineSyncProgress *SyncedTablePipelineProgress `fieldmask:"initial_pipeline_sync_progress"`
}

type SyncedTableFailedStatus struct {
	// The last source table Delta version that was successfully synced to the
	// synced table. The last source table Delta version that was synced to the
	// synced table. Only populated if the table is still synced and available for
	// serving.
	LastProcessedCommitVersion *int64 `fieldmask:"last_processed_commit_version"`
	// The end timestamp of the last time any data was synchronized from the source
	// table to the synced table. Only populated if the table is still synced and
	// available for serving.
	Timestamp *types.Time `fieldmask:"timestamp"`
}

type SyncedTablePipelineProgress struct {
	// The source table Delta version that was last processed by the pipeline. The
	// pipeline may not have completely processed this version yet.
	LatestVersionCurrentlyProcessing *int64 `fieldmask:"latest_version_currently_processing"`
	// The number of rows that have been synced in this update.
	SyncedRowCount *int64 `fieldmask:"synced_row_count"`
	// The total number of rows that need to be synced in this update. This number
	// may be an estimate.
	TotalRowCount *int64 `fieldmask:"total_row_count"`
	// The completion ratio of this update. This is a number between 0 and 1.
	SyncProgressCompletion *float64 `fieldmask:"sync_progress_completion"`
	// The estimated time remaining to complete this update in seconds.
	EstimatedCompletionTimeSeconds *float64 `fieldmask:"estimated_completion_time_seconds"`
	// The current phase of the data synchronization pipeline.
	ProvisioningPhase ProvisioningPhase `fieldmask:"provisioning_phase"`
}

type SyncedTablePosition struct {
	// The starting timestamp of the most recent successful synchronization from the
	// source table to the destination (synced) table. Note this is the starting
	// timestamp of the sync operation, not the end time. E.g., for a batch, this is
	// the time when the sync operation started.
	SyncStartTimestamp *types.Time `fieldmask:"sync_start_timestamp"`
	// The end timestamp of the most recent successful synchronization. This is the
	// time when the data is available in the synced table.
	SyncEndTimestamp *types.Time `fieldmask:"sync_end_timestamp"`
	// Information about the source system at the time of the last sync.
	SourceSyncInfo isSyncedTablePosition_SourceSyncInfo
	// contains filtered or unexported fields
}

type SyncedTablePosition_SourceSyncInfo_DeltaTableSyncInfo struct {
	DeltaTableSyncInfo DeltaTableSyncInfo `fieldmask:"delta_table_sync_info"`
}

type SyncedTableProvisioningStatus struct {
	// Details about initial data synchronization. Only populated when in the
	// PROVISIONING_INITIAL_SNAPSHOT state.
	InitialPipelineSyncProgress *SyncedTablePipelineProgress `fieldmask:"initial_pipeline_sync_progress"`
}

type SyncedTableSchedulingPolicy string

type SyncedTableSpec struct {
	// Scheduling policy of the underlying pipeline.
	SchedulingPolicy SyncedTableSchedulingPolicy `fieldmask:"scheduling_policy"`
	// Three-part (catalog, schema, table) name of the source Delta table.
	SourceTableFullName *string `fieldmask:"source_table_full_name"`
	// Primary Key columns to be used for data insert/update in the destination.
	PrimaryKeyColumns []string `fieldmask:"primary_key_columns"`
	// Time series key to deduplicate (tie-break) rows with the same primary key.
	TimeseriesKey *string `fieldmask:"timeseries_key"`
	// At most one of existing_pipeline_id and new_pipeline_spec should be defined.
	//
	// If existing_pipeline_id is defined, the synced table will be bin packed into
	// the existing pipeline referenced. This avoids creating a new pipeline and
	// allows sharing existing compute. In this case, the scheduling_policy of this
	// synced table must match the scheduling policy of the existing pipeline.
	ExistingPipelineId *string `fieldmask:"existing_pipeline_id"`
	// If true, the synced table's logical database and schema resources in PG will
	// be created if they do not already exist.
	CreateDatabaseObjectsIfMissing *bool `fieldmask:"create_database_objects_if_missing"`
	// At most one of existing_pipeline_id and new_pipeline_spec should be defined.
	//
	// If new_pipeline_spec is defined, a new pipeline is created for this synced
	// table. The location pointed to is used to store intermediate files
	// (checkpoints, event logs etc). The caller must have write permissions to
	// create Delta tables in the specified catalog and schema. Again, note this
	// requires write permissions, whereas the source table only requires read
	// permissions.
	NewPipelineSpec *NewPipelineSpec `fieldmask:"new_pipeline_spec"`
	// When true, enables accelerated sync mode for the initial data load. This
	// significantly improves performance for large tables. Requires workspace-level
	// enablement.
	AcceleratedSync *bool `fieldmask:"accelerated_sync"`
	// Override the default Delta->PG type mapping for specific columns. A
	// TypeOverride with PG_SPECIFIC_TYPE_UNSPECIFIED is rejected; a valid pg_type
	// must be set.
	TypeOverrides []SyncedTableSpec_TypeOverride `fieldmask:"type_overrides"`
}

type SyncedTableSpec_PgSpecificType string

type SyncedTableSpec_TypeOverride struct {
	// Name of the source column whose target PostgreSQL type should be overridden.
	ColumnName *string
	// PostgreSQL-specific target type to use for the column.
	PgType SyncedTableSpec_PgSpecificType
	// Size parameter for the target type, for types that take one (e.g. vector
	// dimension, varchar length). Required when the chosen pg_type needs a size.
	Size *int
}

type SyncedTableState string

type SyncedTableStatus struct {
	// The state of the synced table.
	DetailedState SyncedTableState `fieldmask:"detailed_state"`
	// A text description of the current state of the synced table.
	Message *string `fieldmask:"message"`
	// The detailed status based on the synced table state.
	DetailedStatus isSyncedTableStatus_DetailedStatus
	// ID of the associated pipeline. The pipeline ID may have been provided by the
	// client (in the case of bin packing), or generated by the server (when
	// creating a new pipeline).
	PipelineId *string `fieldmask:"pipeline_id"`
	// Summary of the last successful synchronization from source to destination.
	//
	// Will always be present if there has been a successful sync. Even if the most
	// recent syncs have failed.
	//
	// Limitation: The only exception is if the synced table is doing a FULL
	// REFRESH, then the last sync information will not be available until the full
	// refresh is complete. This limitation will be addressed in a future version.
	//
	// This top-level field is a convenience for consumers who want easy access to
	// last sync information without having to traverse detailed_status.
	LastSync *SyncedTablePosition `fieldmask:"last_sync"`
	// contains filtered or unexported fields
}

type SyncedTableStatus_DetailedStatus_ContinuousUpdateStatus struct {
	ContinuousUpdateStatus SyncedTableContinuousUpdateStatus `fieldmask:"continuous_update_status"`
}

type SyncedTableStatus_DetailedStatus_FailedStatus struct {
	FailedStatus SyncedTableFailedStatus `fieldmask:"failed_status"`
}

type SyncedTableStatus_DetailedStatus_ProvisioningStatus struct {
	ProvisioningStatus SyncedTableProvisioningStatus `fieldmask:"provisioning_status"`
}

type SyncedTableStatus_DetailedStatus_TriggeredUpdateStatus struct {
	TriggeredUpdateStatus SyncedTableTriggeredUpdateStatus `fieldmask:"triggered_update_status"`
}

type SyncedTableTriggeredUpdateStatus struct {
	// The last source table Delta version that was successfully synced to the
	// synced table.
	LastProcessedCommitVersion *int64 `fieldmask:"last_processed_commit_version"`
	// The end timestamp of the last time any data was synchronized from the source
	// table to the synced table. This is when the data is available in the synced
	// table.
	Timestamp *types.Time `fieldmask:"timestamp"`
	// Progress of the active data synchronization pipeline.
	TriggeredUpdateProgress *SyncedTablePipelineProgress `fieldmask:"triggered_update_progress"`
}

type UpdateDatabaseCatalogRequest struct {
	// Note that updating a database catalog is not yet supported.
	DatabaseCatalog *DatabaseCatalog
	// The list of fields to update. Setting this field is not yet supported.
	UpdateMask *types.FieldMask[DatabaseCatalog]
}

type UpdateDatabaseInstanceRequest struct {
	DatabaseInstance *DatabaseInstance
	// The list of fields to update. If unspecified, all fields will be updated when
	// possible. To wipe out custom_tags, specify custom_tags in the update_mask
	// with an empty custom_tags map.
	UpdateMask *types.FieldMask[DatabaseInstance]
}

type UpdateSyncedDatabaseTableRequest struct {
	// Note that updating a synced database table is not yet supported.
	SyncedTable *SyncedDatabaseTable
	// The list of fields to update. Setting this field is not yet supported.
	UpdateMask *types.FieldMask[SyncedDatabaseTable]
}