bigtable_client.ts

// Copyright 2024 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 type * as gax from 'google-gax';
import type {
  Callback,
  CallOptions,
  Descriptors,
  ClientOptions,
} from 'google-gax';
import {PassThrough} from 'stream';
import * as protos from '../../protos/protos';
import jsonProtos = require('../../protos/protos.json');

/**
 * Client JSON configuration object, loaded from
 * `src/v2/bigtable_client_config.json`.
 * This file defines retry strategy and timeouts for all API methods in this library.
 */
import * as gapicConfig from './bigtable_client_config.json';
const version = require('../../../package.json').version;

/**
 *  Service for reading from and writing to existing Bigtable tables.
 * @class
 * @memberof v2
 */
export class BigtableClient {
  private _terminated = false;
  private _opts: ClientOptions;
  private _providedCustomServicePath: boolean;
  private _gaxModule: typeof gax | typeof gax.fallback;
  private _gaxGrpc: gax.GrpcClient | gax.fallback.GrpcClient;
  private _protos: {};
  private _defaults: {[method: string]: gax.CallSettings};
  private _universeDomain: string;
  private _servicePath: string;
  auth: gax.GoogleAuth;
  descriptors: Descriptors = {
    page: {},
    stream: {},
    longrunning: {},
    batching: {},
  };
  warn: (code: string, message: string, warnType?: string) => void;
  innerApiCalls: {[name: string]: Function};
  pathTemplates: {[name: string]: gax.PathTemplate};
  bigtableStub?: Promise<{[name: string]: Function}>;

  /**
   * Construct an instance of BigtableClient.
   *
   * @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/main/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/1.1 REST mode.
   *     For more information, please check the
   *     {@link https://github.com/googleapis/gax-nodejs/blob/main/client-libraries.md#http11-rest-api-mode documentation}.
   * @param {gax} [gaxInstance]: loaded instance of `google-gax`. Useful if you
   *     need to avoid loading the default gRPC version and want to use the fallback
   *     HTTP implementation. Load only fallback version and pass it to the constructor:
   *     ```
   *     const gax = require('google-gax/build/src/fallback'); // avoids loading google-gax with gRPC
   *     const client = new BigtableClient({fallback: true}, gax);
   *     ```
   */
  constructor(
    opts?: ClientOptions,
    gaxInstance?: typeof gax | typeof gax.fallback
  ) {
    // Ensure that options include all the required fields.
    const staticMembers = this.constructor as typeof BigtableClient;
    if (
      opts?.universe_domain &&
      opts?.universeDomain &&
      opts?.universe_domain !== opts?.universeDomain
    ) {
      throw new Error(
        'Please set either universe_domain or universeDomain, but not both.'
      );
    }
    const universeDomainEnvVar =
      typeof process === 'object' && typeof process.env === 'object'
        ? process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']
        : undefined;
    this._universeDomain =
      opts?.universeDomain ??
      opts?.universe_domain ??
      universeDomainEnvVar ??
      'googleapis.com';
    this._servicePath = 'bigtable.' + this._universeDomain;
    const servicePath =
      opts?.servicePath || opts?.apiEndpoint || this._servicePath;
    this._providedCustomServicePath = !!(
      opts?.servicePath || opts?.apiEndpoint
    );
    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);

    // Request numeric enum values if REST transport is used.
    opts.numericEnums = true;

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

    // Load google-gax module synchronously if needed
    if (!gaxInstance) {
      gaxInstance = require('google-gax') as typeof gax;
    }

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

    // 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 useJWTAccessWithScope on the auth object.
    this.auth.useJWTAccessWithScope = true;

    // Set defaultServicePath on the auth object.
    this.auth.defaultServicePath = this._servicePath;

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

    // Determine the client header string.
    const clientHeader = [`gax/${this._gaxModule.version}`, `gapic/${version}`];
    if (typeof process === 'object' && '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 {
      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 = {
      authorizedViewPathTemplate: new this._gaxModule.PathTemplate(
        'projects/{project}/instances/{instance}/tables/{table}/authorizedViews/{authorized_view}'
      ),
      instancePathTemplate: new this._gaxModule.PathTemplate(
        'projects/{project}/instances/{instance}'
      ),
      tablePathTemplate: new this._gaxModule.PathTemplate(
        'projects/{project}/instances/{instance}/tables/{table}'
      ),
    };

    // Some of the methods on this service provide streaming responses.
    // Provide descriptors for these.
    this.descriptors.stream = {
      readRows: new this._gaxModule.StreamDescriptor(
        this._gaxModule.StreamType.SERVER_STREAMING,
        !!opts.fallback,
        !!opts.gaxServerStreamingRetries
      ),
      sampleRowKeys: new this._gaxModule.StreamDescriptor(
        this._gaxModule.StreamType.SERVER_STREAMING,
        !!opts.fallback,
        !!opts.gaxServerStreamingRetries
      ),
      mutateRows: new this._gaxModule.StreamDescriptor(
        this._gaxModule.StreamType.SERVER_STREAMING,
        !!opts.fallback,
        !!opts.gaxServerStreamingRetries
      ),
      generateInitialChangeStreamPartitions:
        new this._gaxModule.StreamDescriptor(
          this._gaxModule.StreamType.SERVER_STREAMING,
          !!opts.fallback,
          !!opts.gaxServerStreamingRetries
        ),
      readChangeStream: new this._gaxModule.StreamDescriptor(
        this._gaxModule.StreamType.SERVER_STREAMING,
        !!opts.fallback,
        !!opts.gaxServerStreamingRetries
      ),
      executeQuery: new this._gaxModule.StreamDescriptor(
        this._gaxModule.StreamType.SERVER_STREAMING,
        !!opts.fallback,
        !!opts.gaxServerStreamingRetries
      ),
    };

    // Put together the default options sent with requests.
    this._defaults = this._gaxGrpc.constructSettings(
      'google.bigtable.v2.Bigtable',
      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 = {};

    // Add a warn function to the client constructor so it can be easily tested.
    this.warn = this._gaxModule.warn;
  }

  /**
   * 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.bigtableStub) {
      return this.bigtableStub;
    }

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

    // Iterate over each of the methods that the service provides
    // and create an API call method for each.
    const bigtableStubMethods = [
      'readRows',
      'sampleRowKeys',
      'mutateRow',
      'mutateRows',
      'checkAndMutateRow',
      'pingAndWarm',
      'readModifyWriteRow',
      'generateInitialChangeStreamPartitions',
      'readChangeStream',
      'executeQuery',
    ];
    for (const methodName of bigtableStubMethods) {
      const callPromise = this.bigtableStub.then(
        stub =>
          (...args: Array<{}>) => {
            if (this._terminated) {
              if (methodName in this.descriptors.stream) {
                const stream = new PassThrough();
                setImmediate(() => {
                  stream.emit(
                    'error',
                    new this._gaxModule.GoogleError(
                      'The client has already been closed.'
                    )
                  );
                });
                return stream;
              }
              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.stream[methodName] || undefined;
      const apiCall = this._gaxModule.createApiCall(
        callPromise,
        this._defaults[methodName],
        descriptor,
        this._opts.fallback
      );

      this.innerApiCalls[methodName] = apiCall;
    }

    return this.bigtableStub;
  }

  /**
   * The DNS address for this API service.
   * @deprecated Use the apiEndpoint method of the client instance.
   * @returns {string} The DNS address for this service.
   */
  static get servicePath() {
    if (
      typeof process === 'object' &&
      typeof process.emitWarning === 'function'
    ) {
      process.emitWarning(
        'Static servicePath is deprecated, please use the instance method instead.',
        'DeprecationWarning'
      );
    }
    return 'bigtable.googleapis.com';
  }

  /**
   * The DNS address for this API service - same as servicePath.
   * @deprecated Use the apiEndpoint method of the client instance.
   * @returns {string} The DNS address for this service.
   */
  static get apiEndpoint() {
    if (
      typeof process === 'object' &&
      typeof process.emitWarning === 'function'
    ) {
      process.emitWarning(
        'Static apiEndpoint is deprecated, please use the instance method instead.',
        'DeprecationWarning'
      );
    }
    return 'bigtable.googleapis.com';
  }

  /**
   * The DNS address for this API service.
   * @returns {string} The DNS address for this service.
   */
  get apiEndpoint() {
    return this._servicePath;
  }

  get universeDomain() {
    return this._universeDomain;
  }

  /**
   * 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/bigtable.data',
      'https://www.googleapis.com/auth/bigtable.data.readonly',
      'https://www.googleapis.com/auth/cloud-bigtable.data',
      'https://www.googleapis.com/auth/cloud-bigtable.data.readonly',
      'https://www.googleapis.com/auth/cloud-platform',
      'https://www.googleapis.com/auth/cloud-platform.read-only',
    ];
  }

  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 --
  // -------------------
  /**
   * Mutates a row atomically. Cells already present in the row are left
   * unchanged unless explicitly changed by `mutation`.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} [request.tableName]
   *   Optional. The unique name of the table to which the mutation should be
   *   applied.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>`.
   * @param {string} [request.authorizedViewName]
   *   Optional. The unique name of the AuthorizedView to which the mutation
   *   should be applied.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   * @param {Buffer} request.rowKey
   *   Required. The key of the row to which the mutation should be applied.
   * @param {number[]} request.mutations
   *   Required. Changes to be atomically applied to the specified row. Entries
   *   are applied in order, meaning that earlier mutations can be masked by later
   *   ones. Must contain at least one entry and at most 100000.
   * @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 {@link protos.google.bigtable.v2.MutateRowResponse|MutateRowResponse}.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation }
   *   for more details and examples.
   */
  mutateRow(
    request?: protos.google.bigtable.v2.IMutateRowRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.bigtable.v2.IMutateRowResponse,
      protos.google.bigtable.v2.IMutateRowRequest | undefined,
      {} | undefined,
    ]
  >;
  mutateRow(
    request: protos.google.bigtable.v2.IMutateRowRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.bigtable.v2.IMutateRowResponse,
      protos.google.bigtable.v2.IMutateRowRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  mutateRow(
    request: protos.google.bigtable.v2.IMutateRowRequest,
    callback: Callback<
      protos.google.bigtable.v2.IMutateRowResponse,
      protos.google.bigtable.v2.IMutateRowRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  mutateRow(
    request?: protos.google.bigtable.v2.IMutateRowRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.bigtable.v2.IMutateRowResponse,
          protos.google.bigtable.v2.IMutateRowRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.bigtable.v2.IMutateRowResponse,
      protos.google.bigtable.v2.IMutateRowRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.bigtable.v2.IMutateRowResponse,
      protos.google.bigtable.v2.IMutateRowRequest | 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 || {};
    const routingParameter = {};
    {
      const fieldValue = request.tableName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp('(?<table_name>projects/[^/]+/instances/[^/]+/tables/[^/]+)')
          );
        if (match) {
          const parameterValue = match.groups?.['table_name'] ?? fieldValue;
          Object.assign(routingParameter, {table_name: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.appProfileId;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<app_profile_id>.*)'));
        if (match) {
          const parameterValue = match.groups?.['app_profile_id'] ?? fieldValue;
          Object.assign(routingParameter, {app_profile_id: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.authorizedViewName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp(
              '(?<authorized_view_name>projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)'
            )
          );
        if (match) {
          const parameterValue =
            match.groups?.['authorized_view_name'] ?? fieldValue;
          Object.assign(routingParameter, {
            authorized_view_name: parameterValue,
          });
        }
      }
    }
    options.otherArgs.headers['x-goog-request-params'] =
      this._gaxModule.routingHeader.fromParams(routingParameter);
    this.initialize();
    return this.innerApiCalls.mutateRow(request, options, callback);
  }
  /**
   * Mutates a row atomically based on the output of a predicate Reader filter.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} [request.tableName]
   *   Optional. The unique name of the table to which the conditional mutation
   *   should be applied.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>`.
   * @param {string} [request.authorizedViewName]
   *   Optional. The unique name of the AuthorizedView to which the conditional
   *   mutation should be applied.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   * @param {Buffer} request.rowKey
   *   Required. The key of the row to which the conditional mutation should be
   *   applied.
   * @param {google.bigtable.v2.RowFilter} request.predicateFilter
   *   The filter to be applied to the contents of the specified row. Depending
   *   on whether or not any results are yielded, either `true_mutations` or
   *   `false_mutations` will be executed. If unset, checks that the row contains
   *   any values at all.
   * @param {number[]} request.trueMutations
   *   Changes to be atomically applied to the specified row if `predicate_filter`
   *   yields at least one cell when applied to `row_key`. Entries are applied in
   *   order, meaning that earlier mutations can be masked by later ones.
   *   Must contain at least one entry if `false_mutations` is empty, and at most
   *   100000.
   * @param {number[]} request.falseMutations
   *   Changes to be atomically applied to the specified row if `predicate_filter`
   *   does not yield any cells when applied to `row_key`. Entries are applied in
   *   order, meaning that earlier mutations can be masked by later ones.
   *   Must contain at least one entry if `true_mutations` is empty, and at most
   *   100000.
   * @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 {@link protos.google.bigtable.v2.CheckAndMutateRowResponse|CheckAndMutateRowResponse}.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation }
   *   for more details and examples.
   */
  checkAndMutateRow(
    request?: protos.google.bigtable.v2.ICheckAndMutateRowRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.bigtable.v2.ICheckAndMutateRowResponse,
      protos.google.bigtable.v2.ICheckAndMutateRowRequest | undefined,
      {} | undefined,
    ]
  >;
  checkAndMutateRow(
    request: protos.google.bigtable.v2.ICheckAndMutateRowRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.bigtable.v2.ICheckAndMutateRowResponse,
      protos.google.bigtable.v2.ICheckAndMutateRowRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  checkAndMutateRow(
    request: protos.google.bigtable.v2.ICheckAndMutateRowRequest,
    callback: Callback<
      protos.google.bigtable.v2.ICheckAndMutateRowResponse,
      protos.google.bigtable.v2.ICheckAndMutateRowRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  checkAndMutateRow(
    request?: protos.google.bigtable.v2.ICheckAndMutateRowRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.bigtable.v2.ICheckAndMutateRowResponse,
          | protos.google.bigtable.v2.ICheckAndMutateRowRequest
          | null
          | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.bigtable.v2.ICheckAndMutateRowResponse,
      protos.google.bigtable.v2.ICheckAndMutateRowRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.bigtable.v2.ICheckAndMutateRowResponse,
      protos.google.bigtable.v2.ICheckAndMutateRowRequest | 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 || {};
    const routingParameter = {};
    {
      const fieldValue = request.tableName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp('(?<table_name>projects/[^/]+/instances/[^/]+/tables/[^/]+)')
          );
        if (match) {
          const parameterValue = match.groups?.['table_name'] ?? fieldValue;
          Object.assign(routingParameter, {table_name: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.appProfileId;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<app_profile_id>.*)'));
        if (match) {
          const parameterValue = match.groups?.['app_profile_id'] ?? fieldValue;
          Object.assign(routingParameter, {app_profile_id: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.authorizedViewName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp(
              '(?<authorized_view_name>projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)'
            )
          );
        if (match) {
          const parameterValue =
            match.groups?.['authorized_view_name'] ?? fieldValue;
          Object.assign(routingParameter, {
            authorized_view_name: parameterValue,
          });
        }
      }
    }
    options.otherArgs.headers['x-goog-request-params'] =
      this._gaxModule.routingHeader.fromParams(routingParameter);
    this.initialize();
    return this.innerApiCalls.checkAndMutateRow(request, options, callback);
  }
  /**
   * Warm up associated instance metadata for this connection.
   * This call is not required but may be useful for connection keep-alive.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.name
   *   Required. The unique name of the instance to check permissions for as well
   *   as respond. Values are of the form
   *   `projects/<project>/instances/<instance>`.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   * @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 {@link protos.google.bigtable.v2.PingAndWarmResponse|PingAndWarmResponse}.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation }
   *   for more details and examples.
   */
  pingAndWarm(
    request?: protos.google.bigtable.v2.IPingAndWarmRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.bigtable.v2.IPingAndWarmResponse,
      protos.google.bigtable.v2.IPingAndWarmRequest | undefined,
      {} | undefined,
    ]
  >;
  pingAndWarm(
    request: protos.google.bigtable.v2.IPingAndWarmRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.bigtable.v2.IPingAndWarmResponse,
      protos.google.bigtable.v2.IPingAndWarmRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  pingAndWarm(
    request: protos.google.bigtable.v2.IPingAndWarmRequest,
    callback: Callback<
      protos.google.bigtable.v2.IPingAndWarmResponse,
      protos.google.bigtable.v2.IPingAndWarmRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  pingAndWarm(
    request?: protos.google.bigtable.v2.IPingAndWarmRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.bigtable.v2.IPingAndWarmResponse,
          protos.google.bigtable.v2.IPingAndWarmRequest | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.bigtable.v2.IPingAndWarmResponse,
      protos.google.bigtable.v2.IPingAndWarmRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.bigtable.v2.IPingAndWarmResponse,
      protos.google.bigtable.v2.IPingAndWarmRequest | 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 || {};
    const routingParameter = {};
    {
      const fieldValue = request.name;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<name>projects/[^/]+/instances/[^/]+)'));
        if (match) {
          const parameterValue = match.groups?.['name'] ?? fieldValue;
          Object.assign(routingParameter, {name: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.appProfileId;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<app_profile_id>.*)'));
        if (match) {
          const parameterValue = match.groups?.['app_profile_id'] ?? fieldValue;
          Object.assign(routingParameter, {app_profile_id: parameterValue});
        }
      }
    }
    options.otherArgs.headers['x-goog-request-params'] =
      this._gaxModule.routingHeader.fromParams(routingParameter);
    this.initialize();
    return this.innerApiCalls.pingAndWarm(request, options, callback);
  }
  /**
   * Modifies a row atomically on the server. The method reads the latest
   * existing timestamp and value from the specified columns and writes a new
   * entry based on pre-defined read/modify/write rules. The new value for the
   * timestamp is the greater of the existing timestamp or the current server
   * time. The method returns the new contents of all modified cells.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} [request.tableName]
   *   Optional. The unique name of the table to which the read/modify/write rules
   *   should be applied.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>`.
   * @param {string} [request.authorizedViewName]
   *   Optional. The unique name of the AuthorizedView to which the
   *   read/modify/write rules should be applied.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   * @param {Buffer} request.rowKey
   *   Required. The key of the row to which the read/modify/write rules should be
   *   applied.
   * @param {number[]} request.rules
   *   Required. Rules specifying how the specified row's contents are to be
   *   transformed into writes. Entries are applied in order, meaning that earlier
   *   rules will affect the results of later ones.
   * @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 {@link protos.google.bigtable.v2.ReadModifyWriteRowResponse|ReadModifyWriteRowResponse}.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation }
   *   for more details and examples.
   */
  readModifyWriteRow(
    request?: protos.google.bigtable.v2.IReadModifyWriteRowRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.bigtable.v2.IReadModifyWriteRowResponse,
      protos.google.bigtable.v2.IReadModifyWriteRowRequest | undefined,
      {} | undefined,
    ]
  >;
  readModifyWriteRow(
    request: protos.google.bigtable.v2.IReadModifyWriteRowRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.bigtable.v2.IReadModifyWriteRowResponse,
      protos.google.bigtable.v2.IReadModifyWriteRowRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  readModifyWriteRow(
    request: protos.google.bigtable.v2.IReadModifyWriteRowRequest,
    callback: Callback<
      protos.google.bigtable.v2.IReadModifyWriteRowResponse,
      protos.google.bigtable.v2.IReadModifyWriteRowRequest | null | undefined,
      {} | null | undefined
    >
  ): void;
  readModifyWriteRow(
    request?: protos.google.bigtable.v2.IReadModifyWriteRowRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.bigtable.v2.IReadModifyWriteRowResponse,
          | protos.google.bigtable.v2.IReadModifyWriteRowRequest
          | null
          | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.bigtable.v2.IReadModifyWriteRowResponse,
      protos.google.bigtable.v2.IReadModifyWriteRowRequest | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.bigtable.v2.IReadModifyWriteRowResponse,
      protos.google.bigtable.v2.IReadModifyWriteRowRequest | 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 || {};
    const routingParameter = {};
    {
      const fieldValue = request.tableName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp('(?<table_name>projects/[^/]+/instances/[^/]+/tables/[^/]+)')
          );
        if (match) {
          const parameterValue = match.groups?.['table_name'] ?? fieldValue;
          Object.assign(routingParameter, {table_name: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.appProfileId;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<app_profile_id>.*)'));
        if (match) {
          const parameterValue = match.groups?.['app_profile_id'] ?? fieldValue;
          Object.assign(routingParameter, {app_profile_id: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.authorizedViewName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp(
              '(?<authorized_view_name>projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)'
            )
          );
        if (match) {
          const parameterValue =
            match.groups?.['authorized_view_name'] ?? fieldValue;
          Object.assign(routingParameter, {
            authorized_view_name: parameterValue,
          });
        }
      }
    }
    options.otherArgs.headers['x-goog-request-params'] =
      this._gaxModule.routingHeader.fromParams(routingParameter);
    this.initialize();
    return this.innerApiCalls.readModifyWriteRow(request, options, callback);
  }

  /**
   * Streams back the contents of all requested rows in key order, optionally
   * applying the same Reader filter to each. Depending on their size,
   * rows and cells may be broken up across multiple responses, but
   * atomicity of each row will still be preserved. See the
   * ReadRowsResponse documentation for details.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} [request.tableName]
   *   Optional. The unique name of the table from which to read.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>`.
   * @param {string} [request.authorizedViewName]
   *   Optional. The unique name of the AuthorizedView from which to read.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   * @param {google.bigtable.v2.RowSet} request.rows
   *   The row keys and/or ranges to read sequentially. If not specified, reads
   *   from all rows.
   * @param {google.bigtable.v2.RowFilter} request.filter
   *   The filter to apply to the contents of the specified row(s). If unset,
   *   reads the entirety of each row.
   * @param {number} request.rowsLimit
   *   The read will stop after committing to N rows' worth of results. The
   *   default (zero) is to return all results.
   * @param {google.bigtable.v2.ReadRowsRequest.RequestStatsView} request.requestStatsView
   *   The view into RequestStats, as described above.
   * @param {boolean} request.reversed
   *   Experimental API - Please note that this API is currently experimental
   *   and can change in the future.
   *
   *   Return rows in lexiographical descending order of the row keys. The row
   *   contents will not be affected by this flag.
   *
   *   Example result set:
   *
   *       [
   *         {key: "k2", "f:col1": "v1", "f:col2": "v1"},
   *         {key: "k1", "f:col1": "v2", "f:col2": "v2"}
   *       ]
   * @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 {@link protos.google.bigtable.v2.ReadRowsResponse|ReadRowsResponse} on 'data' event.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#server-streaming | documentation }
   *   for more details and examples.
   */
  readRows(
    request?: protos.google.bigtable.v2.IReadRowsRequest,
    options?: CallOptions
  ): gax.CancellableStream {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    const routingParameter = {};
    {
      const fieldValue = request.tableName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp('(?<table_name>projects/[^/]+/instances/[^/]+/tables/[^/]+)')
          );
        if (match) {
          const parameterValue = match.groups?.['table_name'] ?? fieldValue;
          Object.assign(routingParameter, {table_name: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.appProfileId;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<app_profile_id>.*)'));
        if (match) {
          const parameterValue = match.groups?.['app_profile_id'] ?? fieldValue;
          Object.assign(routingParameter, {app_profile_id: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.authorizedViewName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp(
              '(?<authorized_view_name>projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)'
            )
          );
        if (match) {
          const parameterValue =
            match.groups?.['authorized_view_name'] ?? fieldValue;
          Object.assign(routingParameter, {
            authorized_view_name: parameterValue,
          });
        }
      }
    }
    options.otherArgs.headers['x-goog-request-params'] =
      this._gaxModule.routingHeader.fromParams(routingParameter);
    this.initialize();
    return this.innerApiCalls.readRows(request, options);
  }

  /**
   * Returns a sample of row keys in the table. The returned row keys will
   * delimit contiguous sections of the table of approximately equal size,
   * which can be used to break up the data for distributed tasks like
   * mapreduces.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} [request.tableName]
   *   Optional. The unique name of the table from which to sample row keys.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>`.
   * @param {string} [request.authorizedViewName]
   *   Optional. The unique name of the AuthorizedView from which to sample row
   *   keys.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   * @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 {@link protos.google.bigtable.v2.SampleRowKeysResponse|SampleRowKeysResponse} on 'data' event.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#server-streaming | documentation }
   *   for more details and examples.
   */
  sampleRowKeys(
    request?: protos.google.bigtable.v2.ISampleRowKeysRequest,
    options?: CallOptions
  ): gax.CancellableStream {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    const routingParameter = {};
    {
      const fieldValue = request.tableName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp('(?<table_name>projects/[^/]+/instances/[^/]+/tables/[^/]+)')
          );
        if (match) {
          const parameterValue = match.groups?.['table_name'] ?? fieldValue;
          Object.assign(routingParameter, {table_name: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.appProfileId;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<app_profile_id>.*)'));
        if (match) {
          const parameterValue = match.groups?.['app_profile_id'] ?? fieldValue;
          Object.assign(routingParameter, {app_profile_id: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.authorizedViewName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp(
              '(?<authorized_view_name>projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)'
            )
          );
        if (match) {
          const parameterValue =
            match.groups?.['authorized_view_name'] ?? fieldValue;
          Object.assign(routingParameter, {
            authorized_view_name: parameterValue,
          });
        }
      }
    }
    options.otherArgs.headers['x-goog-request-params'] =
      this._gaxModule.routingHeader.fromParams(routingParameter);
    this.initialize();
    return this.innerApiCalls.sampleRowKeys(request, options);
  }

  /**
   * Mutates multiple rows in a batch. Each individual row is mutated
   * atomically as in MutateRow, but the entire batch is not executed
   * atomically.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} [request.tableName]
   *   Optional. The unique name of the table to which the mutations should be
   *   applied.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>`.
   * @param {string} [request.authorizedViewName]
   *   Optional. The unique name of the AuthorizedView to which the mutations
   *   should be applied.
   *
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   * @param {number[]} request.entries
   *   Required. The row keys and corresponding mutations to be applied in bulk.
   *   Each entry is applied as an atomic mutation, but the entries may be
   *   applied in arbitrary order (even between entries for the same row).
   *   At least one entry must be specified, and in total the entries can
   *   contain at most 100000 mutations.
   * @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 {@link protos.google.bigtable.v2.MutateRowsResponse|MutateRowsResponse} on 'data' event.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#server-streaming | documentation }
   *   for more details and examples.
   */
  mutateRows(
    request?: protos.google.bigtable.v2.IMutateRowsRequest,
    options?: CallOptions
  ): gax.CancellableStream {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    const routingParameter = {};
    {
      const fieldValue = request.tableName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp('(?<table_name>projects/[^/]+/instances/[^/]+/tables/[^/]+)')
          );
        if (match) {
          const parameterValue = match.groups?.['table_name'] ?? fieldValue;
          Object.assign(routingParameter, {table_name: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.appProfileId;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<app_profile_id>.*)'));
        if (match) {
          const parameterValue = match.groups?.['app_profile_id'] ?? fieldValue;
          Object.assign(routingParameter, {app_profile_id: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.authorizedViewName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(
            RegExp(
              '(?<authorized_view_name>projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+)'
            )
          );
        if (match) {
          const parameterValue =
            match.groups?.['authorized_view_name'] ?? fieldValue;
          Object.assign(routingParameter, {
            authorized_view_name: parameterValue,
          });
        }
      }
    }
    options.otherArgs.headers['x-goog-request-params'] =
      this._gaxModule.routingHeader.fromParams(routingParameter);
    this.initialize();
    return this.innerApiCalls.mutateRows(request, options);
  }

  /**
   * NOTE: This API is intended to be used by Apache Beam BigtableIO.
   * Returns the current list of partitions that make up the table's
   * change stream. The union of partitions will cover the entire keyspace.
   * Partitions can be read with `ReadChangeStream`.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.tableName
   *   Required. The unique name of the table from which to get change stream
   *   partitions. Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>`.
   *   Change streaming must be enabled on the table.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   *   Single cluster routing must be configured on the profile.
   * @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 {@link protos.google.bigtable.v2.GenerateInitialChangeStreamPartitionsResponse|GenerateInitialChangeStreamPartitionsResponse} on 'data' event.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#server-streaming | documentation }
   *   for more details and examples.
   */
  generateInitialChangeStreamPartitions(
    request?: protos.google.bigtable.v2.IGenerateInitialChangeStreamPartitionsRequest,
    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'] =
      this._gaxModule.routingHeader.fromParams({
        table_name: request.tableName ?? '',
      });
    this.initialize();
    return this.innerApiCalls.generateInitialChangeStreamPartitions(
      request,
      options
    );
  }

  /**
   * NOTE: This API is intended to be used by Apache Beam BigtableIO.
   * Reads changes from a table's change stream. Changes will
   * reflect both user-initiated mutations and mutations that are caused by
   * garbage collection.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.tableName
   *   Required. The unique name of the table from which to read a change stream.
   *   Values are of the form
   *   `projects/<project>/instances/<instance>/tables/<table>`.
   *   Change streaming must be enabled on the table.
   * @param {string} request.appProfileId
   *   This value specifies routing for replication. If not specified, the
   *   "default" application profile will be used.
   *   Single cluster routing must be configured on the profile.
   * @param {google.bigtable.v2.StreamPartition} request.partition
   *   The partition to read changes from.
   * @param {google.protobuf.Timestamp} request.startTime
   *   Start reading the stream at the specified timestamp. This timestamp must
   *   be within the change stream retention period, less than or equal to the
   *   current time, and after change stream creation, whichever is greater.
   *   This value is inclusive and will be truncated to microsecond granularity.
   * @param {google.bigtable.v2.StreamContinuationTokens} request.continuationTokens
   *   Tokens that describe how to resume reading a stream where reading
   *   previously left off. If specified, changes will be read starting at the
   *   the position. Tokens are delivered on the stream as part of `Heartbeat`
   *   and `CloseStream` messages.
   *
   *   If a single token is provided, the token’s partition must exactly match
   *   the request’s partition. If multiple tokens are provided, as in the case
   *   of a partition merge, the union of the token partitions must exactly
   *   cover the request’s partition. Otherwise, INVALID_ARGUMENT will be
   *   returned.
   * @param {google.protobuf.Timestamp} request.endTime
   *   If specified, OK will be returned when the stream advances beyond
   *   this time. Otherwise, changes will be continuously delivered on the stream.
   *   This value is inclusive and will be truncated to microsecond granularity.
   * @param {google.protobuf.Duration} request.heartbeatDuration
   *   If specified, the duration between `Heartbeat` messages on the stream.
   *   Otherwise, defaults to 5 seconds.
   * @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 {@link protos.google.bigtable.v2.ReadChangeStreamResponse|ReadChangeStreamResponse} on 'data' event.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#server-streaming | documentation }
   *   for more details and examples.
   */
  readChangeStream(
    request?: protos.google.bigtable.v2.IReadChangeStreamRequest,
    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'] =
      this._gaxModule.routingHeader.fromParams({
        table_name: request.tableName ?? '',
      });
    this.initialize();
    return this.innerApiCalls.readChangeStream(request, options);
  }

  /**
   * Executes a BTQL query against a particular Cloud Bigtable instance.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.instanceName
   *   Required. The unique name of the instance against which the query should be
   *   executed.
   *   Values are of the form `projects/<project>/instances/<instance>`
   * @param {string} [request.appProfileId]
   *   Optional. This value specifies routing for replication. If not specified,
   *   the `default` application profile will be used.
   * @param {string} request.query
   *   Required. The query string.
   * @param {google.bigtable.v2.ProtoFormat} request.protoFormat
   *   Protocol buffer format as described by ProtoSchema and ProtoRows
   *   messages.
   * @param {Buffer} [request.resumeToken]
   *   Optional. If this request is resuming a previously interrupted query
   *   execution, `resume_token` should be copied from the last
   *   PartialResultSet yielded before the interruption. Doing this
   *   enables the query execution to resume where the last one left
   *   off.
   *   The rest of the request parameters must exactly match the
   *   request that yielded this token. Otherwise the request will fail.
   * @param {number[]} request.params
   *   Required. params contains string type keys and Bigtable type values that
   *   bind to placeholders in the query string. In query string, a parameter
   *   placeholder consists of the
   *   `@` character followed by the parameter name (for example, `@firstName`) in
   *   the query string.
   *
   *   For example, if
   *   `params["firstName"] = bytes_value: "foo" type {bytes_type {}}`
   *    then `@firstName` will be replaced with googlesql bytes value "foo" in the
   *    query string during query evaluation.
   *
   *   In case of Value.kind is not set, it will be set to corresponding null
   *   value in googlesql.
   *    `params["firstName"] =  type {string_type {}}`
   *    then `@firstName` will be replaced with googlesql null string.
   *
   *   Value.type should always be set and no inference of type will be made from
   *   Value.kind. If Value.type is not set, we will return INVALID_ARGUMENT
   *   error.
   * @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 {@link protos.google.bigtable.v2.ExecuteQueryResponse|ExecuteQueryResponse} on 'data' event.
   *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#server-streaming | documentation }
   *   for more details and examples.
   */
  executeQuery(
    request?: protos.google.bigtable.v2.IExecuteQueryRequest,
    options?: CallOptions
  ): gax.CancellableStream {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    const routingParameter = {};
    {
      const fieldValue = request.instanceName;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<name>projects/[^/]+/instances/[^/]+)'));
        if (match) {
          const parameterValue = match.groups?.['name'] ?? fieldValue;
          Object.assign(routingParameter, {name: parameterValue});
        }
      }
    }
    {
      const fieldValue = request.appProfileId;
      if (fieldValue !== undefined && fieldValue !== null) {
        const match = fieldValue
          .toString()
          .match(RegExp('(?<app_profile_id>.*)'));
        if (match) {
          const parameterValue = match.groups?.['app_profile_id'] ?? fieldValue;
          Object.assign(routingParameter, {app_profile_id: parameterValue});
        }
      }
    }
    options.otherArgs.headers['x-goog-request-params'] =
      this._gaxModule.routingHeader.fromParams(routingParameter);
    this.initialize();
    return this.innerApiCalls.executeQuery(request, options);
  }

  // --------------------
  // -- Path templates --
  // --------------------

  /**
   * Return a fully-qualified authorizedView resource name string.
   *
   * @param {string} project
   * @param {string} instance
   * @param {string} table
   * @param {string} authorized_view
   * @returns {string} Resource name string.
   */
  authorizedViewPath(
    project: string,
    instance: string,
    table: string,
    authorizedView: string
  ) {
    return this.pathTemplates.authorizedViewPathTemplate.render({
      project: project,
      instance: instance,
      table: table,
      authorized_view: authorizedView,
    });
  }

  /**
   * Parse the project from AuthorizedView resource.
   *
   * @param {string} authorizedViewName
   *   A fully-qualified path representing AuthorizedView resource.
   * @returns {string} A string representing the project.
   */
  matchProjectFromAuthorizedViewName(authorizedViewName: string) {
    return this.pathTemplates.authorizedViewPathTemplate.match(
      authorizedViewName
    ).project;
  }

  /**
   * Parse the instance from AuthorizedView resource.
   *
   * @param {string} authorizedViewName
   *   A fully-qualified path representing AuthorizedView resource.
   * @returns {string} A string representing the instance.
   */
  matchInstanceFromAuthorizedViewName(authorizedViewName: string) {
    return this.pathTemplates.authorizedViewPathTemplate.match(
      authorizedViewName
    ).instance;
  }

  /**
   * Parse the table from AuthorizedView resource.
   *
   * @param {string} authorizedViewName
   *   A fully-qualified path representing AuthorizedView resource.
   * @returns {string} A string representing the table.
   */
  matchTableFromAuthorizedViewName(authorizedViewName: string) {
    return this.pathTemplates.authorizedViewPathTemplate.match(
      authorizedViewName
    ).table;
  }

  /**
   * Parse the authorized_view from AuthorizedView resource.
   *
   * @param {string} authorizedViewName
   *   A fully-qualified path representing AuthorizedView resource.
   * @returns {string} A string representing the authorized_view.
   */
  matchAuthorizedViewFromAuthorizedViewName(authorizedViewName: string) {
    return this.pathTemplates.authorizedViewPathTemplate.match(
      authorizedViewName
    ).authorized_view;
  }

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

  /**
   * Parse the project from Instance resource.
   *
   * @param {string} instanceName
   *   A fully-qualified path representing Instance resource.
   * @returns {string} A string representing the project.
   */
  matchProjectFromInstanceName(instanceName: string) {
    return this.pathTemplates.instancePathTemplate.match(instanceName).project;
  }

  /**
   * Parse the instance from Instance resource.
   *
   * @param {string} instanceName
   *   A fully-qualified path representing Instance resource.
   * @returns {string} A string representing the instance.
   */
  matchInstanceFromInstanceName(instanceName: string) {
    return this.pathTemplates.instancePathTemplate.match(instanceName).instance;
  }

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

  /**
   * Parse the project from Table resource.
   *
   * @param {string} tableName
   *   A fully-qualified path representing Table resource.
   * @returns {string} A string representing the project.
   */
  matchProjectFromTableName(tableName: string) {
    return this.pathTemplates.tablePathTemplate.match(tableName).project;
  }

  /**
   * Parse the instance from Table resource.
   *
   * @param {string} tableName
   *   A fully-qualified path representing Table resource.
   * @returns {string} A string representing the instance.
   */
  matchInstanceFromTableName(tableName: string) {
    return this.pathTemplates.tablePathTemplate.match(tableName).instance;
  }

  /**
   * Parse the table from Table resource.
   *
   * @param {string} tableName
   *   A fully-qualified path representing Table resource.
   * @returns {string} A string representing the table.
   */
  matchTableFromTableName(tableName: string) {
    return this.pathTemplates.tablePathTemplate.match(tableName).table;
  }

  /**
   * 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> {
    if (this.bigtableStub && !this._terminated) {
      return this.bigtableStub.then(stub => {
        this._terminated = true;
        stub.close();
      });
    }
    return Promise.resolve();
  }
}