@googleapis/spanner 7.1.0 → 7.4.0

package/build/v1.d.ts

@@ -73,7 +73,7 @@ export declare namespace spanner_v1 {
         constructor(options: GlobalOptions, google?: GoogleConfigurable);
     }
     /**
-     * Autoscaling config for an instance.
+     * Autoscaling configuration for an instance.
      */
     export interface Schema$AutoscalingConfig {
         /**
@@ -123,6 +123,10 @@ export declare namespace spanner_v1 {
      * A backup of a Cloud Spanner database.
      */
     export interface Schema$Backup {
+        /**
+         * Output only. List of backup schedule URIs that are associated with creating this backup. This is only applicable for scheduled backups, and is empty for on-demand backups. To optimize for storage, whenever possible, multiple schedules are collapsed together to create one backup. In such cases, this field captures the list of all backup schedule URIs that are associated with creating this backup. If collapsing is not done, then this field captures the single backup schedule URI associated with creating this backup.
+         */
+        backupSchedules?: string[] | null;
         /**
          * Output only. The time the CreateBackup request is received. If the request does not specify `version_time`, the `version_time` of the backup will be equivalent to the `create_time`.
          */
@@ -143,10 +147,22 @@ export declare namespace spanner_v1 {
          * Output only. The encryption information for the backup, whether it is protected by one or more KMS keys. The information includes all Cloud KMS key versions used to encrypt the backup. The `encryption_status' field inside of each `EncryptionInfo` is not populated. At least one of the key versions must be available for the backup to be restored. If a key version is revoked in the middle of a restore, the restore behavior is undefined.
          */
         encryptionInformation?: Schema$EncryptionInfo[];
+        /**
+         * Output only. For a backup in an incremental backup chain, this is the storage space needed to keep the data that has changed since the previous backup. For all other backups, this is always the size of the backup. This value may change if backups on the same chain get deleted or expired. This field can be used to calculate the total storage space used by a set of backups. For example, the total space used by all backups of a database can be computed by summing up this field.
+         */
+        exclusiveSizeBytes?: string | null;
         /**
          * Required for the CreateBackup operation. The expiration time of the backup, with microseconds granularity that must be at least 6 hours and at most 366 days from the time the CreateBackup request is processed. Once the `expire_time` has passed, the backup is eligible to be automatically deleted by Cloud Spanner to free the resources used by the backup.
          */
         expireTime?: string | null;
+        /**
+         * Output only. The number of bytes that will be freed by deleting this backup. This value will be zero if, for example, this backup is part of an incremental backup chain and younger backups in the chain require that we keep its data. For backups not in an incremental backup chain, this is always the size of the backup. This value may change if backups on the same chain get created, deleted or expired.
+         */
+        freeableSizeBytes?: string | null;
+        /**
+         * Output only. Populated only for backups in an incremental backup chain. Backups share the same chain id if and only if they belong to the same incremental backup chain. Use this field to determine which backups are part of the same incremental backup chain. The ordering of backups in the chain can be determined by ordering the backup `version_time`.
+         */
+        incrementalBackupChainId?: string | null;
         /**
          * Output only. The max allowed expiration time of the backup, with microseconds granularity. A backup's expiration time can be configured in multiple APIs: CreateBackup, UpdateBackup, CopyBackup. When updating or copying an existing backup, the expiration time specified must be less than `Backup.max_expire_time`.
          */
@@ -155,6 +171,10 @@ export declare namespace spanner_v1 {
          * Output only for the CreateBackup operation. Required for the UpdateBackup operation. A globally unique identifier for the backup which cannot be changed. Values are of the form `projects//instances//backups/a-z*[a-z0-9]` The final segment of the name must be between 2 and 60 characters in length. The backup is stored in the location(s) specified in the instance configuration of the instance containing the backup, identified by the prefix of the backup name of the form `projects//instances/`.
          */
         name?: string | null;
+        /**
+         * Output only. Data deleted at a time older than this is guaranteed not to be retained in order to support this backup. For a backup in an incremental backup chain, this is the version time of the oldest backup that exists or ever existed in the chain. For all other backups, this is the version time of the backup. This field can be used to understand what data is being retained by the backup system.
+         */
+        oldestVersionTime?: string | null;
         /**
          * Output only. The names of the destination backups being created by copying this source backup. The backup names are of the form `projects//instances//backups/`. Referencing backups may exist in different instances. The existence of any referencing backup prevents the backup from being deleted. When the copy operation is done (either successfully completed or cancelled or the destination backup is deleted), the reference to the backup is removed.
          */
@@ -164,7 +184,7 @@ export declare namespace spanner_v1 {
          */
         referencingDatabases?: string[] | null;
         /**
-         * Output only. Size of the backup in bytes.
+         * Output only. Size of the backup in bytes. For a backup in an incremental backup chain, this is the sum of the `exclusive_size_bytes` of itself and all older backups in the chain.
          */
         sizeBytes?: string | null;
         /**
@@ -197,6 +217,48 @@ export declare namespace spanner_v1 {
          */
         versionTime?: string | null;
     }
+    /**
+     * BackupSchedule expresses the automated backup creation specification for a Spanner database. Next ID: 10
+     */
+    export interface Schema$BackupSchedule {
+        /**
+         * Optional. The encryption configuration that will be used to encrypt the backup. If this field is not specified, the backup will use the same encryption configuration as the database.
+         */
+        encryptionConfig?: Schema$CreateBackupEncryptionConfig;
+        /**
+         * The schedule creates only full backups.
+         */
+        fullBackupSpec?: Schema$FullBackupSpec;
+        /**
+         * The schedule creates incremental backup chains.
+         */
+        incrementalBackupSpec?: Schema$IncrementalBackupSpec;
+        /**
+         * Identifier. Output only for the CreateBackupSchedule operation. Required for the UpdateBackupSchedule operation. A globally unique identifier for the backup schedule which cannot be changed. Values are of the form `projects//instances//databases//backupSchedules/a-z*[a-z0-9]` The final segment of the name must be between 2 and 60 characters in length.
+         */
+        name?: string | null;
+        /**
+         * Optional. The retention duration of a backup that must be at least 6 hours and at most 366 days. The backup is eligible to be automatically deleted once the retention period has elapsed.
+         */
+        retentionDuration?: string | null;
+        /**
+         * Optional. The schedule specification based on which the backup creations are triggered.
+         */
+        spec?: Schema$BackupScheduleSpec;
+        /**
+         * Output only. The timestamp at which the schedule was last updated. If the schedule has never been updated, this field contains the timestamp when the schedule was first created.
+         */
+        updateTime?: string | null;
+    }
+    /**
+     * Defines specifications of the backup schedule.
+     */
+    export interface Schema$BackupScheduleSpec {
+        /**
+         * Cron style schedule specification.
+         */
+        cronSpec?: Schema$CrontabSpec;
+    }
     /**
      * The request for BatchCreateSessions.
      */
@@ -283,6 +345,40 @@ export declare namespace spanner_v1 {
          */
         role?: string | null;
     }
+    /**
+     * Metadata type for the long-running operation returned by ChangeQuorum.
+     */
+    export interface Schema$ChangeQuorumMetadata {
+        /**
+         * If set, the time at which this operation failed or was completed successfully.
+         */
+        endTime?: string | null;
+        /**
+         * The request for ChangeQuorum.
+         */
+        request?: Schema$ChangeQuorumRequest;
+        /**
+         * Time the request was received.
+         */
+        startTime?: string | null;
+    }
+    /**
+     * The request for ChangeQuorum.
+     */
+    export interface Schema$ChangeQuorumRequest {
+        /**
+         * Optional. The etag is the hash of the `QuorumInfo`. The `ChangeQuorum` operation is only performed if the etag matches that of the `QuorumInfo` in the current database resource. Otherwise the API returns an `ABORTED` error. The etag is used for optimistic concurrency control as a way to help prevent simultaneous change quorum requests that could create a race condition.
+         */
+        etag?: string | null;
+        /**
+         * Required. Name of the database in which to apply `ChangeQuorum`. Values are of the form `projects//instances//databases/`.
+         */
+        name?: string | null;
+        /**
+         * Required. The type of this quorum.
+         */
+        quorumType?: Schema$QuorumType;
+    }
     /**
      * Metadata associated with a parent-child relationship appearing in a PlanNode.
      */
@@ -431,6 +527,23 @@ export declare namespace spanner_v1 {
          */
         sourceBackup?: string | null;
     }
+    /**
+     * Encryption configuration for the backup to create.
+     */
+    export interface Schema$CreateBackupEncryptionConfig {
+        /**
+         * Required. The encryption type of the backup.
+         */
+        encryptionType?: string | null;
+        /**
+         * Optional. The Cloud KMS key that will be used to protect the backup. This field should be set only when encryption_type is `CUSTOMER_MANAGED_ENCRYPTION`. Values are of the form `projects//locations//keyRings//cryptoKeys/`.
+         */
+        kmsKeyName?: string | null;
+        /**
+         * Optional. Specifies the KMS configuration for the one or more keys used to protect the backup. Values are of the form `projects//locations//keyRings//cryptoKeys/`. The keys referenced by kms_key_names must fully cover all regions of the backup's instance configuration. Some examples: * For single region instance configs, specify a single regional location KMS key. * For multi-regional instance configs of type GOOGLE_MANAGED, either specify a multi-regional location KMS key or multiple regional location KMS keys that cover all regions in the instance config. * For an instance config of type USER_MANAGED, please specify only regional location KMS keys to cover each region in the instance config. Multi-regional location KMS keys are not supported for USER_MANAGED instance configs.
+         */
+        kmsKeyNames?: string[] | null;
+    }
     /**
      * Metadata type for the operation returned by CreateBackup.
      */
@@ -482,7 +595,7 @@ export declare namespace spanner_v1 {
          */
         extraStatements?: string[] | null;
         /**
-         * Optional. Proto descriptors used by CREATE/ALTER PROTO BUNDLE statements in 'extra_statements' above. Contains a protobuf-serialized [google.protobuf.FileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). To generate it, [install](https://grpc.io/docs/protoc-installation/) and run `protoc` with --include_imports and --descriptor_set_out. For example, to generate for moon/shot/app.proto, run ``` $protoc --proto_path=/app_path --proto_path=/lib_path \ --include_imports \ --descriptor_set_out=descriptors.data \ moon/shot/app.proto ``` For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).
+         * Optional. Proto descriptors used by `CREATE/ALTER PROTO BUNDLE` statements in 'extra_statements'. Contains a protobuf-serialized [`google.protobuf.FileDescriptorSet`](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto) descriptor set. To generate it, [install](https://grpc.io/docs/protoc-installation/) and run `protoc` with --include_imports and --descriptor_set_out. For example, to generate for moon/shot/app.proto, run ``` $protoc --proto_path=/app_path --proto_path=/lib_path \ --include_imports \ --descriptor_set_out=descriptors.data \ moon/shot/app.proto ``` For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).
          */
         protoDescriptors?: string | null;
     }
@@ -495,7 +608,7 @@ export declare namespace spanner_v1 {
          */
         cancelTime?: string | null;
         /**
-         * The target instance config end state.
+         * The target instance configuration end state.
          */
         instanceConfig?: Schema$InstanceConfig;
         /**
@@ -508,11 +621,11 @@ export declare namespace spanner_v1 {
      */
     export interface Schema$CreateInstanceConfigRequest {
         /**
-         * Required. The InstanceConfig proto of the configuration to create. instance_config.name must be `/instanceConfigs/`. instance_config.base_config must be a Google managed configuration name, e.g. /instanceConfigs/us-east1, /instanceConfigs/nam3.
+         * Required. The `InstanceConfig` proto of the configuration to create. `instance_config.name` must be `/instanceConfigs/`. `instance_config.base_config` must be a Google-managed configuration name, e.g. /instanceConfigs/us-east1, /instanceConfigs/nam3.
          */
         instanceConfig?: Schema$InstanceConfig;
         /**
-         * Required. The ID of the instance config to create. Valid identifiers are of the form `custom-[-a-z0-9]*[a-z0-9]` and must be between 2 and 64 characters in length. The `custom-` prefix is required to avoid name conflicts with Google managed configurations.
+         * Required. The ID of the instance configuration to create. Valid identifiers are of the form `custom-[-a-z0-9]*[a-z0-9]` and must be between 2 and 64 characters in length. The `custom-` prefix is required to avoid name conflicts with Google-managed configurations.
          */
         instanceConfigId?: string | null;
         /**
@@ -601,6 +714,23 @@ export declare namespace spanner_v1 {
          */
         session?: Schema$Session;
     }
+    /**
+     * CrontabSpec can be used to specify the version time and frequency at which the backup should be created.
+     */
+    export interface Schema$CrontabSpec {
+        /**
+         * Output only. Schedule backups will contain an externally consistent copy of the database at the version time specified in `schedule_spec.cron_spec`. However, Spanner may not initiate the creation of the scheduled backups at that version time. Spanner will initiate the creation of scheduled backups within the time window bounded by the version_time specified in `schedule_spec.cron_spec` and version_time + `creation_window`.
+         */
+        creationWindow?: string | null;
+        /**
+         * Required. Textual representation of the crontab. User can customize the backup frequency and the backup version time using the cron expression. The version time must be in UTC timzeone. The backup will contain an externally consistent copy of the database at the version time. Allowed frequencies are 12 hour, 1 day, 1 week and 1 month. Examples of valid cron specifications: * `0 2/12 * * * ` : every 12 hours at (2, 14) hours past midnight in UTC. * `0 2,14 * * * ` : every 12 hours at (2,14) hours past midnight in UTC. * `0 2 * * * ` : once a day at 2 past midnight in UTC. * `0 2 * * 0 ` : once a week every Sunday at 2 past midnight in UTC. * `0 2 8 * * ` : once a month on 8th day at 2 past midnight in UTC.
+         */
+        text?: string | null;
+        /**
+         * Output only. The time zone of the times in `CrontabSpec.text`. Currently only UTC is supported.
+         */
+        timeZone?: string | null;
+    }
     /**
      * A Cloud Spanner database.
      */
@@ -622,7 +752,7 @@ export declare namespace spanner_v1 {
          */
         earliestVersionTime?: string | null;
         /**
-         * Whether drop protection is enabled for this database. Defaults to false, if not set. For more details, please see how to [prevent accidental database deletion](https://cloud.google.com/spanner/docs/prevent-database-deletion).
+         * Optional. Whether drop protection is enabled for this database. Defaults to false, if not set. For more details, please see how to [prevent accidental database deletion](https://cloud.google.com/spanner/docs/prevent-database-deletion).
          */
         enableDropProtection?: boolean | null;
         /**
@@ -637,6 +767,10 @@ export declare namespace spanner_v1 {
          * Required. The name of the database. Values are of the form `projects//instances//databases/`, where `` is as specified in the `CREATE DATABASE` statement. This name can be passed to other API methods to identify the database.
          */
         name?: string | null;
+        /**
+         * Output only. Applicable only for databases that use dual-region instance configurations. Contains information about the quorum.
+         */
+        quorumInfo?: Schema$QuorumInfo;
         /**
          * Output only. If true, the database is being updated. If false, there are no ongoing update operations for the database.
          */
@@ -744,6 +878,11 @@ export declare namespace spanner_v1 {
          */
         includeReplicas?: Schema$IncludeReplicas;
     }
+    /**
+     * Message type for a dual-region quorum. Currently this type has no options.
+     */
+    export interface Schema$DualRegionQuorum {
+    }
     /**
      * 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); \}
      */
@@ -930,6 +1069,11 @@ export declare namespace spanner_v1 {
          */
         upgradeTime?: string | null;
     }
+    /**
+     * The specification for full backups. A full backup stores the entire contents of the database at a given version time.
+     */
+    export interface Schema$FullBackupSpec {
+    }
     /**
      * The response for GetDatabaseDdl.
      */
@@ -974,6 +1118,11 @@ export declare namespace spanner_v1 {
          */
         replicaSelections?: Schema$ReplicaSelection[];
     }
+    /**
+     * The specification for incremental backup chains. An incremental backup stores the delta of changes between a previous backup and the database contents at a given version time. An incremental backup chain consists of a full backup and zero or more successive incremental backups. The first backup created for an incremental backup chain is always a full backup.
+     */
+    export interface Schema$IncrementalBackupSpec {
+    }
     /**
      * Recommendation to add new indexes to run queries more efficiently.
      */
@@ -1029,6 +1178,10 @@ export declare namespace spanner_v1 {
          * Required. The descriptive name for this instance as it appears in UIs. Must be unique per project and between 4 and 30 characters in length.
          */
         displayName?: string | null;
+        /**
+         * Optional. The `Edition` of the current instance.
+         */
+        edition?: string | null;
         /**
          * Deprecated. This field is not populated.
          */
@@ -1052,11 +1205,11 @@ export declare namespace spanner_v1 {
          */
         name?: string | null;
         /**
-         * The number of nodes allocated to this instance. At most one of either node_count or processing_units should be present in the message. Users can set the node_count field to specify the target number of nodes allocated to the instance. This may be zero in API responses for instances that are not yet in state `READY`. See [the documentation](https://cloud.google.com/spanner/docs/compute-capacity) for more information about nodes and processing units.
+         * The number of nodes allocated to this instance. At most, one of either `node_count` or `processing_units` should be present in the message. Users can set the `node_count` field to specify the target number of nodes allocated to the instance. If autoscaling is enabled, `node_count` is treated as an `OUTPUT_ONLY` field and reflects the current number of nodes allocated to the instance. This might be zero in API responses for instances that are not yet in the `READY` state. For more information, see [Compute capacity, nodes, and processing units](https://cloud.google.com/spanner/docs/compute-capacity).
          */
         nodeCount?: number | null;
         /**
-         * The number of processing units allocated to this instance. At most one of processing_units or node_count should be present in the message. Users can set the processing_units field to specify the target number of processing units allocated to the instance. This may be zero in API responses for instances that are not yet in state `READY`. See [the documentation](https://cloud.google.com/spanner/docs/compute-capacity) for more information about nodes and processing units.
+         * The number of processing units allocated to this instance. At most, one of either `processing_units` or `node_count` should be present in the message. Users can set the `processing_units` field to specify the target number of processing units allocated to the instance. If autoscaling is enabled, `processing_units` is treated as an `OUTPUT_ONLY` field and reflects the current number of processing units allocated to the instance. This might be zero in API responses for instances that are not yet in the `READY` state. For more information, see [Compute capacity, nodes and processing units](https://cloud.google.com/spanner/docs/compute-capacity).
          */
         processingUnits?: number | null;
         /**
@@ -1073,11 +1226,11 @@ export declare namespace spanner_v1 {
      */
     export interface Schema$InstanceConfig {
         /**
-         * Base configuration name, e.g. projects//instanceConfigs/nam3, based on which this configuration is created. Only set for user managed configurations. `base_config` must refer to a configuration of type GOOGLE_MANAGED in the same project as this configuration.
+         * Base configuration name, e.g. projects//instanceConfigs/nam3, based on which this configuration is created. Only set for user-managed configurations. `base_config` must refer to a configuration of type `GOOGLE_MANAGED` in the same project as this configuration.
          */
         baseConfig?: string | null;
         /**
-         * Output only. Whether this instance config is a Google or User Managed Configuration.
+         * Output only. Whether this instance configuration is a Google-managed or user-managed configuration.
          */
         configType?: string | null;
         /**
@@ -1085,11 +1238,11 @@ export declare namespace spanner_v1 {
          */
         displayName?: string | null;
         /**
-         * etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a instance config from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform instance config updates in order to avoid race conditions: An etag is returned in the response which contains instance configs, and systems are expected to put that etag in the request to update instance config to ensure that their change will be applied to the same version of the instance config. If no etag is provided in the call to update instance config, then the existing instance config is overwritten blindly.
+         * etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a instance configuration from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform instance configuration updates in order to avoid race conditions: An etag is returned in the response which contains instance configurations, and systems are expected to put that etag in the request to update instance configuration to ensure that their change is applied to the same version of the instance configuration. If no etag is provided in the call to update the instance configuration, then the existing instance configuration is overwritten blindly.
          */
         etag?: string | null;
         /**
-         * Output only. Describes whether free instances are available to be created in this instance config.
+         * Output only. Describes whether free instances are available to be created in this instance configuration.
          */
         freeInstanceAvailability?: string | null;
         /**
@@ -1103,23 +1256,27 @@ export declare namespace spanner_v1 {
          */
         leaderOptions?: string[] | null;
         /**
-         * A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`.
+         * A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`. User instance configuration must start with `custom-`.
          */
         name?: string | null;
         /**
-         * Output only. The available optional replicas to choose from for user managed configurations. Populated for Google managed configurations.
+         * Output only. The available optional replicas to choose from for user-managed configurations. Populated for Google-managed configurations.
          */
         optionalReplicas?: Schema$ReplicaInfo[];
         /**
-         * Output only. If true, the instance config is being created or updated. If false, there are no ongoing operations for the instance config.
+         * Output only. The `QuorumType` of the instance configuration.
+         */
+        quorumType?: string | null;
+        /**
+         * Output only. If true, the instance configuration is being created or updated. If false, there are no ongoing operations for the instance configuration.
          */
         reconciling?: boolean | null;
         /**
-         * The geographic placement of nodes in this instance configuration and their replication properties.
+         * The geographic placement of nodes in this instance configuration and their replication properties. To create user-managed configurations, input `replicas` must include all replicas in `replicas` of the `base_config` and include one or more replicas in the `optional_replicas` of the `base_config`.
          */
         replicas?: Schema$ReplicaInfo[];
         /**
-         * Output only. The current instance config state. Applicable only for USER_MANAGED configs.
+         * Output only. The current instance configuration state. Applicable only for `USER_MANAGED` configurations.
          */
         state?: string | null;
         /**
@@ -1169,15 +1326,15 @@ export declare namespace spanner_v1 {
          */
         name?: string | null;
         /**
-         * The number of nodes allocated to this instance partition. Users can set the node_count field to specify the target number of nodes allocated to the instance partition. This may be zero in API responses for instance partitions that are not yet in state `READY`.
+         * The number of nodes allocated to this instance partition. Users can set the `node_count` field to specify the target number of nodes allocated to the instance partition. This may be zero in API responses for instance partitions that are not yet in state `READY`.
          */
         nodeCount?: number | null;
         /**
-         * The number of processing units allocated to this instance partition. Users can set the processing_units field to specify the target number of processing units allocated to the instance partition. This may be zero in API responses for instance partitions that are not yet in state `READY`.
+         * The number of processing units allocated to this instance partition. Users can set the `processing_units` field to specify the target number of processing units allocated to the instance partition. This might be zero in API responses for instance partitions that are not yet in the `READY` state.
          */
         processingUnits?: number | null;
         /**
-         * Output only. The names of the backups that reference this instance partition. Referencing backups should share the parent instance. The existence of any referencing backup prevents the instance partition from being deleted.
+         * Output only. Deprecated: This field is not populated. Output only. The names of the backups that reference this instance partition. Referencing backups should share the parent instance. The existence of any referencing backup prevents the instance partition from being deleted.
          */
         referencingBackups?: string[] | null;
         /**
@@ -1298,6 +1455,19 @@ export declare namespace spanner_v1 {
          */
         operations?: Schema$Operation[];
     }
+    /**
+     * The response for ListBackupSchedules.
+     */
+    export interface Schema$ListBackupSchedulesResponse {
+        /**
+         * The list of backup schedules for a database.
+         */
+        backupSchedules?: Schema$BackupSchedule[];
+        /**
+         * `next_page_token` can be sent in a subsequent ListBackupSchedules call to fetch more of the schedules.
+         */
+        nextPageToken?: string | null;
+    }
     /**
      * The response for ListBackups.
      */
@@ -1359,7 +1529,7 @@ export declare namespace spanner_v1 {
          */
         nextPageToken?: string | null;
         /**
-         * The list of matching instance config long-running operations. Each operation's name will be prefixed by the instance config's name. The operation's metadata field type `metadata.type_url` describes the type of the metadata.
+         * The list of matching instance configuration long-running operations. Each operation's name will be prefixed by the name of the instance configuration. The operation's metadata field type `metadata.type_url` describes the type of the metadata.
          */
         operations?: Schema$Operation[];
     }
@@ -1406,7 +1576,7 @@ export declare namespace spanner_v1 {
          */
         nextPageToken?: string | null;
         /**
-         * The list of unreachable instance partitions. It includes the names of instance partitions whose metadata could not be retrieved within instance_partition_deadline.
+         * The list of unreachable instances or instance partitions. It includes the names of instances or instance partitions whose metadata could not be retrieved within instance_partition_deadline.
          */
         unreachable?: string[] | null;
     }
@@ -1565,7 +1735,7 @@ export declare namespace spanner_v1 {
      */
     export interface Schema$MoveInstanceRequest {
         /**
-         * Required. The target instance config for the instance to move. Values are of the form `projects//instanceConfigs/`.
+         * Required. The target instance configuration where to move the instance. Values are of the form `projects//instanceConfigs/`.
          */
         targetConfig?: string | null;
     }
@@ -1735,7 +1905,7 @@ export declare namespace spanner_v1 {
          */
         partitionOptions?: Schema$PartitionOptions;
         /**
-         * Required. The query request to generate partitions for. The request will fail if the query is not root partitionable. For a query to be root partitionable, it needs to satisfy a few conditions. For example, if the query execution plan contains a distributed union operator, then it must be the first operator in the plan. For more information about other conditions, see [Read data in parallel](https://cloud.google.com/spanner/docs/reads#read_data_in_parallel). The query request must not contain DML commands, such as INSERT, UPDATE, or DELETE. Use ExecuteStreamingSql with a PartitionedDml transaction for large, partition-friendly DML operations.
+         * Required. The query request to generate partitions for. The request fails if the query is not root partitionable. For a query to be root partitionable, it needs to satisfy a few conditions. For example, if the query execution plan contains a distributed union operator, then it must be the first operator in the plan. For more information about other conditions, see [Read data in parallel](https://cloud.google.com/spanner/docs/reads#read_data_in_parallel). The query request must not contain DML commands, such as `INSERT`, `UPDATE`, or `DELETE`. Use `ExecuteStreamingSql` with a PartitionedDml transaction for large, partition-friendly DML operations.
          */
         sql?: string | null;
         /**
@@ -1899,6 +2069,40 @@ export declare namespace spanner_v1 {
          */
         queryAdvice?: Schema$QueryAdvisorResult;
     }
+    /**
+     * Information about the dual-region quorum.
+     */
+    export interface Schema$QuorumInfo {
+        /**
+         * Output only. The etag is used for optimistic concurrency control as a way to help prevent simultaneous `ChangeQuorum` requests that might create a race condition.
+         */
+        etag?: string | null;
+        /**
+         * Output only. Whether this `ChangeQuorum` is Google or User initiated.
+         */
+        initiator?: string | null;
+        /**
+         * Output only. The type of this quorum. See QuorumType for more information about quorum type specifications.
+         */
+        quorumType?: Schema$QuorumType;
+        /**
+         * Output only. The timestamp when the request was triggered.
+         */
+        startTime?: string | null;
+    }
+    /**
+     * Information about the database quorum type. This only applies to dual-region instance configs.
+     */
+    export interface Schema$QuorumType {
+        /**
+         * Dual-region quorum type.
+         */
+        dualRegion?: Schema$DualRegionQuorum;
+        /**
+         * Single-region quorum type.
+         */
+        singleRegion?: Schema$SingleRegionQuorum;
+    }
     /**
      * Message type to initiate a read-only transaction.
      */
@@ -1956,6 +2160,14 @@ export declare namespace spanner_v1 {
          * If greater than zero, only the first `limit` rows are yielded. If `limit` is zero, the default is no limit. A limit cannot be specified if `partition_token` is set.
          */
         limit?: string | null;
+        /**
+         * Optional. Lock Hint for the request, it can only be used with read-write transactions.
+         */
+        lockHint?: string | null;
+        /**
+         * Optional. Order for the returned rows. By default, Spanner will return result rows in primary key order except for PartitionRead requests. For applications that do not require rows to be returned in primary key (`ORDER_BY_PRIMARY_KEY`) order, setting `ORDER_BY_NO_ORDER` option allows Spanner to optimize row retrieval, resulting in lower latencies in certain cases (e.g. bulk point lookups).
+         */
+        orderBy?: string | null;
         /**
          * If present, results will be restricted to the specified partition previously created using PartitionRead(). There must be an exact match for the values of fields common to this message and the PartitionReadRequest message used to create this partition_token.
          */
@@ -2043,7 +2255,7 @@ export declare namespace spanner_v1 {
          */
         kmsKeyName?: string | null;
         /**
-         * Optional. Specifies the KMS configuration for the one or more keys used to encrypt the database. Values are of the form `projects//locations//keyRings//cryptoKeys/`. The keys referenced by kms_key_names must fully cover all regions of the database instance configuration. Some examples: * For single region database instance configs, specify a single regional location KMS key. * For multi-regional database instance configs of type GOOGLE_MANAGED, either specify a multi-regional location KMS key or multiple regional location KMS keys that cover all regions in the instance config. * For a database instance config of type USER_MANAGED, please specify only regional location KMS keys to cover each region in the instance config. Multi-regional location KMS keys are not supported for USER_MANAGED instance configs.
+         * Optional. Specifies the KMS configuration for the one or more keys used to encrypt the database. Values have the form `projects//locations//keyRings//cryptoKeys/`. The keys referenced by kms_key_names must fully cover all regions of the database instance configuration. Some examples: * For single region database instance configurations, specify a single regional location KMS key. * For multi-regional database instance configurations of type `GOOGLE_MANAGED`, either specify a multi-regional location KMS key or multiple regional location KMS keys that cover all regions in the instance configuration. * For a database instance configuration of type `USER_MANAGED`, please specify only regional location KMS keys to cover each region in the instance configuration. Multi-regional location KMS keys are not supported for USER_MANAGED instance configurations.
          */
         kmsKeyNames?: string[] | null;
     }
@@ -2239,7 +2451,7 @@ export declare namespace spanner_v1 {
             [key: string]: string;
         } | null;
         /**
-         * Optional. If true, specifies a multiplexed session. A multiplexed session may be used for multiple, concurrent read-only operations but can not be used for read-write transactions, partitioned reads, or partitioned queries. Multiplexed sessions can be created via CreateSession but not via BatchCreateSessions. Multiplexed sessions may not be deleted nor listed.
+         * Optional. If true, specifies a multiplexed session. Use a multiplexed session for multiple, concurrent read-only operations. Don't use them for read-write transactions, partitioned reads, or partitioned queries. Use CreateSession to create multiplexed sessions. Don't use BatchCreateSessions to create a multiplexed session. You can't delete or list multiplexed sessions.
          */
         multiplexed?: boolean | null;
         /**
@@ -2271,6 +2483,15 @@ export declare namespace spanner_v1 {
             [key: string]: number;
         } | null;
     }
+    /**
+     * Message type for a single-region quorum.
+     */
+    export interface Schema$SingleRegionQuorum {
+        /**
+         * Required. The location of the serving region, e.g. "us-central1". The location must be one of the regions within the dual-region instance configuration of your database. The list of valid locations is available using the GetInstanceConfig API. This should only be used if you plan to change quorum to the single-region quorum type.
+         */
+        servingLocation?: string | null;
+    }
     /**
      * A single DML statement.
      */
@@ -2352,7 +2573,7 @@ export declare namespace spanner_v1 {
         readTimestamp?: string | null;
     }
     /**
-     * Transactions: Each session can have at most one active transaction at a time (note that standalone reads and queries use a transaction internally and do count towards the one transaction limit). After the active transaction is completed, the session can immediately be re-used for the next transaction. It is not necessary to create a new session for each transaction. Transaction modes: Cloud Spanner supports three transaction modes: 1. Locking read-write. This type of transaction is the only way to write data into Cloud Spanner. These transactions rely on pessimistic locking and, if necessary, two-phase commit. Locking read-write transactions may abort, requiring the application to retry. 2. Snapshot read-only. Snapshot read-only transactions provide guaranteed consistency across several reads, but do not allow writes. Snapshot read-only transactions can be configured to read at timestamps in the past, or configured to perform a strong read (where Spanner will select a timestamp such that the read is guaranteed to see the effects of all transactions that have committed before the start of the read). Snapshot read-only transactions do not need to be committed. Queries on change streams must be performed with the snapshot read-only transaction mode, specifying a strong read. Please see TransactionOptions.ReadOnly.strong for more details. 3. Partitioned DML. This type of transaction is used to execute a single Partitioned DML statement. Partitioned DML partitions the key space and runs the DML statement over each partition in parallel using separate, internal transactions that commit independently. Partitioned DML transactions do not need to be committed. For transactions that only read, snapshot read-only transactions provide simpler semantics and are almost always faster. In particular, read-only transactions do not take locks, so they do not conflict with read-write transactions. As a consequence of not taking locks, they also do not abort, so retry loops are not needed. Transactions may only read-write data in a single database. They may, however, read-write data in different tables within that database. Locking read-write transactions: Locking transactions may be used to atomically read-modify-write data anywhere in a database. This type of transaction is externally consistent. Clients should attempt to minimize the amount of time a transaction is active. Faster transactions commit with higher probability and cause less contention. Cloud Spanner attempts to keep read locks active as long as the transaction continues to do reads, and the transaction has not been terminated by Commit or Rollback. Long periods of inactivity at the client may cause Cloud Spanner to release a transaction's locks and abort it. Conceptually, a read-write transaction consists of zero or more reads or SQL statements followed by Commit. At any time before Commit, the client can send a Rollback request to abort the transaction. Semantics: Cloud Spanner can commit the transaction if all read locks it acquired are still valid at commit time, and it is able to acquire write locks for all writes. Cloud Spanner can abort the transaction for any reason. If a commit attempt returns `ABORTED`, Cloud Spanner guarantees that the transaction has not modified any user data in Cloud Spanner. Unless the transaction commits, Cloud Spanner makes no guarantees about how long the transaction's locks were held for. It is an error to use Cloud Spanner locks for any sort of mutual exclusion other than between Cloud Spanner transactions themselves. Retrying aborted transactions: When a transaction aborts, the application can choose to retry the whole transaction again. To maximize the chances of successfully committing the retry, the client should execute the retry in the same session as the original attempt. The original session's lock priority increases with each consecutive abort, meaning that each attempt has a slightly better chance of success than the previous. Note that the lock priority is preserved per session (not per transaction). Lock priority is set by the first read or write in the first attempt of a read-write transaction. If the application starts a new session to retry the whole transaction, the transaction loses its original lock priority. Moreover, the lock priority is only preserved if the transaction fails with an `ABORTED` error. Under some circumstances (for example, many transactions attempting to modify the same row(s)), a transaction can abort many times in a short period before successfully committing. Thus, it is not a good idea to cap the number of retries a transaction can attempt; instead, it is better to limit the total amount of time spent retrying. Idle transactions: A transaction is considered idle if it has no outstanding reads or SQL queries and has not started a read or SQL query within the last 10 seconds. Idle transactions can be aborted by Cloud Spanner so that they don't hold on to locks indefinitely. If an idle transaction is aborted, the commit will fail with error `ABORTED`. If this behavior is undesirable, periodically executing a simple SQL query in the transaction (for example, `SELECT 1`) prevents the transaction from becoming idle. Snapshot read-only transactions: Snapshot read-only transactions provides a simpler method than locking read-write transactions for doing several consistent reads. However, this type of transaction does not support writes. Snapshot transactions do not take locks. Instead, they work by choosing a Cloud Spanner timestamp, then executing all reads at that timestamp. Since they do not acquire locks, they do not block concurrent read-write transactions. Unlike locking read-write transactions, snapshot read-only transactions never abort. They can fail if the chosen read timestamp is garbage collected; however, the default garbage collection policy is generous enough that most applications do not need to worry about this in practice. Snapshot read-only transactions do not need to call Commit or Rollback (and in fact are not permitted to do so). To execute a snapshot transaction, the client specifies a timestamp bound, which tells Cloud Spanner how to choose a read timestamp. The types of timestamp bound are: - Strong (the default). - Bounded staleness. - Exact staleness. If the Cloud Spanner database to be read is geographically distributed, stale read-only transactions can execute more quickly than strong or read-write transactions, because they are able to execute far from the leader replica. Each type of timestamp bound is discussed in detail below. Strong: Strong reads are guaranteed to see the effects of all transactions that have committed before the start of the read. Furthermore, all rows yielded by a single read are consistent with each other -- if any part of the read observes a transaction, all parts of the read see the transaction. Strong reads are not repeatable: two consecutive strong read-only transactions might return inconsistent results if there are concurrent writes. If consistency across reads is required, the reads should be executed within a transaction or at an exact read timestamp. Queries on change streams (see below for more details) must also specify the strong read timestamp bound. See TransactionOptions.ReadOnly.strong. Exact staleness: These timestamp bounds execute reads at a user-specified timestamp. Reads at a timestamp are guaranteed to see a consistent prefix of the global transaction history: they observe modifications done by all transactions with a commit timestamp less than or equal to the read timestamp, and observe none of the modifications done by transactions with a larger commit timestamp. They will block until all conflicting transactions that may be assigned commit timestamps <= the read timestamp have finished. The timestamp can either be expressed as an absolute Cloud Spanner commit timestamp or a staleness relative to the current time. These modes do not require a "negotiation phase" to pick a timestamp. As a result, they execute slightly faster than the equivalent boundedly stale concurrency modes. On the other hand, boundedly stale reads usually return fresher results. See TransactionOptions.ReadOnly.read_timestamp and TransactionOptions.ReadOnly.exact_staleness. Bounded staleness: Bounded staleness modes allow Cloud Spanner to pick the read timestamp, subject to a user-provided staleness bound. Cloud Spanner chooses the newest timestamp within the staleness bound that allows execution of the reads at the closest available replica without blocking. All rows yielded are consistent with each other -- if any part of the read observes a transaction, all parts of the read see the transaction. Boundedly stale reads are not repeatable: two stale reads, even if they use the same staleness bound, can execute at different timestamps and thus return inconsistent results. Boundedly stale reads execute in two phases: the first phase negotiates a timestamp among all replicas needed to serve the read. In the second phase, reads are executed at the negotiated timestamp. As a result of the two phase execution, bounded staleness reads are usually a little slower than comparable exact staleness reads. However, they are typically able to return fresher results, and are more likely to execute at the closest replica. Because the timestamp negotiation requires up-front knowledge of which rows will be read, it can only be used with single-use read-only transactions. See TransactionOptions.ReadOnly.max_staleness and TransactionOptions.ReadOnly.min_read_timestamp. Old read timestamps and garbage collection: Cloud Spanner continuously garbage collects deleted and overwritten data in the background to reclaim storage space. This process is known as "version GC". By default, version GC reclaims versions after they are one hour old. Because of this, Cloud Spanner cannot perform reads at read timestamps more than one hour in the past. This restriction also applies to in-progress reads and/or SQL queries whose timestamp become too old while executing. Reads and SQL queries with too-old read timestamps fail with the error `FAILED_PRECONDITION`. You can configure and extend the `VERSION_RETENTION_PERIOD` of a database up to a period as long as one week, which allows Cloud Spanner to perform reads up to one week in the past. Querying change Streams: A Change Stream is a schema object that can be configured to watch data changes on the entire database, a set of tables, or a set of columns in a database. When a change stream is created, Spanner automatically defines a corresponding SQL Table-Valued Function (TVF) that can be used to query the change records in the associated change stream using the ExecuteStreamingSql API. The name of the TVF for a change stream is generated from the name of the change stream: READ_. All queries on change stream TVFs must be executed using the ExecuteStreamingSql API with a single-use read-only transaction with a strong read-only timestamp_bound. The change stream TVF allows users to specify the start_timestamp and end_timestamp for the time range of interest. All change records within the retention period is accessible using the strong read-only timestamp_bound. All other TransactionOptions are invalid for change stream queries. In addition, if TransactionOptions.read_only.return_read_timestamp is set to true, a special value of 2^63 - 2 will be returned in the Transaction message that describes the transaction, instead of a valid read timestamp. This special value should be discarded and not used for any subsequent queries. Please see https://cloud.google.com/spanner/docs/change-streams for more details on how to query the change stream TVFs. Partitioned DML transactions: Partitioned DML transactions are used to execute DML statements with a different execution strategy that provides different, and often better, scalability properties for large, table-wide operations than DML in a ReadWrite transaction. Smaller scoped statements, such as an OLTP workload, should prefer using ReadWrite transactions. Partitioned DML partitions the keyspace and runs the DML statement on each partition in separate, internal transactions. These transactions commit automatically when complete, and run independently from one another. To reduce lock contention, this execution strategy only acquires read locks on rows that match the WHERE clause of the statement. Additionally, the smaller per-partition transactions hold locks for less time. That said, Partitioned DML is not a drop-in replacement for standard DML used in ReadWrite transactions. - The DML statement must be fully-partitionable. Specifically, the statement must be expressible as the union of many statements which each access only a single row of the table. - The statement is not applied atomically to all rows of the table. Rather, the statement is applied atomically to partitions of the table, in independent transactions. Secondary index rows are updated atomically with the base table rows. - Partitioned DML does not guarantee exactly-once execution semantics against a partition. The statement is applied at least once to each partition. It is strongly recommended that the DML statement should be idempotent to avoid unexpected results. For instance, it is potentially dangerous to run a statement such as `UPDATE table SET column = column + 1` as it could be run multiple times against some rows. - The partitions are committed automatically - there is no support for Commit or Rollback. If the call returns an error, or if the client issuing the ExecuteSql call dies, it is possible that some rows had the statement executed on them successfully. It is also possible that statement was never executed against other rows. - Partitioned DML transactions may only contain the execution of a single DML statement via ExecuteSql or ExecuteStreamingSql. - If any error is encountered during the execution of the partitioned DML operation (for instance, a UNIQUE INDEX violation, division by zero, or a value that cannot be stored due to schema constraints), then the operation is stopped at that point and an error is returned. It is possible that at this point, some partitions have been committed (or even committed multiple times), and other partitions have not been run at all. Given the above, Partitioned DML is good fit for large, database-wide, operations that are idempotent, such as deleting old rows from a very large table.
+     * Transactions: Each session can have at most one active transaction at a time (note that standalone reads and queries use a transaction internally and do count towards the one transaction limit). After the active transaction is completed, the session can immediately be re-used for the next transaction. It is not necessary to create a new session for each transaction. Transaction modes: Cloud Spanner supports three transaction modes: 1. Locking read-write. This type of transaction is the only way to write data into Cloud Spanner. These transactions rely on pessimistic locking and, if necessary, two-phase commit. Locking read-write transactions may abort, requiring the application to retry. 2. Snapshot read-only. Snapshot read-only transactions provide guaranteed consistency across several reads, but do not allow writes. Snapshot read-only transactions can be configured to read at timestamps in the past, or configured to perform a strong read (where Spanner will select a timestamp such that the read is guaranteed to see the effects of all transactions that have committed before the start of the read). Snapshot read-only transactions do not need to be committed. Queries on change streams must be performed with the snapshot read-only transaction mode, specifying a strong read. See TransactionOptions.ReadOnly.strong for more details. 3. Partitioned DML. This type of transaction is used to execute a single Partitioned DML statement. Partitioned DML partitions the key space and runs the DML statement over each partition in parallel using separate, internal transactions that commit independently. Partitioned DML transactions do not need to be committed. For transactions that only read, snapshot read-only transactions provide simpler semantics and are almost always faster. In particular, read-only transactions do not take locks, so they do not conflict with read-write transactions. As a consequence of not taking locks, they also do not abort, so retry loops are not needed. Transactions may only read-write data in a single database. They may, however, read-write data in different tables within that database. Locking read-write transactions: Locking transactions may be used to atomically read-modify-write data anywhere in a database. This type of transaction is externally consistent. Clients should attempt to minimize the amount of time a transaction is active. Faster transactions commit with higher probability and cause less contention. Cloud Spanner attempts to keep read locks active as long as the transaction continues to do reads, and the transaction has not been terminated by Commit or Rollback. Long periods of inactivity at the client may cause Cloud Spanner to release a transaction's locks and abort it. Conceptually, a read-write transaction consists of zero or more reads or SQL statements followed by Commit. At any time before Commit, the client can send a Rollback request to abort the transaction. Semantics: Cloud Spanner can commit the transaction if all read locks it acquired are still valid at commit time, and it is able to acquire write locks for all writes. Cloud Spanner can abort the transaction for any reason. If a commit attempt returns `ABORTED`, Cloud Spanner guarantees that the transaction has not modified any user data in Cloud Spanner. Unless the transaction commits, Cloud Spanner makes no guarantees about how long the transaction's locks were held for. It is an error to use Cloud Spanner locks for any sort of mutual exclusion other than between Cloud Spanner transactions themselves. Retrying aborted transactions: When a transaction aborts, the application can choose to retry the whole transaction again. To maximize the chances of successfully committing the retry, the client should execute the retry in the same session as the original attempt. The original session's lock priority increases with each consecutive abort, meaning that each attempt has a slightly better chance of success than the previous. Note that the lock priority is preserved per session (not per transaction). Lock priority is set by the first read or write in the first attempt of a read-write transaction. If the application starts a new session to retry the whole transaction, the transaction loses its original lock priority. Moreover, the lock priority is only preserved if the transaction fails with an `ABORTED` error. Under some circumstances (for example, many transactions attempting to modify the same row(s)), a transaction can abort many times in a short period before successfully committing. Thus, it is not a good idea to cap the number of retries a transaction can attempt; instead, it is better to limit the total amount of time spent retrying. Idle transactions: A transaction is considered idle if it has no outstanding reads or SQL queries and has not started a read or SQL query within the last 10 seconds. Idle transactions can be aborted by Cloud Spanner so that they don't hold on to locks indefinitely. If an idle transaction is aborted, the commit will fail with error `ABORTED`. If this behavior is undesirable, periodically executing a simple SQL query in the transaction (for example, `SELECT 1`) prevents the transaction from becoming idle. Snapshot read-only transactions: Snapshot read-only transactions provides a simpler method than locking read-write transactions for doing several consistent reads. However, this type of transaction does not support writes. Snapshot transactions do not take locks. Instead, they work by choosing a Cloud Spanner timestamp, then executing all reads at that timestamp. Since they do not acquire locks, they do not block concurrent read-write transactions. Unlike locking read-write transactions, snapshot read-only transactions never abort. They can fail if the chosen read timestamp is garbage collected; however, the default garbage collection policy is generous enough that most applications do not need to worry about this in practice. Snapshot read-only transactions do not need to call Commit or Rollback (and in fact are not permitted to do so). To execute a snapshot transaction, the client specifies a timestamp bound, which tells Cloud Spanner how to choose a read timestamp. The types of timestamp bound are: - Strong (the default). - Bounded staleness. - Exact staleness. If the Cloud Spanner database to be read is geographically distributed, stale read-only transactions can execute more quickly than strong or read-write transactions, because they are able to execute far from the leader replica. Each type of timestamp bound is discussed in detail below. Strong: Strong reads are guaranteed to see the effects of all transactions that have committed before the start of the read. Furthermore, all rows yielded by a single read are consistent with each other -- if any part of the read observes a transaction, all parts of the read see the transaction. Strong reads are not repeatable: two consecutive strong read-only transactions might return inconsistent results if there are concurrent writes. If consistency across reads is required, the reads should be executed within a transaction or at an exact read timestamp. Queries on change streams (see below for more details) must also specify the strong read timestamp bound. See TransactionOptions.ReadOnly.strong. Exact staleness: These timestamp bounds execute reads at a user-specified timestamp. Reads at a timestamp are guaranteed to see a consistent prefix of the global transaction history: they observe modifications done by all transactions with a commit timestamp less than or equal to the read timestamp, and observe none of the modifications done by transactions with a larger commit timestamp. They will block until all conflicting transactions that may be assigned commit timestamps <= the read timestamp have finished. The timestamp can either be expressed as an absolute Cloud Spanner commit timestamp or a staleness relative to the current time. These modes do not require a "negotiation phase" to pick a timestamp. As a result, they execute slightly faster than the equivalent boundedly stale concurrency modes. On the other hand, boundedly stale reads usually return fresher results. See TransactionOptions.ReadOnly.read_timestamp and TransactionOptions.ReadOnly.exact_staleness. Bounded staleness: Bounded staleness modes allow Cloud Spanner to pick the read timestamp, subject to a user-provided staleness bound. Cloud Spanner chooses the newest timestamp within the staleness bound that allows execution of the reads at the closest available replica without blocking. All rows yielded are consistent with each other -- if any part of the read observes a transaction, all parts of the read see the transaction. Boundedly stale reads are not repeatable: two stale reads, even if they use the same staleness bound, can execute at different timestamps and thus return inconsistent results. Boundedly stale reads execute in two phases: the first phase negotiates a timestamp among all replicas needed to serve the read. In the second phase, reads are executed at the negotiated timestamp. As a result of the two phase execution, bounded staleness reads are usually a little slower than comparable exact staleness reads. However, they are typically able to return fresher results, and are more likely to execute at the closest replica. Because the timestamp negotiation requires up-front knowledge of which rows will be read, it can only be used with single-use read-only transactions. See TransactionOptions.ReadOnly.max_staleness and TransactionOptions.ReadOnly.min_read_timestamp. Old read timestamps and garbage collection: Cloud Spanner continuously garbage collects deleted and overwritten data in the background to reclaim storage space. This process is known as "version GC". By default, version GC reclaims versions after they are one hour old. Because of this, Cloud Spanner cannot perform reads at read timestamps more than one hour in the past. This restriction also applies to in-progress reads and/or SQL queries whose timestamp become too old while executing. Reads and SQL queries with too-old read timestamps fail with the error `FAILED_PRECONDITION`. You can configure and extend the `VERSION_RETENTION_PERIOD` of a database up to a period as long as one week, which allows Cloud Spanner to perform reads up to one week in the past. Querying change Streams: A Change Stream is a schema object that can be configured to watch data changes on the entire database, a set of tables, or a set of columns in a database. When a change stream is created, Spanner automatically defines a corresponding SQL Table-Valued Function (TVF) that can be used to query the change records in the associated change stream using the ExecuteStreamingSql API. The name of the TVF for a change stream is generated from the name of the change stream: READ_. All queries on change stream TVFs must be executed using the ExecuteStreamingSql API with a single-use read-only transaction with a strong read-only timestamp_bound. The change stream TVF allows users to specify the start_timestamp and end_timestamp for the time range of interest. All change records within the retention period is accessible using the strong read-only timestamp_bound. All other TransactionOptions are invalid for change stream queries. In addition, if TransactionOptions.read_only.return_read_timestamp is set to true, a special value of 2^63 - 2 will be returned in the Transaction message that describes the transaction, instead of a valid read timestamp. This special value should be discarded and not used for any subsequent queries. Please see https://cloud.google.com/spanner/docs/change-streams for more details on how to query the change stream TVFs. Partitioned DML transactions: Partitioned DML transactions are used to execute DML statements with a different execution strategy that provides different, and often better, scalability properties for large, table-wide operations than DML in a ReadWrite transaction. Smaller scoped statements, such as an OLTP workload, should prefer using ReadWrite transactions. Partitioned DML partitions the keyspace and runs the DML statement on each partition in separate, internal transactions. These transactions commit automatically when complete, and run independently from one another. To reduce lock contention, this execution strategy only acquires read locks on rows that match the WHERE clause of the statement. Additionally, the smaller per-partition transactions hold locks for less time. That said, Partitioned DML is not a drop-in replacement for standard DML used in ReadWrite transactions. - The DML statement must be fully-partitionable. Specifically, the statement must be expressible as the union of many statements which each access only a single row of the table. - The statement is not applied atomically to all rows of the table. Rather, the statement is applied atomically to partitions of the table, in independent transactions. Secondary index rows are updated atomically with the base table rows. - Partitioned DML does not guarantee exactly-once execution semantics against a partition. The statement is applied at least once to each partition. It is strongly recommended that the DML statement should be idempotent to avoid unexpected results. For instance, it is potentially dangerous to run a statement such as `UPDATE table SET column = column + 1` as it could be run multiple times against some rows. - The partitions are committed automatically - there is no support for Commit or Rollback. If the call returns an error, or if the client issuing the ExecuteSql call dies, it is possible that some rows had the statement executed on them successfully. It is also possible that statement was never executed against other rows. - Partitioned DML transactions may only contain the execution of a single DML statement via ExecuteSql or ExecuteStreamingSql. - If any error is encountered during the execution of the partitioned DML operation (for instance, a UNIQUE INDEX violation, division by zero, or a value that cannot be stored due to schema constraints), then the operation is stopped at that point and an error is returned. It is possible that at this point, some partitions have been committed (or even committed multiple times), and other partitions have not been run at all. Given the above, Partitioned DML is good fit for large, database-wide, operations that are idempotent, such as deleting old rows from a very large table.
      */
     export interface Schema$TransactionOptions {
         /**
@@ -2499,7 +2720,7 @@ export declare namespace spanner_v1 {
          */
         cancelTime?: string | null;
         /**
-         * The desired instance config after updating.
+         * The desired instance configuration after updating.
          */
         instanceConfig?: Schema$InstanceConfig;
         /**
@@ -2512,7 +2733,7 @@ export declare namespace spanner_v1 {
      */
     export interface Schema$UpdateInstanceConfigRequest {
         /**
-         * Required. The user instance config to update, which must always include the instance config name. Otherwise, only fields mentioned in update_mask need be included. To prevent conflicts of concurrent updates, etag can be used.
+         * Required. The user instance configuration to update, which must always include the instance configuration name. Otherwise, only fields mentioned in update_mask need be included. To prevent conflicts of concurrent updates, etag can be used.
          */
         instanceConfig?: Schema$InstanceConfig;
         /**
@@ -2666,7 +2887,7 @@ export declare namespace spanner_v1 {
         context: APIRequestContext;
         constructor(context: APIRequestContext);
         /**
-         * Lists the user-managed instance config long-running operations in the given project. An instance config operation has a name of the form `projects//instanceConfigs//operations/`. The long-running operation metadata field type `metadata.type_url` describes the type of the metadata. Operations returned include those that have completed/failed/canceled within the last 7 days, and pending operations. Operations returned are ordered by `operation.metadata.value.start_time` in descending order starting from the most recently started operation.
+         * Lists the user-managed instance configuration long-running operations in the given project. An instance configuration operation has a name of the form `projects//instanceConfigs//operations/`. The long-running operation metadata field type `metadata.type_url` describes the type of the metadata. Operations returned include those that have completed/failed/canceled within the last 7 days, and pending operations. Operations returned are ordered by `operation.metadata.value.start_time` in descending order starting from the most recently started operation.
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -2682,7 +2903,7 @@ export declare namespace spanner_v1 {
     }
     export interface Params$Resource$Projects$Instanceconfigoperations$List extends StandardParameters {
         /**
-         * An expression that filters the list of returned operations. A filter expression consists of a field name, a comparison operator, and a value for filtering. The value must be a string, a number, or a boolean. The comparison operator must be one of: `<`, `\>`, `<=`, `\>=`, `!=`, `=`, or `:`. Colon `:` is the contains operator. Filter rules are not case sensitive. The following fields in the Operation are eligible for filtering: * `name` - The name of the long-running operation * `done` - False if the operation is in progress, else true. * `metadata.@type` - the type of metadata. For example, the type string for CreateInstanceConfigMetadata is `type.googleapis.com/google.spanner.admin.instance.v1.CreateInstanceConfigMetadata`. * `metadata.` - any field in metadata.value. `metadata.@type` must be specified first, if filtering on metadata fields. * `error` - Error associated with the long-running operation. * `response.@type` - the type of response. * `response.` - any field in response.value. You can combine multiple expressions by enclosing each expression in parentheses. By default, expressions are combined with AND logic. However, you can specify AND, OR, and NOT logic explicitly. Here are a few examples: * `done:true` - The operation is complete. * `(metadata.@type=` \ `type.googleapis.com/google.spanner.admin.instance.v1.CreateInstanceConfigMetadata) AND` \ `(metadata.instance_config.name:custom-config) AND` \ `(metadata.progress.start_time < \"2021-03-28T14:50:00Z\") AND` \ `(error:*)` - Return operations where: * The operation's metadata type is CreateInstanceConfigMetadata. * The instance config name contains "custom-config". * The operation started before 2021-03-28T14:50:00Z. * The operation resulted in an error.
+         * An expression that filters the list of returned operations. A filter expression consists of a field name, a comparison operator, and a value for filtering. The value must be a string, a number, or a boolean. The comparison operator must be one of: `<`, `\>`, `<=`, `\>=`, `!=`, `=`, or `:`. Colon `:` is the contains operator. Filter rules are not case sensitive. The following fields in the Operation are eligible for filtering: * `name` - The name of the long-running operation * `done` - False if the operation is in progress, else true. * `metadata.@type` - the type of metadata. For example, the type string for CreateInstanceConfigMetadata is `type.googleapis.com/google.spanner.admin.instance.v1.CreateInstanceConfigMetadata`. * `metadata.` - any field in metadata.value. `metadata.@type` must be specified first, if filtering on metadata fields. * `error` - Error associated with the long-running operation. * `response.@type` - the type of response. * `response.` - any field in response.value. You can combine multiple expressions by enclosing each expression in parentheses. By default, expressions are combined with AND logic. However, you can specify AND, OR, and NOT logic explicitly. Here are a few examples: * `done:true` - The operation is complete. * `(metadata.@type=` \ `type.googleapis.com/google.spanner.admin.instance.v1.CreateInstanceConfigMetadata) AND` \ `(metadata.instance_config.name:custom-config) AND` \ `(metadata.progress.start_time < \"2021-03-28T14:50:00Z\") AND` \ `(error:*)` - Return operations where: * The operation's metadata type is CreateInstanceConfigMetadata. * The instance configuration name contains "custom-config". * The operation started before 2021-03-28T14:50:00Z. * The operation resulted in an error.
          */
         filter?: string;
         /**
@@ -2694,7 +2915,7 @@ export declare namespace spanner_v1 {
          */
         pageToken?: string;
         /**
-         * Required. The project of the instance config operations. Values are of the form `projects/`.
+         * Required. The project of the instance configuration operations. Values are of the form `projects/`.
          */
         parent?: string;
     }
@@ -2704,7 +2925,7 @@ export declare namespace spanner_v1 {
         ssdCaches: Resource$Projects$Instanceconfigs$Ssdcaches;
         constructor(context: APIRequestContext);
         /**
-         * Creates an instance config and begins preparing it to be used. The returned long-running operation can be used to track the progress of preparing the new instance config. The instance config name is assigned by the caller. If the named instance config already exists, `CreateInstanceConfig` returns `ALREADY_EXISTS`. Immediately after the request returns: * The instance config is readable via the API, with all requested attributes. The instance config's reconciling field is set to true. Its state is `CREATING`. While the operation is pending: * Cancelling the operation renders the instance config immediately unreadable via the API. * Except for deleting the creating resource, all other attempts to modify the instance config are rejected. Upon completion of the returned operation: * Instances can be created using the instance configuration. * The instance config's reconciling field becomes false. Its state becomes `READY`. The returned long-running operation will have a name of the format `/operations/` and can be used to track creation of the instance config. The metadata field type is CreateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.create` permission on the resource parent.
+         * Creates an instance configuration and begins preparing it to be used. The returned long-running operation can be used to track the progress of preparing the new instance configuration. The instance configuration name is assigned by the caller. If the named instance configuration already exists, `CreateInstanceConfig` returns `ALREADY_EXISTS`. Immediately after the request returns: * The instance configuration is readable via the API, with all requested attributes. The instance configuration's reconciling field is set to true. Its state is `CREATING`. While the operation is pending: * Cancelling the operation renders the instance configuration immediately unreadable via the API. * Except for deleting the creating resource, all other attempts to modify the instance configuration are rejected. Upon completion of the returned operation: * Instances can be created using the instance configuration. * The instance configuration's reconciling field becomes false. Its state becomes `READY`. The returned long-running operation will have a name of the format `/operations/` and can be used to track creation of the instance configuration. The metadata field type is CreateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.create` permission on the resource parent.
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -2718,7 +2939,7 @@ export declare namespace spanner_v1 {
         create(params: Params$Resource$Projects$Instanceconfigs$Create, callback: BodyResponseCallback<Schema$Operation>): void;
         create(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
-         * Deletes the instance config. Deletion is only allowed when no instances are using the configuration. If any instances are using the config, returns `FAILED_PRECONDITION`. Only user managed configurations can be deleted. Authorization requires `spanner.instanceConfigs.delete` permission on the resource name.
+         * Deletes the instance configuration. Deletion is only allowed when no instances are using the configuration. If any instances are using the configuration, returns `FAILED_PRECONDITION`. Only user-managed configurations can be deleted. Authorization requires `spanner.instanceConfigs.delete` permission on the resource name.
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -2746,7 +2967,7 @@ export declare namespace spanner_v1 {
         get(params: Params$Resource$Projects$Instanceconfigs$Get, callback: BodyResponseCallback<Schema$InstanceConfig>): void;
         get(callback: BodyResponseCallback<Schema$InstanceConfig>): void;
         /**
-         * Lists the supported instance configurations for a given project.
+         * Lists the supported instance configurations for a given project. Returns both Google-managed configurations and user-managed configurations.
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -2760,7 +2981,7 @@ export declare namespace spanner_v1 {
         list(params: Params$Resource$Projects$Instanceconfigs$List, callback: BodyResponseCallback<Schema$ListInstanceConfigsResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListInstanceConfigsResponse>): void;
         /**
-         * Updates an instance config. The returned long-running operation can be used to track the progress of updating the instance. If the named instance config does not exist, returns `NOT_FOUND`. Only user managed configurations can be updated. Immediately after the request returns: * The instance config's reconciling field is set to true. While the operation is pending: * Cancelling the operation sets its metadata's cancel_time. The operation is guaranteed to succeed at undoing all changes, after which point it terminates with a `CANCELLED` status. * All other attempts to modify the instance config are rejected. * Reading the instance config via the API continues to give the pre-request values. Upon completion of the returned operation: * Creating instances using the instance configuration uses the new values. * The instance config's new values are readable via the API. * The instance config's reconciling field becomes false. The returned long-running operation will have a name of the format `/operations/` and can be used to track the instance config modification. The metadata field type is UpdateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.update` permission on the resource name.
+         * Updates an instance configuration. The returned long-running operation can be used to track the progress of updating the instance. If the named instance configuration does not exist, returns `NOT_FOUND`. Only user-managed configurations can be updated. Immediately after the request returns: * The instance configuration's reconciling field is set to true. While the operation is pending: * Cancelling the operation sets its metadata's cancel_time. The operation is guaranteed to succeed at undoing all changes, after which point it terminates with a `CANCELLED` status. * All other attempts to modify the instance configuration are rejected. * Reading the instance configuration via the API continues to give the pre-request values. Upon completion of the returned operation: * Creating instances using the instance configuration uses the new values. * The new values of the instance configuration are readable via the API. * The instance configuration's reconciling field becomes false. The returned long-running operation will have a name of the format `/operations/` and can be used to track the instance configuration modification. The metadata field type is UpdateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.update` permission on the resource name.
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -2776,7 +2997,7 @@ export declare namespace spanner_v1 {
     }
     export interface Params$Resource$Projects$Instanceconfigs$Create extends StandardParameters {
         /**
-         * Required. The name of the project in which to create the instance config. Values are of the form `projects/`.
+         * Required. The name of the project in which to create the instance configuration. Values are of the form `projects/`.
          */
         parent?: string;
         /**
@@ -2786,7 +3007,7 @@ export declare namespace spanner_v1 {
     }
     export interface Params$Resource$Projects$Instanceconfigs$Delete extends StandardParameters {
         /**
-         * Used for optimistic concurrency control as a way to help prevent simultaneous deletes of an instance config from overwriting each other. If not empty, the API only deletes the instance config when the etag provided matches the current status of the requested instance config. Otherwise, deletes the instance config without checking the current status of the requested instance config.
+         * Used for optimistic concurrency control as a way to help prevent simultaneous deletes of an instance configuration from overwriting each other. If not empty, the API only deletes the instance configuration when the etag provided matches the current status of the requested instance configuration. Otherwise, deletes the instance configuration without checking the current status of the requested instance configuration.
          */
         etag?: string;
         /**
@@ -2820,7 +3041,7 @@ export declare namespace spanner_v1 {
     }
     export interface Params$Resource$Projects$Instanceconfigs$Patch extends StandardParameters {
         /**
-         * A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`.
+         * A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`. User instance configuration must start with `custom-`.
          */
         name?: string;
         /**
@@ -3106,7 +3327,7 @@ export declare namespace spanner_v1 {
         list(params: Params$Resource$Projects$Instances$List, callback: BodyResponseCallback<Schema$ListInstancesResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListInstancesResponse>): void;
         /**
-         * Moves the instance to the target instance config. The returned long-running operation can be used to track the progress of moving the instance. `MoveInstance` returns `FAILED_PRECONDITION` if the instance meets any of the following criteria: * Has an ongoing move to a different instance config * Has backups * Has an ongoing update * Is under free trial * Contains any CMEK-enabled databases While the operation is pending: * All other attempts to modify the instance, including changes to its compute capacity, are rejected. * The following database and backup admin operations are rejected: * DatabaseAdmin.CreateDatabase, * DatabaseAdmin.UpdateDatabaseDdl (Disabled if default_leader is specified in the request.) * DatabaseAdmin.RestoreDatabase * DatabaseAdmin.CreateBackup * DatabaseAdmin.CopyBackup * Both the source and target instance configs are subject to hourly compute and storage charges. * The instance may experience higher read-write latencies and a higher transaction abort rate. However, moving an instance does not cause any downtime. The returned long-running operation will have a name of the format `/operations/` and can be used to track the move instance operation. The metadata field type is MoveInstanceMetadata. The response field type is Instance, if successful. Cancelling the operation sets its metadata's cancel_time. Cancellation is not immediate since it involves moving any data previously moved to target instance config back to the original instance config. The same operation can be used to track the progress of the cancellation. Upon successful completion of the cancellation, the operation terminates with CANCELLED status. Upon completion(if not cancelled) of the returned operation: * Instance would be successfully moved to the target instance config. * You are billed for compute and storage in target instance config. Authorization requires `spanner.instances.update` permission on the resource instance. For more details, please see [documentation](https://cloud.google.com/spanner/docs/move-instance).
+         * Moves an instance to the target instance configuration. You can use the returned long-running operation to track the progress of moving the instance. `MoveInstance` returns `FAILED_PRECONDITION` if the instance meets any of the following criteria: * Is undergoing a move to a different instance configuration * Has backups * Has an ongoing update * Contains any CMEK-enabled databases * Is a free trial instance While the operation is pending: * All other attempts to modify the instance, including changes to its compute capacity, are rejected. * The following database and backup admin operations are rejected: * `DatabaseAdmin.CreateDatabase` * `DatabaseAdmin.UpdateDatabaseDdl` (disabled if default_leader is specified in the request.) * `DatabaseAdmin.RestoreDatabase` * `DatabaseAdmin.CreateBackup` * `DatabaseAdmin.CopyBackup` * Both the source and target instance configurations are subject to hourly compute and storage charges. * The instance might experience higher read-write latencies and a higher transaction abort rate. However, moving an instance doesn't cause any downtime. The returned long-running operation has a name of the format `/operations/` and can be used to track the move instance operation. The metadata field type is MoveInstanceMetadata. The response field type is Instance, if successful. Cancelling the operation sets its metadata's cancel_time. Cancellation is not immediate because it involves moving any data previously moved to the target instance configuration back to the original instance configuration. You can use this operation to track the progress of the cancellation. Upon successful completion of the cancellation, the operation terminates with `CANCELLED` status. If not cancelled, upon completion of the returned operation: * The instance successfully moves to the target instance configuration. * You are billed for compute and storage in target instance configuration. Authorization requires the `spanner.instances.update` permission on the resource instance. For more details, see [Move an instance](https://cloud.google.com/spanner/docs/move-instance).
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -3671,12 +3892,27 @@ export declare namespace spanner_v1 {
     }
     export class Resource$Projects$Instances$Databases {
         context: APIRequestContext;
+        backupSchedules: Resource$Projects$Instances$Databases$Backupschedules;
         databaseRoles: Resource$Projects$Instances$Databases$Databaseroles;
         operations: Resource$Projects$Instances$Databases$Operations;
         sessions: Resource$Projects$Instances$Databases$Sessions;
         constructor(context: APIRequestContext);
         /**
-         * Creates a new Cloud Spanner database and starts to prepare it for serving. The returned long-running operation will have a name of the format `/operations/` and can be used to track preparation of the database. The metadata field type is CreateDatabaseMetadata. The response field type is Database, if successful.
+         * `ChangeQuorum` is strictly restricted to databases that use dual-region instance configurations. Initiates a background operation to change the quorum of a database from dual-region mode to single-region mode or vice versa. The returned long-running operation has a name of the format `projects//instances//databases//operations/` and can be used to track execution of the `ChangeQuorum`. The metadata field type is ChangeQuorumMetadata. Authorization requires `spanner.databases.changequorum` permission on the resource database.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        changequorum(params: Params$Resource$Projects$Instances$Databases$Changequorum, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        changequorum(params?: Params$Resource$Projects$Instances$Databases$Changequorum, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        changequorum(params: Params$Resource$Projects$Instances$Databases$Changequorum, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        changequorum(params: Params$Resource$Projects$Instances$Databases$Changequorum, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
+        changequorum(params: Params$Resource$Projects$Instances$Databases$Changequorum, callback: BodyResponseCallback<Schema$Operation>): void;
+        changequorum(callback: BodyResponseCallback<Schema$Operation>): void;
+        /**
+         * Creates a new Spanner database and starts to prepare it for serving. The returned long-running operation will have a name of the format `/operations/` and can be used to track preparation of the database. The metadata field type is CreateDatabaseMetadata. The response field type is Database, if successful.
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -3844,6 +4080,16 @@ export declare namespace spanner_v1 {
         updateDdl(params: Params$Resource$Projects$Instances$Databases$Updateddl, callback: BodyResponseCallback<Schema$Operation>): void;
         updateDdl(callback: BodyResponseCallback<Schema$Operation>): void;
     }
+    export interface Params$Resource$Projects$Instances$Databases$Changequorum extends StandardParameters {
+        /**
+         * Required. Name of the database in which to apply `ChangeQuorum`. Values are of the form `projects//instances//databases/`.
+         */
+        name?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$ChangeQuorumRequest;
+    }
     export interface Params$Resource$Projects$Instances$Databases$Create extends StandardParameters {
         /**
          * Required. The name of the instance that will serve the new database. Values are of the form `projects//instances/`.
@@ -3968,6 +4214,206 @@ export declare namespace spanner_v1 {
          */
         requestBody?: Schema$UpdateDatabaseDdlRequest;
     }
+    export class Resource$Projects$Instances$Databases$Backupschedules {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Creates a new backup schedule.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        create(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        create(params?: Params$Resource$Projects$Instances$Databases$Backupschedules$Create, options?: MethodOptions): GaxiosPromise<Schema$BackupSchedule>;
+        create(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        create(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Create, options: MethodOptions | BodyResponseCallback<Schema$BackupSchedule>, callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        create(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Create, callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        create(callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        /**
+         * Deletes a backup schedule.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        delete(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        delete(params?: Params$Resource$Projects$Instances$Databases$Backupschedules$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        delete(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        delete(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
+        delete(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
+        delete(callback: BodyResponseCallback<Schema$Empty>): void;
+        /**
+         * Gets backup schedule for the input schedule name.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        get(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Projects$Instances$Databases$Backupschedules$Get, options?: MethodOptions): GaxiosPromise<Schema$BackupSchedule>;
+        get(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Get, options: MethodOptions | BodyResponseCallback<Schema$BackupSchedule>, callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        get(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Get, callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        get(callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        /**
+         * Gets the access control policy for a database or backup resource. Returns an empty policy if a database or backup exists but does not have a policy set. Authorization requires `spanner.databases.getIamPolicy` permission on resource. For backups, authorization requires `spanner.backups.getIamPolicy` permission on resource.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        getIamPolicy(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Getiampolicy, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        getIamPolicy(params?: Params$Resource$Projects$Instances$Databases$Backupschedules$Getiampolicy, options?: MethodOptions): GaxiosPromise<Schema$Policy>;
+        getIamPolicy(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Getiampolicy, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        getIamPolicy(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Getiampolicy, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
+        getIamPolicy(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Getiampolicy, callback: BodyResponseCallback<Schema$Policy>): void;
+        getIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
+        /**
+         * Lists all the backup schedules for the database.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        list(params: Params$Resource$Projects$Instances$Databases$Backupschedules$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Projects$Instances$Databases$Backupschedules$List, options?: MethodOptions): GaxiosPromise<Schema$ListBackupSchedulesResponse>;
+        list(params: Params$Resource$Projects$Instances$Databases$Backupschedules$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Projects$Instances$Databases$Backupschedules$List, options: MethodOptions | BodyResponseCallback<Schema$ListBackupSchedulesResponse>, callback: BodyResponseCallback<Schema$ListBackupSchedulesResponse>): void;
+        list(params: Params$Resource$Projects$Instances$Databases$Backupschedules$List, callback: BodyResponseCallback<Schema$ListBackupSchedulesResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ListBackupSchedulesResponse>): void;
+        /**
+         * Updates a backup schedule.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        patch(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        patch(params?: Params$Resource$Projects$Instances$Databases$Backupschedules$Patch, options?: MethodOptions): GaxiosPromise<Schema$BackupSchedule>;
+        patch(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        patch(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Patch, options: MethodOptions | BodyResponseCallback<Schema$BackupSchedule>, callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        patch(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Patch, callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        patch(callback: BodyResponseCallback<Schema$BackupSchedule>): void;
+        /**
+         * Sets the access control policy on a database or backup resource. Replaces any existing policy. Authorization requires `spanner.databases.setIamPolicy` permission on resource. For backups, authorization requires `spanner.backups.setIamPolicy` permission on resource.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        setIamPolicy(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Setiampolicy, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        setIamPolicy(params?: Params$Resource$Projects$Instances$Databases$Backupschedules$Setiampolicy, options?: MethodOptions): GaxiosPromise<Schema$Policy>;
+        setIamPolicy(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Setiampolicy, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        setIamPolicy(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Setiampolicy, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
+        setIamPolicy(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Setiampolicy, callback: BodyResponseCallback<Schema$Policy>): void;
+        setIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
+        /**
+         * Returns permissions that the caller has on the specified database or backup resource. Attempting this RPC on a non-existent Cloud Spanner database will result in a NOT_FOUND error if the user has `spanner.databases.list` permission on the containing Cloud Spanner instance. Otherwise returns an empty set of permissions. Calling this method on a backup that does not exist will result in a NOT_FOUND error if the user has `spanner.backups.list` permission on the containing instance.
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        testIamPermissions(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Testiampermissions, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        testIamPermissions(params?: Params$Resource$Projects$Instances$Databases$Backupschedules$Testiampermissions, options?: MethodOptions): GaxiosPromise<Schema$TestIamPermissionsResponse>;
+        testIamPermissions(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Testiampermissions, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        testIamPermissions(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Testiampermissions, options: MethodOptions | BodyResponseCallback<Schema$TestIamPermissionsResponse>, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
+        testIamPermissions(params: Params$Resource$Projects$Instances$Databases$Backupschedules$Testiampermissions, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
+        testIamPermissions(callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
+    }
+    export interface Params$Resource$Projects$Instances$Databases$Backupschedules$Create extends StandardParameters {
+        /**
+         * Required. The Id to use for the backup schedule. The `backup_schedule_id` appended to `parent` forms the full backup schedule name of the form `projects//instances//databases//backupSchedules/`.
+         */
+        backupScheduleId?: string;
+        /**
+         * Required. The name of the database that this backup schedule applies to.
+         */
+        parent?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$BackupSchedule;
+    }
+    export interface Params$Resource$Projects$Instances$Databases$Backupschedules$Delete extends StandardParameters {
+        /**
+         * Required. The name of the schedule to delete. Values are of the form `projects//instances//databases//backupSchedules/`.
+         */
+        name?: string;
+    }
+    export interface Params$Resource$Projects$Instances$Databases$Backupschedules$Get extends StandardParameters {
+        /**
+         * Required. The name of the schedule to retrieve. Values are of the form `projects//instances//databases//backupSchedules/`.
+         */
+        name?: string;
+    }
+    export interface Params$Resource$Projects$Instances$Databases$Backupschedules$Getiampolicy extends StandardParameters {
+        /**
+         * REQUIRED: The Cloud Spanner resource for which the policy is being retrieved. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.
+         */
+        resource?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$GetIamPolicyRequest;
+    }
+    export interface Params$Resource$Projects$Instances$Databases$Backupschedules$List extends StandardParameters {
+        /**
+         * Optional. Number of backup schedules to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.
+         */
+        pageSize?: number;
+        /**
+         * Optional. If non-empty, `page_token` should contain a next_page_token from a previous ListBackupSchedulesResponse to the same `parent`.
+         */
+        pageToken?: string;
+        /**
+         * Required. Database is the parent resource whose backup schedules should be listed. Values are of the form projects//instances//databases/
+         */
+        parent?: string;
+    }
+    export interface Params$Resource$Projects$Instances$Databases$Backupschedules$Patch extends StandardParameters {
+        /**
+         * Identifier. Output only for the CreateBackupSchedule operation. Required for the UpdateBackupSchedule operation. A globally unique identifier for the backup schedule which cannot be changed. Values are of the form `projects//instances//databases//backupSchedules/a-z*[a-z0-9]` The final segment of the name must be between 2 and 60 characters in length.
+         */
+        name?: string;
+        /**
+         * Required. A mask specifying which fields in the BackupSchedule resource should be updated. This mask is relative to the BackupSchedule resource, not to the request message. The field mask must always be specified; this prevents any future fields from being erased accidentally.
+         */
+        updateMask?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$BackupSchedule;
+    }
+    export interface Params$Resource$Projects$Instances$Databases$Backupschedules$Setiampolicy extends StandardParameters {
+        /**
+         * REQUIRED: The Cloud Spanner resource for which the policy is being set. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for databases resources.
+         */
+        resource?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$SetIamPolicyRequest;
+    }
+    export interface Params$Resource$Projects$Instances$Databases$Backupschedules$Testiampermissions extends StandardParameters {
+        /**
+         * REQUIRED: The Cloud Spanner resource for which permissions are being tested. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.
+         */
+        resource?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$TestIamPermissionsRequest;
+    }
     export class Resource$Projects$Instances$Databases$Databaseroles {
         context: APIRequestContext;
         constructor(context: APIRequestContext);
@@ -4663,7 +5109,7 @@ export declare namespace spanner_v1 {
          */
         pageToken?: string;
         /**
-         * Required. The instance whose instance partitions should be listed. Values are of the form `projects//instances/`.
+         * Required. The instance whose instance partitions should be listed. Values are of the form `projects//instances/`. Use `{instance\} = '-'` to list instance partitions for all Instances in a project, e.g., `projects/myproject/instances/-`.
          */
         parent?: string;
     }