spanner_client.ts

// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ** This file is automatically generated by gapic-generator-typescript. **
// ** https://github.com/googleapis/gapic-generator-typescript **
// ** All changes to this file may be overwritten. **

/* global window */
import * as gax from 'google-gax';
import {
  Callback,
  CallOptions,
  Descriptors,
  ClientOptions,
  PaginationCallback,
  GaxCall,
} from 'google-gax';

import {Transform} from 'stream';
import {RequestType} from 'google-gax/build/src/apitypes';
import * as protos from '../../protos/protos';
import jsonProtos = require('../../protos/protos.json');
/**
 * Client JSON configuration object, loaded from
 * `src/v1/spanner_client_config.json`.
 * This file defines retry strategy and timeouts for all API methods in this library.
 */
import * as gapicConfig from './spanner_client_config.json';

const version = require('../../../package.json').version;

/**
 *  Cloud Spanner API
 *
 *  The Cloud Spanner API can be used to manage sessions and execute
 *  transactions on data stored in Cloud Spanner databases.
 * @class
 * @memberof v1
 */
export class SpannerClient {
  private _terminated = false;
  private _opts: ClientOptions;
  private _gaxModule: typeof gax | typeof gax.fallback;
  private _gaxGrpc: gax.GrpcClient | gax.fallback.GrpcClient;
  private _protos: {};
  private _defaults: {[method: string]: gax.CallSettings};
  auth: gax.GoogleAuth;
  descriptors: Descriptors = {
    page: {},
    stream: {},
    longrunning: {},
    batching: {},
  };
  innerApiCalls: {[name: string]: Function};
  pathTemplates: {[name: string]: gax.PathTemplate};
  spannerStub?: Promise<{[name: string]: Function}>;

  /**
   * Construct an instance of SpannerClient.
   *
   * @param {object} [options] - The configuration object.
   * The options accepted by the constructor are described in detail
   * in [this document](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#creating-the-client-instance).
   * The common options are:
   * @param {object} [options.credentials] - Credentials object.
   * @param {string} [options.credentials.client_email]
   * @param {string} [options.credentials.private_key]
   * @param {string} [options.email] - Account email address. Required when
   *     using a .pem or .p12 keyFilename.
   * @param {string} [options.keyFilename] - Full path to the a .json, .pem, or
   *     .p12 key downloaded from the Google Developers Console. If you provide
   *     a path to a JSON file, the projectId option below is not necessary.
   *     NOTE: .pem and .p12 require you to specify options.email as well.
   * @param {number} [options.port] - The port on which to connect to
   *     the remote host.
   * @param {string} [options.projectId] - The project ID from the Google
   *     Developer's Console, e.g. 'grape-spaceship-123'. We will also check
   *     the environment variable GCLOUD_PROJECT for your project ID. If your
   *     app is running in an environment which supports
   *     {@link https://developers.google.com/identity/protocols/application-default-credentials Application Default Credentials},
   *     your project ID will be detected automatically.
   * @param {string} [options.apiEndpoint] - The domain name of the
   *     API remote host.
   * @param {gax.ClientConfig} [options.clientConfig] - Client configuration override.
   *     Follows the structure of {@link gapicConfig}.
   * @param {boolean} [options.fallback] - Use HTTP fallback mode.
   *     In fallback mode, a special browser-compatible transport implementation is used
   *     instead of gRPC transport. In browser context (if the `window` object is defined)
   *     the fallback mode is enabled automatically; set `options.fallback` to `false`
   *     if you need to override this behavior.
   */
  constructor(opts?: ClientOptions) {
    // Ensure that options include all the required fields.
    const staticMembers = this.constructor as typeof SpannerClient;
    const servicePath =
      opts?.servicePath || opts?.apiEndpoint || staticMembers.servicePath;
    const port = opts?.port || staticMembers.port;
    const clientConfig = opts?.clientConfig ?? {};
    const fallback =
      opts?.fallback ??
      (typeof window !== 'undefined' && typeof window?.fetch === 'function');
    opts = Object.assign({servicePath, port, clientConfig, fallback}, opts);

    // If scopes are unset in options and we're connecting to a non-default endpoint, set scopes just in case.
    if (servicePath !== staticMembers.servicePath && !('scopes' in opts)) {
      opts['scopes'] = staticMembers.scopes;
    }

    // Choose either gRPC or proto-over-HTTP implementation of google-gax.
    this._gaxModule = opts.fallback ? gax.fallback : gax;

    // Create a `gaxGrpc` object, with any grpc-specific options sent to the client.
    this._gaxGrpc = new this._gaxModule.GrpcClient(opts);

    // Save options to use in initialize() method.
    this._opts = opts;

    // Save the auth object to the client, for use by other methods.
    this.auth = this._gaxGrpc.auth as gax.GoogleAuth;

    // Set the default scopes in auth client if needed.
    if (servicePath === staticMembers.servicePath) {
      this.auth.defaultScopes = staticMembers.scopes;
    }

    // Determine the client header string.
    const clientHeader = [`gax/${this._gaxModule.version}`, `gapic/${version}`];
    if (typeof process !== 'undefined' && 'versions' in process) {
      clientHeader.push(`gl-node/${process.versions.node}`);
    } else {
      clientHeader.push(`gl-web/${this._gaxModule.version}`);
    }
    if (!opts.fallback) {
      clientHeader.push(`grpc/${this._gaxGrpc.grpcVersion}`);
    } else if (opts.fallback === 'rest') {
      clientHeader.push(`rest/${this._gaxGrpc.grpcVersion}`);
    }
    if (opts.libName && opts.libVersion) {
      clientHeader.push(`${opts.libName}/${opts.libVersion}`);
    }
    // Load the applicable protos.
    this._protos = this._gaxGrpc.loadProtoJSON(jsonProtos);

    // This API contains "path templates"; forward-slash-separated
    // identifiers to uniquely identify resources within the API.
    // Create useful helper objects for these.
    this.pathTemplates = {
      databasePathTemplate: new this._gaxModule.PathTemplate(
        'projects/{project}/instances/{instance}/databases/{database}'
      ),
      sessionPathTemplate: new this._gaxModule.PathTemplate(
        'projects/{project}/instances/{instance}/databases/{database}/sessions/{session}'
      ),
    };

    // Some of the methods on this service return "paged" results,
    // (e.g. 50 results at a time, with tokens to get subsequent
    // pages). Denote the keys used for pagination and results.
    this.descriptors.page = {
      listSessions: new this._gaxModule.PageDescriptor(
        'pageToken',
        'nextPageToken',
        'sessions'
      ),
    };

    // Some of the methods on this service provide streaming responses.
    // Provide descriptors for these.
    this.descriptors.stream = {
      executeStreamingSql: new this._gaxModule.StreamDescriptor(
        gax.StreamType.SERVER_STREAMING
      ),
      streamingRead: new this._gaxModule.StreamDescriptor(
        gax.StreamType.SERVER_STREAMING
      ),
    };

    // Put together the default options sent with requests.
    this._defaults = this._gaxGrpc.constructSettings(
      'google.spanner.v1.Spanner',
      gapicConfig as gax.ClientConfig,
      opts.clientConfig || {},
      {'x-goog-api-client': clientHeader.join(' ')}
    );

    // Set up a dictionary of "inner API calls"; the core implementation
    // of calling the API is handled in `google-gax`, with this code
    // merely providing the destination and request information.
    this.innerApiCalls = {};
  }

  /**
   * Initialize the client.
   * Performs asynchronous operations (such as authentication) and prepares the client.
   * This function will be called automatically when any class method is called for the
   * first time, but if you need to initialize it before calling an actual method,
   * feel free to call initialize() directly.
   *
   * You can await on this method if you want to make sure the client is initialized.
   *
   * @returns {Promise} A promise that resolves to an authenticated service stub.
   */
  initialize() {
    // If the client stub promise is already initialized, return immediately.
    if (this.spannerStub) {
      return this.spannerStub;
    }

    // Put together the "service stub" for
    // google.spanner.v1.Spanner.
    this.spannerStub = this._gaxGrpc.createStub(
      this._opts.fallback
        ? (this._protos as protobuf.Root).lookupService(
            'google.spanner.v1.Spanner'
          )
        : // eslint-disable-next-line @typescript-eslint/no-explicit-any
          (this._protos as any).google.spanner.v1.Spanner,
      this._opts
    ) as Promise<{[method: string]: Function}>;

    // Iterate over each of the methods that the service provides
    // and create an API call method for each.
    const spannerStubMethods = [
      'createSession',
      'batchCreateSessions',
      'getSession',
      'listSessions',
      'deleteSession',
      'executeSql',
      'executeStreamingSql',
      'executeBatchDml',
      'read',
      'streamingRead',
      'beginTransaction',
      'commit',
      'rollback',
      'partitionQuery',
      'partitionRead',
    ];
    for (const methodName of spannerStubMethods) {
      const callPromise = this.spannerStub.then(
        stub =>
          (...args: Array<{}>) => {
            if (this._terminated) {
              return Promise.reject('The client has already been closed.');
            }
            const func = stub[methodName];
            return func.apply(stub, args);
          },
        (err: Error | null | undefined) => () => {
          throw err;
        }
      );

      const descriptor =
        this.descriptors.page[methodName] ||
        this.descriptors.stream[methodName] ||
        undefined;
      const apiCall = this._gaxModule.createApiCall(
        callPromise,
        this._defaults[methodName],
        descriptor
      );

      this.innerApiCalls[methodName] = apiCall;
    }

    return this.spannerStub;
  }

  /**
   * The DNS address for this API service.
   * @returns {string} The DNS address for this service.
   */
  static get servicePath() {
    return 'spanner.googleapis.com';
  }

  /**
   * The DNS address for this API service - same as servicePath(),
   * exists for compatibility reasons.
   * @returns {string} The DNS address for this service.
   */
  static get apiEndpoint() {
    return 'spanner.googleapis.com';
  }

  /**
   * The port for this API service.
   * @returns {number} The default port for this service.
   */
  static get port() {
    return 443;
  }

  /**
   * The scopes needed to make gRPC calls for every method defined
   * in this service.
   * @returns {string[]} List of default scopes.
   */
  static get scopes() {
    return [
      'https://www.googleapis.com/auth/cloud-platform',
      'https://www.googleapis.com/auth/spanner.data',
    ];
  }

  getProjectId(): Promise<string>;
  getProjectId(callback: Callback<string, undefined, undefined>): void;
  /**
   * Return the project ID used by this class.
   * @returns {Promise} A promise that resolves to string containing the project ID.
   */
  getProjectId(
    callback?: Callback<string, undefined, undefined>
  ): Promise<string> | void {
    if (callback) {
      this.auth.getProjectId(callback);
      return;
    }
    return this.auth.getProjectId();
  }

  // -------------------
  // -- Service calls --
  // -------------------
  createSession(
    request: protos.google.spanner.v1.ICreateSessionRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.ICreateSessionRequest | undefined,
      {} | undefined
    ]
  >;
  createSession(
    request: protos.google.spanner.v1.ICreateSessionRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.ICreateSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  createSession(
    request: protos.google.spanner.v1.ICreateSessionRequest,
    callback: Callback<
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.ICreateSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Creates a new session. A session can be used to perform
   * transactions that read and/or modify data in a Cloud Spanner database.
   * Sessions are meant to be reused for many consecutive
   * transactions.
   *
   * Sessions can only execute one transaction at a time. To execute
   * multiple concurrent read-write/write-only transactions, create
   * multiple sessions. Note that standalone reads and queries use a
   * transaction internally, and count toward the one transaction
   * limit.
   *
   * Active sessions use additional server resources, so it is a good idea to
   * delete idle and unneeded sessions.
   * Aside from explicit deletes, Cloud Spanner may delete sessions for which no
   * operations are sent for more than an hour. If a session is deleted,
   * requests to it return `NOT_FOUND`.
   *
   * Idle sessions can be kept alive by sending a trivial SQL query
   * periodically, e.g., `"SELECT 1"`.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.database
   *   Required. The database in which the new session is created.
   * @param {google.spanner.v1.Session} request.session
   *   The session to create.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [Session]{@link google.spanner.v1.Session}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.createSession(request);
   */
  createSession(
    request: protos.google.spanner.v1.ICreateSessionRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.ISession,
          protos.google.spanner.v1.ICreateSessionRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.ICreateSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.ICreateSessionRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        database: request.database || '',
      });
    this.initialize();
    return this.innerApiCalls.createSession(request, options, callback);
  }
  batchCreateSessions(
    request: protos.google.spanner.v1.IBatchCreateSessionsRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.IBatchCreateSessionsResponse,
      protos.google.spanner.v1.IBatchCreateSessionsRequest | undefined,
      {} | undefined
    ]
  >;
  batchCreateSessions(
    request: protos.google.spanner.v1.IBatchCreateSessionsRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.IBatchCreateSessionsResponse,
      protos.google.spanner.v1.IBatchCreateSessionsRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  batchCreateSessions(
    request: protos.google.spanner.v1.IBatchCreateSessionsRequest,
    callback: Callback<
      protos.google.spanner.v1.IBatchCreateSessionsResponse,
      protos.google.spanner.v1.IBatchCreateSessionsRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Creates multiple new sessions.
   *
   * This API can be used to initialize a session cache on the clients.
   * See https://goo.gl/TgSFN2 for best practices on session cache management.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.database
   *   Required. The database in which the new sessions are created.
   * @param {google.spanner.v1.Session} request.sessionTemplate
   *   Parameters to be applied to each created session.
   * @param {number} request.sessionCount
   *   Required. The number of sessions to be created in this batch call.
   *   The API may return fewer than the requested number of sessions. If a
   *   specific number of sessions are desired, the client can make additional
   *   calls to BatchCreateSessions (adjusting
   *   {@link google.spanner.v1.BatchCreateSessionsRequest.session_count|session_count} as necessary).
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [BatchCreateSessionsResponse]{@link google.spanner.v1.BatchCreateSessionsResponse}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.batchCreateSessions(request);
   */
  batchCreateSessions(
    request: protos.google.spanner.v1.IBatchCreateSessionsRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.IBatchCreateSessionsResponse,
          | protos.google.spanner.v1.IBatchCreateSessionsRequest
          | null
          | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.IBatchCreateSessionsResponse,
      protos.google.spanner.v1.IBatchCreateSessionsRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.IBatchCreateSessionsResponse,
      protos.google.spanner.v1.IBatchCreateSessionsRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        database: request.database || '',
      });
    this.initialize();
    return this.innerApiCalls.batchCreateSessions(request, options, callback);
  }
  getSession(
    request: protos.google.spanner.v1.IGetSessionRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.IGetSessionRequest | undefined,
      {} | undefined
    ]
  >;
  getSession(
    request: protos.google.spanner.v1.IGetSessionRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.IGetSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  getSession(
    request: protos.google.spanner.v1.IGetSessionRequest,
    callback: Callback<
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.IGetSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Gets a session. Returns `NOT_FOUND` if the session does not exist.
   * This is mainly useful for determining whether a session is still
   * alive.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.name
   *   Required. The name of the session to retrieve.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [Session]{@link google.spanner.v1.Session}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.getSession(request);
   */
  getSession(
    request: protos.google.spanner.v1.IGetSessionRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.ISession,
          protos.google.spanner.v1.IGetSessionRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.IGetSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.ISession,
      protos.google.spanner.v1.IGetSessionRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        name: request.name || '',
      });
    this.initialize();
    return this.innerApiCalls.getSession(request, options, callback);
  }
  deleteSession(
    request: protos.google.spanner.v1.IDeleteSessionRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IDeleteSessionRequest | undefined,
      {} | undefined
    ]
  >;
  deleteSession(
    request: protos.google.spanner.v1.IDeleteSessionRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IDeleteSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  deleteSession(
    request: protos.google.spanner.v1.IDeleteSessionRequest,
    callback: Callback<
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IDeleteSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Ends a session, releasing server resources associated with it. This will
   * asynchronously trigger cancellation of any operations that are running with
   * this session.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.name
   *   Required. The name of the session to delete.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [Empty]{@link google.protobuf.Empty}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.deleteSession(request);
   */
  deleteSession(
    request: protos.google.spanner.v1.IDeleteSessionRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.protobuf.IEmpty,
          protos.google.spanner.v1.IDeleteSessionRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IDeleteSessionRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IDeleteSessionRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        name: request.name || '',
      });
    this.initialize();
    return this.innerApiCalls.deleteSession(request, options, callback);
  }
  executeSql(
    request: protos.google.spanner.v1.IExecuteSqlRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IExecuteSqlRequest | undefined,
      {} | undefined
    ]
  >;
  executeSql(
    request: protos.google.spanner.v1.IExecuteSqlRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IExecuteSqlRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  executeSql(
    request: protos.google.spanner.v1.IExecuteSqlRequest,
    callback: Callback<
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IExecuteSqlRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Executes an SQL statement, returning all results in a single reply. This
   * method cannot be used to return a result set larger than 10 MiB;
   * if the query yields more data than that, the query fails with
   * a `FAILED_PRECONDITION` error.
   *
   * Operations inside read-write transactions might return `ABORTED`. If
   * this occurs, the application should restart the transaction from
   * the beginning. See {@link google.spanner.v1.Transaction|Transaction} for more details.
   *
   * Larger result sets can be fetched in streaming fashion by calling
   * {@link google.spanner.v1.Spanner.ExecuteStreamingSql|ExecuteStreamingSql} instead.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session in which the SQL query should be performed.
   * @param {google.spanner.v1.TransactionSelector} request.transaction
   *   The transaction to use.
   *
   *   For queries, if none is provided, the default is a temporary read-only
   *   transaction with strong concurrency.
   *
   *   Standard DML statements require a read-write transaction. To protect
   *   against replays, single-use transactions are not supported.  The caller
   *   must either supply an existing transaction ID or begin a new transaction.
   *
   *   Partitioned DML requires an existing Partitioned DML transaction ID.
   * @param {string} request.sql
   *   Required. The SQL string.
   * @param {google.protobuf.Struct} request.params
   *   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.
   * @param {number[]} request.paramTypes
   *   It is not always possible for Cloud Spanner to infer the right SQL type
   *   from a JSON value.  For example, values of type `BYTES` and values
   *   of type `STRING` both appear in {@link google.spanner.v1.ExecuteSqlRequest.params|params} as JSON strings.
   *
   *   In these cases, `param_types` can be used to specify the exact
   *   SQL type for some or all of the SQL statement parameters. See the
   *   definition of {@link google.spanner.v1.Type|Type} for more information
   *   about SQL types.
   * @param {Buffer} request.resumeToken
   *   If this request is resuming a previously interrupted SQL statement
   *   execution, `resume_token` should be copied from the last
   *   {@link google.spanner.v1.PartialResultSet|PartialResultSet} yielded before the interruption. Doing this
   *   enables the new SQL statement execution to resume where the last one left
   *   off. The rest of the request parameters must exactly match the
   *   request that yielded this token.
   * @param {google.spanner.v1.ExecuteSqlRequest.QueryMode} request.queryMode
   *   Used to control the amount of debugging information returned in
   *   {@link google.spanner.v1.ResultSetStats|ResultSetStats}. If {@link google.spanner.v1.ExecuteSqlRequest.partition_token|partition_token} is set, {@link google.spanner.v1.ExecuteSqlRequest.query_mode|query_mode} can only
   *   be set to {@link google.spanner.v1.ExecuteSqlRequest.QueryMode.NORMAL|QueryMode.NORMAL}.
   * @param {Buffer} request.partitionToken
   *   If present, results will be restricted to the specified partition
   *   previously created using PartitionQuery().  There must be an exact
   *   match for the values of fields common to this message and the
   *   PartitionQueryRequest message used to create this partition_token.
   * @param {number} request.seqno
   *   A per-transaction sequence number used to identify this request. This field
   *   makes each request idempotent such that if the request is received multiple
   *   times, at most one will succeed.
   *
   *   The sequence number must be monotonically increasing within the
   *   transaction. If a request arrives for the first time with an out-of-order
   *   sequence number, the transaction may be aborted. Replays of previously
   *   handled requests will yield the same response as the first execution.
   *
   *   Required for DML statements. Ignored for queries.
   * @param {google.spanner.v1.ExecuteSqlRequest.QueryOptions} request.queryOptions
   *   Query optimizer configuration to use for the given query.
   * @param {google.spanner.v1.RequestOptions} request.requestOptions
   *   Common options for this request.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [ResultSet]{@link google.spanner.v1.ResultSet}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.executeSql(request);
   */
  executeSql(
    request: protos.google.spanner.v1.IExecuteSqlRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.IResultSet,
          protos.google.spanner.v1.IExecuteSqlRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IExecuteSqlRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IExecuteSqlRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.executeSql(request, options, callback);
  }
  executeBatchDml(
    request: protos.google.spanner.v1.IExecuteBatchDmlRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.IExecuteBatchDmlResponse,
      protos.google.spanner.v1.IExecuteBatchDmlRequest | undefined,
      {} | undefined
    ]
  >;
  executeBatchDml(
    request: protos.google.spanner.v1.IExecuteBatchDmlRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.IExecuteBatchDmlResponse,
      protos.google.spanner.v1.IExecuteBatchDmlRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  executeBatchDml(
    request: protos.google.spanner.v1.IExecuteBatchDmlRequest,
    callback: Callback<
      protos.google.spanner.v1.IExecuteBatchDmlResponse,
      protos.google.spanner.v1.IExecuteBatchDmlRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Executes a batch of SQL DML statements. This method allows many statements
   * to be run with lower latency than submitting them sequentially with
   * {@link google.spanner.v1.Spanner.ExecuteSql|ExecuteSql}.
   *
   * Statements are executed in sequential order. A request can succeed even if
   * a statement fails. The {@link google.spanner.v1.ExecuteBatchDmlResponse.status|ExecuteBatchDmlResponse.status} field in the
   * response provides information about the statement that failed. Clients must
   * inspect this field to determine whether an error occurred.
   *
   * Execution stops after the first failed statement; the remaining statements
   * are not executed.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session in which the DML statements should be performed.
   * @param {google.spanner.v1.TransactionSelector} request.transaction
   *   Required. The transaction to use. Must be a read-write transaction.
   *
   *   To protect against replays, single-use transactions are not supported. The
   *   caller must either supply an existing transaction ID or begin a new
   *   transaction.
   * @param {number[]} request.statements
   *   Required. The list of statements to execute in this batch. Statements are executed
   *   serially, such that the effects of statement `i` are visible to statement
   *   `i+1`. Each statement must be a DML statement. Execution stops at the
   *   first failed statement; the remaining statements are not executed.
   *
   *   Callers must provide at least one statement.
   * @param {number} request.seqno
   *   Required. A per-transaction sequence number used to identify this request. This field
   *   makes each request idempotent such that if the request is received multiple
   *   times, at most one will succeed.
   *
   *   The sequence number must be monotonically increasing within the
   *   transaction. If a request arrives for the first time with an out-of-order
   *   sequence number, the transaction may be aborted. Replays of previously
   *   handled requests will yield the same response as the first execution.
   * @param {google.spanner.v1.RequestOptions} request.requestOptions
   *   Common options for this request.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [ExecuteBatchDmlResponse]{@link google.spanner.v1.ExecuteBatchDmlResponse}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.executeBatchDml(request);
   */
  executeBatchDml(
    request: protos.google.spanner.v1.IExecuteBatchDmlRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.IExecuteBatchDmlResponse,
          protos.google.spanner.v1.IExecuteBatchDmlRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.IExecuteBatchDmlResponse,
      protos.google.spanner.v1.IExecuteBatchDmlRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.IExecuteBatchDmlResponse,
      protos.google.spanner.v1.IExecuteBatchDmlRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.executeBatchDml(request, options, callback);
  }
  read(
    request: protos.google.spanner.v1.IReadRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IReadRequest | undefined,
      {} | undefined
    ]
  >;
  read(
    request: protos.google.spanner.v1.IReadRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IReadRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  read(
    request: protos.google.spanner.v1.IReadRequest,
    callback: Callback<
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IReadRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Reads rows from the database using key lookups and scans, as a
   * simple key/value style alternative to
   * {@link google.spanner.v1.Spanner.ExecuteSql|ExecuteSql}.  This method cannot be used to
   * return a result set larger than 10 MiB; if the read matches more
   * data than that, the read fails with a `FAILED_PRECONDITION`
   * error.
   *
   * Reads inside read-write transactions might return `ABORTED`. If
   * this occurs, the application should restart the transaction from
   * the beginning. See {@link google.spanner.v1.Transaction|Transaction} for more details.
   *
   * Larger result sets can be yielded in streaming fashion by calling
   * {@link google.spanner.v1.Spanner.StreamingRead|StreamingRead} instead.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session in which the read should be performed.
   * @param {google.spanner.v1.TransactionSelector} request.transaction
   *   The transaction to use. If none is provided, the default is a
   *   temporary read-only transaction with strong concurrency.
   * @param {string} request.table
   *   Required. The name of the table in the database to be read.
   * @param {string} request.index
   *   If non-empty, the name of an index on {@link google.spanner.v1.ReadRequest.table|table}. This index is
   *   used instead of the table primary key when interpreting {@link google.spanner.v1.ReadRequest.key_set|key_set}
   *   and sorting result rows. See {@link google.spanner.v1.ReadRequest.key_set|key_set} for further information.
   * @param {string[]} request.columns
   *   Required. The columns of {@link google.spanner.v1.ReadRequest.table|table} to be returned for each row matching
   *   this request.
   * @param {google.spanner.v1.KeySet} request.keySet
   *   Required. `key_set` identifies the rows to be yielded. `key_set` names the
   *   primary keys of the rows in {@link google.spanner.v1.ReadRequest.table|table} to be yielded, unless {@link google.spanner.v1.ReadRequest.index|index}
   *   is present. If {@link google.spanner.v1.ReadRequest.index|index} is present, then {@link google.spanner.v1.ReadRequest.key_set|key_set} instead names
   *   index keys in {@link google.spanner.v1.ReadRequest.index|index}.
   *
   *   If the {@link google.spanner.v1.ReadRequest.partition_token|partition_token} field is empty, rows are yielded
   *   in table primary key order (if {@link google.spanner.v1.ReadRequest.index|index} is empty) or index key order
   *   (if {@link google.spanner.v1.ReadRequest.index|index} is non-empty).  If the {@link google.spanner.v1.ReadRequest.partition_token|partition_token} field is not
   *   empty, rows will be yielded in an unspecified order.
   *
   *   It is not an error for the `key_set` to name rows that do not
   *   exist in the database. Read yields nothing for nonexistent rows.
   * @param {number} request.limit
   *   If greater than zero, only the first `limit` rows are yielded. If `limit`
   *   is zero, the default is no limit. A limit cannot be specified if
   *   `partition_token` is set.
   * @param {Buffer} request.resumeToken
   *   If this request is resuming a previously interrupted read,
   *   `resume_token` should be copied from the last
   *   {@link google.spanner.v1.PartialResultSet|PartialResultSet} yielded before the interruption. Doing this
   *   enables the new read to resume where the last read left off. The
   *   rest of the request parameters must exactly match the request
   *   that yielded this token.
   * @param {Buffer} request.partitionToken
   *   If present, results will be restricted to the specified partition
   *   previously created using PartitionRead().    There must be an exact
   *   match for the values of fields common to this message and the
   *   PartitionReadRequest message used to create this partition_token.
   * @param {google.spanner.v1.RequestOptions} request.requestOptions
   *   Common options for this request.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [ResultSet]{@link google.spanner.v1.ResultSet}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.read(request);
   */
  read(
    request: protos.google.spanner.v1.IReadRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.IResultSet,
          protos.google.spanner.v1.IReadRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IReadRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.IResultSet,
      protos.google.spanner.v1.IReadRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.read(request, options, callback);
  }
  beginTransaction(
    request: protos.google.spanner.v1.IBeginTransactionRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.ITransaction,
      protos.google.spanner.v1.IBeginTransactionRequest | undefined,
      {} | undefined
    ]
  >;
  beginTransaction(
    request: protos.google.spanner.v1.IBeginTransactionRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.ITransaction,
      protos.google.spanner.v1.IBeginTransactionRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  beginTransaction(
    request: protos.google.spanner.v1.IBeginTransactionRequest,
    callback: Callback<
      protos.google.spanner.v1.ITransaction,
      protos.google.spanner.v1.IBeginTransactionRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Begins a new transaction. This step can often be skipped:
   * {@link google.spanner.v1.Spanner.Read|Read}, {@link google.spanner.v1.Spanner.ExecuteSql|ExecuteSql} and
   * {@link google.spanner.v1.Spanner.Commit|Commit} can begin a new transaction as a
   * side-effect.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session in which the transaction runs.
   * @param {google.spanner.v1.TransactionOptions} request.options
   *   Required. Options for the new transaction.
   * @param {google.spanner.v1.RequestOptions} request.requestOptions
   *   Common options for this request.
   *   Priority is ignored for this request. Setting the priority in this
   *   request_options struct will not do anything. To set the priority for a
   *   transaction, set it on the reads and writes that are part of this
   *   transaction instead.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [Transaction]{@link google.spanner.v1.Transaction}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.beginTransaction(request);
   */
  beginTransaction(
    request: protos.google.spanner.v1.IBeginTransactionRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.ITransaction,
          protos.google.spanner.v1.IBeginTransactionRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.ITransaction,
      protos.google.spanner.v1.IBeginTransactionRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.ITransaction,
      protos.google.spanner.v1.IBeginTransactionRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.beginTransaction(request, options, callback);
  }
  commit(
    request: protos.google.spanner.v1.ICommitRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.ICommitResponse,
      protos.google.spanner.v1.ICommitRequest | undefined,
      {} | undefined
    ]
  >;
  commit(
    request: protos.google.spanner.v1.ICommitRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.ICommitResponse,
      protos.google.spanner.v1.ICommitRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  commit(
    request: protos.google.spanner.v1.ICommitRequest,
    callback: Callback<
      protos.google.spanner.v1.ICommitResponse,
      protos.google.spanner.v1.ICommitRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Commits a transaction. The request includes the mutations to be
   * applied to rows in the database.
   *
   * `Commit` might return an `ABORTED` error. This can occur at any time;
   * commonly, the cause is conflicts with concurrent
   * transactions. However, it can also happen for a variety of other
   * reasons. If `Commit` returns `ABORTED`, the caller should re-attempt
   * the transaction from the beginning, re-using the same session.
   *
   * On very rare occasions, `Commit` might return `UNKNOWN`. This can happen,
   * for example, if the client job experiences a 1+ hour networking failure.
   * At that point, Cloud Spanner has lost track of the transaction outcome and
   * we recommend that you perform another read from the database to see the
   * state of things as they are now.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session in which the transaction to be committed is running.
   * @param {Buffer} request.transactionId
   *   Commit a previously-started transaction.
   * @param {google.spanner.v1.TransactionOptions} request.singleUseTransaction
   *   Execute mutations in a temporary transaction. Note that unlike
   *   commit of a previously-started transaction, commit with a
   *   temporary transaction is non-idempotent. That is, if the
   *   `CommitRequest` is sent to Cloud Spanner more than once (for
   *   instance, due to retries in the application, or in the
   *   transport library), it is possible that the mutations are
   *   executed more than once. If this is undesirable, use
   *   {@link google.spanner.v1.Spanner.BeginTransaction|BeginTransaction} and
   *   {@link google.spanner.v1.Spanner.Commit|Commit} instead.
   * @param {number[]} request.mutations
   *   The mutations to be executed when this transaction commits. All
   *   mutations are applied atomically, in the order they appear in
   *   this list.
   * @param {boolean} request.returnCommitStats
   *   If `true`, then statistics related to the transaction will be included in
   *   the {@link google.spanner.v1.CommitResponse.commit_stats|CommitResponse}. Default value is
   *   `false`.
   * @param {google.spanner.v1.RequestOptions} request.requestOptions
   *   Common options for this request.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [CommitResponse]{@link google.spanner.v1.CommitResponse}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.commit(request);
   */
  commit(
    request: protos.google.spanner.v1.ICommitRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.ICommitResponse,
          protos.google.spanner.v1.ICommitRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.ICommitResponse,
      protos.google.spanner.v1.ICommitRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.ICommitResponse,
      protos.google.spanner.v1.ICommitRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.commit(request, options, callback);
  }
  rollback(
    request: protos.google.spanner.v1.IRollbackRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IRollbackRequest | undefined,
      {} | undefined
    ]
  >;
  rollback(
    request: protos.google.spanner.v1.IRollbackRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IRollbackRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  rollback(
    request: protos.google.spanner.v1.IRollbackRequest,
    callback: Callback<
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IRollbackRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Rolls back a transaction, releasing any locks it holds. It is a good
   * idea to call this for any transaction that includes one or more
   * {@link google.spanner.v1.Spanner.Read|Read} or {@link google.spanner.v1.Spanner.ExecuteSql|ExecuteSql} requests and
   * ultimately decides not to commit.
   *
   * `Rollback` returns `OK` if it successfully aborts the transaction, the
   * transaction was already aborted, or the transaction is not
   * found. `Rollback` never returns `ABORTED`.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session in which the transaction to roll back is running.
   * @param {Buffer} request.transactionId
   *   Required. The transaction to roll back.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [Empty]{@link google.protobuf.Empty}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.rollback(request);
   */
  rollback(
    request: protos.google.spanner.v1.IRollbackRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.protobuf.IEmpty,
          protos.google.spanner.v1.IRollbackRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IRollbackRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.protobuf.IEmpty,
      protos.google.spanner.v1.IRollbackRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.rollback(request, options, callback);
  }
  partitionQuery(
    request: protos.google.spanner.v1.IPartitionQueryRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionQueryRequest | undefined,
      {} | undefined
    ]
  >;
  partitionQuery(
    request: protos.google.spanner.v1.IPartitionQueryRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionQueryRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  partitionQuery(
    request: protos.google.spanner.v1.IPartitionQueryRequest,
    callback: Callback<
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionQueryRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Creates a set of partition tokens that can be used to execute a query
   * operation in parallel.  Each of the returned partition tokens can be used
   * by {@link google.spanner.v1.Spanner.ExecuteStreamingSql|ExecuteStreamingSql} to specify a subset
   * of the query result to read.  The same session and read-only transaction
   * must be used by the PartitionQueryRequest used to create the
   * partition tokens and the ExecuteSqlRequests that use the partition tokens.
   *
   * Partition tokens become invalid when the session used to create them
   * is deleted, is idle for too long, begins a new transaction, or becomes too
   * old.  When any of these happen, it is not possible to resume the query, and
   * the whole operation must be restarted from the beginning.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session used to create the partitions.
   * @param {google.spanner.v1.TransactionSelector} request.transaction
   *   Read only snapshot transactions are supported, read/write and single use
   *   transactions are not.
   * @param {string} request.sql
   *   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 {@link google.spanner.v1.Spanner.ExecuteStreamingSql|ExecuteStreamingSql} with a
   *   PartitionedDml transaction for large, partition-friendly DML operations.
   * @param {google.protobuf.Struct} request.params
   *   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 can contain
   *   letters, numbers, and underscores.
   *
   *   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.
   * @param {number[]} request.paramTypes
   *   It is not always possible for Cloud Spanner to infer the right SQL type
   *   from a JSON value.  For example, values of type `BYTES` and values
   *   of type `STRING` both appear in {@link google.spanner.v1.PartitionQueryRequest.params|params} as JSON strings.
   *
   *   In these cases, `param_types` can be used to specify the exact
   *   SQL type for some or all of the SQL query parameters. See the
   *   definition of {@link google.spanner.v1.Type|Type} for more information
   *   about SQL types.
   * @param {google.spanner.v1.PartitionOptions} request.partitionOptions
   *   Additional options that affect how many partitions are created.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [PartitionResponse]{@link google.spanner.v1.PartitionResponse}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.partitionQuery(request);
   */
  partitionQuery(
    request: protos.google.spanner.v1.IPartitionQueryRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.IPartitionResponse,
          protos.google.spanner.v1.IPartitionQueryRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionQueryRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionQueryRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.partitionQuery(request, options, callback);
  }
  partitionRead(
    request: protos.google.spanner.v1.IPartitionReadRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionReadRequest | undefined,
      {} | undefined
    ]
  >;
  partitionRead(
    request: protos.google.spanner.v1.IPartitionReadRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionReadRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  partitionRead(
    request: protos.google.spanner.v1.IPartitionReadRequest,
    callback: Callback<
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionReadRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Creates a set of partition tokens that can be used to execute a read
   * operation in parallel.  Each of the returned partition tokens can be used
   * by {@link google.spanner.v1.Spanner.StreamingRead|StreamingRead} to specify a subset of the read
   * result to read.  The same session and read-only transaction must be used by
   * the PartitionReadRequest used to create the partition tokens and the
   * ReadRequests that use the partition tokens.  There are no ordering
   * guarantees on rows returned among the returned partition tokens, or even
   * within each individual StreamingRead call issued with a partition_token.
   *
   * Partition tokens become invalid when the session used to create them
   * is deleted, is idle for too long, begins a new transaction, or becomes too
   * old.  When any of these happen, it is not possible to resume the read, and
   * the whole operation must be restarted from the beginning.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session used to create the partitions.
   * @param {google.spanner.v1.TransactionSelector} request.transaction
   *   Read only snapshot transactions are supported, read/write and single use
   *   transactions are not.
   * @param {string} request.table
   *   Required. The name of the table in the database to be read.
   * @param {string} request.index
   *   If non-empty, the name of an index on {@link google.spanner.v1.PartitionReadRequest.table|table}. This index is
   *   used instead of the table primary key when interpreting {@link google.spanner.v1.PartitionReadRequest.key_set|key_set}
   *   and sorting result rows. See {@link google.spanner.v1.PartitionReadRequest.key_set|key_set} for further information.
   * @param {string[]} request.columns
   *   The columns of {@link google.spanner.v1.PartitionReadRequest.table|table} to be returned for each row matching
   *   this request.
   * @param {google.spanner.v1.KeySet} request.keySet
   *   Required. `key_set` identifies the rows to be yielded. `key_set` names the
   *   primary keys of the rows in {@link google.spanner.v1.PartitionReadRequest.table|table} to be yielded, unless {@link google.spanner.v1.PartitionReadRequest.index|index}
   *   is present. If {@link google.spanner.v1.PartitionReadRequest.index|index} is present, then {@link google.spanner.v1.PartitionReadRequest.key_set|key_set} instead names
   *   index keys in {@link google.spanner.v1.PartitionReadRequest.index|index}.
   *
   *   It is not an error for the `key_set` to name rows that do not
   *   exist in the database. Read yields nothing for nonexistent rows.
   * @param {google.spanner.v1.PartitionOptions} request.partitionOptions
   *   Additional options that affect how many partitions are created.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is an object representing [PartitionResponse]{@link google.spanner.v1.PartitionResponse}.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods)
   *   for more details and examples.
   * @example
   * const [response] = await client.partitionRead(request);
   */
  partitionRead(
    request: protos.google.spanner.v1.IPartitionReadRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.spanner.v1.IPartitionResponse,
          protos.google.spanner.v1.IPartitionReadRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionReadRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.spanner.v1.IPartitionResponse,
      protos.google.spanner.v1.IPartitionReadRequest | undefined,
      {} | undefined
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.partitionRead(request, options, callback);
  }

  /**
   * Like {@link google.spanner.v1.Spanner.ExecuteSql|ExecuteSql}, except returns the result
   * set as a stream. Unlike {@link google.spanner.v1.Spanner.ExecuteSql|ExecuteSql}, there
   * is no limit on the size of the returned result set. However, no
   * individual row in the result set can exceed 100 MiB, and no
   * column value can exceed 10 MiB.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session in which the SQL query should be performed.
   * @param {google.spanner.v1.TransactionSelector} request.transaction
   *   The transaction to use.
   *
   *   For queries, if none is provided, the default is a temporary read-only
   *   transaction with strong concurrency.
   *
   *   Standard DML statements require a read-write transaction. To protect
   *   against replays, single-use transactions are not supported.  The caller
   *   must either supply an existing transaction ID or begin a new transaction.
   *
   *   Partitioned DML requires an existing Partitioned DML transaction ID.
   * @param {string} request.sql
   *   Required. The SQL string.
   * @param {google.protobuf.Struct} request.params
   *   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.
   * @param {number[]} request.paramTypes
   *   It is not always possible for Cloud Spanner to infer the right SQL type
   *   from a JSON value.  For example, values of type `BYTES` and values
   *   of type `STRING` both appear in {@link google.spanner.v1.ExecuteSqlRequest.params|params} as JSON strings.
   *
   *   In these cases, `param_types` can be used to specify the exact
   *   SQL type for some or all of the SQL statement parameters. See the
   *   definition of {@link google.spanner.v1.Type|Type} for more information
   *   about SQL types.
   * @param {Buffer} request.resumeToken
   *   If this request is resuming a previously interrupted SQL statement
   *   execution, `resume_token` should be copied from the last
   *   {@link google.spanner.v1.PartialResultSet|PartialResultSet} yielded before the interruption. Doing this
   *   enables the new SQL statement execution to resume where the last one left
   *   off. The rest of the request parameters must exactly match the
   *   request that yielded this token.
   * @param {google.spanner.v1.ExecuteSqlRequest.QueryMode} request.queryMode
   *   Used to control the amount of debugging information returned in
   *   {@link google.spanner.v1.ResultSetStats|ResultSetStats}. If {@link google.spanner.v1.ExecuteSqlRequest.partition_token|partition_token} is set, {@link google.spanner.v1.ExecuteSqlRequest.query_mode|query_mode} can only
   *   be set to {@link google.spanner.v1.ExecuteSqlRequest.QueryMode.NORMAL|QueryMode.NORMAL}.
   * @param {Buffer} request.partitionToken
   *   If present, results will be restricted to the specified partition
   *   previously created using PartitionQuery().  There must be an exact
   *   match for the values of fields common to this message and the
   *   PartitionQueryRequest message used to create this partition_token.
   * @param {number} request.seqno
   *   A per-transaction sequence number used to identify this request. This field
   *   makes each request idempotent such that if the request is received multiple
   *   times, at most one will succeed.
   *
   *   The sequence number must be monotonically increasing within the
   *   transaction. If a request arrives for the first time with an out-of-order
   *   sequence number, the transaction may be aborted. Replays of previously
   *   handled requests will yield the same response as the first execution.
   *
   *   Required for DML statements. Ignored for queries.
   * @param {google.spanner.v1.ExecuteSqlRequest.QueryOptions} request.queryOptions
   *   Query optimizer configuration to use for the given query.
   * @param {google.spanner.v1.RequestOptions} request.requestOptions
   *   Common options for this request.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Stream}
   *   An object stream which emits [PartialResultSet]{@link google.spanner.v1.PartialResultSet} on 'data' event.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#server-streaming)
   *   for more details and examples.
   * @example
   * const stream = client.executeStreamingSql(request);
   * stream.on('data', (response) => { ... });
   * stream.on('end', () => { ... });
   */
  executeStreamingSql(
    request?: protos.google.spanner.v1.IExecuteSqlRequest,
    options?: CallOptions
  ): gax.CancellableStream {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.executeStreamingSql(request, options);
  }

  /**
   * Like {@link google.spanner.v1.Spanner.Read|Read}, except returns the result set as a
   * stream. Unlike {@link google.spanner.v1.Spanner.Read|Read}, there is no limit on the
   * size of the returned result set. However, no individual row in
   * the result set can exceed 100 MiB, and no column value can exceed
   * 10 MiB.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.session
   *   Required. The session in which the read should be performed.
   * @param {google.spanner.v1.TransactionSelector} request.transaction
   *   The transaction to use. If none is provided, the default is a
   *   temporary read-only transaction with strong concurrency.
   * @param {string} request.table
   *   Required. The name of the table in the database to be read.
   * @param {string} request.index
   *   If non-empty, the name of an index on {@link google.spanner.v1.ReadRequest.table|table}. This index is
   *   used instead of the table primary key when interpreting {@link google.spanner.v1.ReadRequest.key_set|key_set}
   *   and sorting result rows. See {@link google.spanner.v1.ReadRequest.key_set|key_set} for further information.
   * @param {string[]} request.columns
   *   Required. The columns of {@link google.spanner.v1.ReadRequest.table|table} to be returned for each row matching
   *   this request.
   * @param {google.spanner.v1.KeySet} request.keySet
   *   Required. `key_set` identifies the rows to be yielded. `key_set` names the
   *   primary keys of the rows in {@link google.spanner.v1.ReadRequest.table|table} to be yielded, unless {@link google.spanner.v1.ReadRequest.index|index}
   *   is present. If {@link google.spanner.v1.ReadRequest.index|index} is present, then {@link google.spanner.v1.ReadRequest.key_set|key_set} instead names
   *   index keys in {@link google.spanner.v1.ReadRequest.index|index}.
   *
   *   If the {@link google.spanner.v1.ReadRequest.partition_token|partition_token} field is empty, rows are yielded
   *   in table primary key order (if {@link google.spanner.v1.ReadRequest.index|index} is empty) or index key order
   *   (if {@link google.spanner.v1.ReadRequest.index|index} is non-empty).  If the {@link google.spanner.v1.ReadRequest.partition_token|partition_token} field is not
   *   empty, rows will be yielded in an unspecified order.
   *
   *   It is not an error for the `key_set` to name rows that do not
   *   exist in the database. Read yields nothing for nonexistent rows.
   * @param {number} request.limit
   *   If greater than zero, only the first `limit` rows are yielded. If `limit`
   *   is zero, the default is no limit. A limit cannot be specified if
   *   `partition_token` is set.
   * @param {Buffer} request.resumeToken
   *   If this request is resuming a previously interrupted read,
   *   `resume_token` should be copied from the last
   *   {@link google.spanner.v1.PartialResultSet|PartialResultSet} yielded before the interruption. Doing this
   *   enables the new read to resume where the last read left off. The
   *   rest of the request parameters must exactly match the request
   *   that yielded this token.
   * @param {Buffer} request.partitionToken
   *   If present, results will be restricted to the specified partition
   *   previously created using PartitionRead().    There must be an exact
   *   match for the values of fields common to this message and the
   *   PartitionReadRequest message used to create this partition_token.
   * @param {google.spanner.v1.RequestOptions} request.requestOptions
   *   Common options for this request.
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Stream}
   *   An object stream which emits [PartialResultSet]{@link google.spanner.v1.PartialResultSet} on 'data' event.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#server-streaming)
   *   for more details and examples.
   * @example
   * const stream = client.streamingRead(request);
   * stream.on('data', (response) => { ... });
   * stream.on('end', () => { ... });
   */
  streamingRead(
    request?: protos.google.spanner.v1.IReadRequest,
    options?: CallOptions
  ): gax.CancellableStream {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        session: request.session || '',
      });
    this.initialize();
    return this.innerApiCalls.streamingRead(request, options);
  }

  listSessions(
    request: protos.google.spanner.v1.IListSessionsRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.spanner.v1.ISession[],
      protos.google.spanner.v1.IListSessionsRequest | null,
      protos.google.spanner.v1.IListSessionsResponse
    ]
  >;
  listSessions(
    request: protos.google.spanner.v1.IListSessionsRequest,
    options: CallOptions,
    callback: PaginationCallback<
      protos.google.spanner.v1.IListSessionsRequest,
      protos.google.spanner.v1.IListSessionsResponse | null | undefined,
      protos.google.spanner.v1.ISession
    >
  ): void;
  listSessions(
    request: protos.google.spanner.v1.IListSessionsRequest,
    callback: PaginationCallback<
      protos.google.spanner.v1.IListSessionsRequest,
      protos.google.spanner.v1.IListSessionsResponse | null | undefined,
      protos.google.spanner.v1.ISession
    >
  ): void;
  /**
   * Lists all sessions in a given database.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.database
   *   Required. The database in which to list sessions.
   * @param {number} request.pageSize
   *   Number of sessions to be returned in the response. If 0 or less, defaults
   *   to the server's maximum allowed page size.
   * @param {string} request.pageToken
   *   If non-empty, `page_token` should contain a
   *   {@link google.spanner.v1.ListSessionsResponse.next_page_token|next_page_token} from a previous
   *   {@link google.spanner.v1.ListSessionsResponse|ListSessionsResponse}.
   * @param {string} request.filter
   *   An expression for filtering the results of the request. Filter rules are
   *   case insensitive. The fields eligible for filtering are:
   *
   *     * `labels.key` where key is the name of a label
   *
   *   Some examples of using filters are:
   *
   *     * `labels.env:*` --> The session has the label "env".
   *     * `labels.env:dev` --> The session has the label "env" and the value of
   *                          the label contains the string "dev".
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Promise} - The promise which resolves to an array.
   *   The first element of the array is Array of [Session]{@link google.spanner.v1.Session}.
   *   The client library will perform auto-pagination by default: it will call the API as many
   *   times as needed and will merge results from all the pages into this array.
   *   Note that it can affect your quota.
   *   We recommend using `listSessionsAsync()`
   *   method described below for async iteration which you can stop as needed.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination)
   *   for more details and examples.
   */
  listSessions(
    request: protos.google.spanner.v1.IListSessionsRequest,
    optionsOrCallback?:
      | CallOptions
      | PaginationCallback<
          protos.google.spanner.v1.IListSessionsRequest,
          protos.google.spanner.v1.IListSessionsResponse | null | undefined,
          protos.google.spanner.v1.ISession
        >,
    callback?: PaginationCallback<
      protos.google.spanner.v1.IListSessionsRequest,
      protos.google.spanner.v1.IListSessionsResponse | null | undefined,
      protos.google.spanner.v1.ISession
    >
  ): Promise<
    [
      protos.google.spanner.v1.ISession[],
      protos.google.spanner.v1.IListSessionsRequest | null,
      protos.google.spanner.v1.IListSessionsResponse
    ]
  > | void {
    request = request || {};
    let options: CallOptions;
    if (typeof optionsOrCallback === 'function' && callback === undefined) {
      callback = optionsOrCallback;
      options = {};
    } else {
      options = optionsOrCallback as CallOptions;
    }
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        database: request.database || '',
      });
    this.initialize();
    return this.innerApiCalls.listSessions(request, options, callback);
  }

  /**
   * Equivalent to `method.name.toCamelCase()`, but returns a NodeJS Stream object.
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.database
   *   Required. The database in which to list sessions.
   * @param {number} request.pageSize
   *   Number of sessions to be returned in the response. If 0 or less, defaults
   *   to the server's maximum allowed page size.
   * @param {string} request.pageToken
   *   If non-empty, `page_token` should contain a
   *   {@link google.spanner.v1.ListSessionsResponse.next_page_token|next_page_token} from a previous
   *   {@link google.spanner.v1.ListSessionsResponse|ListSessionsResponse}.
   * @param {string} request.filter
   *   An expression for filtering the results of the request. Filter rules are
   *   case insensitive. The fields eligible for filtering are:
   *
   *     * `labels.key` where key is the name of a label
   *
   *   Some examples of using filters are:
   *
   *     * `labels.env:*` --> The session has the label "env".
   *     * `labels.env:dev` --> The session has the label "env" and the value of
   *                          the label contains the string "dev".
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Stream}
   *   An object stream which emits an object representing [Session]{@link google.spanner.v1.Session} on 'data' event.
   *   The client library will perform auto-pagination by default: it will call the API as many
   *   times as needed. Note that it can affect your quota.
   *   We recommend using `listSessionsAsync()`
   *   method described below for async iteration which you can stop as needed.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination)
   *   for more details and examples.
   */
  listSessionsStream(
    request?: protos.google.spanner.v1.IListSessionsRequest,
    options?: CallOptions
  ): Transform {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        database: request.database || '',
      });
    const callSettings = new gax.CallSettings(options);
    this.initialize();
    return this.descriptors.page.listSessions.createStream(
      this.innerApiCalls.listSessions as gax.GaxCall,
      request,
      callSettings
    );
  }

  /**
   * Equivalent to `listSessions`, but returns an iterable object.
   *
   * `for`-`await`-`of` syntax is used with the iterable to get response elements on-demand.
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.database
   *   Required. The database in which to list sessions.
   * @param {number} request.pageSize
   *   Number of sessions to be returned in the response. If 0 or less, defaults
   *   to the server's maximum allowed page size.
   * @param {string} request.pageToken
   *   If non-empty, `page_token` should contain a
   *   {@link google.spanner.v1.ListSessionsResponse.next_page_token|next_page_token} from a previous
   *   {@link google.spanner.v1.ListSessionsResponse|ListSessionsResponse}.
   * @param {string} request.filter
   *   An expression for filtering the results of the request. Filter rules are
   *   case insensitive. The fields eligible for filtering are:
   *
   *     * `labels.key` where key is the name of a label
   *
   *   Some examples of using filters are:
   *
   *     * `labels.env:*` --> The session has the label "env".
   *     * `labels.env:dev` --> The session has the label "env" and the value of
   *                          the label contains the string "dev".
   * @param {object} [options]
   *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
   * @returns {Object}
   *   An iterable Object that allows [async iteration](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols).
   *   When you iterate the returned iterable, each element will be an object representing
   *   [Session]{@link google.spanner.v1.Session}. The API will be called under the hood as needed, once per the page,
   *   so you can stop the iteration when you don't need more results.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination)
   *   for more details and examples.
   * @example
   * const iterable = client.listSessionsAsync(request);
   * for await (const response of iterable) {
   *   // process response
   * }
   */
  listSessionsAsync(
    request?: protos.google.spanner.v1.IListSessionsRequest,
    options?: CallOptions
  ): AsyncIterable<protos.google.spanner.v1.ISession> {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        database: request.database || '',
      });
    options = options || {};
    const callSettings = new gax.CallSettings(options);
    this.initialize();
    return this.descriptors.page.listSessions.asyncIterate(
      this.innerApiCalls['listSessions'] as GaxCall,
      request as unknown as RequestType,
      callSettings
    ) as AsyncIterable<protos.google.spanner.v1.ISession>;
  }
  // --------------------
  // -- Path templates --
  // --------------------

  /**
   * Return a fully-qualified database resource name string.
   *
   * @param {string} project
   * @param {string} instance
   * @param {string} database
   * @returns {string} Resource name string.
   */
  databasePath(project: string, instance: string, database: string) {
    return this.pathTemplates.databasePathTemplate.render({
      project: project,
      instance: instance,
      database: database,
    });
  }

  /**
   * Parse the project from Database resource.
   *
   * @param {string} databaseName
   *   A fully-qualified path representing Database resource.
   * @returns {string} A string representing the project.
   */
  matchProjectFromDatabaseName(databaseName: string) {
    return this.pathTemplates.databasePathTemplate.match(databaseName).project;
  }

  /**
   * Parse the instance from Database resource.
   *
   * @param {string} databaseName
   *   A fully-qualified path representing Database resource.
   * @returns {string} A string representing the instance.
   */
  matchInstanceFromDatabaseName(databaseName: string) {
    return this.pathTemplates.databasePathTemplate.match(databaseName).instance;
  }

  /**
   * Parse the database from Database resource.
   *
   * @param {string} databaseName
   *   A fully-qualified path representing Database resource.
   * @returns {string} A string representing the database.
   */
  matchDatabaseFromDatabaseName(databaseName: string) {
    return this.pathTemplates.databasePathTemplate.match(databaseName).database;
  }

  /**
   * Return a fully-qualified session resource name string.
   *
   * @param {string} project
   * @param {string} instance
   * @param {string} database
   * @param {string} session
   * @returns {string} Resource name string.
   */
  sessionPath(
    project: string,
    instance: string,
    database: string,
    session: string
  ) {
    return this.pathTemplates.sessionPathTemplate.render({
      project: project,
      instance: instance,
      database: database,
      session: session,
    });
  }

  /**
   * Parse the project from Session resource.
   *
   * @param {string} sessionName
   *   A fully-qualified path representing Session resource.
   * @returns {string} A string representing the project.
   */
  matchProjectFromSessionName(sessionName: string) {
    return this.pathTemplates.sessionPathTemplate.match(sessionName).project;
  }

  /**
   * Parse the instance from Session resource.
   *
   * @param {string} sessionName
   *   A fully-qualified path representing Session resource.
   * @returns {string} A string representing the instance.
   */
  matchInstanceFromSessionName(sessionName: string) {
    return this.pathTemplates.sessionPathTemplate.match(sessionName).instance;
  }

  /**
   * Parse the database from Session resource.
   *
   * @param {string} sessionName
   *   A fully-qualified path representing Session resource.
   * @returns {string} A string representing the database.
   */
  matchDatabaseFromSessionName(sessionName: string) {
    return this.pathTemplates.sessionPathTemplate.match(sessionName).database;
  }

  /**
   * Parse the session from Session resource.
   *
   * @param {string} sessionName
   *   A fully-qualified path representing Session resource.
   * @returns {string} A string representing the session.
   */
  matchSessionFromSessionName(sessionName: string) {
    return this.pathTemplates.sessionPathTemplate.match(sessionName).session;
  }

  /**
   * Terminate the gRPC channel and close the client.
   *
   * The client will no longer be usable and all future behavior is undefined.
   * @returns {Promise} A promise that resolves when the client is closed.
   */
  close(): Promise<void> {
    this.initialize();
    if (!this._terminated) {
      return this.spannerStub!.then(stub => {
        this._terminated = true;
        stub.close();
      });
    }
    return Promise.resolve();
  }
}