googleapis
Version:
Google APIs Client Library for Node.js
1,050 lines • 337 kB
TypeScript
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace alloydb_v1 {
export interface Options extends GlobalOptions {
version: 'v1';
}
interface StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
/**
* V1 error format.
*/
'$.xgafv'?: string;
/**
* OAuth access token.
*/
access_token?: string;
/**
* Data format for response.
*/
alt?: string;
/**
* JSONP
*/
callback?: string;
/**
* Selector specifying which fields to include in a partial response.
*/
fields?: string;
/**
* API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
*/
key?: string;
/**
* OAuth 2.0 token for the current user.
*/
oauth_token?: string;
/**
* Returns response with indentations and line breaks.
*/
prettyPrint?: boolean;
/**
* Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
*/
quotaUser?: string;
/**
* Legacy upload protocol for media (e.g. "media", "multipart").
*/
uploadType?: string;
/**
* Upload protocol for media (e.g. "raw", "multipart").
*/
upload_protocol?: string;
}
/**
* AlloyDB API
*
* AlloyDB for PostgreSQL is an open source-compatible database service that provides a powerful option for migrating, modernizing, or building commercial-grade applications. It offers full compatibility with standard PostgreSQL, and is more than 4x faster for transactional workloads and up to 100x faster for analytical queries than standard PostgreSQL in our performance tests. AlloyDB for PostgreSQL offers a 99.99 percent availability SLA inclusive of maintenance. AlloyDB is optimized for the most demanding use cases, allowing you to build new applications that require high transaction throughput, large database sizes, or multiple read resources; scale existing PostgreSQL workloads with no application changes; and modernize legacy proprietary databases.
*
* @example
* ```js
* const {google} = require('googleapis');
* const alloydb = google.alloydb('v1');
* ```
*/
export class Alloydb {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* AuthorizedNetwork contains metadata for an authorized network.
*/
export interface Schema$AuthorizedNetwork {
/**
* CIDR range for one authorzied network of the instance.
*/
cidrRange?: string | null;
}
/**
* Message describing the user-specified automated backup policy. All fields in the automated backup policy are optional. Defaults for each field are provided if they are not set.
*/
export interface Schema$AutomatedBackupPolicy {
/**
* The length of the time window during which a backup can be taken. If a backup does not succeed within this time window, it will be canceled and considered failed. The backup window must be at least 5 minutes long. There is no upper bound on the window. If not set, it defaults to 1 hour.
*/
backupWindow?: string | null;
/**
* Whether automated automated backups are enabled. If not set, defaults to true.
*/
enabled?: boolean | null;
/**
* Optional. The encryption config can be specified to encrypt the backups with a customer-managed encryption key (CMEK). When this field is not specified, the backup will use the cluster's encryption config.
*/
encryptionConfig?: Schema$EncryptionConfig;
/**
* Labels to apply to backups created using this configuration.
*/
labels?: {
[key: string]: string;
} | null;
/**
* The location where the backup will be stored. Currently, the only supported option is to store the backup in the same region as the cluster. If empty, defaults to the region of the cluster.
*/
location?: string | null;
/**
* Quantity-based Backup retention policy to retain recent backups.
*/
quantityBasedRetention?: Schema$QuantityBasedRetention;
/**
* Time-based Backup retention policy.
*/
timeBasedRetention?: Schema$TimeBasedRetention;
/**
* Weekly schedule for the Backup.
*/
weeklySchedule?: Schema$WeeklySchedule;
}
/**
* Message describing Backup object
*/
export interface Schema$Backup {
/**
* Annotations to allow client tools to store small amount of arbitrary data. This is distinct from labels. https://google.aip.dev/128
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Required. The full resource name of the backup source cluster (e.g., projects/{project\}/locations/{region\}/clusters/{cluster_id\}).
*/
clusterName?: string | null;
/**
* Output only. The system-generated UID of the cluster which was used to create this resource.
*/
clusterUid?: string | null;
/**
* Output only. Timestamp when the resource finished being created.
*/
createCompletionTime?: string | null;
/**
* Output only. Create time stamp
*/
createTime?: string | null;
/**
* Output only. The database engine major version of the cluster this backup was created from. Any restored cluster created from this backup will have the same database version.
*/
databaseVersion?: string | null;
/**
* Output only. Delete time stamp
*/
deleteTime?: string | null;
/**
* User-provided description of the backup.
*/
description?: string | null;
/**
* User-settable and human-readable display name for the Backup.
*/
displayName?: string | null;
/**
* Optional. The encryption config can be specified to encrypt the backup with a customer-managed encryption key (CMEK). When this field is not specified, the backup will then use default encryption scheme to protect the user data.
*/
encryptionConfig?: Schema$EncryptionConfig;
/**
* Output only. The encryption information for the backup.
*/
encryptionInfo?: Schema$EncryptionInfo;
/**
* For Resource freshness validation (https://google.aip.dev/154)
*/
etag?: string | null;
/**
* Output only. The QuantityBasedExpiry of the backup, specified by the backup's retention policy. Once the expiry quantity is over retention, the backup is eligible to be garbage collected.
*/
expiryQuantity?: Schema$QuantityBasedExpiry;
/**
* Output only. The time at which after the backup is eligible to be garbage collected. It is the duration specified by the backup's retention policy, added to the backup's create_time.
*/
expiryTime?: string | null;
/**
* Labels as key value pairs
*/
labels?: {
[key: string]: string;
} | null;
/**
* Output only. The name of the backup resource with the format: * projects/{project\}/locations/{region\}/backups/{backup_id\} where the cluster and backup ID segments should satisfy the regex expression `[a-z]([a-z0-9-]{0,61\}[a-z0-9])?`, e.g. 1-63 characters of lowercase letters, numbers, and dashes, starting with a letter, and ending with a letter or number. For more details see https://google.aip.dev/122. The prefix of the backup resource name is the name of the parent resource: * projects/{project\}/locations/{region\}
*/
name?: string | null;
/**
* Output only. Reconciling (https://google.aip.dev/128#reconciliation), if true, indicates that the service is actively updating the resource. This can happen due to user-triggered updates or system actions like failover or maintenance.
*/
reconciling?: boolean | null;
/**
* Output only. Reserved for future use.
*/
satisfiesPzs?: boolean | null;
/**
* Output only. The size of the backup in bytes.
*/
sizeBytes?: string | null;
/**
* Output only. The current state of the backup.
*/
state?: string | null;
/**
* Optional. Input only. Immutable. Tag keys/values directly bound to this resource. For example: ``` "123/environment": "production", "123/costCenter": "marketing" ```
*/
tags?: {
[key: string]: string;
} | null;
/**
* The backup type, which suggests the trigger for the backup.
*/
type?: string | null;
/**
* Output only. The system-generated UID of the resource. The UID is assigned when the resource is created, and it is retained until it is deleted.
*/
uid?: string | null;
/**
* Output only. Update time stamp Users should not infer any meaning from this field. Its value is generally unrelated to the timing of the backup creation operation.
*/
updateTime?: string | null;
}
/**
* Message describing a BackupDrBackupSource.
*/
export interface Schema$BackupDrBackupSource {
/**
* Required. The name of the backup resource with the format: * projects/{project\}/locations/{location\}/backupVaults/{backupvault_id\}/dataSources/{datasource_id\}/backups/{backup_id\}
*/
backup?: string | null;
}
/**
* Information about a single window when BackupDR was enabled for this cluster.
*/
export interface Schema$BackupDrEnabledWindow {
/**
* Whether automated backup was previously enabled prior to enabling BackupDR protection for this cluster.
*/
automatedBackupPreviouslyEnabled?: boolean | null;
/**
* The BackupPlanAssociation resource that was used to enable BackupDR protection for this cluster.
*/
backupPlanAssociation?: string | null;
/**
* Whether continuous backup was previously enabled prior to enabling BackupDR protection for this cluster.
*/
continuousBackupPreviouslyEnabled?: boolean | null;
/**
* The time when continuous backup was previously enabled prior to enabling BackupDR protection for this cluster.
*/
continuousBackupPreviouslyEnabledTime?: string | null;
/**
* The retention set for the continuous backup that was previously enabled prior to enabling BackupDR protection for this cluster.
*/
continuousBackupPreviousRecoveryWindowDays?: number | null;
/**
* The DataSource resource that represents the cluster in BackupDR.
*/
dataSource?: string | null;
/**
* Time when the BackupDR protection for this cluster was disabled. This field will be empty if this BackupDR window is the `current_window`.
*/
disabledTime?: string | null;
/**
* Time when the BackupDR protection for this cluster was enabled.
*/
enabledTime?: string | null;
/**
* The retention period for logs generated by BackupDR for this cluster.
*/
logRetentionPeriod?: string | null;
}
/**
* Information about BackupDR protection for this cluster.
*/
export interface Schema$BackupDrInfo {
/**
* The current BackupDR configuration for this cluster. If BackupDR protection is not enabled for this cluster, this field will be empty.
*/
currentWindow?: Schema$BackupDrEnabledWindow;
/**
* Windows during which BackupDR was enabled for this cluster, along with associated configuration for that window. These are used to determine points-in-time for which restores can be performed. The windows are ordered with the most recent window last. Windows are mutally exclusive. Windows which closed more than 1 year ago will be removed from this list.
*/
previousWindows?: Schema$BackupDrEnabledWindow[];
}
/**
* Message describing a BackupDrPitrSource.
*/
export interface Schema$BackupDrPitrSource {
/**
* Required. The name of the backup resource with the format: * projects/{project\}/locations/{location\}/backupVaults/{backupvault_id\}/dataSources/{datasource_id\}
*/
dataSource?: string | null;
/**
* Required. The point in time to restore to.
*/
pointInTime?: string | null;
}
/**
* Message describing a BackupSource.
*/
export interface Schema$BackupSource {
/**
* Required. The name of the backup resource with the format: * projects/{project\}/locations/{region\}/backups/{backup_id\}
*/
backupName?: string | null;
/**
* Output only. The system-generated UID of the backup which was used to create this resource. The UID is generated when the backup is created, and it is retained until the backup is deleted.
*/
backupUid?: string | null;
}
/**
* The request message for Operations.CancelOperation.
*/
export interface Schema$CancelOperationRequest {
}
/**
* Client connection configuration
*/
export interface Schema$ClientConnectionConfig {
/**
* Optional. Configuration to enforce connectors only (ex: AuthProxy) connections to the database.
*/
requireConnectors?: boolean | null;
/**
* Optional. SSL configuration option for this instance.
*/
sslConfig?: Schema$SslConfig;
}
/**
* Operation metadata returned by the CLH during resource state reconciliation.
*/
export interface Schema$CloudControl2SharedOperationsReconciliationOperationMetadata {
/**
* DEPRECATED. Use exclusive_action instead.
*/
deleteResource?: boolean | null;
/**
* Excluisive action returned by the CLH.
*/
exclusiveAction?: string | null;
}
/**
* The source CloudSQL backup resource.
*/
export interface Schema$CloudSQLBackupRunSource {
/**
* Required. The CloudSQL backup run ID.
*/
backupRunId?: string | null;
/**
* Required. The CloudSQL instance ID.
*/
instanceId?: string | null;
/**
* The project ID of the source CloudSQL instance. This should be the same as the AlloyDB cluster's project.
*/
project?: string | null;
}
/**
* A cluster is a collection of regional AlloyDB resources. It can include a primary instance and one or more read pool instances. All cluster resources share a storage layer, which scales as needed.
*/
export interface Schema$Cluster {
/**
* Annotations to allow client tools to store small amount of arbitrary data. This is distinct from labels. https://google.aip.dev/128
*/
annotations?: {
[key: string]: string;
} | null;
/**
* The automated backup policy for this cluster. If no policy is provided then the default policy will be used. If backups are supported for the cluster, the default policy takes one backup a day, has a backup window of 1 hour, and retains backups for 14 days. For more information on the defaults, consult the documentation for the message type.
*/
automatedBackupPolicy?: Schema$AutomatedBackupPolicy;
/**
* Output only. Cluster created from a BackupDR backup.
*/
backupdrBackupSource?: Schema$BackupDrBackupSource;
/**
* Output only. Output only information about BackupDR protection for this cluster.
*/
backupdrInfo?: Schema$BackupDrInfo;
/**
* Output only. Cluster created from backup.
*/
backupSource?: Schema$BackupSource;
/**
* Output only. Cluster created from CloudSQL snapshot.
*/
cloudsqlBackupRunSource?: Schema$CloudSQLBackupRunSource;
/**
* Output only. The type of the cluster. This is an output-only field and it's populated at the Cluster creation time or the Cluster promotion time. The cluster type is determined by which RPC was used to create the cluster (i.e. `CreateCluster` vs. `CreateSecondaryCluster`
*/
clusterType?: string | null;
/**
* Optional. Continuous backup configuration for this cluster.
*/
continuousBackupConfig?: Schema$ContinuousBackupConfig;
/**
* Output only. Continuous backup properties for this cluster.
*/
continuousBackupInfo?: Schema$ContinuousBackupInfo;
/**
* Output only. Create time stamp
*/
createTime?: string | null;
/**
* Optional. The database engine major version. This is an optional field and it is populated at the Cluster creation time. If a database version is not supplied at cluster creation time, then a default database version will be used.
*/
databaseVersion?: string | null;
/**
* Optional. Configuration for Dataplex integration.
*/
dataplexConfig?: Schema$DataplexConfig;
/**
* Output only. Delete time stamp
*/
deleteTime?: string | null;
/**
* User-settable and human-readable display name for the Cluster.
*/
displayName?: string | null;
/**
* Optional. The encryption config can be specified to encrypt the data disks and other persistent data resources of a cluster with a customer-managed encryption key (CMEK). When this field is not specified, the cluster will then use default encryption scheme to protect the user data.
*/
encryptionConfig?: Schema$EncryptionConfig;
/**
* Output only. The encryption information for the cluster.
*/
encryptionInfo?: Schema$EncryptionInfo;
/**
* For Resource freshness validation (https://google.aip.dev/154)
*/
etag?: string | null;
/**
* Input only. Initial user to setup during cluster creation. Required. If used in `RestoreCluster` this is ignored.
*/
initialUser?: Schema$UserPassword;
/**
* Labels as key value pairs
*/
labels?: {
[key: string]: string;
} | null;
/**
* Output only. The maintenance schedule for the cluster, generated for a specific rollout if a maintenance window is set.
*/
maintenanceSchedule?: Schema$MaintenanceSchedule;
/**
* Optional. The maintenance update policy determines when to allow or deny updates.
*/
maintenanceUpdatePolicy?: Schema$MaintenanceUpdatePolicy;
/**
* Input only. Policy to use to automatically select the maintenance version to which to update the cluster's instances.
*/
maintenanceVersionSelectionPolicy?: string | null;
/**
* Output only. Cluster created via DMS migration.
*/
migrationSource?: Schema$MigrationSource;
/**
* Output only. The name of the cluster resource with the format: * projects/{project\}/locations/{region\}/clusters/{cluster_id\} where the cluster ID segment should satisfy the regex expression `[a-z0-9-]+`. For more details see https://google.aip.dev/122. The prefix of the cluster resource name is the name of the parent resource: * projects/{project\}/locations/{region\}
*/
name?: string | null;
/**
* Required. The resource link for the VPC network in which cluster resources are created and from which they are accessible via Private IP. The network must belong to the same project as the cluster. It is specified in the form: `projects/{project\}/global/networks/{network_id\}`. This is required to create a cluster. Deprecated, use network_config.network instead.
*/
network?: string | null;
networkConfig?: Schema$NetworkConfig;
/**
* Output only. Cross Region replication config specific to PRIMARY cluster.
*/
primaryConfig?: Schema$PrimaryConfig;
/**
* Optional. The configuration for Private Service Connect (PSC) for the cluster.
*/
pscConfig?: Schema$PscConfig;
/**
* Output only. Reconciling (https://google.aip.dev/128#reconciliation). Set to true if the current state of Cluster does not match the user's intended state, and the service is actively updating the resource to reconcile them. This can happen due to user-triggered updates or system actions like failover or maintenance.
*/
reconciling?: boolean | null;
/**
* Output only. Reserved for future use.
*/
satisfiesPzs?: boolean | null;
/**
* Cross Region replication config specific to SECONDARY cluster.
*/
secondaryConfig?: Schema$SecondaryConfig;
/**
* SSL configuration for this AlloyDB cluster.
*/
sslConfig?: Schema$SslConfig;
/**
* Output only. The current serving state of the cluster.
*/
state?: string | null;
/**
* Optional. Subscription type of the cluster.
*/
subscriptionType?: string | null;
/**
* Optional. Input only. Immutable. Tag keys/values directly bound to this resource. For example: ``` "123/environment": "production", "123/costCenter": "marketing" ```
*/
tags?: {
[key: string]: string;
} | null;
/**
* Output only. Metadata for free trial clusters
*/
trialMetadata?: Schema$TrialMetadata;
/**
* Output only. The system-generated UID of the resource. The UID is assigned when the resource is created, and it is retained until it is deleted.
*/
uid?: string | null;
/**
* Output only. Update time stamp
*/
updateTime?: string | null;
}
/**
* Upgrade details of a cluster. This cluster can be primary or secondary.
*/
export interface Schema$ClusterUpgradeDetails {
/**
* Cluster type which can either be primary or secondary.
*/
clusterType?: string | null;
/**
* Database version of the cluster after the upgrade operation. This will be the target version if the upgrade was successful otherwise it remains the same as that before the upgrade operation.
*/
databaseVersion?: string | null;
/**
* Upgrade details of the instances directly associated with this cluster.
*/
instanceUpgradeDetails?: Schema$InstanceUpgradeDetails[];
/**
* Normalized name of the cluster
*/
name?: string | null;
/**
* Array containing stage info associated with this cluster.
*/
stageInfo?: Schema$StageInfo[];
/**
* Upgrade status of the cluster.
*/
upgradeStatus?: string | null;
}
/**
* ConnectionInfo singleton resource. https://google.aip.dev/156
*/
export interface Schema$ConnectionInfo {
/**
* Output only. The unique ID of the Instance.
*/
instanceUid?: string | null;
/**
* Output only. The private network IP address for the Instance. This is the default IP for the instance and is always created (even if enable_public_ip is set). This is the connection endpoint for an end-user application.
*/
ipAddress?: string | null;
/**
* The name of the ConnectionInfo singleton resource, e.g.: projects/{project\}/locations/{location\}/clusters/x/instances/x/connectionInfo This field currently has no semantic meaning.
*/
name?: string | null;
/**
* Output only. The public IP addresses for the Instance. This is available ONLY when enable_public_ip is set. This is the connection endpoint for an end-user application.
*/
publicIpAddress?: string | null;
}
/**
* Configuration for Managed Connection Pool (MCP).
*/
export interface Schema$ConnectionPoolConfig {
/**
* Optional. Whether to enable Managed Connection Pool (MCP).
*/
enabled?: boolean | null;
/**
* Optional. Connection Pool flags, as a list of "key": "value" pairs.
*/
flags?: {
[key: string]: string;
} | null;
/**
* Output only. The number of running poolers per instance.
*/
poolerCount?: number | null;
}
/**
* ContinuousBackupConfig describes the continuous backups recovery configurations of a cluster.
*/
export interface Schema$ContinuousBackupConfig {
/**
* Whether ContinuousBackup is enabled.
*/
enabled?: boolean | null;
/**
* The encryption config can be specified to encrypt the backups with a customer-managed encryption key (CMEK). When this field is not specified, the backup will use the cluster's encryption config.
*/
encryptionConfig?: Schema$EncryptionConfig;
/**
* The number of days that are eligible to restore from using PITR. To support the entire recovery window, backups and logs are retained for one day more than the recovery window. If not set, defaults to 14 days.
*/
recoveryWindowDays?: number | null;
}
/**
* ContinuousBackupInfo describes the continuous backup properties of a cluster.
*/
export interface Schema$ContinuousBackupInfo {
/**
* Output only. The earliest restorable time that can be restored to. If continuous backups and recovery was recently enabled, the earliest restorable time is the creation time of the earliest eligible backup within this cluster's continuous backup recovery window. After a cluster has had continuous backups enabled for the duration of its recovery window, the earliest restorable time becomes "now minus the recovery window". For example, assuming a point in time recovery is attempted at 04/16/2025 3:23:00PM with a 14d recovery window, the earliest restorable time would be 04/02/2025 3:23:00PM. This field is only visible if the CLUSTER_VIEW_CONTINUOUS_BACKUP cluster view is provided.
*/
earliestRestorableTime?: string | null;
/**
* Output only. When ContinuousBackup was most recently enabled. Set to null if ContinuousBackup is not enabled.
*/
enabledTime?: string | null;
/**
* Output only. The encryption information for the WALs and backups required for ContinuousBackup.
*/
encryptionInfo?: Schema$EncryptionInfo;
/**
* Output only. Days of the week on which a continuous backup is taken.
*/
schedule?: string[] | null;
}
/**
* Message describing a ContinuousBackupSource.
*/
export interface Schema$ContinuousBackupSource {
/**
* Required. The source cluster from which to restore. This cluster must have continuous backup enabled for this operation to succeed. For the required format, see the comment on the Cluster.name field.
*/
cluster?: string | null;
/**
* Required. The point in time to restore to.
*/
pointInTime?: string | null;
}
/**
* Options for exporting data in CSV format.
*/
export interface Schema$CsvExportOptions {
/**
* Optional. Specifies the character that should appear before a data character that needs to be escaped. The default is the same as quote character. The value of this argument has to be a character in Hex ASCII Code.
*/
escapeCharacter?: string | null;
/**
* Optional. Specifies the character that separates columns within each row (line) of the file. The default is comma. The value of this argument has to be a character in Hex ASCII Code.
*/
fieldDelimiter?: string | null;
/**
* Optional. Specifies the quoting character to be used when a data value is quoted. The default is double-quote. The value of this argument has to be a character in Hex ASCII Code.
*/
quoteCharacter?: string | null;
/**
* Required. The SELECT query used to extract the data.
*/
selectQuery?: string | null;
}
/**
* Options for importing data in CSV format.
*/
export interface Schema$CsvImportOptions {
/**
* Optional. The columns to which CSV data is imported. If not specified, all columns of the database table are loaded with CSV data.
*/
columns?: string[] | null;
/**
* Optional. Specifies the character that should appear before a data character that needs to be escaped. The default is same as quote character. The value of this argument has to be a character in Hex ASCII Code.
*/
escapeCharacter?: string | null;
/**
* Optional. Specifies the character that separates columns within each row (line) of the file. The default is comma. The value of this argument has to be a character in Hex ASCII Code.
*/
fieldDelimiter?: string | null;
/**
* Optional. Specifies the quoting character to be used when a data value is quoted. The default is double-quote. The value of this argument has to be a character in Hex ASCII Code.
*/
quoteCharacter?: string | null;
/**
* Required. The database table to import CSV file into.
*/
table?: string | null;
}
/**
* Configuration for Dataplex integration.
*/
export interface Schema$DataplexConfig {
/**
* Dataplex is enabled by default for resources such as clusters and instances. This flag controls the integration of AlloyDB PG resources (like databases, schemas, and tables) with Dataplex."
*/
enabled?: boolean | null;
}
/**
* DenyMaintenancePeriod definition. Excepting emergencies, maintenance will not be scheduled to start within this deny period. The start_date must be less than the end_date.
*/
export interface Schema$DenyMaintenancePeriod {
/**
* Deny period end date. This can be: * A full date, with non-zero year, month and day values OR * A month and day value, with a zero year for recurring
*/
endDate?: Schema$GoogleTypeDate;
/**
* Deny period start date. This can be: * A full date, with non-zero year, month and day values OR * A month and day value, with a zero year for recurring
*/
startDate?: Schema$GoogleTypeDate;
/**
* Time in UTC when the deny period starts on start_date and ends on end_date. This can be: * Full time OR * All zeros for 00:00:00 UTC
*/
time?: Schema$GoogleTypeTimeOfDay;
}
/**
* A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); \}
*/
export interface Schema$Empty {
}
/**
* EncryptionConfig describes the encryption config of a cluster or a backup that is encrypted with a CMEK (customer-managed encryption key).
*/
export interface Schema$EncryptionConfig {
/**
* The fully-qualified resource name of the KMS key. Each Cloud KMS key is regionalized and has the following format: projects/[PROJECT]/locations/[REGION]/keyRings/[RING]/cryptoKeys/[KEY_NAME]
*/
kmsKeyName?: string | null;
}
/**
* EncryptionInfo describes the encryption information of a cluster or a backup.
*/
export interface Schema$EncryptionInfo {
/**
* Output only. Type of encryption.
*/
encryptionType?: string | null;
/**
* Output only. Cloud KMS key versions that are being used to protect the database or the backup.
*/
kmsKeyVersions?: string[] | null;
}
/**
* Export cluster request.
*/
export interface Schema$ExportClusterRequest {
/**
* Options for exporting data in CSV format. Required field to be set for CSV file type.
*/
csvExportOptions?: Schema$CsvExportOptions;
/**
* Required. Name of the database where the export command will be executed. Note - Value provided should be the same as expected from `SELECT current_database();` and NOT as a resource reference.
*/
database?: string | null;
/**
* Required. Option to export data to cloud storage.
*/
gcsDestination?: Schema$GcsDestination;
/**
* Options for exporting data in SQL format. Required field to be set for SQL file type.
*/
sqlExportOptions?: Schema$SqlExportOptions;
}
/**
* Response of export cluster rpc.
*/
export interface Schema$ExportClusterResponse {
/**
* Required. Option to export data to cloud storage.
*/
gcsDestination?: Schema$GcsDestination;
}
/**
* Message for triggering failover on an Instance
*/
export interface Schema$FailoverInstanceRequest {
/**
* Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server ignores the request if it has already been completed. The server guarantees that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if the original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
*/
requestId?: string | null;
/**
* Optional. If set, performs request validation, for example, permission checks and any other type of validation, but does not actually execute the create request.
*/
validateOnly?: boolean | null;
}
/**
* Destination for Export. Export will be done to cloud storage.
*/
export interface Schema$GcsDestination {
/**
* Required. The path to the file in Google Cloud Storage where the export will be stored. The URI is in the form `gs://bucketName/fileName`.
*/
uri?: string | null;
}
/**
* The response message for Locations.ListLocations.
*/
export interface Schema$GoogleCloudLocationListLocationsResponse {
/**
* A list of locations that matches the specified filter in the request.
*/
locations?: Schema$GoogleCloudLocationLocation[];
/**
* The standard List next-page token.
*/
nextPageToken?: string | null;
}
/**
* A resource that represents a Google Cloud location.
*/
export interface Schema$GoogleCloudLocationLocation {
/**
* The friendly name for this location, typically a nearby city name. For example, "Tokyo".
*/
displayName?: string | null;
/**
* Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"\}
*/
labels?: {
[key: string]: string;
} | null;
/**
* The canonical id for this location. For example: `"us-east1"`.
*/
locationId?: string | null;
/**
* Service-specific metadata. For example the available capacity at the given location.
*/
metadata?: {
[key: string]: any;
} | null;
/**
* Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"`
*/
name?: string | null;
}
/**
* Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp
*/
export interface Schema$GoogleTypeDate {
/**
* Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
*/
day?: number | null;
/**
* Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
*/
month?: number | null;
/**
* Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.
*/
year?: number | null;
}
/**
* Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`.
*/
export interface Schema$GoogleTypeTimeOfDay {
/**
* Hours of a day in 24 hour format. Must be greater than or equal to 0 and typically must be less than or equal to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
*/
hours?: number | null;
/**
* Minutes of an hour. Must be greater than or equal to 0 and less than or equal to 59.
*/
minutes?: number | null;
/**
* Fractions of seconds, in nanoseconds. Must be greater than or equal to 0 and less than or equal to 999,999,999.
*/
nanos?: number | null;
/**
* Seconds of a minute. Must be greater than or equal to 0 and typically must be less than or equal to 59. An API may allow the value 60 if it allows leap-seconds.
*/
seconds?: number | null;
}
/**
* Import cluster request.
*/
export interface Schema$ImportClusterRequest {
/**
* Options for importing data in CSV format.
*/
csvImportOptions?: Schema$CsvImportOptions;
/**
* Optional. Name of the database to which the import will be done. For import from SQL file, this is required only if the file does not specify a database. Note - Value provided should be the same as expected from `SELECT current_database();` and NOT as a resource reference.
*/
database?: string | null;
/**
* Required. The path to the file in Google Cloud Storage where the source file for import will be stored. The URI is in the form `gs://bucketName/fileName`.
*/
gcsUri?: string | null;
/**
* Options for importing data in SQL format.
*/
sqlImportOptions?: Schema$SqlImportOptions;
/**
* Optional. Database user to be used for importing the data. Note - Value provided should be the same as expected from `SELECT current_user;` and NOT as a resource reference.
*/
user?: string | null;
}
/**
* Response of import rpc.
*/
export interface Schema$ImportClusterResponse {
/**
* Required. Size of the object downloaded from Google Cloud Storage in bytes.
*/
bytesDownloaded?: string | null;
}
/**
* Message for triggering fault injection on an instance
*/
export interface Schema$InjectFaultRequest {
/**
* Required. The type of fault to be injected in an instance.
*/
faultType?: string | null;
/**
* Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server ignores the request if it has already been completed. The server guarantees that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if the original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
*/
requestId?: string | null;
/**
* Optional. If set, performs request validation, for example, permission checks and any other type of validation, but does not actually execute the create request.
*/
validateOnly?: boolean | null;
}
/**
* An Instance is a computing unit that an end customer can connect to. It's the main unit of computing resources in AlloyDB.
*/
export interface Schema$Instance {
/**
* Optional. Specifies whether an instance needs to spin up. Once the instance is active, the activation policy can be updated to the `NEVER` to stop the instance. Likewise, the activation policy can be updated to `ALWAYS` to start the instance. There are restrictions around when an instance can/cannot be activated (for example, a read pool instance should be stopped before stopping primary etc.). Please refer to the API documentation for more details.
*/
activationPolicy?: string | null;
/**
* Annotations to allow client tools to store small amount of arbitrary data. This is distinct from labels. https://google.aip.dev/128
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Availability type of an Instance. If empty, defaults to REGIONAL for primary instances. For read pools, availability_type is always UNSPECIFIED. Instances in the read pools are evenly distributed across available zones within the region (i.e. read pools with more than one node will have a node in at least two zones).
*/
availabilityType?: string | null;
/**
* Optional. Client connection specific configurations
*/
clientConnectionConfig?: Schema$ClientConnectionConfig;
/**
* Optional. The configuration for Managed Connection Pool (MCP).
*/
connectionPoolConfig?: Schema$ConnectionPoolConfig;
/**
* Output only. Create time stamp
*/
createTime?: string | null;
/**
* Optional. Controls whether the Data API is enabled for this instance. When enabled, this allows authorized users to connect to the instance from the public internet using the `executeSql` API, even for private IP instances. If this is not specified, the data API is enabled by default for Google internal services like AlloyDB Studio. Disable it explicitly to disallow Google internal services as well.
*/
dataApiAccess?: string | null;
/**
* Database flags. Set at the instance level. They are copied from the primary instance on secondary instance creation. Flags that have restrictions default to the value at primary instance on read instances during creation. Read instances can set new flags or override existing flags that are relevant for reads, for example, for enabling columnar cache on a read instance. Flags set on read instance might or might not be present on the primary instance. This is a list of "key": "value" pairs. "key": The name of the flag. These flags are passed at instance setup time, so include both server options and system variables for Postgres. Flags are specified with underscores, not hyphens. "value": The value of the flag. Booleans are set to **on** for true and **off** for false. This field must be omitted if the flag doesn't take a value.
*/
databaseFlags?: {
[key: string]: string;
} | null;
/**
* Output only. Delete time stamp
*/
deleteTime?: string | null;
/**
* User-settable and human-readable display name for the Instance.
*/
displayName?: string | null;
/**
* For Resource freshness validation (https://google.aip.dev/154)
*/
etag?: string | null;
/**
* The Compute Engine zone that the instance should serve from, per https://cloud.google.com/compute/docs/regions-zones This can ONLY be specified for ZONAL instances. If present for a REGIONAL instance, an error will be thrown. If this is absent for a ZONAL instance, instance is created in a random zone with available capacity.
*/
gceZone?: string | null;
/**
* Required. The type of the instance. Specified at creation time.
*/
instanceType?: string | null;
/**
* Output only. The IP address for the Instance. This is the connection endpoint for an end-user application.
*/
ipAddress?: string | null;
/**
* Labels as key value pairs
*/
labels?: {
[key: string]: string;
} | null;
/**
* Configurations for the machines that host the underlying database engine.
*/
machineConfig?: Schema$MachineConfig;
/**
* Output only. Maintenance version of the instance, for example: POSTGRES_15.2025_07_15.04_00. Output only. Update this field via the parent cluster's maintenance_version field(s).
*/
maintenanceVersionName?: string | null;
/**
* Output only. The name of the instance resource with the format: * projects/{project\}/locations/{region\}/clusters/{cluster_id\}/instances/{instance_id\} where the cluster and instance ID segments should satisfy the regex expression `[a-z]([a-z0-9-]{0,61\}[a-z0-9])?`, e.g. 1-63 characters of lowercase letters, numbers, and dashes, starting with a letter, and ending with a letter or number. For more details see https://google.aip.dev/122. The prefix of the instance resource name is the name of the parent resource: * projects/{project\}/locations/{region\}/clusters/{cluster_id\}
*/
name?: string | null;
/**
* Optional. Instance-level network configuration.
*/
networkConfig?: Schema$InstanceNetworkConfig;
/**
* Output only. List of available read-only VMs in this instance, including the standby for a PRIMARY instance.
*/
nodes?: Schema$Node[];
/**
* Configuration for observability.
*/
observabilityConfig?: Schema$ObservabilityInstanceConfig;
/**
* Output only. All outbound public IP addresses configured for the instance.
*/
outboundPublicIpAddresses?: string[] | null;
/**
* Optional. The configuration for Private Service Connect (PSC) for the instance.
*/
pscInstanceConfig?: Schema$PscInstanceConfig;
/**
* Output only. The public IP addresses for the Instance. This is available ONLY when enable_public_ip is set. This is the connection endpoint for an end-user application.
*/
publicIpAddress?: string | null;
/**
* Configuration for query insights.
*/
queryInsightsConfig?: Schema$QueryInsightsInstanceConfig;
/**
* Read pool instance configuration. This is required if the value of instanceType is READ_POOL.
*/
readPoolConfig?: Schema$ReadPoolConfig;
/**
* Output only. Reconciling (https://google.aip.dev/128#reconciliation). Set to true if the current state of Instance does not match the user's intended state, and the service is actively updating the resource to reconcile them. This can happen due to user-triggered updates or system actions like failover or maintenance.
*/
reconciling?: boolean | null;
/**
* Output only. Reserved for future use.
*/
satisfiesPzs?: boolean | null;
/**
* Output only. The curre