translation_service_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,
  LROperation,
  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/v3beta1/translation_service_client_config.json`.
 * This file defines retry strategy and timeouts for all API methods in this library.
 */
import * as gapicConfig from './translation_service_client_config.json';
import {operationsProtos} from 'google-gax';
const version = require('../../../package.json').version;

/**
 *  Provides natural language translation operations.
 * @class
 * @memberof v3beta1
 */
export class TranslationServiceClient {
  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};
  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};
  operationsClient: gax.OperationsClient;
  translationServiceStub?: Promise<{[name: string]: Function}>;

  /**
   * Construct an instance of TranslationServiceClient.
   *
   * @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 TranslationServiceClient;
    const servicePath =
      opts?.servicePath || opts?.apiEndpoint || staticMembers.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);

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

    // Set defaultServicePath on the auth object.
    this.auth.defaultServicePath = staticMembers.servicePath;

    // 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 = {
      glossaryPathTemplate: new this._gaxModule.PathTemplate(
        'projects/{project}/locations/{location}/glossaries/{glossary}'
      ),
      locationPathTemplate: new this._gaxModule.PathTemplate(
        'projects/{project}/locations/{location}'
      ),
    };

    // 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 = {
      listGlossaries: new this._gaxModule.PageDescriptor(
        'pageToken',
        'nextPageToken',
        'glossaries'
      ),
    };

    const protoFilesRoot = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);

    // This API contains "long-running operations", which return a
    // an Operation object that allows for tracking of the operation,
    // rather than holding a request open.

    this.operationsClient = this._gaxModule
      .lro({
        auth: this.auth,
        grpc: 'grpc' in this._gaxGrpc ? this._gaxGrpc.grpc : undefined,
      })
      .operationsClient(opts);
    const batchTranslateTextResponse = protoFilesRoot.lookup(
      '.google.cloud.translation.v3beta1.BatchTranslateResponse'
    ) as gax.protobuf.Type;
    const batchTranslateTextMetadata = protoFilesRoot.lookup(
      '.google.cloud.translation.v3beta1.BatchTranslateMetadata'
    ) as gax.protobuf.Type;
    const batchTranslateDocumentResponse = protoFilesRoot.lookup(
      '.google.cloud.translation.v3beta1.BatchTranslateDocumentResponse'
    ) as gax.protobuf.Type;
    const batchTranslateDocumentMetadata = protoFilesRoot.lookup(
      '.google.cloud.translation.v3beta1.BatchTranslateDocumentMetadata'
    ) as gax.protobuf.Type;
    const createGlossaryResponse = protoFilesRoot.lookup(
      '.google.cloud.translation.v3beta1.Glossary'
    ) as gax.protobuf.Type;
    const createGlossaryMetadata = protoFilesRoot.lookup(
      '.google.cloud.translation.v3beta1.CreateGlossaryMetadata'
    ) as gax.protobuf.Type;
    const deleteGlossaryResponse = protoFilesRoot.lookup(
      '.google.cloud.translation.v3beta1.DeleteGlossaryResponse'
    ) as gax.protobuf.Type;
    const deleteGlossaryMetadata = protoFilesRoot.lookup(
      '.google.cloud.translation.v3beta1.DeleteGlossaryMetadata'
    ) as gax.protobuf.Type;

    this.descriptors.longrunning = {
      batchTranslateText: new this._gaxModule.LongrunningDescriptor(
        this.operationsClient,
        batchTranslateTextResponse.decode.bind(batchTranslateTextResponse),
        batchTranslateTextMetadata.decode.bind(batchTranslateTextMetadata)
      ),
      batchTranslateDocument: new this._gaxModule.LongrunningDescriptor(
        this.operationsClient,
        batchTranslateDocumentResponse.decode.bind(
          batchTranslateDocumentResponse
        ),
        batchTranslateDocumentMetadata.decode.bind(
          batchTranslateDocumentMetadata
        )
      ),
      createGlossary: new this._gaxModule.LongrunningDescriptor(
        this.operationsClient,
        createGlossaryResponse.decode.bind(createGlossaryResponse),
        createGlossaryMetadata.decode.bind(createGlossaryMetadata)
      ),
      deleteGlossary: new this._gaxModule.LongrunningDescriptor(
        this.operationsClient,
        deleteGlossaryResponse.decode.bind(deleteGlossaryResponse),
        deleteGlossaryMetadata.decode.bind(deleteGlossaryMetadata)
      ),
    };

    // Put together the default options sent with requests.
    this._defaults = this._gaxGrpc.constructSettings(
      'google.cloud.translation.v3beta1.TranslationService',
      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 = gax.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.translationServiceStub) {
      return this.translationServiceStub;
    }

    // Put together the "service stub" for
    // google.cloud.translation.v3beta1.TranslationService.
    this.translationServiceStub = this._gaxGrpc.createStub(
      this._opts.fallback
        ? (this._protos as protobuf.Root).lookupService(
            'google.cloud.translation.v3beta1.TranslationService'
          )
        : // eslint-disable-next-line @typescript-eslint/no-explicit-any
          (this._protos as any).google.cloud.translation.v3beta1
            .TranslationService,
      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 translationServiceStubMethods = [
      'translateText',
      'detectLanguage',
      'getSupportedLanguages',
      'translateDocument',
      'batchTranslateText',
      'batchTranslateDocument',
      'createGlossary',
      'listGlossaries',
      'getGlossary',
      'deleteGlossary',
    ];
    for (const methodName of translationServiceStubMethods) {
      const callPromise = this.translationServiceStub.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.longrunning[methodName] ||
        undefined;
      const apiCall = this._gaxModule.createApiCall(
        callPromise,
        this._defaults[methodName],
        descriptor
      );

      this.innerApiCalls[methodName] = apiCall;
    }

    return this.translationServiceStub;
  }

  /**
   * The DNS address for this API service.
   * @returns {string} The DNS address for this service.
   */
  static get servicePath() {
    return 'translate.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 'translate.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/cloud-translation',
    ];
  }

  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 --
  // -------------------
  translateText(
    request?: protos.google.cloud.translation.v3beta1.ITranslateTextRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.ITranslateTextResponse,
      protos.google.cloud.translation.v3beta1.ITranslateTextRequest | undefined,
      {} | undefined
    ]
  >;
  translateText(
    request: protos.google.cloud.translation.v3beta1.ITranslateTextRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.ITranslateTextResponse,
      | protos.google.cloud.translation.v3beta1.ITranslateTextRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  translateText(
    request: protos.google.cloud.translation.v3beta1.ITranslateTextRequest,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.ITranslateTextResponse,
      | protos.google.cloud.translation.v3beta1.ITranslateTextRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Translates input text and returns translated text.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string[]} request.contents
   *   Required. The content of the input in string format.
   *   We recommend the total content be less than 30k codepoints. The max length
   *   of this field is 1024.
   *   Use BatchTranslateText for larger text.
   * @param {string} [request.mimeType]
   *   Optional. The format of the source text, for example, "text/html",
   *    "text/plain". If left blank, the MIME type defaults to "text/html".
   * @param {string} [request.sourceLanguageCode]
   *   Optional. The BCP-47 language code of the input text if
   *   known, for example, "en-US" or "sr-Latn". Supported language codes are
   *   listed in Language Support. If the source language isn't specified, the API
   *   attempts to identify the source language automatically and returns the
   *   source language within the response.
   * @param {string} request.targetLanguageCode
   *   Required. The BCP-47 language code to use for translation of the input
   *   text, set to one of the language codes listed in Language Support.
   * @param {string} request.parent
   *   Required. Project or location to make a call. Must refer to a caller's
   *   project.
   *
   *   Format: `projects/{project-number-or-id}` or
   *   `projects/{project-number-or-id}/locations/{location-id}`.
   *
   *   For global calls, use `projects/{project-number-or-id}/locations/global` or
   *   `projects/{project-number-or-id}`.
   *
   *   Non-global location is required for requests using AutoML models or
   *   custom glossaries.
   *
   *   Models and glossaries must be within the same region (have same
   *   location-id), otherwise an INVALID_ARGUMENT (400) error is returned.
   * @param {string} [request.model]
   *   Optional. The `model` type requested for this translation.
   *
   *   The format depends on model type:
   *
   *   - AutoML Translation models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}`
   *
   *   - General (built-in) models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,
   *
   *
   *   For global (non-regionalized) requests, use `location-id` `global`.
   *   For example,
   *   `projects/{project-number-or-id}/locations/global/models/general/nmt`.
   *
   *   If not provided, the default Google model (NMT) will be used
   * @param {google.cloud.translation.v3beta1.TranslateTextGlossaryConfig} [request.glossaryConfig]
   *   Optional. Glossary to be applied. The glossary must be
   *   within the same region (have the same location-id) as the model, otherwise
   *   an INVALID_ARGUMENT (400) error is returned.
   * @param {number[]} [request.labels]
   *   Optional. The labels with user-defined metadata for the request.
   *
   *   Label keys and values can be no longer than 63 characters
   *   (Unicode codepoints), can only contain lowercase letters, numeric
   *   characters, underscores and dashes. International characters are allowed.
   *   Label values are optional. Label keys must start with a letter.
   *
   *   See https://cloud.google.com/translate/docs/labels for more information.
   * @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 [TranslateTextResponse]{@link google.cloud.translation.v3beta1.TranslateTextResponse}.
   *   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.translateText(request);
   */
  translateText(
    request?: protos.google.cloud.translation.v3beta1.ITranslateTextRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.cloud.translation.v3beta1.ITranslateTextResponse,
          | protos.google.cloud.translation.v3beta1.ITranslateTextRequest
          | null
          | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.cloud.translation.v3beta1.ITranslateTextResponse,
      | protos.google.cloud.translation.v3beta1.ITranslateTextRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.ITranslateTextResponse,
      protos.google.cloud.translation.v3beta1.ITranslateTextRequest | 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({
        parent: request.parent || '',
      });
    this.initialize();
    return this.innerApiCalls.translateText(request, options, callback);
  }
  detectLanguage(
    request?: protos.google.cloud.translation.v3beta1.IDetectLanguageRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.IDetectLanguageResponse,
      (
        | protos.google.cloud.translation.v3beta1.IDetectLanguageRequest
        | undefined
      ),
      {} | undefined
    ]
  >;
  detectLanguage(
    request: protos.google.cloud.translation.v3beta1.IDetectLanguageRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.IDetectLanguageResponse,
      | protos.google.cloud.translation.v3beta1.IDetectLanguageRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  detectLanguage(
    request: protos.google.cloud.translation.v3beta1.IDetectLanguageRequest,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.IDetectLanguageResponse,
      | protos.google.cloud.translation.v3beta1.IDetectLanguageRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Detects the language of text within a request.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.parent
   *   Required. Project or location to make a call. Must refer to a caller's
   *   project.
   *
   *   Format: `projects/{project-number-or-id}/locations/{location-id}` or
   *   `projects/{project-number-or-id}`.
   *
   *   For global calls, use `projects/{project-number-or-id}/locations/global` or
   *   `projects/{project-number-or-id}`.
   *
   *   Only models within the same region (has same location-id) can be used.
   *   Otherwise an INVALID_ARGUMENT (400) error is returned.
   * @param {string} [request.model]
   *   Optional. The language detection model to be used.
   *
   *   Format:
   *   `projects/{project-number-or-id}/locations/{location-id}/models/language-detection/{model-id}`
   *
   *   Only one language detection model is currently supported:
   *   `projects/{project-number-or-id}/locations/{location-id}/models/language-detection/default`.
   *
   *   If not specified, the default model is used.
   * @param {string} request.content
   *   The content of the input stored as a string.
   * @param {string} [request.mimeType]
   *   Optional. The format of the source text, for example, "text/html",
   *   "text/plain". If left blank, the MIME type defaults to "text/html".
   * @param {number[]} [request.labels]
   *   Optional. The labels with user-defined metadata for the request.
   *
   *   Label keys and values can be no longer than 63 characters
   *   (Unicode codepoints), can only contain lowercase letters, numeric
   *   characters, underscores and dashes. International characters are allowed.
   *   Label values are optional. Label keys must start with a letter.
   *
   *   See https://cloud.google.com/translate/docs/labels for more information.
   * @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 [DetectLanguageResponse]{@link google.cloud.translation.v3beta1.DetectLanguageResponse}.
   *   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.detectLanguage(request);
   */
  detectLanguage(
    request?: protos.google.cloud.translation.v3beta1.IDetectLanguageRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.cloud.translation.v3beta1.IDetectLanguageResponse,
          | protos.google.cloud.translation.v3beta1.IDetectLanguageRequest
          | null
          | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.cloud.translation.v3beta1.IDetectLanguageResponse,
      | protos.google.cloud.translation.v3beta1.IDetectLanguageRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.IDetectLanguageResponse,
      (
        | protos.google.cloud.translation.v3beta1.IDetectLanguageRequest
        | 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({
        parent: request.parent || '',
      });
    this.initialize();
    return this.innerApiCalls.detectLanguage(request, options, callback);
  }
  getSupportedLanguages(
    request?: protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.ISupportedLanguages,
      (
        | protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest
        | undefined
      ),
      {} | undefined
    ]
  >;
  getSupportedLanguages(
    request: protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.ISupportedLanguages,
      | protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  getSupportedLanguages(
    request: protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.ISupportedLanguages,
      | protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Returns a list of supported languages for translation.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.parent
   *   Required. Project or location to make a call. Must refer to a caller's
   *   project.
   *
   *   Format: `projects/{project-number-or-id}` or
   *   `projects/{project-number-or-id}/locations/{location-id}`.
   *
   *   For global calls, use `projects/{project-number-or-id}/locations/global` or
   *   `projects/{project-number-or-id}`.
   *
   *   Non-global location is required for AutoML models.
   *
   *   Only models within the same region (have same location-id) can be used,
   *   otherwise an INVALID_ARGUMENT (400) error is returned.
   * @param {string} [request.displayLanguageCode]
   *   Optional. The language to use to return localized, human readable names
   *   of supported languages. If missing, then display names are not returned
   *   in a response.
   * @param {string} [request.model]
   *   Optional. Get supported languages of this model.
   *
   *   The format depends on model type:
   *
   *   - AutoML Translation models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}`
   *
   *   - General (built-in) models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,
   *
   *
   *   Returns languages supported by the specified model.
   *   If missing, we get supported languages of Google general NMT model.
   * @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 [SupportedLanguages]{@link google.cloud.translation.v3beta1.SupportedLanguages}.
   *   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.getSupportedLanguages(request);
   */
  getSupportedLanguages(
    request?: protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.cloud.translation.v3beta1.ISupportedLanguages,
          | protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest
          | null
          | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.cloud.translation.v3beta1.ISupportedLanguages,
      | protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.ISupportedLanguages,
      (
        | protos.google.cloud.translation.v3beta1.IGetSupportedLanguagesRequest
        | 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({
        parent: request.parent || '',
      });
    this.initialize();
    return this.innerApiCalls.getSupportedLanguages(request, options, callback);
  }
  translateDocument(
    request?: protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.ITranslateDocumentResponse,
      (
        | protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest
        | undefined
      ),
      {} | undefined
    ]
  >;
  translateDocument(
    request: protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.ITranslateDocumentResponse,
      | protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  translateDocument(
    request: protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.ITranslateDocumentResponse,
      | protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Translates documents in synchronous mode.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.parent
   *   Required. Location to make a regional call.
   *
   *   Format: `projects/{project-number-or-id}/locations/{location-id}`.
   *
   *   For global calls, use `projects/{project-number-or-id}/locations/global`.
   *
   *   Non-global location is required for requests using AutoML models or custom
   *   glossaries.
   *
   *   Models and glossaries must be within the same region (have the same
   *   location-id), otherwise an INVALID_ARGUMENT (400) error is returned.
   * @param {string} [request.sourceLanguageCode]
   *   Optional. The BCP-47 language code of the input document if known, for
   *   example, "en-US" or "sr-Latn". Supported language codes are listed in
   *   Language Support. If the source language isn't specified, the API attempts
   *   to identify the source language automatically and returns the source
   *   language within the response. Source language must be specified if the
   *   request contains a glossary or a custom model.
   * @param {string} request.targetLanguageCode
   *   Required. The BCP-47 language code to use for translation of the input
   *   document, set to one of the language codes listed in Language Support.
   * @param {google.cloud.translation.v3beta1.DocumentInputConfig} request.documentInputConfig
   *   Required. Input configurations.
   * @param {google.cloud.translation.v3beta1.DocumentOutputConfig} [request.documentOutputConfig]
   *   Optional. Output configurations.
   *   Defines if the output file should be stored within Cloud Storage as well
   *   as the desired output format. If not provided the translated file will
   *   only be returned through a byte-stream and its output mime type will be
   *   the same as the input file's mime type.
   * @param {string} [request.model]
   *   Optional. The `model` type requested for this translation.
   *
   *   The format depends on model type:
   *
   *   - AutoML Translation models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}`
   *
   *   - General (built-in) models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,
   *
   *
   *   If not provided, the default Google model (NMT) will be used for
   *   translation.
   * @param {google.cloud.translation.v3beta1.TranslateTextGlossaryConfig} [request.glossaryConfig]
   *   Optional. Glossary to be applied. The glossary must be within the same
   *   region (have the same location-id) as the model, otherwise an
   *   INVALID_ARGUMENT (400) error is returned.
   * @param {number[]} [request.labels]
   *   Optional. The labels with user-defined metadata for the request.
   *
   *   Label keys and values can be no longer than 63 characters (Unicode
   *   codepoints), can only contain lowercase letters, numeric characters,
   *   underscores and dashes. International characters are allowed. Label values
   *   are optional. Label keys must start with a letter.
   *
   *   See https://cloud.google.com/translate/docs/advanced/labels for more
   *   information.
   * @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 [TranslateDocumentResponse]{@link google.cloud.translation.v3beta1.TranslateDocumentResponse}.
   *   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.translateDocument(request);
   */
  translateDocument(
    request?: protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.cloud.translation.v3beta1.ITranslateDocumentResponse,
          | protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest
          | null
          | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.cloud.translation.v3beta1.ITranslateDocumentResponse,
      | protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.ITranslateDocumentResponse,
      (
        | protos.google.cloud.translation.v3beta1.ITranslateDocumentRequest
        | 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({
        parent: request.parent || '',
      });
    this.initialize();
    return this.innerApiCalls.translateDocument(request, options, callback);
  }
  getGlossary(
    request?: protos.google.cloud.translation.v3beta1.IGetGlossaryRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.IGlossary,
      protos.google.cloud.translation.v3beta1.IGetGlossaryRequest | undefined,
      {} | undefined
    ]
  >;
  getGlossary(
    request: protos.google.cloud.translation.v3beta1.IGetGlossaryRequest,
    options: CallOptions,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.IGlossary,
      | protos.google.cloud.translation.v3beta1.IGetGlossaryRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  getGlossary(
    request: protos.google.cloud.translation.v3beta1.IGetGlossaryRequest,
    callback: Callback<
      protos.google.cloud.translation.v3beta1.IGlossary,
      | protos.google.cloud.translation.v3beta1.IGetGlossaryRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Gets a glossary. Returns NOT_FOUND, if the glossary doesn't
   * exist.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.name
   *   Required. The name of the glossary 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 [Glossary]{@link google.cloud.translation.v3beta1.Glossary}.
   *   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.getGlossary(request);
   */
  getGlossary(
    request?: protos.google.cloud.translation.v3beta1.IGetGlossaryRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          protos.google.cloud.translation.v3beta1.IGlossary,
          | protos.google.cloud.translation.v3beta1.IGetGlossaryRequest
          | null
          | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      protos.google.cloud.translation.v3beta1.IGlossary,
      | protos.google.cloud.translation.v3beta1.IGetGlossaryRequest
      | null
      | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.IGlossary,
      protos.google.cloud.translation.v3beta1.IGetGlossaryRequest | 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.getGlossary(request, options, callback);
  }

  batchTranslateText(
    request?: protos.google.cloud.translation.v3beta1.IBatchTranslateTextRequest,
    options?: CallOptions
  ): Promise<
    [
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateMetadata
      >,
      protos.google.longrunning.IOperation | undefined,
      {} | undefined
    ]
  >;
  batchTranslateText(
    request: protos.google.cloud.translation.v3beta1.IBatchTranslateTextRequest,
    options: CallOptions,
    callback: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): void;
  batchTranslateText(
    request: protos.google.cloud.translation.v3beta1.IBatchTranslateTextRequest,
    callback: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Translates a large volume of text in asynchronous batch mode.
   * This function provides real-time output as the inputs are being processed.
   * If caller cancels a request, the partial results (for an input file, it's
   * all or nothing) may still be available on the specified output location.
   *
   * This call returns immediately and you can
   * use google.longrunning.Operation.name to poll the status of the call.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.parent
   *   Required. Location to make a call. Must refer to a caller's project.
   *
   *   Format: `projects/{project-number-or-id}/locations/{location-id}`.
   *
   *   The `global` location is not supported for batch translation.
   *
   *   Only AutoML Translation models or glossaries within the same region (have
   *   the same location-id) can be used, otherwise an INVALID_ARGUMENT (400)
   *   error is returned.
   * @param {string} request.sourceLanguageCode
   *   Required. Source language code.
   * @param {string[]} request.targetLanguageCodes
   *   Required. Specify up to 10 language codes here.
   * @param {number[]} [request.models]
   *   Optional. The models to use for translation. Map's key is target language
   *   code. Map's value is model name. Value can be a built-in general model,
   *   or an AutoML Translation model.
   *
   *   The value format depends on model type:
   *
   *   - AutoML Translation models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}`
   *
   *   - General (built-in) models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,
   *
   *
   *   If the map is empty or a specific model is
   *   not requested for a language pair, then default google model (nmt) is used.
   * @param {number[]} request.inputConfigs
   *   Required. Input configurations.
   *   The total number of files matched should be <= 100.
   *   The total content size should be <= 100M Unicode codepoints.
   *   The files must use UTF-8 encoding.
   * @param {google.cloud.translation.v3beta1.OutputConfig} request.outputConfig
   *   Required. Output configuration.
   *   If 2 input configs match to the same file (that is, same input path),
   *   we don't generate output for duplicate inputs.
   * @param {number[]} [request.glossaries]
   *   Optional. Glossaries to be applied for translation.
   *   It's keyed by target language code.
   * @param {number[]} [request.labels]
   *   Optional. The labels with user-defined metadata for the request.
   *
   *   Label keys and values can be no longer than 63 characters
   *   (Unicode codepoints), can only contain lowercase letters, numeric
   *   characters, underscores and dashes. International characters are allowed.
   *   Label values are optional. Label keys must start with a letter.
   *
   *   See https://cloud.google.com/translate/docs/labels for more information.
   * @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
   *   a long running operation. Its `promise()` method returns a promise
   *   you can `await` for.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations)
   *   for more details and examples.
   * @example
   * const [operation] = await client.batchTranslateText(request);
   * const [response] = await operation.promise();
   */
  batchTranslateText(
    request?: protos.google.cloud.translation.v3beta1.IBatchTranslateTextRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          LROperation<
            protos.google.cloud.translation.v3beta1.IBatchTranslateResponse,
            protos.google.cloud.translation.v3beta1.IBatchTranslateMetadata
          >,
          protos.google.longrunning.IOperation | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateMetadata
      >,
      protos.google.longrunning.IOperation | 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({
        parent: request.parent || '',
      });
    this.initialize();
    return this.innerApiCalls.batchTranslateText(request, options, callback);
  }
  /**
   * Check the status of the long running operation returned by `batchTranslateText()`.
   * @param {String} name
   *   The operation name that will be passed.
   * @returns {Promise} - The promise which resolves to an object.
   *   The decoded operation object has result and metadata field to get information from.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations)
   *   for more details and examples.
   * @example
   * const decodedOperation = await checkBatchTranslateTextProgress(name);
   * console.log(decodedOperation.result);
   * console.log(decodedOperation.done);
   * console.log(decodedOperation.metadata);
   */
  async checkBatchTranslateTextProgress(
    name: string
  ): Promise<
    LROperation<
      protos.google.cloud.translation.v3beta1.BatchTranslateResponse,
      protos.google.cloud.translation.v3beta1.BatchTranslateMetadata
    >
  > {
    const request = new operationsProtos.google.longrunning.GetOperationRequest(
      {name}
    );
    const [operation] = await this.operationsClient.getOperation(request);
    const decodeOperation = new gax.Operation(
      operation,
      this.descriptors.longrunning.batchTranslateText,
      gax.createDefaultBackoffSettings()
    );
    return decodeOperation as LROperation<
      protos.google.cloud.translation.v3beta1.BatchTranslateResponse,
      protos.google.cloud.translation.v3beta1.BatchTranslateMetadata
    >;
  }
  batchTranslateDocument(
    request?: protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentRequest,
    options?: CallOptions
  ): Promise<
    [
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentMetadata
      >,
      protos.google.longrunning.IOperation | undefined,
      {} | undefined
    ]
  >;
  batchTranslateDocument(
    request: protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentRequest,
    options: CallOptions,
    callback: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): void;
  batchTranslateDocument(
    request: protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentRequest,
    callback: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Translates a large volume of documents in asynchronous batch mode.
   * This function provides real-time output as the inputs are being processed.
   * If caller cancels a request, the partial results (for an input file, it's
   * all or nothing) may still be available on the specified output location.
   *
   * This call returns immediately and you can use
   * google.longrunning.Operation.name to poll the status of the call.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.parent
   *   Required. Location to make a regional call.
   *
   *   Format: `projects/{project-number-or-id}/locations/{location-id}`.
   *
   *   The `global` location is not supported for batch translation.
   *
   *   Only AutoML Translation models or glossaries within the same region (have
   *   the same location-id) can be used, otherwise an INVALID_ARGUMENT (400)
   *   error is returned.
   * @param {string} request.sourceLanguageCode
   *   Required. The BCP-47 language code of the input document if known, for
   *   example, "en-US" or "sr-Latn". Supported language codes are listed in
   *   Language Support (https://cloud.google.com/translate/docs/languages).
   * @param {string[]} request.targetLanguageCodes
   *   Required. The BCP-47 language code to use for translation of the input
   *   document. Specify up to 10 language codes here.
   * @param {number[]} request.inputConfigs
   *   Required. Input configurations.
   *   The total number of files matched should be <= 100.
   *   The total content size to translate should be <= 100M Unicode codepoints.
   *   The files must use UTF-8 encoding.
   * @param {google.cloud.translation.v3beta1.BatchDocumentOutputConfig} request.outputConfig
   *   Required. Output configuration.
   *   If 2 input configs match to the same file (that is, same input path),
   *   we don't generate output for duplicate inputs.
   * @param {number[]} [request.models]
   *   Optional. The models to use for translation. Map's key is target language
   *   code. Map's value is the model name. Value can be a built-in general model,
   *   or an AutoML Translation model.
   *
   *   The value format depends on model type:
   *
   *   - AutoML Translation models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}`
   *
   *   - General (built-in) models:
   *     `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,
   *
   *
   *   If the map is empty or a specific model is not requested for a language
   *   pair, then default google model (nmt) is used.
   * @param {number[]} [request.glossaries]
   *   Optional. Glossaries to be applied. It's keyed by target language code.
   * @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
   *   a long running operation. Its `promise()` method returns a promise
   *   you can `await` for.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations)
   *   for more details and examples.
   * @example
   * const [operation] = await client.batchTranslateDocument(request);
   * const [response] = await operation.promise();
   */
  batchTranslateDocument(
    request?: protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          LROperation<
            protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentResponse,
            protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentMetadata
          >,
          protos.google.longrunning.IOperation | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      LROperation<
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentResponse,
        protos.google.cloud.translation.v3beta1.IBatchTranslateDocumentMetadata
      >,
      protos.google.longrunning.IOperation | 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({
        parent: request.parent || '',
      });
    this.initialize();
    return this.innerApiCalls.batchTranslateDocument(
      request,
      options,
      callback
    );
  }
  /**
   * Check the status of the long running operation returned by `batchTranslateDocument()`.
   * @param {String} name
   *   The operation name that will be passed.
   * @returns {Promise} - The promise which resolves to an object.
   *   The decoded operation object has result and metadata field to get information from.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations)
   *   for more details and examples.
   * @example
   * const decodedOperation = await checkBatchTranslateDocumentProgress(name);
   * console.log(decodedOperation.result);
   * console.log(decodedOperation.done);
   * console.log(decodedOperation.metadata);
   */
  async checkBatchTranslateDocumentProgress(
    name: string
  ): Promise<
    LROperation<
      protos.google.cloud.translation.v3beta1.BatchTranslateDocumentResponse,
      protos.google.cloud.translation.v3beta1.BatchTranslateDocumentMetadata
    >
  > {
    const request = new operationsProtos.google.longrunning.GetOperationRequest(
      {name}
    );
    const [operation] = await this.operationsClient.getOperation(request);
    const decodeOperation = new gax.Operation(
      operation,
      this.descriptors.longrunning.batchTranslateDocument,
      gax.createDefaultBackoffSettings()
    );
    return decodeOperation as LROperation<
      protos.google.cloud.translation.v3beta1.BatchTranslateDocumentResponse,
      protos.google.cloud.translation.v3beta1.BatchTranslateDocumentMetadata
    >;
  }
  createGlossary(
    request?: protos.google.cloud.translation.v3beta1.ICreateGlossaryRequest,
    options?: CallOptions
  ): Promise<
    [
      LROperation<
        protos.google.cloud.translation.v3beta1.IGlossary,
        protos.google.cloud.translation.v3beta1.ICreateGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | undefined,
      {} | undefined
    ]
  >;
  createGlossary(
    request: protos.google.cloud.translation.v3beta1.ICreateGlossaryRequest,
    options: CallOptions,
    callback: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IGlossary,
        protos.google.cloud.translation.v3beta1.ICreateGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): void;
  createGlossary(
    request: protos.google.cloud.translation.v3beta1.ICreateGlossaryRequest,
    callback: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IGlossary,
        protos.google.cloud.translation.v3beta1.ICreateGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Creates a glossary and returns the long-running operation. Returns
   * NOT_FOUND, if the project doesn't exist.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.parent
   *   Required. The project name.
   * @param {google.cloud.translation.v3beta1.Glossary} request.glossary
   *   Required. The glossary 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
   *   a long running operation. Its `promise()` method returns a promise
   *   you can `await` for.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations)
   *   for more details and examples.
   * @example
   * const [operation] = await client.createGlossary(request);
   * const [response] = await operation.promise();
   */
  createGlossary(
    request?: protos.google.cloud.translation.v3beta1.ICreateGlossaryRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          LROperation<
            protos.google.cloud.translation.v3beta1.IGlossary,
            protos.google.cloud.translation.v3beta1.ICreateGlossaryMetadata
          >,
          protos.google.longrunning.IOperation | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IGlossary,
        protos.google.cloud.translation.v3beta1.ICreateGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      LROperation<
        protos.google.cloud.translation.v3beta1.IGlossary,
        protos.google.cloud.translation.v3beta1.ICreateGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | 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({
        parent: request.parent || '',
      });
    this.initialize();
    return this.innerApiCalls.createGlossary(request, options, callback);
  }
  /**
   * Check the status of the long running operation returned by `createGlossary()`.
   * @param {String} name
   *   The operation name that will be passed.
   * @returns {Promise} - The promise which resolves to an object.
   *   The decoded operation object has result and metadata field to get information from.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations)
   *   for more details and examples.
   * @example
   * const decodedOperation = await checkCreateGlossaryProgress(name);
   * console.log(decodedOperation.result);
   * console.log(decodedOperation.done);
   * console.log(decodedOperation.metadata);
   */
  async checkCreateGlossaryProgress(
    name: string
  ): Promise<
    LROperation<
      protos.google.cloud.translation.v3beta1.Glossary,
      protos.google.cloud.translation.v3beta1.CreateGlossaryMetadata
    >
  > {
    const request = new operationsProtos.google.longrunning.GetOperationRequest(
      {name}
    );
    const [operation] = await this.operationsClient.getOperation(request);
    const decodeOperation = new gax.Operation(
      operation,
      this.descriptors.longrunning.createGlossary,
      gax.createDefaultBackoffSettings()
    );
    return decodeOperation as LROperation<
      protos.google.cloud.translation.v3beta1.Glossary,
      protos.google.cloud.translation.v3beta1.CreateGlossaryMetadata
    >;
  }
  deleteGlossary(
    request?: protos.google.cloud.translation.v3beta1.IDeleteGlossaryRequest,
    options?: CallOptions
  ): Promise<
    [
      LROperation<
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryResponse,
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | undefined,
      {} | undefined
    ]
  >;
  deleteGlossary(
    request: protos.google.cloud.translation.v3beta1.IDeleteGlossaryRequest,
    options: CallOptions,
    callback: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryResponse,
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): void;
  deleteGlossary(
    request: protos.google.cloud.translation.v3beta1.IDeleteGlossaryRequest,
    callback: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryResponse,
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): void;
  /**
   * Deletes a glossary, or cancels glossary construction
   * if the glossary isn't created yet.
   * Returns NOT_FOUND, if the glossary doesn't exist.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.name
   *   Required. The name of the glossary 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
   *   a long running operation. Its `promise()` method returns a promise
   *   you can `await` for.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations)
   *   for more details and examples.
   * @example
   * const [operation] = await client.deleteGlossary(request);
   * const [response] = await operation.promise();
   */
  deleteGlossary(
    request?: protos.google.cloud.translation.v3beta1.IDeleteGlossaryRequest,
    optionsOrCallback?:
      | CallOptions
      | Callback<
          LROperation<
            protos.google.cloud.translation.v3beta1.IDeleteGlossaryResponse,
            protos.google.cloud.translation.v3beta1.IDeleteGlossaryMetadata
          >,
          protos.google.longrunning.IOperation | null | undefined,
          {} | null | undefined
        >,
    callback?: Callback<
      LROperation<
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryResponse,
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | null | undefined,
      {} | null | undefined
    >
  ): Promise<
    [
      LROperation<
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryResponse,
        protos.google.cloud.translation.v3beta1.IDeleteGlossaryMetadata
      >,
      protos.google.longrunning.IOperation | 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.deleteGlossary(request, options, callback);
  }
  /**
   * Check the status of the long running operation returned by `deleteGlossary()`.
   * @param {String} name
   *   The operation name that will be passed.
   * @returns {Promise} - The promise which resolves to an object.
   *   The decoded operation object has result and metadata field to get information from.
   *   Please see the
   *   [documentation](https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations)
   *   for more details and examples.
   * @example
   * const decodedOperation = await checkDeleteGlossaryProgress(name);
   * console.log(decodedOperation.result);
   * console.log(decodedOperation.done);
   * console.log(decodedOperation.metadata);
   */
  async checkDeleteGlossaryProgress(
    name: string
  ): Promise<
    LROperation<
      protos.google.cloud.translation.v3beta1.DeleteGlossaryResponse,
      protos.google.cloud.translation.v3beta1.DeleteGlossaryMetadata
    >
  > {
    const request = new operationsProtos.google.longrunning.GetOperationRequest(
      {name}
    );
    const [operation] = await this.operationsClient.getOperation(request);
    const decodeOperation = new gax.Operation(
      operation,
      this.descriptors.longrunning.deleteGlossary,
      gax.createDefaultBackoffSettings()
    );
    return decodeOperation as LROperation<
      protos.google.cloud.translation.v3beta1.DeleteGlossaryResponse,
      protos.google.cloud.translation.v3beta1.DeleteGlossaryMetadata
    >;
  }
  listGlossaries(
    request?: protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
    options?: CallOptions
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.IGlossary[],
      protos.google.cloud.translation.v3beta1.IListGlossariesRequest | null,
      protos.google.cloud.translation.v3beta1.IListGlossariesResponse
    ]
  >;
  listGlossaries(
    request: protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
    options: CallOptions,
    callback: PaginationCallback<
      protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
      | protos.google.cloud.translation.v3beta1.IListGlossariesResponse
      | null
      | undefined,
      protos.google.cloud.translation.v3beta1.IGlossary
    >
  ): void;
  listGlossaries(
    request: protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
    callback: PaginationCallback<
      protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
      | protos.google.cloud.translation.v3beta1.IListGlossariesResponse
      | null
      | undefined,
      protos.google.cloud.translation.v3beta1.IGlossary
    >
  ): void;
  /**
   * Lists glossaries in a project. Returns NOT_FOUND, if the project doesn't
   * exist.
   *
   * @param {Object} request
   *   The request object that will be sent.
   * @param {string} request.parent
   *   Required. The name of the project from which to list all of the glossaries.
   * @param {number} [request.pageSize]
   *   Optional. Requested page size. The server may return fewer glossaries than
   *   requested. If unspecified, the server picks an appropriate default.
   * @param {string} [request.pageToken]
   *   Optional. A token identifying a page of results the server should return.
   *   Typically, this is the value of [ListGlossariesResponse.next_page_token]
   *   returned from the previous call to `ListGlossaries` method.
   *   The first page is returned if `page_token`is empty or missing.
   * @param {string} [request.filter]
   *   Optional. Filter specifying constraints of a list operation.
   *   Specify the constraint by the format of "key=value", where key must be
   *   "src" or "tgt", and the value must be a valid language code.
   *   For multiple restrictions, concatenate them by "AND" (uppercase only),
   *   such as: "src=en-US AND tgt=zh-CN". Notice that the exact match is used
   *   here, which means using 'en-US' and 'en' can lead to different results,
   *   which depends on the language code you used when you create the glossary.
   *   For the unidirectional glossaries, the "src" and "tgt" add restrictions
   *   on the source and target language code separately.
   *   For the equivalent term set glossaries, the "src" and/or "tgt" add
   *   restrictions on the term set.
   *   For example: "src=en-US AND tgt=zh-CN" will only pick the unidirectional
   *   glossaries which exactly match the source language code as "en-US" and the
   *   target language code "zh-CN", but all equivalent term set glossaries which
   *   contain "en-US" and "zh-CN" in their language set will be picked.
   *   If missing, no filtering is performed.
   * @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 [Glossary]{@link google.cloud.translation.v3beta1.Glossary}.
   *   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 `listGlossariesAsync()`
   *   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.
   */
  listGlossaries(
    request?: protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
    optionsOrCallback?:
      | CallOptions
      | PaginationCallback<
          protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
          | protos.google.cloud.translation.v3beta1.IListGlossariesResponse
          | null
          | undefined,
          protos.google.cloud.translation.v3beta1.IGlossary
        >,
    callback?: PaginationCallback<
      protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
      | protos.google.cloud.translation.v3beta1.IListGlossariesResponse
      | null
      | undefined,
      protos.google.cloud.translation.v3beta1.IGlossary
    >
  ): Promise<
    [
      protos.google.cloud.translation.v3beta1.IGlossary[],
      protos.google.cloud.translation.v3beta1.IListGlossariesRequest | null,
      protos.google.cloud.translation.v3beta1.IListGlossariesResponse
    ]
  > | 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({
        parent: request.parent || '',
      });
    this.initialize();
    return this.innerApiCalls.listGlossaries(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.parent
   *   Required. The name of the project from which to list all of the glossaries.
   * @param {number} [request.pageSize]
   *   Optional. Requested page size. The server may return fewer glossaries than
   *   requested. If unspecified, the server picks an appropriate default.
   * @param {string} [request.pageToken]
   *   Optional. A token identifying a page of results the server should return.
   *   Typically, this is the value of [ListGlossariesResponse.next_page_token]
   *   returned from the previous call to `ListGlossaries` method.
   *   The first page is returned if `page_token`is empty or missing.
   * @param {string} [request.filter]
   *   Optional. Filter specifying constraints of a list operation.
   *   Specify the constraint by the format of "key=value", where key must be
   *   "src" or "tgt", and the value must be a valid language code.
   *   For multiple restrictions, concatenate them by "AND" (uppercase only),
   *   such as: "src=en-US AND tgt=zh-CN". Notice that the exact match is used
   *   here, which means using 'en-US' and 'en' can lead to different results,
   *   which depends on the language code you used when you create the glossary.
   *   For the unidirectional glossaries, the "src" and "tgt" add restrictions
   *   on the source and target language code separately.
   *   For the equivalent term set glossaries, the "src" and/or "tgt" add
   *   restrictions on the term set.
   *   For example: "src=en-US AND tgt=zh-CN" will only pick the unidirectional
   *   glossaries which exactly match the source language code as "en-US" and the
   *   target language code "zh-CN", but all equivalent term set glossaries which
   *   contain "en-US" and "zh-CN" in their language set will be picked.
   *   If missing, no filtering is performed.
   * @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 [Glossary]{@link google.cloud.translation.v3beta1.Glossary} 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 `listGlossariesAsync()`
   *   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.
   */
  listGlossariesStream(
    request?: protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
    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({
        parent: request.parent || '',
      });
    const callSettings = new gax.CallSettings(options);
    this.initialize();
    return this.descriptors.page.listGlossaries.createStream(
      this.innerApiCalls.listGlossaries as gax.GaxCall,
      request,
      callSettings
    );
  }

  /**
   * Equivalent to `listGlossaries`, 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.parent
   *   Required. The name of the project from which to list all of the glossaries.
   * @param {number} [request.pageSize]
   *   Optional. Requested page size. The server may return fewer glossaries than
   *   requested. If unspecified, the server picks an appropriate default.
   * @param {string} [request.pageToken]
   *   Optional. A token identifying a page of results the server should return.
   *   Typically, this is the value of [ListGlossariesResponse.next_page_token]
   *   returned from the previous call to `ListGlossaries` method.
   *   The first page is returned if `page_token`is empty or missing.
   * @param {string} [request.filter]
   *   Optional. Filter specifying constraints of a list operation.
   *   Specify the constraint by the format of "key=value", where key must be
   *   "src" or "tgt", and the value must be a valid language code.
   *   For multiple restrictions, concatenate them by "AND" (uppercase only),
   *   such as: "src=en-US AND tgt=zh-CN". Notice that the exact match is used
   *   here, which means using 'en-US' and 'en' can lead to different results,
   *   which depends on the language code you used when you create the glossary.
   *   For the unidirectional glossaries, the "src" and "tgt" add restrictions
   *   on the source and target language code separately.
   *   For the equivalent term set glossaries, the "src" and/or "tgt" add
   *   restrictions on the term set.
   *   For example: "src=en-US AND tgt=zh-CN" will only pick the unidirectional
   *   glossaries which exactly match the source language code as "en-US" and the
   *   target language code "zh-CN", but all equivalent term set glossaries which
   *   contain "en-US" and "zh-CN" in their language set will be picked.
   *   If missing, no filtering is performed.
   * @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
   *   [Glossary]{@link google.cloud.translation.v3beta1.Glossary}. 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.listGlossariesAsync(request);
   * for await (const response of iterable) {
   *   // process response
   * }
   */
  listGlossariesAsync(
    request?: protos.google.cloud.translation.v3beta1.IListGlossariesRequest,
    options?: CallOptions
  ): AsyncIterable<protos.google.cloud.translation.v3beta1.IGlossary> {
    request = request || {};
    options = options || {};
    options.otherArgs = options.otherArgs || {};
    options.otherArgs.headers = options.otherArgs.headers || {};
    options.otherArgs.headers['x-goog-request-params'] =
      gax.routingHeader.fromParams({
        parent: request.parent || '',
      });
    options = options || {};
    const callSettings = new gax.CallSettings(options);
    this.initialize();
    return this.descriptors.page.listGlossaries.asyncIterate(
      this.innerApiCalls['listGlossaries'] as GaxCall,
      request as unknown as RequestType,
      callSettings
    ) as AsyncIterable<protos.google.cloud.translation.v3beta1.IGlossary>;
  }
  // --------------------
  // -- Path templates --
  // --------------------

  /**
   * Return a fully-qualified glossary resource name string.
   *
   * @param {string} project
   * @param {string} location
   * @param {string} glossary
   * @returns {string} Resource name string.
   */
  glossaryPath(project: string, location: string, glossary: string) {
    return this.pathTemplates.glossaryPathTemplate.render({
      project: project,
      location: location,
      glossary: glossary,
    });
  }

  /**
   * Parse the project from Glossary resource.
   *
   * @param {string} glossaryName
   *   A fully-qualified path representing Glossary resource.
   * @returns {string} A string representing the project.
   */
  matchProjectFromGlossaryName(glossaryName: string) {
    return this.pathTemplates.glossaryPathTemplate.match(glossaryName).project;
  }

  /**
   * Parse the location from Glossary resource.
   *
   * @param {string} glossaryName
   *   A fully-qualified path representing Glossary resource.
   * @returns {string} A string representing the location.
   */
  matchLocationFromGlossaryName(glossaryName: string) {
    return this.pathTemplates.glossaryPathTemplate.match(glossaryName).location;
  }

  /**
   * Parse the glossary from Glossary resource.
   *
   * @param {string} glossaryName
   *   A fully-qualified path representing Glossary resource.
   * @returns {string} A string representing the glossary.
   */
  matchGlossaryFromGlossaryName(glossaryName: string) {
    return this.pathTemplates.glossaryPathTemplate.match(glossaryName).glossary;
  }

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

  /**
   * Parse the project from Location resource.
   *
   * @param {string} locationName
   *   A fully-qualified path representing Location resource.
   * @returns {string} A string representing the project.
   */
  matchProjectFromLocationName(locationName: string) {
    return this.pathTemplates.locationPathTemplate.match(locationName).project;
  }

  /**
   * Parse the location from Location resource.
   *
   * @param {string} locationName
   *   A fully-qualified path representing Location resource.
   * @returns {string} A string representing the location.
   */
  matchLocationFromLocationName(locationName: string) {
    return this.pathTemplates.locationPathTemplate.match(locationName).location;
  }

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