text: "use strict";
  // Copyright 2020 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 google_gax_1 = require("google-gax");
  const path = require("path");
  const gapicConfig = require("./subscriber_client_config.json");
  const version = require('../../../package.json').version;
  /**
   *  The service that an application uses to manipulate subscriptions and to
   *  consume messages from a subscription via the `Pull` method or by
   *  establishing a bi-directional stream using the `StreamingPull` method.
   * @class
   * @memberof v1
   */
  class SubscriberClient {
      /**
       * Construct an instance of SubscriberClient.
       *
       * @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 {string} [options.apiEndpoint] - The domain name of the
       *     API remote host.
       */
      constructor(opts) {
          this._terminated = false;
          this.descriptors = {
              page: {},
              stream: {},
              longrunning: {},
              batching: {},
          };
          // 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;
          // users can override the config from client side, like retry codes name.
          // The detailed structure of the clientConfig can be found here: https://github.com/googleapis/gax-nodejs/blob/master/src/gax.ts#L546
          // The way to override client config for Showcase API:
          //
          // const customConfig = {"interfaces": {"google.showcase.v1beta1.Echo": {"methods": {"Echo": {"retry_codes_name": "idempotent", "retry_params_name": "default"}}}}}
          // const showcaseClient = new showcaseClient({ projectId, customConfig });
          opts.clientConfig = opts.clientConfig || {};
          // If we're running in browser, it's OK to omit `fallback` since
          // google-gax has `browser` field in its `package.json`.
          // For Electron (which does not respect `browser` field),
          // pass `{fallback: true}` to the SubscriberClient constructor.
          this._gaxModule = opts.fallback ? gax.fallback : gax;
          // Create a `gaxGrpc` object, with any grpc-specific options
          // sent to the client.
          opts.scopes = this.constructor.scopes;
          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;
          this.iamClient = new google_gax_1.IamClient(this._gaxGrpc, opts);
          // 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}`);
          }
          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');
          this._protos = this._gaxGrpc.loadProto(opts.fallback
              ? // eslint-disable-next-line @typescript-eslint/no-var-requires
                  require('../../protos/protos.json')
              : nodejsProtoPath);
          // This API contains "path templates"; forward-slash-separated
          // identifiers to uniquely identify resources within the API.
          // Create useful helper objects for these.
          this.pathTemplates = {
              projectPathTemplate: new this._gaxModule.PathTemplate('projects/{project}'),
              projectTopicPathTemplate: new this._gaxModule.PathTemplate('projects/{project}/topics/{topic}'),
              snapshotPathTemplate: new this._gaxModule.PathTemplate('projects/{project}/snapshots/{snapshot}'),
              subscriptionPathTemplate: new this._gaxModule.PathTemplate('projects/{project}/subscriptions/{subscription}'),
          };
          // 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 = {
              listSubscriptions: new this._gaxModule.PageDescriptor('pageToken', 'nextPageToken', 'subscriptions'),
              listSnapshots: new this._gaxModule.PageDescriptor('pageToken', 'nextPageToken', 'snapshots'),
          };
          // Some of the methods on this service provide streaming responses.
          // Provide descriptors for these.
          this.descriptors.stream = {
              streamingPull: new this._gaxModule.StreamDescriptor(gax.StreamType.BIDI_STREAMING),
          };
          // Put together the default options sent with requests.
          this._defaults = this._gaxGrpc.constructSettings('google.pubsub.v1.Subscriber', 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 = {};
      }
      /**
       * 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.subscriberStub) {
              return this.subscriberStub;
          }
          // Put together the "service stub" for
          // google.pubsub.v1.Subscriber.
          this.subscriberStub = this._gaxGrpc.createStub(this._opts.fallback
              ? this._protos.lookupService('google.pubsub.v1.Subscriber')
              : // eslint-disable-next-line @typescript-eslint/no-explicit-any
                  this._protos.google.pubsub.v1.Subscriber, this._opts);
          // Iterate over each of the methods that the service provides
          // and create an API call method for each.
          const subscriberStubMethods = [
              'createSubscription',
              'getSubscription',
              'updateSubscription',
              'listSubscriptions',
              'deleteSubscription',
              'modifyAckDeadline',
              'acknowledge',
              'pull',
              'streamingPull',
              'modifyPushConfig',
              'getSnapshot',
              'listSnapshots',
              'createSnapshot',
              'updateSnapshot',
              'deleteSnapshot',
              'seek',
          ];
          for (const methodName of subscriberStubMethods) {
              const callPromise = this.subscriberStub.then(stub => (...args) => {
                  if (this._terminated) {
                      return Promise.reject('The client has already been closed.');
                  }
                  const func = stub[methodName];
                  return func.apply(stub, args);
              }, (err) => () => {
                  throw err;
              });
              const apiCall = this._gaxModule.createApiCall(callPromise, this._defaults[methodName], this.descriptors.page[methodName] ||
                  this.descriptors.stream[methodName] ||
                  this.descriptors.longrunning[methodName]);
              this.innerApiCalls[methodName] = apiCall;
          }
          return this.subscriberStub;
      }
      /**
       * The DNS address for this API service.
       */
      static get servicePath() {
          return 'pubsub.googleapis.com';
      }
      /**
       * The DNS address for this API service - same as servicePath(),
       * exists for compatibility reasons.
       */
      static get apiEndpoint() {
          return 'pubsub.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',
              'https://www.googleapis.com/auth/pubsub',
          ];
      }
      /**
       * 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();
      }
      /**
       * Creates a subscription to a given topic. See the
       * <a href="https://cloud.google.com/pubsub/docs/admin#resource_names">
       * resource name rules</a>.
       * If the subscription already exists, returns `ALREADY_EXISTS`.
       * If the corresponding topic doesn't exist, returns `NOT_FOUND`.
       *
       * If the name is not provided in the request, the server will assign a random
       * name for this subscription on the same project as the topic, conforming
       * to the
       * [resource name
       * format](https://cloud.google.com/pubsub/docs/admin#resource_names). The
       * generated name is populated in the returned Subscription object. Note that
       * for REST API requests, you must specify a name in the request.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.name
       *   Required. The name of the subscription. It must have the format
       *   `"projects/{project}/subscriptions/{subscription}"`. `{subscription}` must
       *   start with a letter, and contain only letters (`[A-Za-z]`), numbers
       *   (`[0-9]`), dashes (`-`), underscores (`_`), periods (`.`), tildes (`~`),
       *   plus (`+`) or percent signs (`%`). It must be between 3 and 255 characters
       *   in length, and it must not start with `"goog"`.
       * @param {string} request.topic
       *   Required. The name of the topic from which this subscription is receiving
       *   messages. Format is `projects/{project}/topics/{topic}`. The value of this
       *   field will be `_deleted-topic_` if the topic has been deleted.
       * @param {google.pubsub.v1.PushConfig} request.pushConfig
       *   If push delivery is used with this subscription, this field is
       *   used to configure it. An empty `pushConfig` signifies that the subscriber
       *   will pull and ack messages using API methods.
       * @param {number} request.ackDeadlineSeconds
       *   The approximate amount of time (on a best-effort basis) Pub/Sub waits for
       *   the subscriber to acknowledge receipt before resending the message. In the
       *   interval after the message is delivered and before it is acknowledged, it
       *   is considered to be <i>outstanding</i>. During that time period, the
       *   message will not be redelivered (on a best-effort basis).
       *
       *   For pull subscriptions, this value is used as the initial value for the ack
       *   deadline. To override this value for a given message, call
       *   `ModifyAckDeadline` with the corresponding `ack_id` if using
       *   non-streaming pull or send the `ack_id` in a
       *   `StreamingModifyAckDeadlineRequest` if using streaming pull.
       *   The minimum custom deadline you can specify is 10 seconds.
       *   The maximum custom deadline you can specify is 600 seconds (10 minutes).
       *   If this parameter is 0, a default value of 10 seconds is used.
       *
       *   For push delivery, this value is also used to set the request timeout for
       *   the call to the push endpoint.
       *
       *   If the subscriber never acknowledges the message, the Pub/Sub
       *   system will eventually redeliver the message.
       * @param {boolean} request.retainAckedMessages
       *   Indicates whether to retain acknowledged messages. If true, then
       *   messages are not expunged from the subscription's backlog, even if they are
       *   acknowledged, until they fall out of the `message_retention_duration`
       *   window. This must be true if you would like to
       *   <a
       *   href="https://cloud.google.com/pubsub/docs/replay-overview#seek_to_a_time">
       *   Seek to a timestamp</a>.
       * @param {google.protobuf.Duration} request.messageRetentionDuration
       *   How long to retain unacknowledged messages in the subscription's backlog,
       *   from the moment a message is published.
       *   If `retain_acked_messages` is true, then this also configures the retention
       *   of acknowledged messages, and thus configures how far back in time a `Seek`
       *   can be done. Defaults to 7 days. Cannot be more than 7 days or less than 10
       *   minutes.
       * @param {number[]} request.labels
       *   See <a href="https://cloud.google.com/pubsub/docs/labels"> Creating and
       *   managing labels</a>.
       * @param {boolean} request.enableMessageOrdering
       *   If true, messages published with the same `ordering_key` in `PubsubMessage`
       *   will be delivered to the subscribers in the order in which they
       *   are received by the Pub/Sub system. Otherwise, they may be delivered in
       *   any order.
       *   <b>EXPERIMENTAL:</b> This feature is part of a closed alpha release. This
       *   API might be changed in backward-incompatible ways and is not recommended
       *   for production use. It is not subject to any SLA or deprecation policy.
       * @param {google.pubsub.v1.ExpirationPolicy} request.expirationPolicy
       *   A policy that specifies the conditions for this subscription's expiration.
       *   A subscription is considered active as long as any connected subscriber is
       *   successfully consuming messages from the subscription or is issuing
       *   operations on the subscription. If `expiration_policy` is not set, a
       *   *default policy* with `ttl` of 31 days will be used. The minimum allowed
       *   value for `expiration_policy.ttl` is 1 day.
       * @param {string} request.filter
       *   An expression written in the Pub/Sub [filter
       *   language](https://cloud.google.com/pubsub/docs/filtering). If non-empty,
       *   then only `PubsubMessage`s whose `attributes` field matches the filter are
       *   delivered on this subscription. If empty, then no messages are filtered
       *   out.
       * @param {google.pubsub.v1.DeadLetterPolicy} request.deadLetterPolicy
       *   A policy that specifies the conditions for dead lettering messages in
       *   this subscription. If dead_letter_policy is not set, dead lettering
       *   is disabled.
       *
       *   The Cloud Pub/Sub service account associated with this subscriptions's
       *   parent project (i.e.,
       *   service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com) must have
       *   permission to Acknowledge() messages on this subscription.
       * @param {google.pubsub.v1.RetryPolicy} request.retryPolicy
       *   A policy that specifies how Pub/Sub retries message delivery for this
       *   subscription.
       *
       *   If not set, the default retry policy is applied. This generally implies
       *   that messages will be retried as soon as possible for healthy subscribers.
       *   RetryPolicy will be triggered on NACKs or acknowledgement deadline
       *   exceeded events for a given message.
       * @param {boolean} request.detached
       *   Indicates whether the subscription is detached from its topic. Detached
       *   subscriptions don't receive messages from their topic and don't retain any
       *   backlog. `Pull` and `StreamingPull` requests will return
       *   FAILED_PRECONDITION. If the subscription is a push subscription, pushes to
       *   the endpoint will not be made.
       * @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 [Subscription]{@link google.pubsub.v1.Subscription}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      createSubscription(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          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.createSubscription(request, options, callback);
      }
      /**
       * Gets the configuration details of a subscription.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.subscription
       *   Required. The name of the subscription to get.
       *   Format is `projects/{project}/subscriptions/{sub}`.
       * @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 [Subscription]{@link google.pubsub.v1.Subscription}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      getSubscription(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              subscription: request.subscription || '',
          });
          this.initialize();
          return this.innerApiCalls.getSubscription(request, options, callback);
      }
      /**
       * Updates an existing subscription. Note that certain properties of a
       * subscription, such as its topic, are not modifiable.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {google.pubsub.v1.Subscription} request.subscription
       *   Required. The updated subscription object.
       * @param {google.protobuf.FieldMask} request.updateMask
       *   Required. Indicates which fields in the provided subscription to update.
       *   Must be specified and non-empty.
       * @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 [Subscription]{@link google.pubsub.v1.Subscription}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      updateSubscription(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              'subscription.name': request.subscription.name || '',
          });
          this.initialize();
          return this.innerApiCalls.updateSubscription(request, options, callback);
      }
      /**
       * Deletes an existing subscription. All messages retained in the subscription
       * are immediately dropped. Calls to `Pull` after deletion will return
       * `NOT_FOUND`. After a subscription is deleted, a new one may be created with
       * the same name, but the new one has no association with the old
       * subscription or its topic unless the same topic is specified.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.subscription
       *   Required. The subscription to delete.
       *   Format is `projects/{project}/subscriptions/{sub}`.
       * @param {object} [options]
       *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
       * @returns {Promise} - The promise which resolves to an array.
       *   The first element of the array is an object representing [Empty]{@link google.protobuf.Empty}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      deleteSubscription(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              subscription: request.subscription || '',
          });
          this.initialize();
          return this.innerApiCalls.deleteSubscription(request, options, callback);
      }
      /**
       * Modifies the ack deadline for a specific message. This method is useful
       * to indicate that more time is needed to process a message by the
       * subscriber, or to make the message available for redelivery if the
       * processing was interrupted. Note that this does not modify the
       * subscription-level `ackDeadlineSeconds` used for subsequent messages.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.subscription
       *   Required. The name of the subscription.
       *   Format is `projects/{project}/subscriptions/{sub}`.
       * @param {string[]} request.ackIds
       *   Required. List of acknowledgment IDs.
       * @param {number} request.ackDeadlineSeconds
       *   Required. The new ack deadline with respect to the time this request was
       *   sent to the Pub/Sub system. For example, if the value is 10, the new ack
       *   deadline will expire 10 seconds after the `ModifyAckDeadline` call was
       *   made. Specifying zero might immediately make the message available for
       *   delivery to another subscriber client. This typically results in an
       *   increase in the rate of message redeliveries (that is, duplicates).
       *   The minimum deadline you can specify is 0 seconds.
       *   The maximum deadline you can specify is 600 seconds (10 minutes).
       * @param {object} [options]
       *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
       * @returns {Promise} - The promise which resolves to an array.
       *   The first element of the array is an object representing [Empty]{@link google.protobuf.Empty}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      modifyAckDeadline(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              subscription: request.subscription || '',
          });
          this.initialize();
          return this.innerApiCalls.modifyAckDeadline(request, options, callback);
      }
      /**
       * Acknowledges the messages associated with the `ack_ids` in the
       * `AcknowledgeRequest`. The Pub/Sub system can remove the relevant messages
       * from the subscription.
       *
       * Acknowledging a message whose ack deadline has expired may succeed,
       * but such a message may be redelivered later. Acknowledging a message more
       * than once will not result in an error.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.subscription
       *   Required. The subscription whose message is being acknowledged.
       *   Format is `projects/{project}/subscriptions/{sub}`.
       * @param {string[]} request.ackIds
       *   Required. The acknowledgment ID for the messages being acknowledged that
       *   was returned by the Pub/Sub system in the `Pull` response. Must not be
       *   empty.
       * @param {object} [options]
       *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
       * @returns {Promise} - The promise which resolves to an array.
       *   The first element of the array is an object representing [Empty]{@link google.protobuf.Empty}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      acknowledge(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              subscription: request.subscription || '',
          });
          this.initialize();
          return this.innerApiCalls.acknowledge(request, options, callback);
      }
      /**
       * Pulls messages from the server. The server may return `UNAVAILABLE` if
       * there are too many concurrent pull requests pending for the given
       * subscription.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.subscription
       *   Required. The subscription from which messages should be pulled.
       *   Format is `projects/{project}/subscriptions/{sub}`.
       * @param {boolean} [request.returnImmediately]
       *   Optional. If this field set to true, the system will respond immediately
       *   even if it there are no messages available to return in the `Pull`
       *   response. Otherwise, the system may wait (for a bounded amount of time)
       *   until at least one message is available, rather than returning no messages.
       *   Warning: setting this field to `true` is discouraged because it adversely
       *   impacts the performance of `Pull` operations. We recommend that users do
       *   not set this field.
       * @param {number} request.maxMessages
       *   Required. The maximum number of messages to return for this request. Must
       *   be a positive integer. The Pub/Sub system may return fewer than the number
       *   specified.
       * @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 [PullResponse]{@link google.pubsub.v1.PullResponse}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      pull(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              subscription: request.subscription || '',
          });
          this.initialize();
          return this.innerApiCalls.pull(request, options, callback);
      }
      /**
       * Modifies the `PushConfig` for a specified subscription.
       *
       * This may be used to change a push subscription to a pull one (signified by
       * an empty `PushConfig`) or vice versa, or change the endpoint URL and other
       * attributes of a push subscription. Messages will accumulate for delivery
       * continuously through the call regardless of changes to the `PushConfig`.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.subscription
       *   Required. The name of the subscription.
       *   Format is `projects/{project}/subscriptions/{sub}`.
       * @param {google.pubsub.v1.PushConfig} request.pushConfig
       *   Required. The push configuration for future deliveries.
       *
       *   An empty `pushConfig` indicates that the Pub/Sub system should
       *   stop pushing messages from the given subscription and allow
       *   messages to be pulled and acknowledged - effectively pausing
       *   the subscription if `Pull` or `StreamingPull` is not called.
       * @param {object} [options]
       *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
       * @returns {Promise} - The promise which resolves to an array.
       *   The first element of the array is an object representing [Empty]{@link google.protobuf.Empty}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      modifyPushConfig(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              subscription: request.subscription || '',
          });
          this.initialize();
          return this.innerApiCalls.modifyPushConfig(request, options, callback);
      }
      /**
       * Gets the configuration details of a snapshot. Snapshots are used in
       * <a href="https://cloud.google.com/pubsub/docs/replay-overview">Seek</a>
       * operations, which allow you to manage message acknowledgments in bulk. That
       * is, you can set the acknowledgment state of messages in an existing
       * subscription to the state captured by a snapshot.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.snapshot
       *   Required. The name of the snapshot to get.
       *   Format is `projects/{project}/snapshots/{snap}`.
       * @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 [Snapshot]{@link google.pubsub.v1.Snapshot}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      getSnapshot(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              snapshot: request.snapshot || '',
          });
          this.initialize();
          return this.innerApiCalls.getSnapshot(request, options, callback);
      }
      /**
       * Creates a snapshot from the requested subscription. Snapshots are used in
       * <a href="https://cloud.google.com/pubsub/docs/replay-overview">Seek</a>
       * operations, which allow
       * you to manage message acknowledgments in bulk. That is, you can set the
       * acknowledgment state of messages in an existing subscription to the state
       * captured by a snapshot.
       * <br><br>If the snapshot already exists, returns `ALREADY_EXISTS`.
       * If the requested subscription doesn't exist, returns `NOT_FOUND`.
       * If the backlog in the subscription is too old -- and the resulting snapshot
       * would expire in less than 1 hour -- then `FAILED_PRECONDITION` is returned.
       * See also the `Snapshot.expire_time` field. If the name is not provided in
       * the request, the server will assign a random
       * name for this snapshot on the same project as the subscription, conforming
       * to the
       * [resource name
       * format](https://cloud.google.com/pubsub/docs/admin#resource_names). The
       * generated name is populated in the returned Snapshot object. Note that for
       * REST API requests, you must specify a name in the request.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.name
       *   Required. User-provided name for this snapshot. If the name is not provided
       *   in the request, the server will assign a random name for this snapshot on
       *   the same project as the subscription. Note that for REST API requests, you
       *   must specify a name.  See the <a
       *   href="https://cloud.google.com/pubsub/docs/admin#resource_names"> resource
       *   name rules</a>. Format is `projects/{project}/snapshots/{snap}`.
       * @param {string} request.subscription
       *   Required. The subscription whose backlog the snapshot retains.
       *   Specifically, the created snapshot is guaranteed to retain:
       *    (a) The existing backlog on the subscription. More precisely, this is
       *        defined as the messages in the subscription's backlog that are
       *        unacknowledged upon the successful completion of the
       *        `CreateSnapshot` request; as well as:
       *    (b) Any messages published to the subscription's topic following the
       *        successful completion of the CreateSnapshot request.
       *   Format is `projects/{project}/subscriptions/{sub}`.
       * @param {number[]} request.labels
       *   See <a href="https://cloud.google.com/pubsub/docs/labels"> Creating and
       *   managing labels</a>.
       * @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 [Snapshot]{@link google.pubsub.v1.Snapshot}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      createSnapshot(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          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.createSnapshot(request, options, callback);
      }
      /**
       * Updates an existing snapshot. Snapshots are used in
       * <a href="https://cloud.google.com/pubsub/docs/replay-overview">Seek</a>
       * operations, which allow
       * you to manage message acknowledgments in bulk. That is, you can set the
       * acknowledgment state of messages in an existing subscription to the state
       * captured by a snapshot.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {google.pubsub.v1.Snapshot} request.snapshot
       *   Required. The updated snapshot object.
       * @param {google.protobuf.FieldMask} request.updateMask
       *   Required. Indicates which fields in the provided snapshot to update.
       *   Must be specified and non-empty.
       * @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 [Snapshot]{@link google.pubsub.v1.Snapshot}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      updateSnapshot(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              'snapshot.name': request.snapshot.name || '',
          });
          this.initialize();
          return this.innerApiCalls.updateSnapshot(request, options, callback);
      }
      /**
       * Removes an existing snapshot. Snapshots are used in
       * <a href="https://cloud.google.com/pubsub/docs/replay-overview">Seek</a>
       * operations, which allow
       * you to manage message acknowledgments in bulk. That is, you can set the
       * acknowledgment state of messages in an existing subscription to the state
       * captured by a snapshot.<br><br>
       * When the snapshot is deleted, all messages retained in the snapshot
       * are immediately dropped. After a snapshot is deleted, a new one may be
       * created with the same name, but the new one has no association with the old
       * snapshot or its subscription, unless the same subscription is specified.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.snapshot
       *   Required. The name of the snapshot to delete.
       *   Format is `projects/{project}/snapshots/{snap}`.
       * @param {object} [options]
       *   Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details.
       * @returns {Promise} - The promise which resolves to an array.
       *   The first element of the array is an object representing [Empty]{@link google.protobuf.Empty}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      deleteSnapshot(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              snapshot: request.snapshot || '',
          });
          this.initialize();
          return this.innerApiCalls.deleteSnapshot(request, options, callback);
      }
      /**
       * Seeks an existing subscription to a point in time or to a given snapshot,
       * whichever is provided in the request. Snapshots are used in
       * <a href="https://cloud.google.com/pubsub/docs/replay-overview">Seek</a>
       * operations, which allow
       * you to manage message acknowledgments in bulk. That is, you can set the
       * acknowledgment state of messages in an existing subscription to the state
       * captured by a snapshot. Note that both the subscription and the snapshot
       * must be on the same topic.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.subscription
       *   Required. The subscription to affect.
       * @param {google.protobuf.Timestamp} request.time
       *   The time to seek to.
       *   Messages retained in the subscription that were published before this
       *   time are marked as acknowledged, and messages retained in the
       *   subscription that were published after this time are marked as
       *   unacknowledged. Note that this operation affects only those messages
       *   retained in the subscription (configured by the combination of
       *   `message_retention_duration` and `retain_acked_messages`). For example,
       *   if `time` corresponds to a point before the message retention
       *   window (or to a point before the system's notion of the subscription
       *   creation time), only retained messages will be marked as unacknowledged,
       *   and already-expunged messages will not be restored.
       * @param {string} request.snapshot
       *   The snapshot to seek to. The snapshot's topic must be the same as that of
       *   the provided subscription.
       *   Format is `projects/{project}/snapshots/{snap}`.
       * @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 [SeekResponse]{@link google.pubsub.v1.SeekResponse}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      seek(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              subscription: request.subscription || '',
          });
          this.initialize();
          return this.innerApiCalls.seek(request, options, callback);
      }
      /**
       * Establishes a stream with the server, which sends messages down to the
       * client. The client streams acknowledgements and ack deadline modifications
       * back to the server. The server will close the stream and return the status
       * on any error. The server may close the stream with status `UNAVAILABLE` to
       * reassign server-side resources, in which case, the client should
       * re-establish the stream. Flow control can be achieved by configuring the
       * underlying RPC channel.
       *
       * @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 [StreamingPullRequest]{@link google.pubsub.v1.StreamingPullRequest} for write() method, and
       *   will emit objects representing [StreamingPullResponse]{@link google.pubsub.v1.StreamingPullResponse} on 'data' event asynchronously.
       */
      streamingPull(options) {
          this.initialize();
          return this.innerApiCalls.streamingPull(options);
      }
      /**
       * Lists matching subscriptions.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.project
       *   Required. The name of the project in which to list subscriptions.
       *   Format is `projects/{project-id}`.
       * @param {number} request.pageSize
       *   Maximum number of subscriptions to return.
       * @param {string} request.pageToken
       *   The value returned by the last `ListSubscriptionsResponse`; indicates that
       *   this is a continuation of a prior `ListSubscriptions` call, and that the
       *   system should return the next page of data.
       * @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 [Subscription]{@link google.pubsub.v1.Subscription}.
       *   The client library support 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.
       *
       *   When autoPaginate: false is specified through options, the array has three elements.
       *   The first element is Array of [Subscription]{@link google.pubsub.v1.Subscription} that corresponds to
       *   the one page received from the API server.
       *   If the second element is not null it contains the request object of type [ListSubscriptionsRequest]{@link google.pubsub.v1.ListSubscriptionsRequest}
       *   that can be used to obtain the next page of the results.
       *   If it is null, the next page does not exist.
       *   The third element contains the raw response received from the API server. Its type is
       *   [ListSubscriptionsResponse]{@link google.pubsub.v1.ListSubscriptionsResponse}.
       *
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      listSubscriptions(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              project: request.project || '',
          });
          this.initialize();
          return this.innerApiCalls.listSubscriptions(request, options, callback);
      }
      /**
       * Equivalent to {@link listSubscriptions}, but returns a NodeJS Stream object.
       *
       * This fetches the paged responses for {@link listSubscriptions} continuously
       * and invokes the callback registered for 'data' event for each element in the
       * responses.
       *
       * The returned object has 'end' method when no more elements are required.
       *
       * autoPaginate option will be ignored.
       *
       * @see {@link https://nodejs.org/api/stream.html}
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.project
       *   Required. The name of the project in which to list subscriptions.
       *   Format is `projects/{project-id}`.
       * @param {number} request.pageSize
       *   Maximum number of subscriptions to return.
       * @param {string} request.pageToken
       *   The value returned by the last `ListSubscriptionsResponse`; indicates that
       *   this is a continuation of a prior `ListSubscriptions` call, and that the
       *   system should return the next page of data.
       * @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 [Subscription]{@link google.pubsub.v1.Subscription} on 'data' event.
       */
      listSubscriptionsStream(request, options) {
          request = request || {};
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              project: request.project || '',
          });
          const callSettings = new gax.CallSettings(options);
          this.initialize();
          return this.descriptors.page.listSubscriptions.createStream(this.innerApiCalls.listSubscriptions, request, callSettings);
      }
      /**
       * Equivalent to {@link listSubscriptions}, but returns an iterable object.
       *
       * for-await-of syntax is used with the iterable to recursively get response element on-demand.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.project
       *   Required. The name of the project in which to list subscriptions.
       *   Format is `projects/{project-id}`.
       * @param {number} request.pageSize
       *   Maximum number of subscriptions to return.
       * @param {string} request.pageToken
       *   The value returned by the last `ListSubscriptionsResponse`; indicates that
       *   this is a continuation of a prior `ListSubscriptions` call, and that the
       *   system should return the next page of data.
       * @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 conforms to @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols.
       */
      listSubscriptionsAsync(request, options) {
          request = request || {};
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              project: request.project || '',
          });
          options = options || {};
          const callSettings = new gax.CallSettings(options);
          this.initialize();
          return this.descriptors.page.listSubscriptions.asyncIterate(this.innerApiCalls['listSubscriptions'], request, callSettings);
      }
      /**
       * Lists the existing snapshots. Snapshots are used in
       * <a href="https://cloud.google.com/pubsub/docs/replay-overview">Seek</a>
       * operations, which allow
       * you to manage message acknowledgments in bulk. That is, you can set the
       * acknowledgment state of messages in an existing subscription to the state
       * captured by a snapshot.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.project
       *   Required. The name of the project in which to list snapshots.
       *   Format is `projects/{project-id}`.
       * @param {number} request.pageSize
       *   Maximum number of snapshots to return.
       * @param {string} request.pageToken
       *   The value returned by the last `ListSnapshotsResponse`; indicates that this
       *   is a continuation of a prior `ListSnapshots` call, and that the system
       *   should return the next page of data.
       * @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 [Snapshot]{@link google.pubsub.v1.Snapshot}.
       *   The client library support 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.
       *
       *   When autoPaginate: false is specified through options, the array has three elements.
       *   The first element is Array of [Snapshot]{@link google.pubsub.v1.Snapshot} that corresponds to
       *   the one page received from the API server.
       *   If the second element is not null it contains the request object of type [ListSnapshotsRequest]{@link google.pubsub.v1.ListSnapshotsRequest}
       *   that can be used to obtain the next page of the results.
       *   If it is null, the next page does not exist.
       *   The third element contains the raw response received from the API server. Its type is
       *   [ListSnapshotsResponse]{@link google.pubsub.v1.ListSnapshotsResponse}.
       *
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      listSnapshots(request, optionsOrCallback, callback) {
          request = request || {};
          let options;
          if (typeof optionsOrCallback === 'function' && callback === undefined) {
              callback = optionsOrCallback;
              options = {};
          }
          else {
              options = optionsOrCallback;
          }
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              project: request.project || '',
          });
          this.initialize();
          return this.innerApiCalls.listSnapshots(request, options, callback);
      }
      /**
       * Equivalent to {@link listSnapshots}, but returns a NodeJS Stream object.
       *
       * This fetches the paged responses for {@link listSnapshots} continuously
       * and invokes the callback registered for 'data' event for each element in the
       * responses.
       *
       * The returned object has 'end' method when no more elements are required.
       *
       * autoPaginate option will be ignored.
       *
       * @see {@link https://nodejs.org/api/stream.html}
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.project
       *   Required. The name of the project in which to list snapshots.
       *   Format is `projects/{project-id}`.
       * @param {number} request.pageSize
       *   Maximum number of snapshots to return.
       * @param {string} request.pageToken
       *   The value returned by the last `ListSnapshotsResponse`; indicates that this
       *   is a continuation of a prior `ListSnapshots` call, and that the system
       *   should return the next page of data.
       * @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 [Snapshot]{@link google.pubsub.v1.Snapshot} on 'data' event.
       */
      listSnapshotsStream(request, options) {
          request = request || {};
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              project: request.project || '',
          });
          const callSettings = new gax.CallSettings(options);
          this.initialize();
          return this.descriptors.page.listSnapshots.createStream(this.innerApiCalls.listSnapshots, request, callSettings);
      }
      /**
       * Equivalent to {@link listSnapshots}, but returns an iterable object.
       *
       * for-await-of syntax is used with the iterable to recursively get response element on-demand.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.project
       *   Required. The name of the project in which to list snapshots.
       *   Format is `projects/{project-id}`.
       * @param {number} request.pageSize
       *   Maximum number of snapshots to return.
       * @param {string} request.pageToken
       *   The value returned by the last `ListSnapshotsResponse`; indicates that this
       *   is a continuation of a prior `ListSnapshots` call, and that the system
       *   should return the next page of data.
       * @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 conforms to @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols.
       */
      listSnapshotsAsync(request, options) {
          request = request || {};
          options = options || {};
          options.otherArgs = options.otherArgs || {};
          options.otherArgs.headers = options.otherArgs.headers || {};
          options.otherArgs.headers['x-goog-request-params'] = gax.routingHeader.fromParams({
              project: request.project || '',
          });
          options = options || {};
          const callSettings = new gax.CallSettings(options);
          this.initialize();
          return this.descriptors.page.listSnapshots.asyncIterate(this.innerApiCalls['listSnapshots'], request, callSettings);
      }
      /**
       * Gets the access control policy for a resource. Returns an empty policy
       * if the resource exists and does not have a policy set.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.resource
       *   REQUIRED: The resource for which the policy is being requested.
       *   See the operation documentation for the appropriate value for this field.
       * @param {Object} [request.options]
       *   OPTIONAL: A `GetPolicyOptions` object for specifying options to
       *   `GetIamPolicy`. This field is only used by Cloud IAM.
       *
       *   This object should have the same structure as [GetPolicyOptions]{@link google.iam.v1.GetPolicyOptions}
       * @param {Object} [options]
       *   Optional parameters. You can override the default settings for this call, e.g, timeout,
       *   retries, paginations, etc. See [gax.CallOptions]{@link https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html} for the details.
       * @param {function(?Error, ?Object)} [callback]
       *   The function which will be called with the result of the API call.
       *
       *   The second parameter to the callback is an object representing [Policy]{@link google.iam.v1.Policy}.
       * @returns {Promise} - The promise which resolves to an array.
       *   The first element of the array is an object representing [Policy]{@link google.iam.v1.Policy}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      getIamPolicy(request, options, callback) {
          return this.iamClient.getIamPolicy(request, options, callback);
      }
      /**
       * Returns permissions that a caller has on the specified resource. If the
       * resource does not exist, this will return an empty set of
       * permissions, not a NOT_FOUND error.
       *
       * Note: This operation is designed to be used for building
       * permission-aware UIs and command-line tools, not for authorization
       * checking. This operation may "fail open" without warning.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.resource
       *   REQUIRED: The resource for which the policy detail is being requested.
       *   See the operation documentation for the appropriate value for this field.
       * @param {string[]} request.permissions
       *   The set of permissions to check for the `resource`. Permissions with
       *   wildcards (such as '*' or 'storage.*') are not allowed. For more
       *   information see
       *   [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).
       * @param {Object} [options]
       *   Optional parameters. You can override the default settings for this call, e.g, timeout,
       *   retries, paginations, etc. See [gax.CallOptions]{@link https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html} for the details.
       * @param {function(?Error, ?Object)} [callback]
       *   The function which will be called with the result of the API call.
       *
       *   The second parameter to the callback is an object representing [TestIamPermissionsResponse]{@link google.iam.v1.TestIamPermissionsResponse}.
       * @returns {Promise} - The promise which resolves to an array.
       *   The first element of the array is an object representing [TestIamPermissionsResponse]{@link google.iam.v1.TestIamPermissionsResponse}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       */
      setIamPolicy(request, options, callback) {
          return this.iamClient.setIamPolicy(request, options, callback);
      }
      /**
       * Returns permissions that a caller has on the specified resource. If the
       * resource does not exist, this will return an empty set of
       * permissions, not a NOT_FOUND error.
       *
       * Note: This operation is designed to be used for building
       * permission-aware UIs and command-line tools, not for authorization
       * checking. This operation may "fail open" without warning.
       *
       * @param {Object} request
       *   The request object that will be sent.
       * @param {string} request.resource
       *   REQUIRED: The resource for which the policy detail is being requested.
       *   See the operation documentation for the appropriate value for this field.
       * @param {string[]} request.permissions
       *   The set of permissions to check for the `resource`. Permissions with
       *   wildcards (such as '*' or 'storage.*') are not allowed. For more
       *   information see
       *   [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).
       * @param {Object} [options]
       *   Optional parameters. You can override the default settings for this call, e.g, timeout,
       *   retries, paginations, etc. See [gax.CallOptions]{@link https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html} for the details.
       * @param {function(?Error, ?Object)} [callback]
       *   The function which will be called with the result of the API call.
       *
       *   The second parameter to the callback is an object representing [TestIamPermissionsResponse]{@link google.iam.v1.TestIamPermissionsResponse}.
       * @returns {Promise} - The promise which resolves to an array.
       *   The first element of the array is an object representing [TestIamPermissionsResponse]{@link google.iam.v1.TestIamPermissionsResponse}.
       *   The promise has a method named "cancel" which cancels the ongoing API call.
       *
       */
      testIamPermissions(request, options, callback) {
          return this.iamClient.testIamPermissions(request, options, callback);
      }
      // --------------------
      // -- Path templates --
      // --------------------
      /**
       * Return a fully-qualified project resource name string.
       *
       * @param {string} project
       * @returns {string} Resource name string.
       */
      projectPath(project) {
          return this.pathTemplates.projectPathTemplate.render({
              project: project,
          });
      }
      /**
       * Parse the project from Project resource.
       *
       * @param {string} projectName
       *   A fully-qualified path representing Project resource.
       * @returns {string} A string representing the project.
       */
      matchProjectFromProjectName(projectName) {
          return this.pathTemplates.projectPathTemplate.match(projectName).project;
      }
      /**
       * Return a fully-qualified projectTopic resource name string.
       *
       * @param {string} project
       * @param {string} topic
       * @returns {string} Resource name string.
       */
      projectTopicPath(project, topic) {
          return this.pathTemplates.projectTopicPathTemplate.render({
              project: project,
              topic: topic,
          });
      }
      /**
       * Parse the project from ProjectTopic resource.
       *
       * @param {string} projectTopicName
       *   A fully-qualified path representing project_topic resource.
       * @returns {string} A string representing the project.
       */
      matchProjectFromProjectTopicName(projectTopicName) {
          return this.pathTemplates.projectTopicPathTemplate.match(projectTopicName)
              .project;
      }
      /**
       * Parse the topic from ProjectTopic resource.
       *
       * @param {string} projectTopicName
       *   A fully-qualified path representing project_topic resource.
       * @returns {string} A string representing the topic.
       */
      matchTopicFromProjectTopicName(projectTopicName) {
          return this.pathTemplates.projectTopicPathTemplate.match(projectTopicName)
              .topic;
      }
      /**
       * Return a fully-qualified snapshot resource name string.
       *
       * @param {string} project
       * @param {string} snapshot
       * @returns {string} Resource name string.
       */
      snapshotPath(project, snapshot) {
          return this.pathTemplates.snapshotPathTemplate.render({
              project: project,
              snapshot: snapshot,
          });
      }
      /**
       * Parse the project from Snapshot resource.
       *
       * @param {string} snapshotName
       *   A fully-qualified path representing Snapshot resource.
       * @returns {string} A string representing the project.
       */
      matchProjectFromSnapshotName(snapshotName) {
          return this.pathTemplates.snapshotPathTemplate.match(snapshotName).project;
      }
      /**
       * Parse the snapshot from Snapshot resource.
       *
       * @param {string} snapshotName
       *   A fully-qualified path representing Snapshot resource.
       * @returns {string} A string representing the snapshot.
       */
      matchSnapshotFromSnapshotName(snapshotName) {
          return this.pathTemplates.snapshotPathTemplate.match(snapshotName).snapshot;
      }
      /**
       * Return a fully-qualified subscription resource name string.
       *
       * @param {string} project
       * @param {string} subscription
       * @returns {string} Resource name string.
       */
      subscriptionPath(project, subscription) {
          return this.pathTemplates.subscriptionPathTemplate.render({
              project: project,
              subscription: subscription,
          });
      }
      /**
       * Parse the project from Subscription resource.
       *
       * @param {string} subscriptionName
       *   A fully-qualified path representing Subscription resource.
       * @returns {string} A string representing the project.
       */
      matchProjectFromSubscriptionName(subscriptionName) {
          return this.pathTemplates.subscriptionPathTemplate.match(subscriptionName)
              .project;
      }
      /**
       * Parse the subscription from Subscription resource.
       *
       * @param {string} subscriptionName
       *   A fully-qualified path representing Subscription resource.
       * @returns {string} A string representing the subscription.
       */
      matchSubscriptionFromSubscriptionName(subscriptionName) {
          return this.pathTemplates.subscriptionPathTemplate.match(subscriptionName)
              .subscription;
      }
      /**
       * Terminate the GRPC channel and close the client.
       *
       * The client will no longer be usable and all future behavior is undefined.
       */
      close() {
          this.initialize();
          if (!this._terminated) {
              return this.subscriberStub.then(stub => {
                  this._terminated = true;
                  stub.close();
              });
          }
          return Promise.resolve();
      }
  }
  exports.SubscriberClient = SubscriberClient;
  //# sourceMappingURL=subscriber_client.js.map