@googleapis/spanner 1.1.1 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [3.0.0](https://github.com/googleapis/google-api-nodejs-client/compare/spanner-v2.0.0...spanner-v3.0.0) (2023-11-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* This release has breaking changes.
+
+### Features
+
+* run the generator ([#3371](https://github.com/googleapis/google-api-nodejs-client/issues/3371)) ([d3fd980](https://github.com/googleapis/google-api-nodejs-client/commit/d3fd980907c318048c7ee471c38033cf529a3c04))
+* **spanner:** update the API ([19c8a5e](https://github.com/googleapis/google-api-nodejs-client/commit/19c8a5e40f233682de4a75d7f802e0fd7d80f8ef))
+
+## [2.0.0](https://github.com/googleapis/google-api-nodejs-client/compare/spanner-v1.1.1...spanner-v2.0.0) (2023-10-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* This release has breaking changes.
+
+### Features
+
+* run the generator ([#3355](https://github.com/googleapis/google-api-nodejs-client/issues/3355)) ([5504c86](https://github.com/googleapis/google-api-nodejs-client/commit/5504c86fd61740886047320e2ed70f02a164acd7))
+* **spanner:** update the API ([3d046d5](https://github.com/googleapis/google-api-nodejs-client/commit/3d046d5e6193f876b4ade162c3581e43f057031f))
+
 ## [1.1.1](https://github.com/googleapis/google-api-nodejs-client/compare/spanner-v1.1.0...spanner-v1.1.1) (2023-08-25)
 
 

package/build/v1.d.ts

@@ -72,6 +72,53 @@ export declare namespace spanner_v1 {
         scans: Resource$Scans;
         constructor(options: GlobalOptions, google?: GoogleConfigurable);
     }
+    /**
+     * Autoscaling config for an instance.
+     */
+    export interface Schema$AutoscalingConfig {
+        /**
+         * Required. Autoscaling limits for an instance.
+         */
+        autoscalingLimits?: Schema$AutoscalingLimits;
+        /**
+         * Required. The autoscaling targets for an instance.
+         */
+        autoscalingTargets?: Schema$AutoscalingTargets;
+    }
+    /**
+     * The autoscaling limits for the instance. Users can define the minimum and maximum compute capacity allocated to the instance, and the autoscaler will only scale within that range. Users can either use nodes or processing units to specify the limits, but should use the same unit to set both the min_limit and max_limit.
+     */
+    export interface Schema$AutoscalingLimits {
+        /**
+         * Maximum number of nodes allocated to the instance. If set, this number should be greater than or equal to min_nodes.
+         */
+        maxNodes?: number | null;
+        /**
+         * Maximum number of processing units allocated to the instance. If set, this number should be multiples of 1000 and be greater than or equal to min_processing_units.
+         */
+        maxProcessingUnits?: number | null;
+        /**
+         * Minimum number of nodes allocated to the instance. If set, this number should be greater than or equal to 1.
+         */
+        minNodes?: number | null;
+        /**
+         * Minimum number of processing units allocated to the instance. If set, this number should be multiples of 1000.
+         */
+        minProcessingUnits?: number | null;
+    }
+    /**
+     * The autoscaling targets for an instance.
+     */
+    export interface Schema$AutoscalingTargets {
+        /**
+         * Required. The target high priority cpu utilization percentage that the autoscaler should be trying to achieve for the instance. This number is on a scale from 0 (no utilization) to 100 (full utilization). The valid range is [10, 90] inclusive.
+         */
+        highPriorityCpuUtilizationPercent?: number | null;
+        /**
+         * Required. The target storage utilization percentage that the autoscaler should be trying to achieve for the instance. This number is on a scale from 0 (no utilization) to 100 (full utilization). The valid range is [10, 100] inclusive.
+         */
+        storageUtilizationPercent?: number | null;
+    }
     /**
      * A backup of a Cloud Spanner database.
      */
@@ -168,6 +215,36 @@ export declare namespace spanner_v1 {
          */
         session?: Schema$Session[];
     }
+    /**
+     * The request for BatchWrite.
+     */
+    export interface Schema$BatchWriteRequest {
+        /**
+         * Required. The groups of mutations to be applied.
+         */
+        mutationGroups?: Schema$MutationGroup[];
+        /**
+         * Common options for this request.
+         */
+        requestOptions?: Schema$RequestOptions;
+    }
+    /**
+     * The result of applying a batch of mutations.
+     */
+    export interface Schema$BatchWriteResponse {
+        /**
+         * The commit timestamp of the transaction that applied this batch. Present if `status` is `OK`, absent otherwise.
+         */
+        commitTimestamp?: string | null;
+        /**
+         * The mutation groups applied in this batch. The values index into the `mutation_groups` field in the corresponding `BatchWriteRequest`.
+         */
+        indexes?: number[] | null;
+        /**
+         * An `OK` status indicates success. Any other status indicates a failure.
+         */
+        status?: Schema$Status;
+    }
     /**
      * The request for BeginTransaction.
      */
@@ -600,6 +677,19 @@ export declare namespace spanner_v1 {
          */
         shortMessage?: Schema$LocalizedString;
     }
+    /**
+     * The DirectedReadOptions can be used to indicate which replicas or regions should be used for non-transactional reads or queries. DirectedReadOptions may only be specified for a read-only transaction, otherwise the API will return an `INVALID_ARGUMENT` error.
+     */
+    export interface Schema$DirectedReadOptions {
+        /**
+         * Exclude_replicas indicates that should be excluded from serving requests. Spanner will not route requests to the replicas in this list.
+         */
+        excludeReplicas?: Schema$ExcludeReplicas;
+        /**
+         * Include_replicas indicates the order of replicas (as they appear in this list) to process the request. If auto_failover_disabled is set to true and all replicas are exhausted without finding a healthy replica, Spanner will wait for a replica in the list to become available, requests may fail due to `DEADLINE_EXCEEDED` errors.
+         */
+        includeReplicas?: Schema$IncludeReplicas;
+    }
     /**
      * 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); \}
      */
@@ -631,6 +721,15 @@ export declare namespace spanner_v1 {
          */
         kmsKeyVersion?: string | null;
     }
+    /**
+     * An ExcludeReplicas contains a repeated set of ReplicaSelection that should be excluded from serving requests.
+     */
+    export interface Schema$ExcludeReplicas {
+        /**
+         * The directed read replica selector.
+         */
+        replicaSelections?: Schema$ReplicaSelection[];
+    }
     /**
      * The request for ExecuteBatchDml.
      */
@@ -673,6 +772,10 @@ export declare namespace spanner_v1 {
          * If this is for a partitioned query and this field is set to `true`, the request is executed with Spanner Data Boost independent compute resources. If the field is set to `true` but the request does not set `partition_token`, the API returns an `INVALID_ARGUMENT` error.
          */
         dataBoostEnabled?: boolean | null;
+        /**
+         * Directed read options for this request.
+         */
+        directedReadOptions?: Schema$DirectedReadOptions;
         /**
          * Parameter names and values that bind to placeholders in the SQL string. A parameter placeholder consists of the `@` character followed by the parameter name (for example, `@firstName`). Parameter names must conform to the naming requirements of identifiers as specified at https://cloud.google.com/spanner/docs/lexical#identifiers. Parameters can appear anywhere that a literal value is expected. The same parameter name can be used more than once, for example: `"WHERE id \> @msg_id AND id < @msg_id + 100"` It is an error to execute a SQL statement with unbound parameters.
          */
@@ -800,6 +903,32 @@ export declare namespace spanner_v1 {
          */
         requestedPolicyVersion?: number | null;
     }
+    /**
+     * An IncludeReplicas contains a repeated set of ReplicaSelection which indicates the order in which replicas should be considered.
+     */
+    export interface Schema$IncludeReplicas {
+        /**
+         * If true, Spanner will not route requests to a replica outside the include_replicas list when all of the specified replicas are unavailable or unhealthy. Default value is `false`.
+         */
+        autoFailoverDisabled?: boolean | null;
+        /**
+         * The directed read replica selector.
+         */
+        replicaSelections?: Schema$ReplicaSelection[];
+    }
+    /**
+     * Recommendation to add new indexes to run queries more efficiently.
+     */
+    export interface Schema$IndexAdvice {
+        /**
+         * Optional. DDL statements to add new indexes that will improve the query.
+         */
+        ddl?: string[] | null;
+        /**
+         * Optional. Estimated latency improvement factor. For example if the query currently takes 500 ms to run and the estimated latency with new indexes is 100 ms this field will be 5.
+         */
+        improvementFactor?: number | null;
+    }
     /**
      * A message representing a (sparse) collection of hot keys for specific key buckets.
      */
@@ -826,6 +955,10 @@ export declare namespace spanner_v1 {
      * An isolated set of Cloud Spanner resources on which databases can be hosted.
      */
     export interface Schema$Instance {
+        /**
+         * Optional. The autoscaling configuration. Autoscaling is enabled if this field is set. When autoscaling is enabled, node_count and processing_units are treated as OUTPUT_ONLY fields and reflect the current compute capacity allocated to the instance.
+         */
+        autoscalingConfig?: Schema$AutoscalingConfig;
         /**
          * Required. The name of the instance's configuration. Values are of the form `projects//instanceConfigs/`. See also InstanceConfig and ListInstanceConfigs.
          */
@@ -1307,6 +1440,15 @@ export declare namespace spanner_v1 {
          */
         update?: Schema$Write;
     }
+    /**
+     * A group of mutations to be committed together. Related mutations should be placed in a group. For example, two mutations inserting rows with the same primary key prefix in both parent and child tables are related.
+     */
+    export interface Schema$MutationGroup {
+        /**
+         * Required. The mutations in this group.
+         */
+        mutations?: Schema$Mutation[];
+    }
     /**
      * This resource represents a long-running operation that is the result of a network API call.
      */
@@ -1330,7 +1472,7 @@ export declare namespace spanner_v1 {
          */
         name?: string | null;
         /**
-         * The normal response of the operation in case of success. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
+         * The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
          */
         response?: {
             [key: string]: any;
@@ -1439,7 +1581,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. The query plan of a root partitionable query has a single distributed union operator. A distributed union operator conceptually divides one or more tables into multiple splits, remotely evaluates a subquery independently on each split, and then unions all results. This 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 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, the first operator in the query execution plan must be a distributed union operator. 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;
         /**
@@ -1527,7 +1669,7 @@ export declare namespace spanner_v1 {
         shortRepresentation?: Schema$ShortRepresentation;
     }
     /**
-     * An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** { "bindings": [ { "role": "roles/resourcemanager.organizationAdmin", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] \}, { "role": "roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" ], "condition": { "title": "expirable access", "description": "Does not grant access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00:00:00.000Z')", \} \} ], "etag": "BwWWja0YfJA=", "version": 3 \} **YAML example:** bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).
+     * An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** ``` { "bindings": [ { "role": "roles/resourcemanager.organizationAdmin", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] \}, { "role": "roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" ], "condition": { "title": "expirable access", "description": "Does not grant access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00:00:00.000Z')", \} \} ], "etag": "BwWWja0YfJA=", "version": 3 \} ``` **YAML example:** ``` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 ``` For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).
      */
     export interface Schema$Policy {
         /**
@@ -1568,6 +1710,15 @@ export declare namespace spanner_v1 {
          */
         word?: string | null;
     }
+    /**
+     * Output of query advisor analysis.
+     */
+    export interface Schema$QueryAdvisorResult {
+        /**
+         * Optional. Index Recommendation for a query. This is an optional field and the recommendation will only be available when the recommendation guarantees significant improvement in query performance.
+         */
+        indexAdvice?: Schema$IndexAdvice[];
+    }
     /**
      * Query optimizer configuration.
      */
@@ -1589,6 +1740,10 @@ export declare namespace spanner_v1 {
          * The nodes in the query plan. Plan nodes are returned in pre-order starting with the plan root. Each PlanNode's `id` corresponds to its index in `plan_nodes`.
          */
         planNodes?: Schema$PlanNode[];
+        /**
+         * Optional. The advices/recommendations for a query. Currently this field will be serving index recommendations for a query.
+         */
+        queryAdvice?: Schema$QueryAdvisorResult;
     }
     /**
      * Message type to initiate a read-only transaction.
@@ -1631,6 +1786,10 @@ export declare namespace spanner_v1 {
          * If this is for a partitioned read and this field is set to `true`, the request is executed with Spanner Data Boost independent compute resources. If the field is set to `true` but the request does not set `partition_token`, the API returns an `INVALID_ARGUMENT` error.
          */
         dataBoostEnabled?: boolean | null;
+        /**
+         * Directed read options for this request.
+         */
+        directedReadOptions?: Schema$DirectedReadOptions;
         /**
          * If non-empty, the name of an index on table. This index is used instead of the table primary key when interpreting key_set and sorting result rows. See key_set for further information.
          */
@@ -1687,6 +1846,19 @@ export declare namespace spanner_v1 {
          */
         type?: string | null;
     }
+    /**
+     * The directed read replica selector. Callers must provide one or more of the following fields for replica selection: * `location` - The location must be one of the regions within the multi-region configuration of your database. * `type` - The type of the replica. Some examples of using replica_selectors are: * `location:us-east1` --\> The "us-east1" replica(s) of any available type will be used to process the request. * `type:READ_ONLY` --\> The "READ_ONLY" type replica(s) in nearest . available location will be used to process the request. * `location:us-east1 type:READ_ONLY` --\> The "READ_ONLY" type replica(s) in location "us-east1" will be used to process the request.
+     */
+    export interface Schema$ReplicaSelection {
+        /**
+         * The location or region of the serving requests, e.g. "us-east1".
+         */
+        location?: string | null;
+        /**
+         * The type of replica.
+         */
+        type?: string | null;
+    }
     /**
      * Common request options for various APIs.
      */
@@ -2325,6 +2497,7 @@ export declare namespace spanner_v1 {
     export class Resource$Projects$Instanceconfigs {
         context: APIRequestContext;
         operations: Resource$Projects$Instanceconfigs$Operations;
+        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.
@@ -2547,6 +2720,107 @@ export declare namespace spanner_v1 {
          */
         pageToken?: string;
     }
+    export class Resource$Projects$Instanceconfigs$Ssdcaches {
+        context: APIRequestContext;
+        operations: Resource$Projects$Instanceconfigs$Ssdcaches$Operations;
+        constructor(context: APIRequestContext);
+    }
+    export class Resource$Projects$Instanceconfigs$Ssdcaches$Operations {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.
+         *
+         * @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.
+         */
+        cancel(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        cancel(params?: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        cancel(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        cancel(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
+        cancel(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel, callback: BodyResponseCallback<Schema$Empty>): void;
+        cancel(callback: BodyResponseCallback<Schema$Empty>): void;
+        /**
+         * Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
+         *
+         * @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$Instanceconfigs$Ssdcaches$Operations$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        delete(params?: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        delete(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        delete(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
+        delete(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
+        delete(callback: BodyResponseCallback<Schema$Empty>): void;
+        /**
+         * Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
+         *
+         * @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$Instanceconfigs$Ssdcaches$Operations$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        get(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
+        get(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get, callback: BodyResponseCallback<Schema$Operation>): void;
+        get(callback: BodyResponseCallback<Schema$Operation>): void;
+        /**
+         * Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.
+         *
+         * @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$Instanceconfigs$Ssdcaches$Operations$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List, options?: MethodOptions): GaxiosPromise<Schema$ListOperationsResponse>;
+        list(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List, options: MethodOptions | BodyResponseCallback<Schema$ListOperationsResponse>, callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
+        list(params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List, callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
+    }
+    export interface Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel extends StandardParameters {
+        /**
+         * The name of the operation resource to be cancelled.
+         */
+        name?: string;
+    }
+    export interface Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete extends StandardParameters {
+        /**
+         * The name of the operation resource to be deleted.
+         */
+        name?: string;
+    }
+    export interface Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get extends StandardParameters {
+        /**
+         * The name of the operation resource.
+         */
+        name?: string;
+    }
+    export interface Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List extends StandardParameters {
+        /**
+         * The standard list filter.
+         */
+        filter?: string;
+        /**
+         * The name of the operation's parent resource.
+         */
+        name?: string;
+        /**
+         * The standard list page size.
+         */
+        pageSize?: number;
+        /**
+         * The standard list page token.
+         */
+        pageToken?: string;
+    }
     export class Resource$Projects$Instances {
         context: APIRequestContext;
         backupOperations: Resource$Projects$Instances$Backupoperations;
@@ -3630,6 +3904,20 @@ export declare namespace spanner_v1 {
         batchCreate(params: Params$Resource$Projects$Instances$Databases$Sessions$Batchcreate, options: MethodOptions | BodyResponseCallback<Schema$BatchCreateSessionsResponse>, callback: BodyResponseCallback<Schema$BatchCreateSessionsResponse>): void;
         batchCreate(params: Params$Resource$Projects$Instances$Databases$Sessions$Batchcreate, callback: BodyResponseCallback<Schema$BatchCreateSessionsResponse>): void;
         batchCreate(callback: BodyResponseCallback<Schema$BatchCreateSessionsResponse>): void;
+        /**
+         * Batches the supplied mutation groups in a collection of efficient transactions. All mutations in a group are committed atomically. However, mutations across groups can be committed non-atomically in an unspecified order and thus, they must be independent of each other. Partial failure is possible, i.e., some groups may have been committed successfully, while some may have failed. The results of individual batches are streamed into the response as the batches are applied. BatchWrite requests are not replay protected, meaning that each mutation group may be applied more than once. Replays of non-idempotent mutations may have undesirable effects. For example, replays of an insert mutation may produce an already exists error or if you use generated or commit timestamp-based keys, it may result in additional rows being added to the mutation's table. We recommend structuring your mutation groups to be idempotent to avoid this issue.
+         *
+         * @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.
+         */
+        batchWrite(params: Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        batchWrite(params?: Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite, options?: MethodOptions): GaxiosPromise<Schema$BatchWriteResponse>;
+        batchWrite(params: Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        batchWrite(params: Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite, options: MethodOptions | BodyResponseCallback<Schema$BatchWriteResponse>, callback: BodyResponseCallback<Schema$BatchWriteResponse>): void;
+        batchWrite(params: Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite, callback: BodyResponseCallback<Schema$BatchWriteResponse>): void;
+        batchWrite(callback: BodyResponseCallback<Schema$BatchWriteResponse>): void;
         /**
          * Begins a new transaction. This step can often be skipped: Read, ExecuteSql and Commit can begin a new transaction as a side-effect.
          *
@@ -3837,6 +4125,16 @@ export declare namespace spanner_v1 {
          */
         requestBody?: Schema$BatchCreateSessionsRequest;
     }
+    export interface Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite extends StandardParameters {
+        /**
+         * Required. The session in which the batch request is to be run.
+         */
+        session?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$BatchWriteRequest;
+    }
     export interface Params$Resource$Projects$Instances$Databases$Sessions$Begintransaction extends StandardParameters {
         /**
          * Required. The session in which the transaction runs.