googleapis
Version:
Google APIs Client Library for Node.js
1,048 lines • 346 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_v1beta {
export interface Options extends GlobalOptions {
version: 'v1beta';
}
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('v1beta');
* ```
*/
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;
}
/**
* Configuration for autoscaling.
*/
export interface Schema$AutoScalingConfig {
/**
* Policy for the MIG autoscaler.
*/
policy?: Schema$Policy;
/**
* Optional list of schedules for the MIG autoscaler. If not set, no schedules are created.
*/
schedules?: Schema$Schedule[];
}
/**
* 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;
/**
* Output only. Set to true if the cluster corresponding to this backup is deleted. This field is only populated for when using the BACKUP_VIEW_CLUSTER_DELETED view.
*/
clusterDeleted?: boolean | 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;
}
/**
* 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;
/**
* Optional. Deprecated and unused. This field will be removed in the near future.
*/
geminiConfig?: Schema$GeminiClusterConfig;
/**
* 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;
/**
* Output only. AlloyDB per-cluster service account. This service account is created per-cluster per-project, and is different from the per-project service account. The per-cluster service account naming format is subject to change.
*/
serviceAccountEmail?: string | null;
/**
* 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 pem-encoded chain that may be used to verify the X.509 certificate. Expected to be in issuer-to-root order according to RFC 5246.
*/
pemCertificateChain?: string[] | null;
/**
* Output only. The DNS name to use with PSC for the Instance.
*/
pscDnsName?: 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. Deprecated. Use 'flags' instead. The default pool size. Defaults to 20. Note: This field should not be added to client libraries if not present already.
*/
defaultPoolSize?: string | null;
/**
* Optional. Deprecated; Prefer 'enabled' as this will be removed soon.
*/
enable?: boolean | null;
/**
* 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;
/**
* Optional. Deprecated. Use 'flags' instead. The list of startup parameters to ignore. Defaults to ["extra_float_digits"] Note: This field should not be added to client libraries if not present already.
*/
ignoreStartupParameters?: string[] | null;
/**
* Optional. Deprecated. Use 'flags' instead. The maximum number of client connections allowed. Note: This field should not be added to client libraries if not present already.
*/
maxClientConn?: string | null;
/**
* Optional. Deprecated. Use 'flags' instead. The maximum number of prepared statements allowed. MCP makes sure that any statement prepared by a client, up to this limit, is available on the backing server connection in transaction and statement pooling mode. Even if the statement was originally prepared on another server connection. Defaults to 0. Note: This field should not be added to client libraries if not present already.
*/
maxPreparedStatements?: string | null;
/**
* Optional. Deprecated. Use 'flags' instead. The minimum pool size. Defaults to 0. Note: This field should not be added to client libraries if not present already.
*/
minPoolSize?: string | null;
/**
* Output only. The number of running poolers per instance.
*/
poolerCount?: number | null;
/**
* Optional. Deprecated. Use 'flags' instead. The pool mode. Defaults to `POOL_MODE_TRANSACTION`. Note: This field should not be added to client libraries if not present already.
*/
poolMode?: string | null;
/**
* Optional. Deprecated. Use 'flags' instead. The maximum number of seconds queries are allowed to spend waiting for execution. If the query is not assigned to a server during that time, the client is disconnected. 0 disables. Note: This field should not be added to client libraries if not present already.
*/
queryWaitTimeout?: string | null;
/**
* Optional. Deprecated. Use 'flags' instead. The maximum number of seconds a server is allowed to be idle before it is disconnected. 0 disables. Note: This field should not be added to client libraries if not present already.
*/
serverIdleTimeout?: string | null;
/**
* Optional. Deprecated. Use 'flags' instead. The list of users that are allowed to connect to the MCP stats console. The users must exist in the database. Note: This field should not be added to client libraries if not present already.
*/
statsUsers?: string[] | 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;
}
/**
* CPU utilization policy for the autoscaler.
*/
export interface Schema$CpuUtilization {
/**
* Target CPU utilization as a float between 0 and 1.
*/
utilizationTarget?: number | 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;
}
/**
* 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;
}
/**
* Instance level configuration parameters related to the Gemini Cloud Assist product.
*/
export interface Schema$GCAInstanceConfig {
/**
* Output only. Represents the GCA entitlement state of the instance.
*/
gcaEntitlement?: string | 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;
}
/**
* Deprecated and unused. This message will be removed in the near future.
*/
export interface Schema$GeminiClusterConfig {
/**
* Output only. Deprecated and unused. This field will be removed in the near future.
*/
entitled?: boolean | null;
}
/**
* Deprecated and unused. This message will be removed in the near future.
*/
export interface Schema$GeminiInstanceConfig {
/**
* Output only. Deprecated and unused. This field will be removed in the near future.
*/
entitled?: boolean | 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;
}
/**
* 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.