text: "use strict";
  // Copyright 2019 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. **
  Object.defineProperty(exports, "__esModule", { value: true });
  const gax = require("google-gax");
  const path = require("path");
  const gapicConfig = require("./speech_client_config.json");
  const version = require('../../../package.json').version;
  /**
   *  Service that implements Google Cloud Speech API.
   * @class
   * @memberof v1p1beta1
   */
  class SpeechClient {
      /**
       * Construct an instance of SpeechClient.
       *
       * @param {object} [options] - The configuration object. See the subsequent
       *   parameters for more details.
       * @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 {function} [options.promise] - Custom promise module to use instead
       *     of native Promises.
       * @param {string} [options.apiEndpoint] - The domain name of the
       *     API remote host.
       */
      constructor(opts) {
          this._descriptors = { page: {}, stream: {}, longrunning: {} };
          this._terminated = false;
          // Ensure that options include the service address and port.
          const staticMembers = this.constructor;
          const servicePath = opts && opts.servicePath
              ? opts.servicePath
              : opts && opts.apiEndpoint
                  ? opts.apiEndpoint
                  : staticMembers.servicePath;
          const port = opts && opts.port ? opts.port : staticMembers.port;
          if (!opts) {
              opts = { servicePath, port };
          }
          opts.servicePath = opts.servicePath || servicePath;
          opts.port = opts.port || port;
          opts.clientConfig = opts.clientConfig || {};
          const isBrowser = typeof window !== 'undefined';
          if (isBrowser) {
              opts.fallback = true;
          }
          // If we are in browser, we are already using fallback because of the
          // "browser" field in package.json.
          // But if we were explicitly requested to use fallback, let's do it now.
          const gaxModule = !isBrowser && opts.fallback ? gax.fallback : gax;
          // Create a `gaxGrpc` object, with any grpc-specific options
          // sent to the client.
          opts.scopes = this.constructor.scopes;
          const gaxGrpc = new gaxModule.GrpcClient(opts);
          // Save the auth object to the client, for use by other methods.
          this.auth = gaxGrpc.auth;
          // Determine the client header string.
          const clientHeader = [`gax/${gaxModule.version}`, `gapic/${version}`];
          if (typeof process !== 'undefined' && 'versions' in process) {
              clientHeader.push(`gl-node/${process.versions.node}`);
          }
          else {
              clientHeader.push(`gl-web/${gaxModule.version}`);
          }
          if (!opts.fallback) {
              clientHeader.push(`grpc/${gaxGrpc.grpcVersion}`);
          }
          if (opts.libName && opts.libVersion) {
              clientHeader.push(`${opts.libName}/${opts.libVersion}`);
          }
          // Load the applicable protos.
          // For Node.js, pass the path to JSON proto file.
          // For browsers, pass the JSON content.
          const nodejsProtoPath = path.join(__dirname, '..', '..', 'protos', 'protos.json');
          const protos = gaxGrpc.loadProto(opts.fallback ? require('../../protos/protos.json') : nodejsProtoPath);
          // Some of the methods on this service provide streaming responses.
          // Provide descriptors for these.
          this._descriptors.stream = {
              streamingRecognize: new gaxModule.StreamDescriptor(gax.StreamType.BIDI_STREAMING),
          };
          // 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.
          const protoFilesRoot = opts.fallback
              ? gaxModule.protobuf.Root.fromJSON(require('../../protos/protos.json'))
              : gaxModule.protobuf.loadSync(nodejsProtoPath);
          this.operationsClient = gaxModule
              .lro({
              auth: this.auth,
              grpc: 'grpc' in gaxGrpc ? gaxGrpc.grpc : undefined,
          })
              .operationsClient(opts);
          const longRunningRecognizeResponse = protoFilesRoot.lookup('.google.cloud.speech.v1p1beta1.LongRunningRecognizeResponse');
          const longRunningRecognizeMetadata = protoFilesRoot.lookup('.google.cloud.speech.v1p1beta1.LongRunningRecognizeMetadata');
          this._descriptors.longrunning = {
              longRunningRecognize: new gaxModule.LongrunningDescriptor(this.operationsClient, longRunningRecognizeResponse.decode.bind(longRunningRecognizeResponse), longRunningRecognizeMetadata.decode.bind(longRunningRecognizeMetadata)),
          };
          // Put together the default options sent with requests.
          const defaults = gaxGrpc.constructSettings('google.cloud.speech.v1p1beta1.Speech', gapicConfig, 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 = {};
          // Put together the "service stub" for
          // google.cloud.speech.v1p1beta1.Speech.
          this.speechStub = gaxGrpc.createStub(opts.fallback
              ? protos.lookupService('google.cloud.speech.v1p1beta1.Speech')
              : // tslint:disable-next-line no-any
                  protos.google.cloud.speech.v1p1beta1.Speech, opts);
          // Iterate over each of the methods that the service provides
          // and create an API call method for each.
          const speechStubMethods = [
              'recognize',
              'longRunningRecognize',
              'streamingRecognize',
          ];
          for (const methodName of speechStubMethods) {
              const innerCallPromise = this.speechStub.then(stub => (...args) => {
                  if (this._terminated) {
                      return Promise.reject('The client has already been closed.');
                  }
                  return stub[methodName].apply(stub, args);
              }, (err) => () => {
                  throw err;
              });
              const apiCall = gaxModule.createApiCall(innerCallPromise, defaults[methodName], this._descriptors.page[methodName] ||
                  this._descriptors.stream[methodName] ||
                  this._descriptors.longrunning[methodName]);
              this._innerApiCalls[methodName] = (argument, callOptions, callback) => {
                  return apiCall(argument, callOptions, callback);
              };
          }
      }
      /**
       * The DNS address for this API service.
       */
      static get servicePath() {
          return 'speech.googleapis.com';
      }
      /**
       * The DNS address for this API service - same as servicePath(),
       * exists for compatibility reasons.
       */
      static get apiEndpoint() {
          return 'speech.googleapis.com';
      }
      /**
       * The port for this API service.
       */
      static get port() {
          return 443;
      }
      /**
       * The scopes needed to make gRPC calls for every method defined
       * in this service.
       */
      static get scopes() {
          return ['https://www.googleapis.com/auth/cloud-platform'];
      }
      /**
       * Return the project ID used by this class.
       * @param {function(Error, string)} callback - the callback to
       *   be called with the current project Id.
       */
      getProjectId(callback) {
          if (callback) {
              this.auth.getProjectId(callback);
              return;
          }
          return this.auth.getProjectId();
      }
      /**
       * Performs synchronous speech recognition: receive results after all audio
       * has been sent and processed.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {google.cloud.speech.v1p1beta1.RecognitionConfig} request.config
       *   Required. Provides information to the recognizer that specifies how to
       *   process the request.
       * @param {google.cloud.speech.v1p1beta1.RecognitionAudio} request.audio
       *   Required. The audio data to be recognized.
       * @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 [RecognizeResponse]{@link google.cloud.speech.v1p1beta1.RecognizeResponse}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      recognize(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          return this._innerApiCalls.recognize(request, options, callback);
      }
      /**
       * Performs bidirectional streaming speech recognition: receive results while
       * sending audio. This method is only available via the gRPC API (not REST).
       *
       * @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 is both readable and writable. It accepts objects
       *   representing [StreamingRecognizeRequest]{@link google.cloud.speech.v1p1beta1.StreamingRecognizeRequest} for write() method, and
       *   will emit objects representing [StreamingRecognizeResponse]{@link google.cloud.speech.v1p1beta1.StreamingRecognizeResponse} on 'data' event asynchronously.
       */
      _streamingRecognize(options) {
          options = options || {};
          return this._innerApiCalls.streamingRecognize(options);
      }
      /**
       * Performs asynchronous speech recognition: receive results via the
       * google.longrunning.Operations interface. Returns either an
       * `Operation.error` or an `Operation.response` which contains
       * a `LongRunningRecognizeResponse` message.
       * For more information on asynchronous speech recognition, see the
       * [how-to](https://cloud.google.com/speech-to-text/docs/async-recognize).
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {google.cloud.speech.v1p1beta1.RecognitionConfig} request.config
       *   Required. Provides information to the recognizer that specifies how to
       *   process the request.
       * @param {google.cloud.speech.v1p1beta1.RecognitionAudio} request.audio
       *   Required. The audio data to be recognized.
       * @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 [Operation]{@link google.longrunning.Operation}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      longRunningRecognize(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          return this._innerApiCalls.longRunningRecognize(request, options, callback);
      }
      /**
       * Terminate the GRPC channel and close the client.
       *
       * The client will no longer be usable and all future behavior is undefined.
       */
      close() {
          if (!this._terminated) {
              return this.speechStub.then(stub => {
                  this._terminated = true;
                  stub.close();
              });
          }
          return Promise.resolve();
      }
  }
  exports.SpeechClient = SpeechClient;
  //# sourceMappingURL=speech_client.js.map