@googleapis/spanner 1.1.1 → 3.0.0

package/v1.ts

@@ -126,6 +126,53 @@ export namespace spanner_v1 {
     }
   }
 
+  /**
+   * 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.
    */
@@ -222,6 +269,36 @@ export 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.
    */
@@ -654,6 +731,19 @@ export 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); \}
    */
@@ -684,6 +774,15 @@ export 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.
    */
@@ -726,6 +825,10 @@ export 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.
      */
@@ -849,6 +952,32 @@ export 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.
    */
@@ -871,6 +1000,10 @@ export 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.
      */
@@ -1342,6 +1475,15 @@ export 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.
    */
@@ -1363,7 +1505,7 @@ export 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} | null;
   }
@@ -1465,7 +1607,7 @@ export 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;
     /**
@@ -1549,7 +1691,7 @@ export 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 {
     /**
@@ -1590,6 +1732,15 @@ export 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.
    */
@@ -1611,6 +1762,10 @@ export 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.
@@ -1653,6 +1808,10 @@ export 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.
      */
@@ -1709,6 +1868,19 @@ export 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.
    */
@@ -2430,11 +2602,15 @@ export namespace spanner_v1 {
   export class Resource$Projects$Instanceconfigs {
     context: APIRequestContext;
     operations: Resource$Projects$Instanceconfigs$Operations;
+    ssdCaches: Resource$Projects$Instanceconfigs$Ssdcaches;
     constructor(context: APIRequestContext) {
       this.context = context;
       this.operations = new Resource$Projects$Instanceconfigs$Operations(
         this.context
       );
+      this.ssdCaches = new Resource$Projects$Instanceconfigs$Ssdcaches(
+        this.context
+      );
     }
 
     /**
@@ -2738,19 +2914,429 @@ export namespace spanner_v1 {
         | BodyResponseCallback<Schema$ListInstanceConfigsResponse>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$ListInstanceConfigsResponse>
+        | BodyResponseCallback<Schema$ListInstanceConfigsResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$ListInstanceConfigsResponse>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Projects$Instanceconfigs$List;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Projects$Instanceconfigs$List;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://spanner.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/v1/{+parent}/instanceConfigs').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['parent'],
+        pathParams: ['parent'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$ListInstanceConfigsResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$ListInstanceConfigsResponse>(parameters);
+      }
+    }
+
+    /**
+     * 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.
+     *
+     * @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$Instanceconfigs$Patch,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    patch(
+      params?: Params$Resource$Projects$Instanceconfigs$Patch,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Operation>;
+    patch(
+      params: Params$Resource$Projects$Instanceconfigs$Patch,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    patch(
+      params: Params$Resource$Projects$Instanceconfigs$Patch,
+      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    patch(
+      params: Params$Resource$Projects$Instanceconfigs$Patch,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    patch(callback: BodyResponseCallback<Schema$Operation>): void;
+    patch(
+      paramsOrCallback?:
+        | Params$Resource$Projects$Instanceconfigs$Patch
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$Operation> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Projects$Instanceconfigs$Patch;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Projects$Instanceconfigs$Patch;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://spanner.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+            method: 'PATCH',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['name'],
+        pathParams: ['name'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Operation>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Operation>(parameters);
+      }
+    }
+  }
+
+  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/`.
+     */
+    parent?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$CreateInstanceConfigRequest;
+  }
+  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.
+     */
+    etag?: string;
+    /**
+     * Required. The name of the instance configuration to be deleted. Values are of the form `projects//instanceConfigs/`
+     */
+    name?: string;
+    /**
+     * An option to validate, but not actually execute, a request, and provide the same response.
+     */
+    validateOnly?: boolean;
+  }
+  export interface Params$Resource$Projects$Instanceconfigs$Get
+    extends StandardParameters {
+    /**
+     * Required. The name of the requested instance configuration. Values are of the form `projects//instanceConfigs/`.
+     */
+    name?: string;
+  }
+  export interface Params$Resource$Projects$Instanceconfigs$List
+    extends StandardParameters {
+    /**
+     * Number of instance configurations to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.
+     */
+    pageSize?: number;
+    /**
+     * If non-empty, `page_token` should contain a next_page_token from a previous ListInstanceConfigsResponse.
+     */
+    pageToken?: string;
+    /**
+     * Required. The name of the project for which a list of supported instance configurations is requested. Values are of the form `projects/`.
+     */
+    parent?: string;
+  }
+  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*`.
+     */
+    name?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$UpdateInstanceConfigRequest;
+  }
+
+  export class Resource$Projects$Instanceconfigs$Operations {
+    context: APIRequestContext;
+    constructor(context: APIRequestContext) {
+      this.context = context;
+    }
+
+    /**
+     * 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$Operations$Cancel,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    cancel(
+      params?: Params$Resource$Projects$Instanceconfigs$Operations$Cancel,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Empty>;
+    cancel(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Cancel,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    cancel(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Cancel,
+      options: MethodOptions | BodyResponseCallback<Schema$Empty>,
+      callback: BodyResponseCallback<Schema$Empty>
+    ): void;
+    cancel(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Cancel,
+      callback: BodyResponseCallback<Schema$Empty>
+    ): void;
+    cancel(callback: BodyResponseCallback<Schema$Empty>): void;
+    cancel(
+      paramsOrCallback?:
+        | Params$Resource$Projects$Instanceconfigs$Operations$Cancel
+        | BodyResponseCallback<Schema$Empty>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Empty>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Empty>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$Empty> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Projects$Instanceconfigs$Operations$Cancel;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params =
+          {} as Params$Resource$Projects$Instanceconfigs$Operations$Cancel;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://spanner.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/v1/{+name}:cancel').replace(/([^:]\/)\/+/g, '$1'),
+            method: 'POST',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['name'],
+        pathParams: ['name'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Empty>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Empty>(parameters);
+      }
+    }
+
+    /**
+     * 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$Operations$Delete,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    delete(
+      params?: Params$Resource$Projects$Instanceconfigs$Operations$Delete,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Empty>;
+    delete(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Delete,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    delete(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Delete,
+      options: MethodOptions | BodyResponseCallback<Schema$Empty>,
+      callback: BodyResponseCallback<Schema$Empty>
+    ): void;
+    delete(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Delete,
+      callback: BodyResponseCallback<Schema$Empty>
+    ): void;
+    delete(callback: BodyResponseCallback<Schema$Empty>): void;
+    delete(
+      paramsOrCallback?:
+        | Params$Resource$Projects$Instanceconfigs$Operations$Delete
+        | BodyResponseCallback<Schema$Empty>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Empty>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Empty>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$Empty> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Projects$Instanceconfigs$Operations$Delete;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params =
+          {} as Params$Resource$Projects$Instanceconfigs$Operations$Delete;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://spanner.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+            method: 'DELETE',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['name'],
+        pathParams: ['name'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Empty>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Empty>(parameters);
+      }
+    }
+
+    /**
+     * 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$Operations$Get,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    get(
+      params?: Params$Resource$Projects$Instanceconfigs$Operations$Get,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Operation>;
+    get(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Get,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    get(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Get,
+      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    get(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$Get,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    get(callback: BodyResponseCallback<Schema$Operation>): void;
+    get(
+      paramsOrCallback?:
+        | Params$Resource$Projects$Instanceconfigs$Operations$Get
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Operation>
         | BodyResponseCallback<Readable>
-    ):
-      | void
-      | GaxiosPromise<Schema$ListInstanceConfigsResponse>
-      | GaxiosPromise<Readable> {
+    ): void | GaxiosPromise<Schema$Operation> | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Projects$Instanceconfigs$List;
+        {}) as Params$Resource$Projects$Instanceconfigs$Operations$Get;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Projects$Instanceconfigs$List;
+        params = {} as Params$Resource$Projects$Instanceconfigs$Operations$Get;
         options = {};
       }
 
@@ -2763,81 +3349,83 @@ export namespace spanner_v1 {
       const parameters = {
         options: Object.assign(
           {
-            url: (rootUrl + '/v1/{+parent}/instanceConfigs').replace(
-              /([^:]\/)\/+/g,
-              '$1'
-            ),
+            url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
             method: 'GET',
           },
           options
         ),
         params,
-        requiredParams: ['parent'],
-        pathParams: ['parent'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$ListInstanceConfigsResponse>(
+        createAPIRequest<Schema$Operation>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$ListInstanceConfigsResponse>(parameters);
+        return createAPIRequest<Schema$Operation>(parameters);
       }
     }
 
     /**
-     * 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.
+     * 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.
      */
-    patch(
-      params: Params$Resource$Projects$Instanceconfigs$Patch,
+    list(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$List,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
-    patch(
-      params?: Params$Resource$Projects$Instanceconfigs$Patch,
+    list(
+      params?: Params$Resource$Projects$Instanceconfigs$Operations$List,
       options?: MethodOptions
-    ): GaxiosPromise<Schema$Operation>;
-    patch(
-      params: Params$Resource$Projects$Instanceconfigs$Patch,
+    ): GaxiosPromise<Schema$ListOperationsResponse>;
+    list(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$List,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    patch(
-      params: Params$Resource$Projects$Instanceconfigs$Patch,
-      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
-      callback: BodyResponseCallback<Schema$Operation>
+    list(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$List,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$ListOperationsResponse>,
+      callback: BodyResponseCallback<Schema$ListOperationsResponse>
     ): void;
-    patch(
-      params: Params$Resource$Projects$Instanceconfigs$Patch,
-      callback: BodyResponseCallback<Schema$Operation>
+    list(
+      params: Params$Resource$Projects$Instanceconfigs$Operations$List,
+      callback: BodyResponseCallback<Schema$ListOperationsResponse>
     ): void;
-    patch(callback: BodyResponseCallback<Schema$Operation>): void;
-    patch(
+    list(callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
+    list(
       paramsOrCallback?:
-        | Params$Resource$Projects$Instanceconfigs$Patch
-        | BodyResponseCallback<Schema$Operation>
+        | Params$Resource$Projects$Instanceconfigs$Operations$List
+        | BodyResponseCallback<Schema$ListOperationsResponse>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Schema$ListOperationsResponse>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Schema$ListOperationsResponse>
         | BodyResponseCallback<Readable>
-    ): void | GaxiosPromise<Schema$Operation> | GaxiosPromise<Readable> {
+    ):
+      | void
+      | GaxiosPromise<Schema$ListOperationsResponse>
+      | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Projects$Instanceconfigs$Patch;
+        {}) as Params$Resource$Projects$Instanceconfigs$Operations$List;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Projects$Instanceconfigs$Patch;
+        params = {} as Params$Resource$Projects$Instanceconfigs$Operations$List;
         options = {};
       }
 
@@ -2851,7 +3439,7 @@ export namespace spanner_v1 {
         options: Object.assign(
           {
             url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
-            method: 'PATCH',
+            method: 'GET',
           },
           options
         ),
@@ -2861,79 +3449,70 @@ export namespace spanner_v1 {
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$Operation>(
+        createAPIRequest<Schema$ListOperationsResponse>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$Operation>(parameters);
+        return createAPIRequest<Schema$ListOperationsResponse>(parameters);
       }
     }
   }
 
-  export interface Params$Resource$Projects$Instanceconfigs$Create
+  export interface Params$Resource$Projects$Instanceconfigs$Operations$Cancel
     extends StandardParameters {
     /**
-     * Required. The name of the project in which to create the instance config. Values are of the form `projects/`.
-     */
-    parent?: string;
-
-    /**
-     * Request body metadata
+     * The name of the operation resource to be cancelled.
      */
-    requestBody?: Schema$CreateInstanceConfigRequest;
+    name?: string;
   }
-  export interface Params$Resource$Projects$Instanceconfigs$Delete
+  export interface Params$Resource$Projects$Instanceconfigs$Operations$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.
-     */
-    etag?: string;
-    /**
-     * Required. The name of the instance configuration to be deleted. Values are of the form `projects//instanceConfigs/`
+     * The name of the operation resource to be deleted.
      */
     name?: string;
-    /**
-     * An option to validate, but not actually execute, a request, and provide the same response.
-     */
-    validateOnly?: boolean;
   }
-  export interface Params$Resource$Projects$Instanceconfigs$Get
+  export interface Params$Resource$Projects$Instanceconfigs$Operations$Get
     extends StandardParameters {
     /**
-     * Required. The name of the requested instance configuration. Values are of the form `projects//instanceConfigs/`.
+     * The name of the operation resource.
      */
     name?: string;
   }
-  export interface Params$Resource$Projects$Instanceconfigs$List
+  export interface Params$Resource$Projects$Instanceconfigs$Operations$List
     extends StandardParameters {
     /**
-     * Number of instance configurations to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.
+     * The standard list filter.
      */
-    pageSize?: number;
+    filter?: string;
     /**
-     * If non-empty, `page_token` should contain a next_page_token from a previous ListInstanceConfigsResponse.
+     * The name of the operation's parent resource.
      */
-    pageToken?: string;
+    name?: string;
     /**
-     * Required. The name of the project for which a list of supported instance configurations is requested. Values are of the form `projects/`.
+     * The standard list page size.
      */
-    parent?: string;
-  }
-  export interface Params$Resource$Projects$Instanceconfigs$Patch
-    extends StandardParameters {
+    pageSize?: number;
     /**
-     * A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`.
+     * The standard list page token.
      */
-    name?: string;
+    pageToken?: string;
+  }
 
-    /**
-     * Request body metadata
-     */
-    requestBody?: Schema$UpdateInstanceConfigRequest;
+  export class Resource$Projects$Instanceconfigs$Ssdcaches {
+    context: APIRequestContext;
+    operations: Resource$Projects$Instanceconfigs$Ssdcaches$Operations;
+    constructor(context: APIRequestContext) {
+      this.context = context;
+      this.operations =
+        new Resource$Projects$Instanceconfigs$Ssdcaches$Operations(
+          this.context
+        );
+    }
   }
 
-  export class Resource$Projects$Instanceconfigs$Operations {
+  export class Resource$Projects$Instanceconfigs$Ssdcaches$Operations {
     context: APIRequestContext;
     constructor(context: APIRequestContext) {
       this.context = context;
@@ -2948,31 +3527,31 @@ export namespace spanner_v1 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     cancel(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$Cancel,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
     cancel(
-      params?: Params$Resource$Projects$Instanceconfigs$Operations$Cancel,
+      params?: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel,
       options?: MethodOptions
     ): GaxiosPromise<Schema$Empty>;
     cancel(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$Cancel,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     cancel(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$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$Operations$Cancel,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel,
       callback: BodyResponseCallback<Schema$Empty>
     ): void;
     cancel(callback: BodyResponseCallback<Schema$Empty>): void;
     cancel(
       paramsOrCallback?:
-        | Params$Resource$Projects$Instanceconfigs$Operations$Cancel
+        | Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel
         | BodyResponseCallback<Schema$Empty>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
@@ -2985,13 +3564,13 @@ export namespace spanner_v1 {
         | BodyResponseCallback<Readable>
     ): void | GaxiosPromise<Schema$Empty> | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Projects$Instanceconfigs$Operations$Cancel;
+        {}) as Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
         params =
-          {} as Params$Resource$Projects$Instanceconfigs$Operations$Cancel;
+          {} as Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Cancel;
         options = {};
       }
 
@@ -3033,31 +3612,31 @@ export namespace spanner_v1 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     delete(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$Delete,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
     delete(
-      params?: Params$Resource$Projects$Instanceconfigs$Operations$Delete,
+      params?: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete,
       options?: MethodOptions
     ): GaxiosPromise<Schema$Empty>;
     delete(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$Delete,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     delete(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$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$Operations$Delete,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete,
       callback: BodyResponseCallback<Schema$Empty>
     ): void;
     delete(callback: BodyResponseCallback<Schema$Empty>): void;
     delete(
       paramsOrCallback?:
-        | Params$Resource$Projects$Instanceconfigs$Operations$Delete
+        | Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete
         | BodyResponseCallback<Schema$Empty>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
@@ -3070,13 +3649,13 @@ export namespace spanner_v1 {
         | BodyResponseCallback<Readable>
     ): void | GaxiosPromise<Schema$Empty> | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Projects$Instanceconfigs$Operations$Delete;
+        {}) as Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
         params =
-          {} as Params$Resource$Projects$Instanceconfigs$Operations$Delete;
+          {} as Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Delete;
         options = {};
       }
 
@@ -3118,31 +3697,31 @@ export namespace spanner_v1 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     get(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$Get,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
     get(
-      params?: Params$Resource$Projects$Instanceconfigs$Operations$Get,
+      params?: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get,
       options?: MethodOptions
     ): GaxiosPromise<Schema$Operation>;
     get(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$Get,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     get(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$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$Operations$Get,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get,
       callback: BodyResponseCallback<Schema$Operation>
     ): void;
     get(callback: BodyResponseCallback<Schema$Operation>): void;
     get(
       paramsOrCallback?:
-        | Params$Resource$Projects$Instanceconfigs$Operations$Get
+        | Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get
         | BodyResponseCallback<Schema$Operation>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
@@ -3155,12 +3734,13 @@ export namespace spanner_v1 {
         | BodyResponseCallback<Readable>
     ): void | GaxiosPromise<Schema$Operation> | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Projects$Instanceconfigs$Operations$Get;
+        {}) as Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Projects$Instanceconfigs$Operations$Get;
+        params =
+          {} as Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$Get;
         options = {};
       }
 
@@ -3202,33 +3782,33 @@ export namespace spanner_v1 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     list(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$List,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
     list(
-      params?: Params$Resource$Projects$Instanceconfigs$Operations$List,
+      params?: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List,
       options?: MethodOptions
     ): GaxiosPromise<Schema$ListOperationsResponse>;
     list(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$List,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     list(
-      params: Params$Resource$Projects$Instanceconfigs$Operations$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$Operations$List,
+      params: Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List,
       callback: BodyResponseCallback<Schema$ListOperationsResponse>
     ): void;
     list(callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
     list(
       paramsOrCallback?:
-        | Params$Resource$Projects$Instanceconfigs$Operations$List
+        | Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List
         | BodyResponseCallback<Schema$ListOperationsResponse>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
@@ -3244,12 +3824,13 @@ export namespace spanner_v1 {
       | GaxiosPromise<Schema$ListOperationsResponse>
       | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Projects$Instanceconfigs$Operations$List;
+        {}) as Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Projects$Instanceconfigs$Operations$List;
+        params =
+          {} as Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List;
         options = {};
       }
 
@@ -3283,28 +3864,28 @@ export namespace spanner_v1 {
     }
   }
 
-  export interface Params$Resource$Projects$Instanceconfigs$Operations$Cancel
+  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$Operations$Delete
+  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$Operations$Get
+  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$Operations$List
+  export interface Params$Resource$Projects$Instanceconfigs$Ssdcaches$Operations$List
     extends StandardParameters {
     /**
      * The standard list filter.
@@ -7642,6 +8223,97 @@ export namespace spanner_v1 {
       }
     }
 
+    /**
+     * 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;
+    batchWrite(
+      paramsOrCallback?:
+        | Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite
+        | BodyResponseCallback<Schema$BatchWriteResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$BatchWriteResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$BatchWriteResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$BatchWriteResponse>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params =
+          {} as Params$Resource$Projects$Instances$Databases$Sessions$Batchwrite;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://spanner.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/v1/{+session}:batchWrite').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'POST',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['session'],
+        pathParams: ['session'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$BatchWriteResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$BatchWriteResponse>(parameters);
+      }
+    }
+
     /**
      * Begins a new transaction. This step can often be skipped: Read, ExecuteSql and Commit can begin a new transaction as a side-effect.
      *
@@ -8907,6 +9579,18 @@ export 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 {
     /**