postgres

type ApiError struct {
	ErrorCode  ErrorCode
	Message    *string
	StackTrace *string
	Details    []json.RawMessage
}

type Branch struct {
	// Output only. The full resource path of the branch. Format:
	// projects/{project_id}/branches/{branch_id}
	Name *string `fieldmask:"name"`
	// System-generated unique ID for the branch.
	Uid *string `fieldmask:"uid"`
	// The project containing this branch (API resource hierarchy). Format:
	// projects/{project_id}
	//
	// Note: This field indicates where the branch exists in the resource hierarchy.
	// For point-in-time branching from another branch, see `status.source_branch`.
	Parent *string `fieldmask:"parent"`
	// A timestamp indicating when the branch was created.
	CreateTime *types.Time `fieldmask:"create_time"`
	// A timestamp indicating when the branch was last updated.
	UpdateTime *types.Time `fieldmask:"update_time"`
	// The spec contains the branch configuration.
	Spec *BranchSpec `fieldmask:"spec"`
	// The current status of a Branch.
	Status *BranchStatus `fieldmask:"status"`
	// The part of the name, chosen by the user when the resource was created.
	BranchId *string `fieldmask:"branch_id"`
}

type BranchOperationMetadata struct {
}

type BranchSpec struct {
	// The name of the source branch from which this branch was created (data
	// lineage for point-in-time recovery). If not specified, defaults to the
	// project's default branch. Format: projects/{project_id}/branches/{branch_id}
	SourceBranch *string `fieldmask:"source_branch"`
	// The Log Sequence Number (LSN) on the source branch from which this branch was
	// created.
	SourceBranchLsn *string `fieldmask:"source_branch_lsn"`
	// The point in time on the source branch from which this branch was created.
	SourceBranchTime *types.Time `fieldmask:"source_branch_time"`
	// When set to true, protects the branch from deletion and reset. Associated
	// compute endpoints and the project cannot be deleted while the branch is
	// protected.
	IsProtected *bool `fieldmask:"is_protected"`
	// Expiration configuration for the branch. One of expire_time, ttl, or
	// no_expiry must be provided. To disable expiration, set no_expiry to true.
	//
	// When updating this field, use "spec.expiration" in the update_mask.
	Expiration isBranchSpec_Expiration
	// The snapshot this branch was created from. When set, the branch's data comes
	// from the snapshot rather than a source branch, so source_branch,
	// source_branch_lsn, and source_branch_time must be empty. The snapshot must be
	// AVAILABLE and belong to this branch's project. Format:
	// projects/{project_id}/snapshots/{snapshot_id}
	SourceSnapshot *string `fieldmask:"source_snapshot"`
	// contains filtered or unexported fields
}

type BranchSpec_Expiration_ExpireTime struct {
	ExpireTime types.Time `fieldmask:"expire_time"`
}

type BranchSpec_Expiration_NoExpiry struct {
	NoExpiry bool `fieldmask:"no_expiry"`
}

type BranchSpec_Expiration_Ttl struct {
	Ttl types.Duration `fieldmask:"ttl"`
}

type BranchStatus struct {
	// The name of the source branch from which this branch was created. Format:
	// projects/{project_id}/branches/{branch_id}
	SourceBranch *string `fieldmask:"source_branch"`
	// The Log Sequence Number (LSN) on the source branch from which this branch was
	// created.
	SourceBranchLsn *string `fieldmask:"source_branch_lsn"`
	// The point in time on the source branch from which this branch was created.
	SourceBranchTime *types.Time `fieldmask:"source_branch_time"`
	// Whether the branch is the project's default branch.
	Default *bool `fieldmask:"default"`
	// Whether the branch is protected.
	IsProtected *bool `fieldmask:"is_protected"`
	// The branch's state, indicating if it is initializing, ready for use, or
	// archived.
	CurrentState BranchStatus_State `fieldmask:"current_state"`
	// The pending state of the branch, if a state transition is in progress.
	PendingState BranchStatus_State `fieldmask:"pending_state"`
	// A timestamp indicating when the `current_state` began.
	StateChangeTime *types.Time `fieldmask:"state_change_time"`
	// The logical size of the branch.
	LogicalSizeBytes *int64 `fieldmask:"logical_size_bytes"`
	// Absolute expiration time for the branch. Empty if expiration is disabled.
	ExpireTime *types.Time `fieldmask:"expire_time"`
	// Part of the resource name.
	BranchId *string `fieldmask:"branch_id"`
	// A timestamp indicating when the branch was deleted. Empty if the branch is
	// not deleted.
	DeleteTime *types.Time `fieldmask:"delete_time"`
	// A timestamp indicating when the branch is scheduled to be purged. Empty if
	// the branch is not deleted, otherwise set to a timestamp in the future.
	PurgeTime *types.Time `fieldmask:"purge_time"`
	// The snapshot this branch was restored from. Set only for branches created by
	// restoring a snapshot; unset for all other branches. Format:
	// projects/{project_id}/snapshots/{snapshot_id}
	SourceSnapshot *string `fieldmask:"source_snapshot"`
}

type BranchStatus_State string

type Catalog struct {
	// Output only. The full resource path of the catalog.
	//
	// Format: "catalogs/{catalog_id}".
	Name *string
	// System-generated unique identifier for the catalog.
	Uid *string
	// The desired state of the Catalog.
	Spec *Catalog_CatalogSpec
	// The observed state of the Catalog.
	Status *Catalog_CatalogStatus
	// A timestamp indicating when the catalog was created.
	CreateTime *types.Time
	// A timestamp indicating when the catalog was last updated.
	UpdateTime *types.Time
	// The part of the name, chosen by the user when the resource was created.
	CatalogId *string
}

type CatalogOperationMetadata struct {
}

type Catalog_CatalogSpec struct {
	// The name of the Postgres database inside the specified Lakebase project and
	// branch to be associated with the UC catalog. This database must already
	// exist, unless create_database_if_missing is set to true on creation.
	//
	// A database can only be registered with one UC catalog at a time. To
	// re-register a database with a different catalog, the existing catalog must be
	// deleted first.
	//
	// A child branch inherits the fact of parent's registration. This means the
	// same-named database in a child branch cannot be registered with a second
	// catalog while the parent's registration exists. To allow registering the
	// database of a child branch, drop and recreate the database on the child
	// branch. This removes the fact of parent's registration from this branch only.
	//
	// Doing Point In Time Restore (PITR) prior to the moment before the Postgres DB
	// was registered in the Catalog drops the fact of registration of the database.
	// So the user should avoid doing so.
	PostgresDatabase *string
	// If set to true, the specified postgres_database is created on behalf of the
	// calling user if it does not already exist. In this case, the calling user has
	// a role created for them in Postgres if they do not already have one.
	//
	// Defaults to false, meaning that the request fails if the specified
	// postgres_database does not already exist.
	CreateDatabaseIfMissing *bool
	// The resource path of the branch associated with the catalog.
	//
	// Format: projects/{project_id}/branches/{branch_id}.
	Branch *string
}

type Catalog_CatalogStatus struct {
	// The name of the Postgres database associated with the catalog.
	PostgresDatabase *string
	// The resource path of the project associated with the catalog.
	//
	// Format: projects/{project_id}.
	Project *string
	// The resource path of the branch associated with the catalog.
	//
	// Format: projects/{project_id}/branches/{branch_id}.
	Branch *string
}

type CdfConfig struct {
	// Output only. The full resource name of the CdfConfig. Format:
	// projects/{project}/branches/{branch}/databases/{database}/cdf-configs/{cdf_config}
	Name *string
	// The Unity Catalog catalog that replicated tables are written into. Set at
	// creation; the CdfConfig is immutable.
	Catalog *string
	// The Unity Catalog schema that replicated tables are written into. Set at
	// creation; the CdfConfig is immutable.
	Schema *string
	// When the CdfConfig was created.
	CreateTime *types.Time
	// The user-specified id; equals the final segment of `name`. Defaults to the
	// Postgres schema name for configs without an explicit id.
	CdfConfigId *string
	// The Postgres schema this CdfConfig replicates from. Unique within the parent
	// database. Set at creation; the CdfConfig is immutable.
	PostgresSchema *string
}

type CdfConfigOperationMetadata struct {
}

type CdfState string

type CdfStatus struct {
	// Output only. The full resource name of the CdfStatus. Format:
	// projects/{project}/branches/{branch}/databases/{database}/cdf-configs/{cdf_config}/cdf-statuses/{cdf_status}
	// The {cdf_status} segment is the Postgres table name.
	Name *string
	// The Postgres table being replicated.
	PostgresTable *string
	// The Unity Catalog table receiving replicated data.
	UcTable *string
	// The current replication state of this table.
	State CdfState
	// The high-watermark Log Sequence Number (LSN) committed to Delta Lake.
	CommittedLsn *string
	// The last time changes for this table were written to Delta Lake.
	LastSyncTime *types.Time
	// When replication for this table was first established.
	CreateTime *types.Time
	// Human-readable detail for the current state (e.g. the skip/error reason).
	// Empty for healthy states.
	StatusDetail *string
}

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

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

type CreateBranchRequest struct {
	// The Project where this Branch will be created. Format: projects/{project_id}
	Parent *string
	// The ID to use for the Branch. This becomes the final component of the
	// branch's resource name. The ID is required and must be 1-63 characters long,
	// start with a lowercase letter, and contain only lowercase letters, numbers,
	// and hyphens. For example, `development` becomes
	// `projects/my-app/branches/development`.
	BranchId *string
	// The Branch to create.
	Branch *Branch
	// If true, update the branch if it already exists instead of returning an
	// error.
	ReplaceExisting *bool
}

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

type CreateCatalogRequest struct {
	// The ID in the Unity Catalog. It becomes the full resource name, for example
	// "my_catalog" becomes "catalogs/my_catalog".
	CatalogId *string
	Catalog   *Catalog
}

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

type CreateCdfConfigRequest struct {
	// The parent database under which to create the CdfConfig. Format:
	// projects/{project}/branches/{branch}/databases/{database}
	Parent *string
	// The CdfConfig to create. The catalog, schema, and postgres_schema fields are
	// required; all other fields are output only and ignored on input.
	CdfConfig *CdfConfig
	// The user-specified id for the CdfConfig, forming the final segment of its
	// resource name. Must match the pattern `[a-z][a-z0-9_]{0,62}`. Defaults to the
	// Postgres schema name when omitted.
	CdfConfigId *string
}

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

type CreateDataApiRequest struct {
	// Parent database:
	// projects/{project_id}/branches/{branch_id}/databases/{database_id}
	Parent *string
	// The Data API configuration to create.
	DataApi *DataApi
}

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

type CreateDatabaseRequest struct {
	// The Branch where this Database will be created. Format:
	// projects/{project_id}/branches/{branch_id}
	Parent *string
	// The ID to use for the Database, which will become the final component of the
	// database's resource name. This ID becomes the database name in postgres.
	//
	// This value should be 4-63 characters, and only use characters available in
	// DNS names, as defined by RFC-1123
	//
	// If database_id is not specified in the request, it is generated
	// automatically.
	DatabaseId *string
	// The desired specification of a Database.
	Database *Database
	// If true, update the database if it already exists instead of returning an
	// error.
	ReplaceExisting *bool
}

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

type CreateEndpointRequest struct {
	// The Branch where this Endpoint will be created. Format:
	// projects/{project_id}/branches/{branch_id}
	Parent *string
	// The ID to use for the Endpoint. This becomes the final component of the
	// endpoint's resource name. The ID is required and must be 1-63 characters
	// long, start with a lowercase letter, and contain only lowercase letters,
	// numbers, and hyphens. For example, `primary` becomes
	// `projects/my-app/branches/development/endpoints/primary`.
	EndpointId *string
	// The Endpoint to create.
	Endpoint *Endpoint
	// If true, update the endpoint if it already exists instead of returning an
	// error.
	ReplaceExisting *bool
}

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

type CreateProjectRequest struct {
	// The ID to use for the Project. This becomes the final component of the
	// project's resource name. The ID is required and must be 1-63 characters long,
	// start with a lowercase letter, and contain only lowercase letters, numbers,
	// and hyphens. For example, `my-app` becomes `projects/my-app`.
	ProjectId *string
	// The Project to create.
	Project *Project
}

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

type CreateRoleRequest struct {
	// The Branch where this Role is created. Format:
	// projects/{project_id}/branches/{branch_id}
	Parent *string
	// The ID to use for the Role, which will become the final component of the
	// role's resource name. This ID becomes the role in Postgres.
	//
	// This value should be 4-63 characters, and valid characters are lowercase
	// letters, numbers, and hyphens, as defined by RFC 1123.
	//
	// If role_id is not specified in the request, it is generated automatically.
	RoleId *string
	// The desired specification of a Role.
	Role *Role
	// If true, update the role if it already exists instead of returning an error.
	//
	// When the role already exists, the provided `role` spec fully replaces the
	// existing one: `membership_roles` is overwritten, not merged. Leaving
	// `membership_roles` empty clears all of the role's existing memberships,
	// including `DATABRICKS_SUPERUSER`. Always send the complete desired list of
	// memberships when using this field.
	ReplaceExisting *bool
}

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

type CreateSnapshotRequest struct {
	// The project in which to create the snapshot. Format: projects/{project_id}
	Parent *string
	// The snapshot to create.
	Snapshot *Snapshot
	// Client-chosen ID for the snapshot. It becomes the final segment of the
	// snapshot resource name and cannot be changed after creation.
	SnapshotId *string
}

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

type CreateSyncedTableRequest struct {
	// The ID to use for the Synced Table. This becomes the final component of the
	// SyncedTable's resource name. ID is required and is the synced table name,
	// containing (catalog, schema, table) tuple. Elements of the tuple are the UC
	// entity names.
	//
	// Example: "{catalog}.{schema}.{table}"
	//
	// synced_table_id represents both of the following:
	//
	// 1. An online VIEW virtual table in the Unity Catalog accessible via the
	// Lakehouse Federation. 2. Postgres table named "{table}" in schema "{schema}"
	// in the connected Postgres database
	SyncedTableId *string
	SyncedTable   *SyncedTable
}

type DailySchedule struct {
	// The hour of the day, in UTC, at which to take the snapshot, in [0, 23].
	Hour *int
}

type DataApi struct {
	// Resource name:
	// projects/{project_id}/branches/{branch_id}/databases/{database_id}/data-api
	Name *string `fieldmask:"name"`
	// The database containing this Data API configuration. Format:
	// projects/{project_id}/branches/{branch_id}/databases/{database_id}
	Parent *string `fieldmask:"parent"`
	// A timestamp indicating when the Data API was first enabled.
	CreateTime *types.Time `fieldmask:"create_time"`
	// A timestamp indicating when the Data API configuration was last updated.
	UpdateTime *types.Time `fieldmask:"update_time"`
	// The desired Data API configuration.
	Spec *DataApi_DataApiSpec `fieldmask:"spec"`
	// The observed Data API state (read-only).
	Status *DataApi_DataApiStatus `fieldmask:"status"`
}

type DataApiOperationMetadata struct {
}

type DataApi_DataApiSpec struct {
	// Enable aggregate functions (count, sum, avg, etc.) in Data API responses.
	// Default: true.
	DbAggregatesEnabled *bool `fieldmask:"db_aggregates_enabled"`
	// Additional schemas to include in the PostgreSQL search path. Each entry must
	// be a valid PostgreSQL schema name.
	DbExtraSearchPath []string `fieldmask:"db_extra_search_path"`
	// Maximum number of rows returned in a single Data API response. Must be a
	// positive integer.
	DbMaxRows *int `fieldmask:"db_max_rows"`
	// Database schemas exposed through the Data API. Each entry must be a valid
	// PostgreSQL schema name (1-63 chars, [a-zA-Z_][a-zA-Z0-9_$]*). Maximum 100
	// entries. Default: ["public"].
	DbSchemas []string `fieldmask:"db_schemas"`
	// JSON path to the role claim in JWT tokens (e.g., ".sub"). Default: ".sub".
	JwtRoleClaimKey *string `fieldmask:"jwt_role_claim_key"`
	// Maximum lifetime for cached JWT tokens. Zero duration disables caching.
	JwtCacheMaxLifetime *types.Duration `fieldmask:"jwt_cache_max_lifetime"`
	// OpenAPI documentation mode for the Data API endpoint.
	OpenapiMode OpenApiMode `fieldmask:"openapi_mode"`
	// Allowed origins for CORS requests. Each entry should be a valid origin URL,
	// or use "*" to allow all origins.
	ServerCorsAllowedOrigins []string `fieldmask:"server_cors_allowed_origins"`
	// Enable the Server-Timing header in Data API responses.
	ServerTimingEnabled *bool `fieldmask:"server_timing_enabled"`
}

type DataApi_DataApiStatus struct {
	// Actual aggregate function setting read from the database.
	DbAggregatesEnabled *bool `fieldmask:"db_aggregates_enabled"`
	// Actual extra search path schemas read from the database.
	DbExtraSearchPath []string `fieldmask:"db_extra_search_path"`
	// Actual max rows setting read from the database.
	DbMaxRows *int `fieldmask:"db_max_rows"`
	// Actual exposed schemas read from the database.
	DbSchemas []string `fieldmask:"db_schemas"`
	// Actual JWT role claim key read from the database.
	JwtRoleClaimKey *string `fieldmask:"jwt_role_claim_key"`
	// Actual JWT cache max lifetime read from the database.
	JwtCacheMaxLifetime *types.Duration `fieldmask:"jwt_cache_max_lifetime"`
	// Actual OpenAPI mode read from the database.
	OpenapiMode OpenApiMode `fieldmask:"openapi_mode"`
	// Actual CORS allowed origins read from the database.
	ServerCorsAllowedOrigins []string `fieldmask:"server_cors_allowed_origins"`
	// Actual Server-Timing header setting read from the database.
	ServerTimingEnabled *bool `fieldmask:"server_timing_enabled"`
	// Data API endpoint URL.
	Url *string `fieldmask:"url"`
	// Schemas available in the database (for reference when configuring
	// db_schemas).
	AvailableSchemas []string `fieldmask:"available_schemas"`
}

type Database struct {
	// The resource name of the database. Format:
	// projects/{project_id}/branches/{branch_id}/databases/{database_id}
	Name *string `fieldmask:"name"`
	// The branch containing this database. Format:
	// projects/{project_id}/branches/{branch_id}
	Parent *string `fieldmask:"parent"`
	// A timestamp indicating when the database was created.
	CreateTime *types.Time `fieldmask:"create_time"`
	// A timestamp indicating when the database was last updated.
	UpdateTime *types.Time `fieldmask:"update_time"`
	// The desired state of the Database.
	Spec *Database_DatabaseSpec `fieldmask:"spec"`
	// The observed state of the Database.
	Status *Database_DatabaseStatus `fieldmask:"status"`
	// The part of the name, chosen by the user when the resource was created.
	DatabaseId *string `fieldmask:"database_id"`
}

type DatabaseCredential struct {
	// The OAuth token that can be used as a password when connecting to a database.
	Token *string
	// Timestamp in UTC of when this credential expires.
	ExpireTime *types.Time
}

type DatabaseOperationMetadata struct {
}

type Database_DatabaseSpec struct {
	// The name of the role that owns the database. Format:
	// projects/{project_id}/branches/{branch_id}/roles/{role_id}
	//
	// To change the owner, pass valid existing Role name when updating the Database
	//
	// A database always has an owner.
	Role *string `fieldmask:"role"`
	// The name of the Postgres database.
	//
	// This expects a valid Postgres identifier as specified in the link below.
	// https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
	// Required when creating the Database.
	//
	// To rename, pass a valid postgres identifier when updating the Database.
	PostgresDatabase *string `fieldmask:"postgres_database"`
}

type Database_DatabaseStatus struct {
	// The name of the role that owns the database. Format:
	// projects/{project_id}/branches/{branch_id}/roles/{role_id}
	Role *string `fieldmask:"role"`
	// The name of the Postgres database.
	PostgresDatabase *string `fieldmask:"postgres_database"`
	// Part of the resource name.
	DatabaseId *string `fieldmask:"database_id"`
}

type DayOfWeek string

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

type DeleteBranchRequest struct {
	// The full resource path of the branch to delete. Format:
	// projects/{project_id}/branches/{branch_id}
	Name *string
	// If true, permanently delete the branch; if false, soft delete.
	Purge *bool
}

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

type DeleteCatalogRequest struct {
	// The full resource path of the catalog to delete.
	//
	// Format: "catalogs/{catalog_id}".
	Name *string
}

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

type DeleteCdfConfigRequest struct {
	// The resource name of the CdfConfig to delete. Format:
	// projects/{project}/branches/{branch}/databases/{database}/cdf-configs/{cdf_config}
	Name *string
	// When true, also drops the replicated Delta tables in Unity Catalog. When
	// false (the default), the replicated tables are preserved at their last synced
	// state.
	Force *bool
}

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

type DeleteDataApiRequest struct {
	// Resource name:
	// projects/{project_id}/branches/{branch_id}/databases/{database_id}/data-api
	Name *string
}

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

type DeleteDatabaseRequest struct {
	// The resource name of the postgres database. Format:
	// projects/{project_id}/branches/{branch_id}/databases/{database_id}
	Name *string
}

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

type DeleteEndpointRequest struct {
	// The full resource path of the endpoint to delete. Format:
	// projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id}
	Name *string
}

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

type DeleteProjectRequest struct {
	// The full resource path of the project to delete. Format:
	// projects/{project_id}
	Name *string
	// If true, permanently deletes the project (hard delete). If false or unset,
	// performs a soft delete.
	Purge *bool
}

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

type DeleteRoleRequest struct {
	// The full resource path of the role to delete. Format:
	// projects/{project_id}/branches/{branch_id}/roles/{role_id}
	Name *string
	// Reassign objects. If this is set, all objects owned by the role are
	// reassigned to the role specified in this parameter.
	//
	// NOTE: setting this requires spinning up a compute to succeed, since it
	// involves running SQL queries.
	ReassignOwnedTo *string
}

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

type DeleteSnapshotRequest struct {
	// The resource name of the snapshot to delete. Format:
	// projects/{project_id}/snapshots/{snapshot_id}
	Name *string
}

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

type DeleteSyncedTableRequest struct {
	// The Full resource name of the synced table, of the format
	// "synced_tables/{catalog}.{schema}.{table}", where (catalog, schema, table)
	// are the UC entity names.
	Name *string
}

type DeltaTableSyncInfo struct {
	// The Delta Lake commit version that was last successfully synced.
	DeltaCommitVersion *int64
	// 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.
	DeltaCommitTime *types.Time
}

type Endpoint struct {
	// Output only. The full resource path of the endpoint. Format:
	// projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id}
	Name *string `fieldmask:"name"`
	// System-generated unique ID for the endpoint.
	Uid *string `fieldmask:"uid"`
	// The branch containing this endpoint (API resource hierarchy). Format:
	// projects/{project_id}/branches/{branch_id}
	Parent *string `fieldmask:"parent"`
	// A timestamp indicating when the compute endpoint was created.
	CreateTime *types.Time `fieldmask:"create_time"`
	// A timestamp indicating when the compute endpoint was last updated.
	UpdateTime *types.Time `fieldmask:"update_time"`
	// The spec contains the compute endpoint configuration, including autoscaling
	// limits, suspend timeout, and disabled state.
	Spec *EndpointSpec `fieldmask:"spec"`
	// Current operational status of the compute endpoint.
	Status *EndpointStatus `fieldmask:"status"`
	// The part of the name, chosen by the user when the resource was created.
	EndpointId *string `fieldmask:"endpoint_id"`
}

type EndpointGroupSpec struct {
	// The minimum number of computes in the endpoint group. Currently, this must be
	// equal to max. This must be greater than or equal to 1.
	Min *int `fieldmask:"min"`
	// The maximum number of computes in the endpoint group. Currently, this must be
	// equal to min. Set to 1 for single compute endpoints, to disable HA. To
	// manually suspend all computes in an endpoint group, set disabled to true on
	// the EndpointSpec.
	Max *int `fieldmask:"max"`
	// Whether to allow read-only connections to read-write endpoints. Only relevant
	// for read-write endpoints where size.max > 1.
	EnableReadableSecondaries *bool `fieldmask:"enable_readable_secondaries"`
}

type EndpointGroupStatus struct {
	// The minimum number of computes in the endpoint group. Currently, this must be
	// equal to max. This must be greater than or equal to 1.
	Min *int `fieldmask:"min"`
	// The maximum number of computes in the endpoint group. Currently, this must be
	// equal to min. Set to 1 for single compute endpoints, to disable HA. To
	// manually suspend all computes in an endpoint group, set disabled to true on
	// the EndpointSpec.
	Max *int `fieldmask:"max"`
	// Whether read-only connections to read-write endpoints are allowed. Only
	// relevant if read replicas are configured by specifying size.max > 1.
	EnableReadableSecondaries *bool `fieldmask:"enable_readable_secondaries"`
}

type EndpointHosts struct {
	// The hostname to connect to this endpoint. For read-write endpoints, this is a
	// read-write hostname which connects to the primary compute. For read-only
	// endpoints, this is a read-only hostname which allows read-only operations.
	Host *string `fieldmask:"host"`
	// An optionally defined read-only host for the endpoint, without pooling. For
	// read-only endpoints, this attribute is always defined and is equivalent to
	// host. For read-write endpoints, this attribute is defined if the enclosing
	// endpoint is a group with greater than 1 computes configured, and has readable
	// secondaries enabled.
	ReadOnlyHost *string `fieldmask:"read_only_host"`
	// The read-write hostname of the compute endpoint, with pooling. This attribute
	// is only defined for read-write endpoints.
	ReadWritePooledHost *string `fieldmask:"read_write_pooled_host"`
	// The read-only hostname of the compute endpoint, with pooling. This attribute
	// is always defined for read-only endpoints, and may be defined for read-write
	// endpoints if configured with read replicas and allow read-only connections.
	ReadOnlyPooledHost *string `fieldmask:"read_only_pooled_host"`
}

type EndpointOperationMetadata struct {
}

type EndpointSettings struct {
	// A raw representation of Postgres settings.
	PgSettings map[string]string `fieldmask:"pg_settings"`
}

type EndpointSpec struct {
	// The endpoint type. A branch can only have one READ_WRITE endpoint.
	EndpointType EndpointType `fieldmask:"endpoint_type"`
	// The minimum number of Compute Units. Minimum value is 0.5.
	AutoscalingLimitMinCu *float64 `fieldmask:"autoscaling_limit_min_cu"`
	// The maximum number of Compute Units. The maximum value is 64. The difference
	// between the minimum and maximum Compute Units (max - min) must not exceed 16.
	AutoscalingLimitMaxCu *float64 `fieldmask:"autoscaling_limit_max_cu"`
	// Whether to restrict connections to the compute endpoint. Enabling this option
	// schedules a suspend compute operation. A disabled compute endpoint cannot be
	// enabled by a connection or console action.
	Disabled *bool `fieldmask:"disabled"`
	// Duration of inactivity after which the compute endpoint is automatically
	// suspended. One of suspend_timeout_duration or no_suspension can be provided.
	// When not specified default suspension behavior will be used (consult with
	// documentation).
	//
	// When updating this field, use "spec.suspension" in the update_mask.
	Suspension isEndpointSpec_Suspension
	Settings   *EndpointSettings `fieldmask:"settings"`
	// Settings for optional HA configuration of the endpoint. If unspecified, the
	// endpoint defaults to non HA settings, with a single compute backing the
	// endpoint (and no readable secondaries for Read/Write endpoints).
	Group *EndpointGroupSpec `fieldmask:"group"`
	// contains filtered or unexported fields
}

type EndpointSpec_Suspension_NoSuspension struct {
	NoSuspension bool `fieldmask:"no_suspension"`
}

type EndpointSpec_Suspension_SuspendTimeoutDuration struct {
	SuspendTimeoutDuration types.Duration `fieldmask:"suspend_timeout_duration"`
}

type EndpointStatus struct {
	// The endpoint type. A branch can only have one READ_WRITE endpoint.
	EndpointType EndpointType `fieldmask:"endpoint_type"`
	// Contains host information for connecting to the endpoint.
	Hosts *EndpointHosts `fieldmask:"hosts"`
	// A timestamp indicating when the compute endpoint was last active.
	LastActiveTime *types.Time `fieldmask:"last_active_time"`
	// The minimum number of Compute Units.
	AutoscalingLimitMinCu *float64 `fieldmask:"autoscaling_limit_min_cu"`
	// The maximum number of Compute Units. The maximum value is 64. The difference
	// between the minimum and maximum Compute Units (max - min) must not exceed 16.
	AutoscalingLimitMaxCu *float64             `fieldmask:"autoscaling_limit_max_cu"`
	CurrentState          EndpointStatus_State `fieldmask:"current_state"`
	PendingState          EndpointStatus_State `fieldmask:"pending_state"`
	// Whether to restrict connections to the compute endpoint. Enabling this option
	// schedules a suspend compute operation. A disabled compute endpoint cannot be
	// enabled by a connection or console action.
	Disabled *bool `fieldmask:"disabled"`
	// Duration of inactivity after which the compute endpoint is automatically
	// suspended.
	SuspendTimeoutDuration *types.Duration   `fieldmask:"suspend_timeout_duration"`
	Settings               *EndpointSettings `fieldmask:"settings"`
	// Details on the HA configuration of the endpoint.
	Group *EndpointGroupStatus `fieldmask:"group"`
	// Part of the resource name.
	EndpointId *string `fieldmask:"endpoint_id"`
}

type EndpointStatus_State string

type EndpointType string

type ErrorCode string

type GenerateDatabaseCredentialRequest struct {
	// The returned token will be scoped to UC tables with the specified
	// permissions.
	Claims []RequestedClaims
	// The endpoint resource name for which this credential will be generated.
	// Format: projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id}
	Endpoint *string
	// Expiration information for the credential. Users can specify either
	// expire_time or ttl. If unspecified, maximum allowed duration (1 hour) is
	// used.
	Expiration isGenerateDatabaseCredentialRequest_Expiration
}

type GenerateDatabaseCredentialRequest_Expiration_ExpireTime struct {
	ExpireTime types.Time
}

type GenerateDatabaseCredentialRequest_Expiration_Ttl struct {
	Ttl types.Duration
}

type GetBranchRequest struct {
	// The full resource path of the branch to retrieve. Format:
	// projects/{project_id}/branches/{branch_id}
	Name *string
}

type GetCatalogRequest struct {
	// The full resource path of the catalog to retrieve.
	//
	// Format: "catalogs/{catalog_id}".
	Name *string
}

type GetCdfConfigRequest struct {
	// The resource name of the CdfConfig to retrieve. Format:
	// projects/{project}/branches/{branch}/databases/{database}/cdf-configs/{cdf_config}
	Name *string
}

type GetCdfStatusRequest struct {
	// The resource name of the CdfStatus to retrieve. Format:
	// projects/{project}/branches/{branch}/databases/{database}/cdf-configs/{cdf_config}/cdf-statuses/{cdf_status}
	Name *string
}

type GetDataApiRequest struct {
	// Resource name:
	// projects/{project_id}/branches/{branch_id}/databases/{database_id}/data-api
	Name *string
}

type GetDatabaseRequest struct {
	// The name of the Database to retrieve. Format:
	// projects/{project_id}/branches/{branch_id}/databases/{database_id}
	Name *string
}

type GetEndpointRequest struct {
	// The full resource path of the endpoint to retrieve. Format:
	// projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id}
	Name *string
}

type GetOperationRequest struct {
	// The name of the operation resource.
	Name *string
}

type GetProjectRequest struct {
	// The full resource path of the project to retrieve. Format:
	// projects/{project_id}
	Name *string
}

type GetRoleRequest struct {
	// The full resource path of the role to retrieve. Format:
	// projects/{project_id}/branches/{branch_id}/roles/{role_id}
	Name *string
}

type GetSnapshotRequest struct {
	// The resource name of the snapshot to retrieve. Format:
	// projects/{project_id}/snapshots/{snapshot_id}
	Name *string
}

type GetSnapshotScheduleRequest struct {
	// The resource name of the branch's snapshot schedule. Format:
	// projects/{project_id}/branches/{branch_id}/snapshot-schedule
	Name *string
}

type GetSyncedTableRequest struct {
	// The Full resource name of the synced table. Format:
	// "synced_tables/{catalog}.{schema}.{table}", where (catalog, schema, table)
	// are the entity names in the Unity Catalog.
	Name *string
}

type InitialBranchSpec struct {
	// Whether the initial default branch should be protected from deletion.
	IsProtected *bool `fieldmask:"is_protected"`
}

type InitialEndpointSpec struct {
	// Settings for HA configuration of the endpoint.
	Group *EndpointGroupSpec `fieldmask:"group"`
	// The minimum number of Compute Units for the initial endpoint.
	AutoscalingLimitMinCu *float64 `fieldmask:"autoscaling_limit_min_cu"`
	// The maximum number of Compute Units for the initial endpoint.
	AutoscalingLimitMaxCu *float64 `fieldmask:"autoscaling_limit_max_cu"`
	Suspension            isInitialEndpointSpec_Suspension
	// contains filtered or unexported fields
}

type InitialEndpointSpec_Suspension_NoSuspension struct {
	NoSuspension bool `fieldmask:"no_suspension"`
}

type InitialEndpointSpec_Suspension_SuspendTimeoutDuration struct {
	SuspendTimeoutDuration types.Duration `fieldmask:"suspend_timeout_duration"`
}

type ListBranchesRequest struct {
	// The Project that owns this collection of branches. Format:
	// projects/{project_id}
	Parent *string
	// Page token from a previous response. If not provided, returns the first page.
	PageToken *string
	// Upper bound for items returned. Cannot be negative.
	PageSize *int
	// Whether to include soft-deleted branches in the response. When true, deleted
	// branches are included alongside active branches. Purged branches are never
	// returned.
	ShowDeleted *bool
}

type ListBranchesResponse struct {
	// List of branches in the project.
	Branches []Branch
	// Token to request the next page of branches.
	NextPageToken *string
}

type ListCdfConfigsRequest struct {
	// The parent database to list CdfConfigs for. Format:
	// projects/{project}/branches/{branch}/databases/{database}
	Parent *string
	// Maximum number of CdfConfigs to return.
	PageSize *int
	// Pagination token returned by a previous ListCdfConfigs call. Empty on the
	// first page.
	PageToken *string
}

type ListCdfConfigsResponse struct {
	// The CdfConfigs under the parent database.
	CdfConfigs []CdfConfig
	// Token to retrieve the next page of results; empty when there are no more.
	NextPageToken *string
}

type ListCdfStatusesRequest struct {
	// The parent CdfConfig to list CdfStatuses for. Format:
	// projects/{project}/branches/{branch}/databases/{database}/cdf-configs/{cdf_config}
	Parent *string
	// Maximum number of CdfStatuses to return.
	PageSize *int
	// Pagination token returned by a previous ListCdfStatuses call. Empty on the
	// first page.
	PageToken *string
}

type ListCdfStatusesResponse struct {
	// The replicated tables under the parent CdfConfig.
	CdfStatuses []CdfStatus
	// Token to retrieve the next page of results; empty when there are no more.
	NextPageToken *string
}

type ListDatabasesRequest struct {
	// The Branch that owns this collection of databases. Format:
	// projects/{project_id}/branches/{branch_id}
	Parent *string
	// Pagination token to go to the next page of Databases. Requests first page if
	// absent.
	PageToken *string
	// Upper bound for items returned.
	PageSize *int
}

type ListDatabasesResponse struct {
	// List of databases.
	Databases []Database
	// Pagination token to request the next page of databases.
	NextPageToken *string
}

type ListEndpointsRequest struct {
	// The Branch that owns this collection of endpoints. Format:
	// projects/{project_id}/branches/{branch_id}
	Parent *string
	// Page token from a previous response. If not provided, returns the first page.
	PageToken *string
	// Upper bound for items returned. Cannot be negative.
	PageSize *int
}

type ListEndpointsResponse struct {
	// List of compute endpoints in the branch.
	Endpoints []Endpoint
	// Token to request the next page of compute endpoints.
	NextPageToken *string
}

type ListProjectsRequest struct {
	// Page token from a previous response. If not provided, returns the first page.
	PageToken *string
	// Upper bound for items returned. Cannot be negative. The maximum value is 100.
	PageSize *int
	// Whether to include soft-deleted projects in the response. When true,
	// soft-deleted projects are included alongside active projects. Hard-deleted
	// and already-purged projects are never returned.
	ShowDeleted *bool
}

type ListProjectsResponse struct {
	// List of all projects in the workspace that the user has permission to access.
	Projects []Project
	// Token to request the next page of projects.
	NextPageToken *string
}

type ListRolesRequest struct {
	// The Branch that owns this collection of roles. Format:
	// projects/{project_id}/branches/{branch_id}
	Parent *string
	// Page token from a previous response. If not provided, returns the first page.
	PageToken *string
	// Upper bound for items returned. Cannot be negative.
	PageSize *int
}

type ListRolesResponse struct {
	// List of Postgres roles in the branch.
	Roles []Role
	// Token to request the next page of Postgres roles.
	NextPageToken *string
}

type ListSnapshotsRequest struct {
	// The project that owns the snapshots. Format: projects/{project_id}
	Parent *string
	// Page token from a previous response; omit for the first page.
	PageToken *string
	// Maximum number of snapshots to return per page.
	PageSize *int
}

type ListSnapshotsResponse struct {
	// The snapshots in the project.
	Snapshots []Snapshot
	// Token to retrieve the next page; empty if there are no more pages.
	NextPageToken *string
}

type MonthlySchedule struct {
	// The day of the month on which to take the snapshot, in [1, 31]. In shorter
	// months the snapshot is taken on the last day instead (day 31 runs on Feb 28
	// or 29, and on Apr 30), so every month gets exactly one snapshot.
	Day *int
	// The hour of the day, in UTC, at which to take the snapshot, in [0, 23].
	Hour *int
}

type NewPipelineSpec struct {
	// 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
	// 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
	// Budget policy to set on the newly created pipeline.
	BudgetPolicyId *string
	// Release channel of the underlying pipeline's runtime. Some source table
	// configurations (e.g., read-time CDF) require PREVIEW. Defaults to CURRENT if
	// not specified.
	PipelineChannel NewPipelineSpec_PipelineChannel
}

type NewPipelineSpec_PipelineChannel string

type OpenApiMode string

type Operation struct {
	// The server-assigned name, which is only unique within the same service that
	// originally returns it. If you use the default HTTP mapping, the `name` should
	// be a resource name ending with `operations/{unique_id}`.
	Name *string
	// Service-specific metadata associated with the operation. It typically
	// contains progress information and common metadata such as create time. Some
	// services might not provide such metadata.
	Metadata json.RawMessage
	// If the value is `false`, it means the operation is still in progress. If
	// `true`, the operation is completed, and either `error` or `response` is
	// available.
	Done *bool
	// The operation result, which can be either an `error` or a valid `response`.
	// If `done` == `false`, neither `error` nor `response` is set. If `done` ==
	// `true`, exactly one of `error` or `response` can be set. Some services might
	// not provide the result.
	Result isOperation_Result
}

type Operation_Result_Error struct {
	Error ApiError
}

type Operation_Result_Response struct {
	Response json.RawMessage
}

type Project struct {
	// Output only. The full resource path of the project. Format:
	// projects/{project_id}
	Name *string `fieldmask:"name"`
	// System-generated unique ID for the project.
	Uid *string `fieldmask:"uid"`
	// A timestamp indicating when the project was created.
	CreateTime *types.Time `fieldmask:"create_time"`
	// A timestamp indicating when the project was last updated.
	UpdateTime *types.Time `fieldmask:"update_time"`
	// The spec contains the project configuration, including display_name,
	// pg_version (Postgres version), history_retention_duration, and
	// default_endpoint_settings.
	Spec *ProjectSpec `fieldmask:"spec"`
	// The current status of a Project.
	Status *ProjectStatus `fieldmask:"status"`
	// Configuration settings for the initial Read/Write endpoint created inside the
	// initial branch for a newly created project. If omitted, the initial endpoint
	// created will have default settings, without high availability configured.
	// This field does not apply to any endpoints created after project creation.
	// Use spec.default_endpoint_settings to configure default settings for
	// endpoints created after project creation.
	InitialEndpointSpec *InitialEndpointSpec `fieldmask:"initial_endpoint_spec"`
	// A timestamp indicating when the project was soft-deleted. Empty if the
	// project is not deleted, otherwise set to a timestamp in the past.
	DeleteTime *types.Time `fieldmask:"delete_time"`
	// A timestamp indicating when the project is scheduled for permanent deletion.
	// Empty if the project is not deleted, otherwise set to a timestamp in the
	// future.
	PurgeTime *types.Time `fieldmask:"purge_time"`
	// Configuration for the initial default branch created as part of project
	// creation. Allows overriding branch protection. These settings only apply at
	// creation time and do not affect resources created after project creation.
	InitialBranchSpec *InitialBranchSpec `fieldmask:"initial_branch_spec"`
	// The part of the name, chosen by the user when the resource was created.
	ProjectId *string `fieldmask:"project_id"`
}

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

type ProjectDefaultEndpointSettings struct {
	// The minimum number of Compute Units. Minimum value is 0.5.
	AutoscalingLimitMinCu *float64 `fieldmask:"autoscaling_limit_min_cu"`
	// The maximum number of Compute Units. Minimum value is 0.5.
	AutoscalingLimitMaxCu *float64 `fieldmask:"autoscaling_limit_max_cu"`
	Suspension            isProjectDefaultEndpointSettings_Suspension
	// A raw representation of Postgres settings.
	PgSettings map[string]string `fieldmask:"pg_settings"`
	// contains filtered or unexported fields
}

type ProjectDefaultEndpointSettings_Suspension_NoSuspension struct {
	NoSuspension bool `fieldmask:"no_suspension"`
}

type ProjectDefaultEndpointSettings_Suspension_SuspendTimeoutDuration struct {
	SuspendTimeoutDuration types.Duration `fieldmask:"suspend_timeout_duration"`
}

type ProjectOperationMetadata struct {
}

type ProjectSpec struct {
	// Human-readable project name. Length should be between 1 and 256 characters.
	DisplayName *string `fieldmask:"display_name"`
	// The major Postgres version number. The set of supported versions may vary;
	// consult the API documentation for currently accepted values.
	PgVersion *int `fieldmask:"pg_version"`
	// The number of seconds to retain the shared history for point in time recovery
	// for all branches in this project. Value should be between 172800s (2 days)
	// and 3024000s (35 days).
	HistoryRetentionDuration *types.Duration                 `fieldmask:"history_retention_duration"`
	DefaultEndpointSettings  *ProjectDefaultEndpointSettings `fieldmask:"default_endpoint_settings"`
	// The desired budget policy to associate with the project. See
	// status.budget_policy_id for the policy that is actually applied to the
	// project.
	BudgetPolicyId *string `fieldmask:"budget_policy_id"`
	// Custom tags to associate with the project. Forwarded to LBM for billing and
	// cost tracking. To update tags, provide the new tag list and include
	// "spec.custom_tags" in the update_mask. To clear all tags, provide an empty
	// list and include "spec.custom_tags" in the update_mask. To preserve existing
	// tags, omit this field from the update_mask (or use wildcard "*" which
	// auto-excludes empty tags).
	CustomTags []ProjectCustomTag `fieldmask:"custom_tags"`
	// Whether to enable PG native password login on all endpoints in this project.
	// Defaults to false.
	EnablePgNativeLogin *bool `fieldmask:"enable_pg_native_login"`
	// The full resource path for the default branch of the project Format:
	// projects/{project_id}/branches/{branch_id}
	DefaultBranch *string `fieldmask:"default_branch"`
}

type ProjectStatus struct {
	// The effective human-readable project name.
	DisplayName *string `fieldmask:"display_name"`
	// The effective major Postgres version number.
	PgVersion *int `fieldmask:"pg_version"`
	// The effective number of seconds to retain the shared history for point in
	// time recovery.
	HistoryRetentionDuration *types.Duration `fieldmask:"history_retention_duration"`
	// The effective default endpoint settings.
	DefaultEndpointSettings *ProjectDefaultEndpointSettings `fieldmask:"default_endpoint_settings"`
	// The logical size limit for a branch.
	BranchLogicalSizeLimitBytes *int64 `fieldmask:"branch_logical_size_limit_bytes"`
	// The current space occupied by the project in storage.
	SyntheticStorageSizeBytes *int64 `fieldmask:"synthetic_storage_size_bytes"`
	// The most recent time when any endpoint of this project was active.
	ComputeLastActiveTime *types.Time `fieldmask:"compute_last_active_time"`
	// The budget policy that is applied to the project.
	BudgetPolicyId *string `fieldmask:"budget_policy_id"`
	// The effective custom tags associated with the project.
	CustomTags []ProjectCustomTag `fieldmask:"custom_tags"`
	// The email of the project owner.
	Owner *string `fieldmask:"owner"`
	// Whether to enable PG native password login on all endpoints in this project.
	EnablePgNativeLogin *bool `fieldmask:"enable_pg_native_login"`
	// The full resource path of the default branch of the project
	DefaultBranch *string `fieldmask:"default_branch"`
	// Part of the resource name.
	ProjectId *string `fieldmask:"project_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 {
	ResourceName isRequestedResource_ResourceName
}

type RequestedResource_ResourceName_TableName struct {
	TableName string
}

type Role struct {
	// Output only. The full resource path of the role. Format:
	// projects/{project_id}/branches/{branch_id}/roles/{role_id}
	Name *string `fieldmask:"name"`
	// The Branch where this Role exists. Format:
	// projects/{project_id}/branches/{branch_id}
	Parent     *string     `fieldmask:"parent"`
	CreateTime *types.Time `fieldmask:"create_time"`
	UpdateTime *types.Time `fieldmask:"update_time"`
	// The spec contains the role configuration, including identity type,
	// authentication method, and role attributes.
	Spec *Role_RoleSpec `fieldmask:"spec"`
	// Current status of the role, including its identity type, authentication
	// method, and role attributes.
	Status *Role_RoleStatus `fieldmask:"status"`
	// The part of the name, chosen by the user when the resource was created.
	RoleId *string `fieldmask:"role_id"`
}

type RoleOperationMetadata struct {
}

type Role_Attributes struct {
	Createdb   *bool `fieldmask:"createdb"`
	Createrole *bool `fieldmask:"createrole"`
	Bypassrls  *bool `fieldmask:"bypassrls"`
}

type Role_AuthMethod string

type Role_IdentityType string

type Role_MembershipRole string

type Role_RoleSpec struct {
	// An enum value for a standard role that this role is a member of.
	MembershipRoles []Role_MembershipRole `fieldmask:"membership_roles"`
	// The type of role. When specifying a managed-identity, the chosen role_id must
	// be a valid:
	//
	// * application ID for SERVICE_PRINCIPAL * user email for USER * group name for
	// GROUP
	IdentityType Role_IdentityType `fieldmask:"identity_type"`
	// The desired API-exposed Postgres role attribute to associate with the role.
	// Optional.
	Attributes *Role_Attributes `fieldmask:"attributes"`
	// Controls how the Postgres role authenticates when a client opens a database
	// connection. Supported values:
	//
	// * LAKEBASE_OAUTH_V1: the role authenticates by presenting a Databricks OAuth
	// access token derived from the backing managed identity (the <Databricks>
	// user, service principal, or group named by the role's `postgres_role`). No
	// static password exists for roles using this method. *
	// PG_PASSWORD_SCRAM_SHA_256: the role authenticates with a Postgres password
	// verified server-side using the SCRAM-SHA-256 mechanism. Lakebase generates a
	// password for the role. * NO_LOGIN: the role cannot open a Postgres session at
	// all. Useful for roles that exist only to own objects or to aggregate
	// privileges that are then granted to other, loginable roles.
	//
	// If auth_method is left unspecified, a meaningful authentication method is
	// derived from the identity_type: * For the managed identities, OAUTH is used.
	// * For the regular postgres roles, authentication based on postgres passwords
	// is used.
	//
	// NOTE: for the <Databricks> identity type GROUP, LAKEBASE_OAUTH_V1 is the
	// default auth method (group can login as well).
	AuthMethod Role_AuthMethod `fieldmask:"auth_method"`
	// The name of the Postgres role.
	//
	// This expects a valid Postgres identifier as specified in the link below.
	// https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
	//
	// Required when creating the Role.
	//
	// If you wish to create a Postgres Role backed by a managed <Databricks>
	// identity, then postgres_role must be one of the following:
	//
	// 1. user email for IdentityType.USER 2. app ID for
	// IdentityType.SERVICE_PRINCIPAL 2. group name for IdentityType.GROUP
	PostgresRole *string `fieldmask:"postgres_role"`
}

type Role_RoleStatus struct {
	// An enum value for a standard role that this role is a member of.
	MembershipRoles []Role_MembershipRole `fieldmask:"membership_roles"`
	// The type of the role.
	IdentityType Role_IdentityType `fieldmask:"identity_type"`
	// The PG role attributes associated with the role.
	Attributes *Role_Attributes `fieldmask:"attributes"`
	AuthMethod Role_AuthMethod  `fieldmask:"auth_method"`
	// The name of the Postgres role.
	PostgresRole *string `fieldmask:"postgres_role"`
	// Part of the resource name.
	RoleId *string `fieldmask:"role_id"`
}

type ScheduleCadence struct {
	// The recurrence pattern. Exactly one arm must be set; an unset cadence is
	// rejected with INVALID_PARAMETER_VALUE.
	Schedule isScheduleCadence_Schedule
	// How long snapshots from this cadence are kept before automatic deletion. Must
	// be at least 1 hour. Applied when a snapshot is taken; not retroactive, so
	// changing it affects only later snapshots.
	Retention *types.Duration
}

type ScheduleCadence_Schedule_DailySchedule struct {
	DailySchedule DailySchedule
}

type ScheduleCadence_Schedule_MonthlySchedule struct {
	MonthlySchedule MonthlySchedule
}

type ScheduleCadence_Schedule_WeeklySchedule struct {
	WeeklySchedule WeeklySchedule
}

type Snapshot struct {
	// The resource name of the snapshot. Format:
	// projects/{project_id}/snapshots/{snapshot_id}
	Name *string
	// Unique system-generated ID for the snapshot.
	Uid *string
	// When the snapshot was created.
	CreateTime *types.Time
	// Client-provided configuration of the snapshot.
	Spec *SnapshotSpec
	// Server-observed state of the snapshot.
	Status *SnapshotStatus
	// The user-chosen ID; the final segment of `name`.
	SnapshotId *string
}

type SnapshotOperationMetadata struct {
}

type SnapshotSchedule struct {
	// The resource name of the branch's snapshot schedule. Format:
	// projects/{project_id}/branches/{branch_id}/snapshot-schedule
	Name *string `fieldmask:"name"`
	// The cadences at which automatic snapshots are taken. Update replaces the
	// whole set; an empty set disables automatic snapshots. Order is not
	// significant. When several cadences fire together, one snapshot is taken,
	// retained for the longest of their retentions.
	Schedule []ScheduleCadence `fieldmask:"schedule"`
}

type SnapshotScheduleOperationMetadata struct {
}

type SnapshotSpec struct {
	// The source branch to snapshot. Format:
	// projects/{project_id}/branches/{branch_id}
	SourceBranch *string
	// The point in time to snapshot from. If unset, the current head of the source
	// branch is used. The chosen LSN or timestamp must fall within the project's
	// point-in-time-recovery window (its history_retention_duration); otherwise the
	// request returns INVALID_PARAMETER_VALUE.
	PointInTime isSnapshotSpec_PointInTime
	// Expiration policy. If unset, the snapshot is kept until deleted.
	Expiration isSnapshotSpec_Expiration
}

type SnapshotSpec_Expiration_ExpireTime struct {
	ExpireTime types.Time
}

type SnapshotSpec_Expiration_NoExpiry struct {
	NoExpiry bool
}

type SnapshotSpec_Expiration_Ttl struct {
	Ttl types.Duration
}

type SnapshotSpec_PointInTime_SourceBranchLsn struct {
	SourceBranchLsn string
}

type SnapshotSpec_PointInTime_SourceBranchTime struct {
	SourceBranchTime types.Time
}

type SnapshotStatus struct {
	// The source branch the snapshot was taken from. Format:
	// projects/{project_id}/branches/{branch_id}
	SourceBranch *string
	// Observed expiration state of the snapshot.
	Expiration isSnapshotStatus_Expiration
	// Full logical size of the snapshot, in bytes.
	FullSizeBytes *int64
	// Incremental storage size in bytes since the previous snapshot. Unset when the
	// snapshot is not billed on incremental usage.
	DiffSizeBytes *int64
}

type SnapshotStatus_Expiration_ExpireTime struct {
	ExpireTime types.Time
}

type SnapshotStatus_Expiration_NoExpiry struct {
	NoExpiry bool
}

type SyncedTable struct {
	// Output only. The Full resource name of the synced table in Postgres where
	// (catalog, schema, table) are the UC entity names.
	//
	// Format "synced_tables/{catalog}.{schema}.{table}"
	//
	// For the corresponding source table in the Unity catalog look for the
	// "source_table_full_name" attribute.
	Name *string
	// The Unity Catalog table ID for this synced table.
	Uid *string
	// Configuration details of the synced table, such as the source table,
	// scheduling policy, etc. This attribute is specified at creation time and most
	// fields are returned as is on subsequent queries.
	Spec *SyncedTable_SyncedTableSpec
	// Synced Table data synchronization status.
	Status     *SyncedTable_SyncedTableStatus
	CreateTime *types.Time
	// The part of the name, chosen by the user when the resource was created.
	SyncedTableId *string
}

type SyncedTableOperationMetadata struct {
}

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
	// The number of rows that have been synced in this update.
	SyncedRowCount *int64
	// The total number of rows that need to be synced in this update. This number
	// may be an estimate.
	TotalRowCount *int64
	// The completion ratio of this update. This is a number between 0 and 1.
	SyncProgressCompletion *float64
	// The estimated time remaining to complete this update in seconds.
	EstimatedCompletionTimeSeconds *float64
}

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.
	SyncStartTime *types.Time
	// The end timestamp of the most recent successful synchronization. This is the
	// time when the data is available in the synced table.
	SyncEndTime *types.Time
	// Information about the source system at the time of the last sync.
	SourceSyncInfo isSyncedTablePosition_SourceSyncInfo
}

type SyncedTablePosition_SourceSyncInfo_DeltaTableSyncInfo struct {
	DeltaTableSyncInfo DeltaTableSyncInfo
}

type SyncedTableState string

type SyncedTable_SyncedTableSpec struct {
	// The Postgres database name where the synced table will be created in.
	//
	// If this synced table is created inside a Lakebase Catalog, this attribute can
	// be omitted on creation and is inferred from the postgres_database associated
	// with the Lakebase Catalog. If specified when inside a Lakebase Catalog, the
	// value must match.
	//
	// A value must be specified when creating a synced table inside a Standard
	// Catalog.
	PostgresDatabase *string
	// The full resource name the branch associated with the table.
	//
	// Format: "projects/{project_id}/branches/{branch_id}".
	Branch *string
	// Scheduling policy of the underlying pipeline.
	SchedulingPolicy SyncedTable_SyncedTableSpec_SyncedTableSchedulingPolicy
	// Three-part (catalog, schema, table) name of the source Delta table.
	//
	// For the corresponding destination table, use any of the two:
	//
	// * synced_table_id used at the creation of the SyncedTable * "name" consisting
	// of "synced_tables/" prefix and the full name of the destination table.
	SourceTableFullName *string
	// Primary Key columns to be used for data insert/update in the destination.
	PrimaryKeyColumns []string
	// Time series key to deduplicate (tie-break) rows with the same primary key.
	TimeseriesKey *string
	// ID of an existing pipeline to bin-pack this synced table into. At most one of
	// existing_pipeline_id and new_pipeline_spec should be defined.
	//
	// The pipeline used for the synced table is returned via the top level
	// pipeline_id attribute.
	ExistingPipelineId *string
	// If true, the synced table's logical database and schema resources in PG will
	// be created if they do not already exist. The request will fail if this is
	// false and the database/schema do not exist.
	//
	// Defaults to true if omitted.
	CreateDatabaseObjectsIfMissing *bool
	// Specification for creating a new pipeline. At most one of
	// existing_pipeline_id and new_pipeline_spec should be defined.
	//
	// The pipeline used for the synced table is returned via the top level
	// pipeline_id attribute.
	NewPipelineSpec *NewPipelineSpec
	// When true, enables accelerated sync mode for the initial data load. This
	// significantly improves performance for large tables. Requires workspace-level
	// enablement through Lakebase Accelerated Sync preview.
	AcceleratedSync *bool
	// 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 []SyncedTable_SyncedTableSpec_TypeOverride
	// Extra PostgreSQL-only columns to add to the synced table.
	ExtraColumns []SyncedTable_SyncedTableSpec_ExtraColumn
}

type SyncedTable_SyncedTableSpec_ExtraColumn struct {
	// Name of the column.
	ColumnName *string
	// PostgreSQL type of the column, for example "tsvector" or "vector(1024)".
	ColumnType  *string
	Maintenance SyncedTable_SyncedTableSpec_ExtraColumn_Maintenance
	// SQL expression used to compute the column's value, for example
	// "to_tsvector('english', content)".
	Compute *string
}

type SyncedTable_SyncedTableSpec_ExtraColumn_Maintenance string

type SyncedTable_SyncedTableSpec_PgSpecificType string

type SyncedTable_SyncedTableSpec_SyncedTableSchedulingPolicy string

type SyncedTable_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 SyncedTable_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 SyncedTable_SyncedTableStatus struct {
	// A text description of the current state of the synced table.
	Message *string
	// The state of the synced table.
	DetailedState SyncedTableState
	// Summary of the last successful synchronization from source to destination.
	LastSync            *SyncedTablePosition
	OngoingSyncProgress *SyncedTablePipelineProgress
	// The current phase of the data synchronization pipeline.
	ProvisioningPhase ProvisioningPhase
	// The last source table Delta version that was successfully synced to the
	// synced table.
	LastProcessedCommitVersion *int64
	// 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.
	LastSyncTime *types.Time
	// ID of the associated pipeline.
	PipelineId *string
	// The provisioning state of the synced table entity in Unity Catalog.
	UnityCatalogProvisioningState ProvisioningInfo_State
	// The full resource name of the project associated with the table.
	//
	// Format: "projects/{project_id}".
	Project *string
}

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

type UndeleteBranchRequest struct {
	// The full resource path of the branch to undelete. Format:
	// projects/{project_id}/branches/{branch_id}
	Name *string
}

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

type UndeleteProjectRequest struct {
	// The full resource path of the project to undelete. Format:
	// projects/{project_id}
	Name *string
}

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

type UpdateBranchRequest struct {
	// The Branch to update.
	//
	// The branch's `name` field is used to identify the branch to update. Format:
	// projects/{project_id}/branches/{branch_id}
	Branch *Branch
	// The list of fields to update.
	UpdateMask *types.FieldMask[Branch]
}

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

type UpdateDataApiRequest struct {
	// The Data API configuration to update. The data_api's `name` field identifies
	// the resource.
	DataApi *DataApi
	// The list of fields to update.
	UpdateMask *types.FieldMask[DataApi]
}

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

type UpdateDatabaseRequest struct {
	// The Database to update.
	//
	// The database's `name` field is used to identify the database to update.
	// Format: projects/{project_id}/branches/{branch_id}/databases/{database_id}
	Database *Database
	// The list of fields to update.
	UpdateMask *types.FieldMask[Database]
}

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

type UpdateEndpointRequest struct {
	// The Endpoint to update.
	//
	// The endpoint's `name` field is used to identify the endpoint to update.
	// Format: projects/{project_id}/branches/{branch_id}/endpoints/{endpoint_id}
	Endpoint *Endpoint
	// The list of fields to update.
	UpdateMask *types.FieldMask[Endpoint]
}

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

type UpdateProjectRequest struct {
	// The Project to update.
	//
	// The project's `name` field is used to identify the project to update. Format:
	// projects/{project_id}
	Project *Project
	// The list of fields to update.
	UpdateMask *types.FieldMask[Project]
}

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

type UpdateRoleRequest struct {
	// The Postgres Role to update.
	//
	// The role's `name` field is used to identify the role to update. Format:
	// projects/{project_id}/branches/{branch_id}/roles/{role_id}
	Role *Role
	// The list of fields to update.
	UpdateMask *types.FieldMask[Role]
}

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

type UpdateSnapshotScheduleRequest struct {
	// The snapshot schedule to set. Its `name` identifies the branch. Format:
	// projects/{project_id}/branches/{branch_id}/snapshot-schedule
	SnapshotSchedule *SnapshotSchedule
	// Fields to update. The only updatable path is `schedule`, which replaces the
	// entire set of cadences.
	UpdateMask *types.FieldMask[SnapshotSchedule]
}

type WeeklySchedule struct {
	// The day of the week on which to take the snapshot.
	DayOfWeek DayOfWeek
	// The hour of the day, in UTC, at which to take the snapshot, in [0, 23].
	Hour *int
}