@google-cloud/pubsub

  • Version 2.12.0
  • Published
  • 2.86 MB
  • 15 dependencies
  • Apache-2.0 license

Install

npm i @google-cloud/pubsub
yarn add @google-cloud/pubsub
pnpm add @google-cloud/pubsub

Overview

Cloud Pub/Sub Client Library for Node.js

Index

Classes

Interfaces

Type Aliases

Namespaces

Classes

class IAM

class IAM {}
  • [IAM (Identity and Access Management)](https://cloud.google.com/pubsub/access_control) allows you to set permissions on invidual resources and offers a wider range of roles: editor, owner, publisher, subscriber, and viewer. This gives you greater flexibility and allows you to set more fine-grained access control.

    For example: * Grant access on a per-topic or per-subscription basis, rather than for the whole Cloud project. * Grant access with limited capabilities, such as to only publish messages to a topic, or to only to consume messages from a subscription, but not to delete the topic or subscription.

    *The IAM access control features described in this document are Beta, including the API methods to get and set IAM policies, and to test IAM permissions. Cloud Pub/Sub's use of IAM features is not covered by any SLA or deprecation policy, and may be subject to backward-incompatible changes.*

    Parameter pubsub

    PubSub Object.

    Parameter id

    The name of the topic or subscription.

    Example 1

    const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

    const topic = pubsub.topic('my-topic'); // topic.iam

    const subscription = pubsub.subscription('my-subscription'); // subscription.iam

    See Also

constructor

constructor(pubsub: PubSub, id: string);

    property id

    id: string;

      property pubsub

      pubsub: PubSub;

        property request

        request: <T, R = void>(
        config: RequestConfig,
        callback: RequestCallback<T, R>
        ) => void;

          method getPolicy

          getPolicy: {
          (gaxOpts?: any): Promise<GetPolicyResponse>;
          (callback: NormalCallback<Policy>): void;
          (gaxOpts: any, callback: NormalCallback<Policy>): void;
          };

            method setPolicy

            setPolicy: {
            (policy: Policy, gaxOpts?: any): Promise<SetPolicyResponse>;
            (policy: Policy, gaxOpts: any, callback: NormalCallback<Policy>): void;
            (policy: Policy, callback: NormalCallback<Policy>): void;
            };

              method testPermissions

              testPermissions: {
              (
              permissions: string | string[],
              gaxOpts?: any
              ): Promise<TestIamPermissionsResponse>;
              (
              permissions: string | string[],
              gaxOpts: any,
              callback: TestIamPermissionsCallback
              ): void;
              (permissions: string | string[], callback: TestIamPermissionsCallback): void;
              };

                class Message

                class Message {}
                • Message objects provide a simple interface for users to get message data and acknowledge the message.

                  Example 1

                  subscription.on('message', message => { // { // ackId: 'RUFeQBJMJAxESVMrQwsqWBFOBCEhPjA', // attributes: {key: 'value'}, // data: Buffer.from('Hello, world!'), // id: '1551297743043', // orderingKey: 'ordering-key', // publishTime: new PreciseDate('2019-02-27T20:02:19.029534186Z'), // received: 1551297743043, // length: 13 // } });

                constructor

                constructor(
                sub: Subscriber,
                { ackId, message, deliveryAttempt }: google.pubsub.v1.IReceivedMessage
                );
                • Parameter sub

                  The parent subscriber.

                  Parameter message

                  The raw message response.

                property ackId

                ackId: string;

                  property attributes

                  attributes: { [key: string]: string };

                    property data

                    data: any;

                      property deliveryAttempt

                      deliveryAttempt: number;

                        property id

                        id: string;

                          property length

                          readonly length: number;
                          • The length of the message data.

                            {number}

                          property orderingKey

                          orderingKey?: string;

                            property publishTime

                            publishTime: any;

                              property received

                              received: number;

                                method ack

                                ack: () => void;
                                • Acknowledges the message.

                                  Example 1

                                  subscription.on('message', message => { message.ack(); });

                                method modAck

                                modAck: (deadline: number) => void;
                                • Modifies the ack deadline.

                                  Parameter deadline

                                  The number of seconds to extend the deadline.

                                method nack

                                nack: () => void;
                                • Removes the message from our inventory and schedules it to be redelivered.

                                  Example 1

                                  subscription.on('message', message => { message.nack(); });

                                class PublishError

                                class PublishError extends Error implements grpc.ServiceError {}
                                • Exception to be thrown during failed ordered publish.

                                  Error

                                constructor

                                constructor(key: string, err: any);

                                  property code

                                  code: any;

                                    property details

                                    details: string;

                                      property error

                                      error: any;

                                        property metadata

                                        metadata: any;

                                          property orderingKey

                                          orderingKey: string;

                                            class PubSub

                                            class PubSub {}
                                            • [Cloud Pub/Sub](https://developers.google.com/pubsub/overview) is a reliable, many-to-many, asynchronous messaging service from Cloud Platform.

                                              Parameter options

                                              Configuration options.

                                              Example 1

                                              Import the client library const {PubSub} = require('@google-cloud/pubsub');

                                              Example 2

                                              Create a client that uses Application Default Credentials (ADC): const pubsub = new PubSub();

                                              Example 3

                                              Create a client with explicit credentials: const pubsub = new PubSub({ projectId: 'your-project-id', keyFilename: '/path/to/keyfile.json' });

                                              Example 4

                                              include:samples/quickstart.js region_tag:pubsub_quickstart_create_topic Full quickstart example:

                                              See Also

                                            constructor

                                            constructor(options?: ClientConfig);

                                              property api

                                              api: { [key: string]: any };

                                                property auth

                                                auth: any;

                                                  property getSnapshotsStream

                                                  getSnapshotsStream: () => ObjectStream<Snapshot>;

                                                    property getSubscriptionsStream

                                                    getSubscriptionsStream: () => ObjectStream<Subscription>;

                                                      property getTopicsStream

                                                      getTopicsStream: () => ObjectStream<Topic>;

                                                        property isEmulator

                                                        isEmulator: boolean;

                                                          property isOpen

                                                          isOpen: boolean;

                                                            property options

                                                            options: ClientConfig;

                                                              property projectId

                                                              projectId: string;

                                                                property Promise

                                                                Promise?: PromiseConstructor;

                                                                  method close

                                                                  close: {
                                                                  (): Promise<void>;
                                                                  (callback: NormalCallback<google.protobuf.IEmpty>): void;
                                                                  };

                                                                    method closeAllClients_

                                                                    closeAllClients_: () => Promise<void>;
                                                                    • Close all open client objects.

                                                                      Returns

                                                                      {Promise}

                                                                    method createSubscription

                                                                    createSubscription: {
                                                                    (
                                                                    topic: Topic | string,
                                                                    name: string,
                                                                    options?: CreateSubscriptionOptions
                                                                    ): Promise<CreateSubscriptionResponse>;
                                                                    (topic: string | Topic, name: string, callback: SubscriptionCallback): void;
                                                                    (
                                                                    topic: string | Topic,
                                                                    name: string,
                                                                    options: CreateSubscriptionOptions,
                                                                    callback: SubscriptionCallback
                                                                    ): void;
                                                                    };

                                                                      method createTopic

                                                                      createTopic: {
                                                                      (name: string, gaxOpts?: any): Promise<CreateTopicResponse>;
                                                                      (name: string, callback: TopicCallback): void;
                                                                      (name: string, gaxOpts: any, callback: TopicCallback): void;
                                                                      };

                                                                        method detachSubscription

                                                                        detachSubscription: {
                                                                        (name: string, gaxOpts?: any): Promise<DetachSubscriptionResponse>;
                                                                        (name: string, callback: NormalCallback<google.protobuf.IEmpty>): void;
                                                                        (
                                                                        name: string,
                                                                        gaxOpts: any,
                                                                        callback: NormalCallback<google.protobuf.IEmpty>
                                                                        ): void;
                                                                        };

                                                                          method determineBaseUrl_

                                                                          determineBaseUrl_: () => void;
                                                                          • Determine the appropriate endpoint to use for API requests, first trying the apiEndpoint parameter. If that isn't set, we try the Pub/Sub emulator environment variable (PUBSUB_EMULATOR_HOST). If that is also null, we try the standard gcloud alpha pubsub environment variable (CLOUDSDK_API_ENDPOINT_OVERRIDES_PUBSUB). Otherwise the default production API is used.

                                                                            Note that if the URL doesn't end in '.googleapis.com', we will assume that it's an emulator and disable strict SSL checks.

                                                                          method getClient_

                                                                          getClient_: (config: GetClientConfig, callback: GetClientCallback) => void;
                                                                          • Get the PubSub client object.

                                                                            Parameter config

                                                                            Configuration object.

                                                                            Parameter

                                                                            {object} config.gaxOpts GAX options.

                                                                            Parameter

                                                                            {function} config.method The gax method to call.

                                                                            Parameter

                                                                            {object} config.reqOpts Request options.

                                                                            Parameter callback

                                                                            The callback function.

                                                                          method getClientAsync_

                                                                          getClientAsync_: (config: GetClientConfig) => Promise<gax.ClientStub>;
                                                                          • Get the PubSub client object.

                                                                            Parameter config

                                                                            Configuration object.

                                                                            Parameter

                                                                            {object} config.gaxOpts GAX options.

                                                                            Parameter

                                                                            {function} config.method The gax method to call.

                                                                            Parameter

                                                                            {object} config.reqOpts Request options.

                                                                            Returns

                                                                            {Promise}

                                                                          method getSnapshots

                                                                          getSnapshots: {
                                                                          (options?: PageOptions): Promise<GetSnapshotsResponse>;
                                                                          (
                                                                          callback: PagedCallback<
                                                                          Snapshot,
                                                                          google.pubsub.v1.IListSnapshotsResponse
                                                                          >
                                                                          ): void;
                                                                          (
                                                                          options: PageOptions,
                                                                          callback: PagedCallback<
                                                                          Snapshot,
                                                                          google.pubsub.v1.IListSnapshotsResponse
                                                                          >
                                                                          ): void;
                                                                          };

                                                                            method getSubscriptions

                                                                            getSubscriptions: {
                                                                            (options?: GetSubscriptionsOptions): Promise<GetSubscriptionsResponse>;
                                                                            (callback: GetSubscriptionsCallback): void;
                                                                            (options: GetSubscriptionsOptions, callback: GetSubscriptionsCallback): void;
                                                                            };

                                                                              method getTopics

                                                                              getTopics: {
                                                                              (options?: PageOptions): Promise<GetTopicsResponse>;
                                                                              (callback: PagedCallback<Topic, google.pubsub.v1.IListTopicsResponse>): void;
                                                                              (
                                                                              options: PageOptions,
                                                                              callback: PagedCallback<Topic, google.pubsub.v1.IListTopicsResponse>
                                                                              ): void;
                                                                              };

                                                                                method request

                                                                                request: <T, R = void>(
                                                                                config: RequestConfig,
                                                                                callback: RequestCallback<T, R>
                                                                                ) => void;
                                                                                • Funnel all API requests through this method, to be sure we have a project ID.

                                                                                  Parameter config

                                                                                  Configuration object.

                                                                                  Parameter

                                                                                  {object} config.gaxOpts GAX options.

                                                                                  Parameter

                                                                                  {function} config.method The gax method to call.

                                                                                  Parameter

                                                                                  {object} config.reqOpts Request options.

                                                                                  Parameter callback

                                                                                  The callback function.

                                                                                method snapshot

                                                                                snapshot: (name: string) => Snapshot;
                                                                                • Create a Snapshot object. See Subscription#createSnapshot to create a snapshot.

                                                                                  Parameter name

                                                                                  The name of the snapshot.

                                                                                  Returns

                                                                                  {Snapshot} A Snapshot instance.

                                                                                  Throws

                                                                                  {Error} If a name is not provided.

                                                                                  Example 1

                                                                                  const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

                                                                                  const snapshot = pubsub.snapshot('my-snapshot');

                                                                                method subscription

                                                                                subscription: (name: string, options?: SubscriptionOptions) => Subscription;
                                                                                • Create a Subscription object. This command by itself will not run any API requests. You will receive a Subscription object, which will allow you to interact with a subscription.

                                                                                  Parameter name

                                                                                  Name of the subscription.

                                                                                  Parameter options

                                                                                  Configuration object.

                                                                                  Returns

                                                                                  {Subscription} A Subscription instance.

                                                                                  Throws

                                                                                  {Error} If subscription name is omitted.

                                                                                  Example 1

                                                                                  const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

                                                                                  const subscription = pubsub.subscription('my-subscription');

                                                                                  // Register a listener for message events. subscription.on('message', function(message) { // Called every time a message is received. // message.id = ID of the message. // message.ackId = ID used to acknowledge the message receival. // message.data = Contents of the message. // message.attributes = Attributes of the message. // message.publishTime = Date when Pub/Sub received the message. });

                                                                                method topic

                                                                                topic: (name: string, options?: PublishOptions) => Topic;
                                                                                • Create a Topic object. See PubSub#createTopic to create a topic.

                                                                                  Parameter name

                                                                                  The name of the topic.

                                                                                  Parameter options

                                                                                  Publisher configuration object.

                                                                                  Returns

                                                                                  {Topic} A Topic instance.

                                                                                  Throws

                                                                                  {Error} If a name is not provided.

                                                                                  Example 1

                                                                                  const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

                                                                                  const topic = pubsub.topic('my-topic');

                                                                                class Snapshot

                                                                                class Snapshot {}
                                                                                • A Snapshot object will give you access to your Cloud Pub/Sub snapshot.

                                                                                  Snapshots are sometimes retrieved when using various methods:

                                                                                  - PubSub#getSnapshots - PubSub#getSnapshotsStream - PubSub#snapshot

                                                                                  Snapshots may be created with:

                                                                                  - Subscription#createSnapshot

                                                                                  You can use snapshots to seek a subscription to a specific point in time.

                                                                                  - Subscription#seek

                                                                                  Example 1

                                                                                  //- // From PubSub#getSnapshots: //- pubsub.getSnapshots((err, snapshots) => { // snapshots is an array of Snapshot objects. });

                                                                                  //- // From PubSub#getSnapshotsStream: //- pubsub.getSnapshotsStream() .on('error', console.error) .on('data', (snapshot) => { // snapshot is a Snapshot object. });

                                                                                  //- // From PubSub#snapshot: //- const snapshot = pubsub.snapshot('my-snapshot'); // snapshot is a Snapshot object.

                                                                                  //- // Create a snapshot with {module:pubsub/subscription#createSnapshot}: //- const subscription = pubsub.subscription('my-subscription');

                                                                                  subscription.createSnapshot('my-snapshot', (err, snapshot) => { if (!err) { // snapshot is a Snapshot object. } });

                                                                                  //- // Seek to your snapshot: //- const subscription = pubsub.subscription('my-subscription');

                                                                                  subscription.seek('my-snapshot', (err) => { if (err) { // Error handling omitted. } });

                                                                                constructor

                                                                                constructor(parent: PubSub | Subscription, name: string);

                                                                                  property metadata

                                                                                  metadata?: google.pubsub.v1.ISnapshot;

                                                                                    property name

                                                                                    name: string;

                                                                                      property parent

                                                                                      parent: PubSub | Subscription;

                                                                                        method create

                                                                                        create: {
                                                                                        (gaxOpts?: any): Promise<CreateSnapshotResponse>;
                                                                                        (callback: CreateSnapshotCallback): void;
                                                                                        (gaxOpts: any, callback: CreateSnapshotCallback): void;
                                                                                        };

                                                                                          method delete

                                                                                          delete: {
                                                                                          (): Promise<EmptyResponse>;
                                                                                          (callback: NormalCallback<google.protobuf.IEmpty>): void;
                                                                                          };

                                                                                            method formatName_

                                                                                            static formatName_: (projectId: string, name: string) => string;

                                                                                              method seek

                                                                                              seek: {
                                                                                              (gaxOpts?: any): Promise<SeekResponse>;
                                                                                              (callback: NormalCallback<google.pubsub.v1.ISeekResponse>): void;
                                                                                              (
                                                                                              gaxOpts: any,
                                                                                              callback: NormalCallback<google.pubsub.v1.ISeekResponse>
                                                                                              ): void;
                                                                                              };

                                                                                                class Subscription

                                                                                                class Subscription extends EventEmitter {}
                                                                                                • A Subscription object will give you access to your Cloud Pub/Sub subscription.

                                                                                                  Subscriptions are sometimes retrieved when using various methods:

                                                                                                  - PubSub#getSubscriptions - Topic#getSubscriptions

                                                                                                  Subscription objects may be created directly with:

                                                                                                  - PubSub#createSubscription - Topic#createSubscription

                                                                                                  All Subscription objects are instances of an [EventEmitter](http://nodejs.org/api/events.html). The subscription will pull for messages automatically as long as there is at least one listener assigned for the message event. Available events:

                                                                                                  Upon receipt of a message: on(event: 'message', listener: (message: Message) => void): this;

                                                                                                  Upon receipt of an error: on(event: 'error', listener: (error: Error) => void): this;

                                                                                                  Upon the closing of the subscriber: on(event: 'close', listener: Function): this;

                                                                                                  By default Subscription objects allow you to process 100 messages at the same time. You can fine tune this value by adjusting the options.flowControl.maxMessages option.

                                                                                                  If your subscription is seeing more re-deliveries than preferable, you might try increasing your options.ackDeadline value or decreasing the options.streamingOptions.maxStreams value.

                                                                                                  Subscription objects handle ack management, by automatically extending the ack deadline while the message is being processed, to then issue the ack or nack of such message when the processing is done. **Note:** message redelivery is still possible.

                                                                                                  By default each PubSub instance can handle 100 open streams, with default options this translates to less than 20 Subscriptions per PubSub instance. If you wish to create more Subscriptions than that, you can either create multiple PubSub instances or lower the options.streamingOptions.maxStreams value on each Subscription object.

                                                                                                  Parameter pubsub

                                                                                                  PubSub object.

                                                                                                  Parameter name

                                                                                                  The name of the subscription.

                                                                                                  Parameter options

                                                                                                  Options for handling messages.

                                                                                                  Example 1

                                                                                                  From PubSub#getSubscriptions const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

                                                                                                  pubsub.getSubscriptions((err, subscriptions) => { // subscriptions is an array of Subscription objects. });

                                                                                                  Example 2

                                                                                                  From Topic#getSubscriptions const topic = pubsub.topic('my-topic'); topic.getSubscriptions((err, subscriptions) => { // subscriptions is an array of Subscription objects. });

                                                                                                  Example 3

                                                                                                  Topic#createSubscription const topic = pubsub.topic('my-topic'); topic.createSubscription('new-subscription', (err, subscription) => { // subscription is a Subscription object. });

                                                                                                  Example 4

                                                                                                  Topic#subscription const topic = pubsub.topic('my-topic'); const subscription = topic.subscription('my-subscription'); // subscription is a Subscription object.

                                                                                                  Example 5

                                                                                                  Once you have obtained a subscription object, you may begin to register listeners. This will automatically trigger pulling for messages. // Register an error handler. subscription.on('error', (err) => {});

                                                                                                  // Register a close handler in case the subscriber closes unexpectedly subscription.on('close', () => {});

                                                                                                  // Register a listener for message events. function onMessage(message) { // Called every time a message is received.

                                                                                                  // message.id = ID of the message. // message.ackId = ID used to acknowledge the message receival. // message.data = Contents of the message. // message.attributes = Attributes of the message. // message.publishTime = Date when Pub/Sub received the message.

                                                                                                  // Ack the message: // message.ack();

                                                                                                  // This doesn't ack the message, but allows more messages to be retrieved // if your limit was hit or if you don't want to ack the message. // message.nack(); } subscription.on('message', onMessage);

                                                                                                  // Remove the listener from receiving message events. subscription.removeListener('message', onMessage);

                                                                                                  Example 6

                                                                                                  To apply a fine level of flow control, consider the following configuration const subscription = topic.subscription('my-sub', { flowControl: { maxMessages: 1, // this tells the client to manage and lock any excess messages allowExcessMessages: false } });

                                                                                                constructor

                                                                                                constructor(pubsub: PubSub, name: string, options?: SubscriptionOptions);

                                                                                                  property iam

                                                                                                  iam: IAM;

                                                                                                    property isOpen

                                                                                                    readonly isOpen: boolean;
                                                                                                    • Indicates if the Subscription is open and receiving messages.

                                                                                                      {boolean}

                                                                                                    property metadata

                                                                                                    metadata?: google.pubsub.v1.ISubscription;

                                                                                                      property name

                                                                                                      name: string;

                                                                                                        property projectId

                                                                                                        readonly projectId: string;
                                                                                                        • {string}

                                                                                                        property pubsub

                                                                                                        pubsub: PubSub;

                                                                                                          property request

                                                                                                          request: <T, R = void>(
                                                                                                          config: RequestConfig,
                                                                                                          callback: RequestCallback<T, R>
                                                                                                          ) => void;

                                                                                                            property topic

                                                                                                            topic?: string | Topic;

                                                                                                              method close

                                                                                                              close: { (): Promise<void>; (callback: SubscriptionCloseCallback): void };

                                                                                                                method create

                                                                                                                create: {
                                                                                                                (options?: CreateSubscriptionOptions): Promise<CreateSubscriptionResponse>;
                                                                                                                (callback: SubscriptionCallback): void;
                                                                                                                (options: CreateSubscriptionOptions, callback: SubscriptionCallback): void;
                                                                                                                };

                                                                                                                  method createSnapshot

                                                                                                                  createSnapshot: {
                                                                                                                  (name: string, gaxOpts?: any): Promise<CreateSnapshotResponse>;
                                                                                                                  (name: string, callback: CreateSnapshotCallback): void;
                                                                                                                  (name: string, gaxOpts: any, callback: CreateSnapshotCallback): void;
                                                                                                                  };

                                                                                                                    method delete

                                                                                                                    delete: {
                                                                                                                    (gaxOpts?: any): Promise<EmptyResponse>;
                                                                                                                    (callback: NormalCallback<google.protobuf.IEmpty>): void;
                                                                                                                    (gaxOpts: any, callback: NormalCallback<google.protobuf.IEmpty>): void;
                                                                                                                    };

                                                                                                                      method detached

                                                                                                                      detached: {
                                                                                                                      (): Promise<DetachedResponse>;
                                                                                                                      (callback: NormalCallback<boolean>): void;
                                                                                                                      };

                                                                                                                        method exists

                                                                                                                        exists: {
                                                                                                                        (): Promise<ExistsResponse>;
                                                                                                                        (callback: NormalCallback<boolean>): void;
                                                                                                                        };

                                                                                                                          method formatMetadata_

                                                                                                                          static formatMetadata_: (
                                                                                                                          metadata: SubscriptionMetadata
                                                                                                                          ) => google.pubsub.v1.ISubscription;

                                                                                                                            method formatName_

                                                                                                                            static formatName_: (projectId: string, name: string) => string;

                                                                                                                              method get

                                                                                                                              get: {
                                                                                                                              (gaxOpts?: GetSubscriptionOptions): Promise<GetSubscriptionResponse>;
                                                                                                                              (callback: SubscriptionCallback): void;
                                                                                                                              (gaxOpts: any, callback: SubscriptionCallback): void;
                                                                                                                              };

                                                                                                                                method getMetadata

                                                                                                                                getMetadata: {
                                                                                                                                (gaxOpts?: any): Promise<GetSubscriptionMetadataResponse>;
                                                                                                                                (callback: NormalCallback<google.pubsub.v1.ISubscription>): void;
                                                                                                                                (
                                                                                                                                gaxOpts: any,
                                                                                                                                callback: NormalCallback<google.pubsub.v1.ISubscription>
                                                                                                                                ): void;
                                                                                                                                };

                                                                                                                                  method modifyPushConfig

                                                                                                                                  modifyPushConfig: {
                                                                                                                                  (config: PushConfig, gaxOpts?: any): Promise<EmptyResponse>;
                                                                                                                                  (
                                                                                                                                  config: google.pubsub.v1.IPushConfig,
                                                                                                                                  callback: NormalCallback<google.protobuf.IEmpty>
                                                                                                                                  ): void;
                                                                                                                                  (
                                                                                                                                  config: google.pubsub.v1.IPushConfig,
                                                                                                                                  gaxOpts: any,
                                                                                                                                  callback: NormalCallback<google.protobuf.IEmpty>
                                                                                                                                  ): void;
                                                                                                                                  };

                                                                                                                                    method open

                                                                                                                                    open: () => void;
                                                                                                                                    • Opens the Subscription to receive messages. In general this method shouldn't need to be called, unless you wish to receive messages after calling Subscription#close. Alternatively one could just assign a new message event listener which will also re-open the Subscription.

                                                                                                                                      Example 1

                                                                                                                                      subscription.on('message', message => message.ack());

                                                                                                                                      // Close the subscription. subscription.close(err => { if (err) { // Error handling omitted. }

                                                                                                                                      The subscription has been closed and messages will no longer be received. });

                                                                                                                                      // Resume receiving messages. subscription.open();

                                                                                                                                    method seek

                                                                                                                                    seek: {
                                                                                                                                    (snapshot: string | Date, gaxOpts?: any): Promise<SeekResponse>;
                                                                                                                                    (
                                                                                                                                    snapshot: string | Date,
                                                                                                                                    callback: NormalCallback<google.pubsub.v1.ISeekResponse>
                                                                                                                                    ): void;
                                                                                                                                    (
                                                                                                                                    snapshot: string | Date,
                                                                                                                                    gaxOpts: any,
                                                                                                                                    callback: NormalCallback<google.pubsub.v1.ISeekResponse>
                                                                                                                                    ): void;
                                                                                                                                    };

                                                                                                                                      method setMetadata

                                                                                                                                      setMetadata: {
                                                                                                                                      (
                                                                                                                                      metadata: SubscriptionMetadata,
                                                                                                                                      gaxOpts?: any
                                                                                                                                      ): Promise<SetSubscriptionMetadataResponse>;
                                                                                                                                      (
                                                                                                                                      metadata: SubscriptionMetadata,
                                                                                                                                      callback: NormalCallback<google.pubsub.v1.ISubscription>
                                                                                                                                      ): void;
                                                                                                                                      (
                                                                                                                                      metadata: SubscriptionMetadata,
                                                                                                                                      gaxOpts: any,
                                                                                                                                      callback: NormalCallback<google.pubsub.v1.ISubscription>
                                                                                                                                      ): void;
                                                                                                                                      };

                                                                                                                                        method setOptions

                                                                                                                                        setOptions: (options: SubscriberOptions) => void;
                                                                                                                                        • Sets the Subscription options.

                                                                                                                                          Parameter options

                                                                                                                                          The options.

                                                                                                                                        method snapshot

                                                                                                                                        snapshot: (name: string) => Snapshot;
                                                                                                                                        • Create a Snapshot object. See Subscription#createSnapshot to create a snapshot.

                                                                                                                                          Parameter name

                                                                                                                                          The name of the snapshot.

                                                                                                                                          Returns

                                                                                                                                          {Snapshot}

                                                                                                                                          Throws

                                                                                                                                          {Error} If a name is not provided.

                                                                                                                                          Example 1

                                                                                                                                          const snapshot = subscription.snapshot('my-snapshot');

                                                                                                                                        class Topic

                                                                                                                                        class Topic {}
                                                                                                                                        • A Topic object allows you to interact with a Cloud Pub/Sub topic.

                                                                                                                                          Parameter pubsub

                                                                                                                                          PubSub object.

                                                                                                                                          Parameter name

                                                                                                                                          Name of the topic.

                                                                                                                                          Parameter options

                                                                                                                                          Publisher configuration object.

                                                                                                                                          Example 1

                                                                                                                                          const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

                                                                                                                                          const topic = pubsub.topic('my-topic');

                                                                                                                                          Example 2

                                                                                                                                          To enable message ordering, set enableMessageOrdering to true. Please note that this does not persist to an actual topic. const topic = pubsub.topic('ordered-topic', {enableMessageOrdering: true});

                                                                                                                                        constructor

                                                                                                                                        constructor(pubsub: PubSub, name: string, options?: PublishOptions);

                                                                                                                                          property getSubscriptionsStream

                                                                                                                                          getSubscriptionsStream: () => ObjectStream<Subscription>;

                                                                                                                                            property iam

                                                                                                                                            iam: IAM;

                                                                                                                                              property metadata

                                                                                                                                              metadata?: google.pubsub.v1.ITopic;

                                                                                                                                                property name

                                                                                                                                                name: string;

                                                                                                                                                  property parent

                                                                                                                                                  parent: PubSub;

                                                                                                                                                    property publisher

                                                                                                                                                    publisher: Publisher;

                                                                                                                                                      property pubsub

                                                                                                                                                      pubsub: PubSub;

                                                                                                                                                        property request

                                                                                                                                                        request: <T, R = void>(
                                                                                                                                                        config: RequestConfig,
                                                                                                                                                        callback: RequestCallback<T, R>
                                                                                                                                                        ) => void;

                                                                                                                                                          method create

                                                                                                                                                          create: {
                                                                                                                                                          (gaxOpts?: any): Promise<CreateTopicResponse>;
                                                                                                                                                          (callback: TopicCallback): void;
                                                                                                                                                          (gaxOpts: any, callback: TopicCallback): void;
                                                                                                                                                          };

                                                                                                                                                            method createSubscription

                                                                                                                                                            createSubscription: {
                                                                                                                                                            (name: string, callback: SubscriptionCallback): void;
                                                                                                                                                            (
                                                                                                                                                            name: string,
                                                                                                                                                            options?: CreateSubscriptionOptions
                                                                                                                                                            ): Promise<SubscriptionResponse>;
                                                                                                                                                            (
                                                                                                                                                            name: string,
                                                                                                                                                            options: CreateSubscriptionOptions,
                                                                                                                                                            callback: SubscriptionCallback
                                                                                                                                                            ): void;
                                                                                                                                                            };

                                                                                                                                                              method delete

                                                                                                                                                              delete: {
                                                                                                                                                              (callback: NormalCallback<google.protobuf.IEmpty>): void;
                                                                                                                                                              (gaxOpts?: any): Promise<EmptyResponse>;
                                                                                                                                                              (gaxOpts: any, callback: NormalCallback<google.protobuf.IEmpty>): void;
                                                                                                                                                              };

                                                                                                                                                                method exists

                                                                                                                                                                exists: {
                                                                                                                                                                (): Promise<ExistsResponse>;
                                                                                                                                                                (callback: NormalCallback<boolean>): void;
                                                                                                                                                                };

                                                                                                                                                                  method flush

                                                                                                                                                                  flush: {
                                                                                                                                                                  (): Promise<void>;
                                                                                                                                                                  (callback: NormalCallback<google.protobuf.IEmpty>): void;
                                                                                                                                                                  };

                                                                                                                                                                    method formatName_

                                                                                                                                                                    static formatName_: (projectId: string, name: string) => string;
                                                                                                                                                                    • Format the name of a topic. A Topic's full name is in the format of 'projects/{projectId}/topics/{topicName}'.

                                                                                                                                                                      {string}

                                                                                                                                                                    method get

                                                                                                                                                                    get: {
                                                                                                                                                                    (callback: TopicCallback): void;
                                                                                                                                                                    (gaxOpts?: any): Promise<TopicResponse>;
                                                                                                                                                                    (gaxOpts: any, callback: TopicCallback): void;
                                                                                                                                                                    };

                                                                                                                                                                      method getMetadata

                                                                                                                                                                      getMetadata: {
                                                                                                                                                                      (callback: NormalCallback<google.pubsub.v1.ITopic>): void;
                                                                                                                                                                      (gaxOpts: any, callback: NormalCallback<google.pubsub.v1.ITopic>): void;
                                                                                                                                                                      (gaxOpts?: any): Promise<MetadataResponse>;
                                                                                                                                                                      };

                                                                                                                                                                        method getPublishOptionDefaults

                                                                                                                                                                        getPublishOptionDefaults: () => PublishOptions;
                                                                                                                                                                        • Get the default publisher options. These may be modified and passed back into Topic#setPublishOptions.

                                                                                                                                                                          Example 1

                                                                                                                                                                          const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

                                                                                                                                                                          const topic = pubsub.topic('my-topic');

                                                                                                                                                                          const defaults = topic.getPublishOptionDefaults(); defaults.batching.maxMilliseconds = 10; topic.setPublishOptions(defaults);

                                                                                                                                                                        method getSubscriptions

                                                                                                                                                                        getSubscriptions: {
                                                                                                                                                                        (
                                                                                                                                                                        callback: PagedCallback<
                                                                                                                                                                        Subscription,
                                                                                                                                                                        google.pubsub.v1.IListTopicSubscriptionsResponse
                                                                                                                                                                        >
                                                                                                                                                                        ): void;
                                                                                                                                                                        (
                                                                                                                                                                        options: PageOptions,
                                                                                                                                                                        callback: PagedCallback<
                                                                                                                                                                        Subscription,
                                                                                                                                                                        google.pubsub.v1.IListTopicSubscriptionsResponse
                                                                                                                                                                        >
                                                                                                                                                                        ): void;
                                                                                                                                                                        (options?: PageOptions): Promise<GetTopicSubscriptionsResponse>;
                                                                                                                                                                        };

                                                                                                                                                                          method publish

                                                                                                                                                                          publish: {
                                                                                                                                                                          (data: any, attributes?: Attributes): Promise<string>;
                                                                                                                                                                          (data: any, callback: NormalCallback<string>): void;
                                                                                                                                                                          (data: any, attributes: Attributes, callback: NormalCallback<string>): void;
                                                                                                                                                                          };

                                                                                                                                                                            method publishJSON

                                                                                                                                                                            publishJSON: {
                                                                                                                                                                            (json: object, attributes?: Attributes): Promise<string>;
                                                                                                                                                                            (json: object, callback: NormalCallback<string>): void;
                                                                                                                                                                            (
                                                                                                                                                                            json: object,
                                                                                                                                                                            attributes: Attributes,
                                                                                                                                                                            callback: NormalCallback<string>
                                                                                                                                                                            ): void;
                                                                                                                                                                            };

                                                                                                                                                                              method publishMessage

                                                                                                                                                                              publishMessage: {
                                                                                                                                                                              (message: MessageOptions): Promise<[string]>;
                                                                                                                                                                              (message: MessageOptions, callback: NormalCallback<string>): void;
                                                                                                                                                                              };

                                                                                                                                                                                method resumePublishing

                                                                                                                                                                                resumePublishing: (orderingKey: string) => void;
                                                                                                                                                                                • In the event that the client fails to publish an ordered message, all subsequent publish calls using the same ordering key will fail. Calling this method will disregard the publish failure, allowing the supplied ordering key to be used again in the future.

                                                                                                                                                                                  Parameter orderingKey

                                                                                                                                                                                  The ordering key in question.

                                                                                                                                                                                  Example 1

                                                                                                                                                                                  const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub(); const topic = pubsub.topic('my-topic', {messageOrdering: true});

                                                                                                                                                                                  const orderingKey = 'foo'; const data = Buffer.from('Hello, order!');

                                                                                                                                                                                  topic.publishMessage({data, orderingKey}, err => { if (err) { topic.resumePublishing(orderingKey); } });

                                                                                                                                                                                method setMetadata

                                                                                                                                                                                setMetadata: {
                                                                                                                                                                                (options: TopicMetadata, gaxOpts?: any): Promise<SetTopicMetadataResponse>;
                                                                                                                                                                                (
                                                                                                                                                                                options: google.pubsub.v1.ITopic,
                                                                                                                                                                                callback: NormalCallback<google.pubsub.v1.ITopic>
                                                                                                                                                                                ): void;
                                                                                                                                                                                (
                                                                                                                                                                                options: google.pubsub.v1.ITopic,
                                                                                                                                                                                gaxOpts: any,
                                                                                                                                                                                callback: NormalCallback<google.pubsub.v1.ITopic>
                                                                                                                                                                                ): void;
                                                                                                                                                                                };

                                                                                                                                                                                  method setPublishOptions

                                                                                                                                                                                  setPublishOptions: (options: PublishOptions) => void;
                                                                                                                                                                                  • Set the publisher options.

                                                                                                                                                                                    Parameter options

                                                                                                                                                                                    The publisher options.

                                                                                                                                                                                    Example 1

                                                                                                                                                                                    const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

                                                                                                                                                                                    const topic = pubsub.topic('my-topic');

                                                                                                                                                                                    topic.setPublishOptions({ batching: { maxMilliseconds: 10 } });

                                                                                                                                                                                  method subscription

                                                                                                                                                                                  subscription: (name: string, options?: SubscriptionOptions) => Subscription;
                                                                                                                                                                                  • Create a Subscription object. This command by itself will not run any API requests. You will receive a {module:pubsub/subscription} object, which will allow you to interact with a subscription.

                                                                                                                                                                                    Parameter name

                                                                                                                                                                                    Name of the subscription.

                                                                                                                                                                                    Parameter options

                                                                                                                                                                                    Configuration object. {Subscription}

                                                                                                                                                                                    Throws

                                                                                                                                                                                    {Error} If subscription name is omitted.

                                                                                                                                                                                    Example 1

                                                                                                                                                                                    const {PubSub} = require('@google-cloud/pubsub'); const pubsub = new PubSub();

                                                                                                                                                                                    const topic = pubsub.topic('my-topic'); const subscription = topic.subscription('my-subscription');

                                                                                                                                                                                    // Register a listener for message events. subscription.on('message', (message) => { // Called every time a message is received. // message.id = ID of the message. // message.ackId = ID used to acknowledge the message receival. // message.data = Contents of the message. // message.attributes = Attributes of the message. // message.publishTime = Timestamp when Pub/Sub received the message. });

                                                                                                                                                                                  Interfaces

                                                                                                                                                                                  interface Attributes

                                                                                                                                                                                  interface Attributes {}

                                                                                                                                                                                    index signature

                                                                                                                                                                                    [key: string]: string;

                                                                                                                                                                                      interface ClientConfig

                                                                                                                                                                                      interface ClientConfig extends gax.GrpcClientOptions {}

                                                                                                                                                                                        property apiEndpoint

                                                                                                                                                                                        apiEndpoint?: string;

                                                                                                                                                                                          property port

                                                                                                                                                                                          port?: string | number;

                                                                                                                                                                                            property servicePath

                                                                                                                                                                                            servicePath?: string;

                                                                                                                                                                                              property sslCreds

                                                                                                                                                                                              sslCreds?: gax.grpc.ChannelCredentials;

                                                                                                                                                                                                interface IamPermissionsMap

                                                                                                                                                                                                interface IamPermissionsMap {}
                                                                                                                                                                                                • Shows which IAM permissions is allowed. The key to this object are the IAM permissions (string) and the values are booleans, true if permissions are granted to the corresponding key.

                                                                                                                                                                                                index signature

                                                                                                                                                                                                [key: string]: boolean;

                                                                                                                                                                                                  interface PageOptions

                                                                                                                                                                                                  interface PageOptions {}

                                                                                                                                                                                                    property autoPaginate

                                                                                                                                                                                                    autoPaginate?: boolean;

                                                                                                                                                                                                      property gaxOpts

                                                                                                                                                                                                      gaxOpts?: CallOptions;

                                                                                                                                                                                                        property pageSize

                                                                                                                                                                                                        pageSize?: number;

                                                                                                                                                                                                          property pageToken

                                                                                                                                                                                                          pageToken?: string;

                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                            type CreateSnapshotCallback

                                                                                                                                                                                                            type CreateSnapshotCallback = ResourceCallback<Snapshot, google.pubsub.v1.ISnapshot>;

                                                                                                                                                                                                              type CreateSnapshotResponse

                                                                                                                                                                                                              type CreateSnapshotResponse = [Snapshot, google.pubsub.v1.ISnapshot];

                                                                                                                                                                                                                type CreateSubscriptionCallback

                                                                                                                                                                                                                type CreateSubscriptionCallback = SubscriptionCallback;

                                                                                                                                                                                                                  type CreateSubscriptionOptions

                                                                                                                                                                                                                  type CreateSubscriptionOptions = SubscriptionMetadata & {
                                                                                                                                                                                                                  gaxOpts?: CallOptions;
                                                                                                                                                                                                                  flowControl?: FlowControlOptions;
                                                                                                                                                                                                                  };

                                                                                                                                                                                                                    type CreateSubscriptionResponse

                                                                                                                                                                                                                    type CreateSubscriptionResponse = SubscriptionResponse;

                                                                                                                                                                                                                      type CreateTopicCallback

                                                                                                                                                                                                                      type CreateTopicCallback = TopicCallback;

                                                                                                                                                                                                                        type CreateTopicResponse

                                                                                                                                                                                                                        type CreateTopicResponse = TopicResponse;

                                                                                                                                                                                                                          type EmptyCallback

                                                                                                                                                                                                                          type EmptyCallback = RequestCallback<google.protobuf.IEmpty>;

                                                                                                                                                                                                                            type EmptyResponse

                                                                                                                                                                                                                            type EmptyResponse = [google.protobuf.IEmpty];

                                                                                                                                                                                                                              type ExistsCallback

                                                                                                                                                                                                                              type ExistsCallback = RequestCallback<boolean>;

                                                                                                                                                                                                                                type ExistsResponse

                                                                                                                                                                                                                                type ExistsResponse = [boolean];

                                                                                                                                                                                                                                  type GetPolicyCallback

                                                                                                                                                                                                                                  type GetPolicyCallback = RequestCallback<Policy>;

                                                                                                                                                                                                                                    type GetPolicyResponse

                                                                                                                                                                                                                                    type GetPolicyResponse = [Policy];

                                                                                                                                                                                                                                      type GetSnapshotsCallback

                                                                                                                                                                                                                                      type GetSnapshotsCallback = RequestCallback<
                                                                                                                                                                                                                                      Snapshot,
                                                                                                                                                                                                                                      google.pubsub.v1.IListSnapshotsResponse
                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                        type GetSnapshotsResponse

                                                                                                                                                                                                                                        type GetSnapshotsResponse = PagedResponse<
                                                                                                                                                                                                                                        Snapshot,
                                                                                                                                                                                                                                        google.pubsub.v1.IListSnapshotsResponse
                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                          type GetSubscriptionCallback

                                                                                                                                                                                                                                          type GetSubscriptionCallback = SubscriptionCallback;

                                                                                                                                                                                                                                            type GetSubscriptionMetadataCallback

                                                                                                                                                                                                                                            type GetSubscriptionMetadataCallback = MetadataCallback;

                                                                                                                                                                                                                                              type GetSubscriptionMetadataResponse

                                                                                                                                                                                                                                              type GetSubscriptionMetadataResponse = MetadataResponse;

                                                                                                                                                                                                                                                type GetSubscriptionOptions

                                                                                                                                                                                                                                                type GetSubscriptionOptions = CallOptions & {
                                                                                                                                                                                                                                                autoCreate?: boolean;
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  type GetSubscriptionResponse

                                                                                                                                                                                                                                                  type GetSubscriptionResponse = SubscriptionResponse;

                                                                                                                                                                                                                                                    type GetSubscriptionsCallback

                                                                                                                                                                                                                                                    type GetSubscriptionsCallback =
                                                                                                                                                                                                                                                    | GetAllSubscriptionsCallback
                                                                                                                                                                                                                                                    | GetTopicSubscriptionsCallback;

                                                                                                                                                                                                                                                      type GetSubscriptionsResponse

                                                                                                                                                                                                                                                      type GetSubscriptionsResponse =
                                                                                                                                                                                                                                                      | GetAllSubscriptionsResponse
                                                                                                                                                                                                                                                      | GetTopicSubscriptionsResponse;

                                                                                                                                                                                                                                                        type GetTopicCallback

                                                                                                                                                                                                                                                        type GetTopicCallback = TopicCallback;

                                                                                                                                                                                                                                                          type GetTopicMetadataCallback

                                                                                                                                                                                                                                                          type GetTopicMetadataCallback = MetadataCallback;

                                                                                                                                                                                                                                                            type GetTopicMetadataResponse

                                                                                                                                                                                                                                                            type GetTopicMetadataResponse = MetadataResponse;

                                                                                                                                                                                                                                                              type GetTopicOptions

                                                                                                                                                                                                                                                              type GetTopicOptions = CallOptions & {
                                                                                                                                                                                                                                                              autoCreate?: boolean;
                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                type GetTopicResponse

                                                                                                                                                                                                                                                                type GetTopicResponse = TopicResponse;

                                                                                                                                                                                                                                                                  type GetTopicsCallback

                                                                                                                                                                                                                                                                  type GetTopicsCallback = RequestCallback<
                                                                                                                                                                                                                                                                  Topic,
                                                                                                                                                                                                                                                                  google.pubsub.v1.IListTopicsResponse
                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                    type GetTopicsResponse

                                                                                                                                                                                                                                                                    type GetTopicsResponse = PagedResponse<Topic, google.pubsub.v1.IListTopicsResponse>;

                                                                                                                                                                                                                                                                      type GetTopicSubscriptionsCallback

                                                                                                                                                                                                                                                                      type GetTopicSubscriptionsCallback = RequestCallback<
                                                                                                                                                                                                                                                                      Subscription,
                                                                                                                                                                                                                                                                      google.pubsub.v1.IListTopicSubscriptionsResponse
                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                        type GetTopicSubscriptionsResponse

                                                                                                                                                                                                                                                                        type GetTopicSubscriptionsResponse = PagedResponse<
                                                                                                                                                                                                                                                                        Subscription,
                                                                                                                                                                                                                                                                        google.pubsub.v1.IListTopicSubscriptionsResponse
                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                          type Policy

                                                                                                                                                                                                                                                                          type Policy = {
                                                                                                                                                                                                                                                                          etag?: string | Buffer;
                                                                                                                                                                                                                                                                          } & Omit<IamProtos.google.iam.v1.IPolicy, 'etag'>;

                                                                                                                                                                                                                                                                            type PublishCallback

                                                                                                                                                                                                                                                                            type PublishCallback = RequestCallback<string>;

                                                                                                                                                                                                                                                                              type PushConfig

                                                                                                                                                                                                                                                                              type PushConfig = google.pubsub.v1.IPushConfig;

                                                                                                                                                                                                                                                                                type SeekCallback

                                                                                                                                                                                                                                                                                type SeekCallback = RequestCallback<google.pubsub.v1.ISeekResponse>;

                                                                                                                                                                                                                                                                                  type SeekResponse

                                                                                                                                                                                                                                                                                  type SeekResponse = [google.pubsub.v1.ISeekResponse];

                                                                                                                                                                                                                                                                                    type SetPolicyCallback

                                                                                                                                                                                                                                                                                    type SetPolicyCallback = RequestCallback<Policy>;

                                                                                                                                                                                                                                                                                      type SetPolicyResponse

                                                                                                                                                                                                                                                                                      type SetPolicyResponse = [Policy];

                                                                                                                                                                                                                                                                                        type SetSubscriptionMetadataCallback

                                                                                                                                                                                                                                                                                        type SetSubscriptionMetadataCallback = MetadataCallback;

                                                                                                                                                                                                                                                                                          type SetSubscriptionMetadataResponse

                                                                                                                                                                                                                                                                                          type SetSubscriptionMetadataResponse = MetadataResponse;

                                                                                                                                                                                                                                                                                            type SetTopicMetadataCallback

                                                                                                                                                                                                                                                                                            type SetTopicMetadataCallback = MetadataCallback;

                                                                                                                                                                                                                                                                                              type SetTopicMetadataResponse

                                                                                                                                                                                                                                                                                              type SetTopicMetadataResponse = MetadataResponse;

                                                                                                                                                                                                                                                                                                type SubscriptionCloseCallback

                                                                                                                                                                                                                                                                                                type SubscriptionCloseCallback = (err?: Error) => void;

                                                                                                                                                                                                                                                                                                  type SubscriptionMetadata

                                                                                                                                                                                                                                                                                                  type SubscriptionMetadata = {
                                                                                                                                                                                                                                                                                                  messageRetentionDuration?: google.protobuf.IDuration | number;
                                                                                                                                                                                                                                                                                                  pushEndpoint?: string;
                                                                                                                                                                                                                                                                                                  oidcToken?: OidcToken;
                                                                                                                                                                                                                                                                                                  } & Omit<google.pubsub.v1.ISubscription, 'messageRetentionDuration'>;

                                                                                                                                                                                                                                                                                                    type SubscriptionOptions

                                                                                                                                                                                                                                                                                                    type SubscriptionOptions = SubscriberOptions & {
                                                                                                                                                                                                                                                                                                    topic?: Topic;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      type TestIamPermissionsCallback

                                                                                                                                                                                                                                                                                                      type TestIamPermissionsCallback = ResourceCallback<
                                                                                                                                                                                                                                                                                                      IamPermissionsMap,
                                                                                                                                                                                                                                                                                                      IamProtos.google.iam.v1.ITestIamPermissionsResponse
                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                        type TestIamPermissionsResponse

                                                                                                                                                                                                                                                                                                        type TestIamPermissionsResponse = [
                                                                                                                                                                                                                                                                                                        IamPermissionsMap,
                                                                                                                                                                                                                                                                                                        IamProtos.google.iam.v1.ITestIamPermissionsResponse
                                                                                                                                                                                                                                                                                                        ];

                                                                                                                                                                                                                                                                                                          type TopicMetadata

                                                                                                                                                                                                                                                                                                          type TopicMetadata = google.pubsub.v1.ITopic;

                                                                                                                                                                                                                                                                                                            Namespaces

                                                                                                                                                                                                                                                                                                            namespace protos

                                                                                                                                                                                                                                                                                                            module 'build/protos/protos.d.ts' {}
                                                                                                                                                                                                                                                                                                            • Namespace google.

                                                                                                                                                                                                                                                                                                            namespace protos.google

                                                                                                                                                                                                                                                                                                            namespace protos.google {}
                                                                                                                                                                                                                                                                                                            • Namespace google.

                                                                                                                                                                                                                                                                                                            namespace protos.google.api

                                                                                                                                                                                                                                                                                                            namespace protos.google.api {}
                                                                                                                                                                                                                                                                                                            • Namespace api.

                                                                                                                                                                                                                                                                                                            class CustomHttpPattern

                                                                                                                                                                                                                                                                                                            class CustomHttpPattern implements ICustomHttpPattern {}
                                                                                                                                                                                                                                                                                                            • Represents a CustomHttpPattern.

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(properties?: ICustomHttpPattern);
                                                                                                                                                                                                                                                                                                            • Constructs a new CustomHttpPattern.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                            kind: string;
                                                                                                                                                                                                                                                                                                            • CustomHttpPattern kind.

                                                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                                                            path: string;
                                                                                                                                                                                                                                                                                                            • CustomHttpPattern path.

                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                            static create: (
                                                                                                                                                                                                                                                                                                            properties?: google.api.ICustomHttpPattern
                                                                                                                                                                                                                                                                                                            ) => google.api.CustomHttpPattern;
                                                                                                                                                                                                                                                                                                            • Creates a new CustomHttpPattern instance using the specified properties.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              CustomHttpPattern instance

                                                                                                                                                                                                                                                                                                            method decode

                                                                                                                                                                                                                                                                                                            static decode: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                            length?: number
                                                                                                                                                                                                                                                                                                            ) => google.api.CustomHttpPattern;
                                                                                                                                                                                                                                                                                                            • Decodes a CustomHttpPattern message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Parameter length

                                                                                                                                                                                                                                                                                                              Message length if known beforehand

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              CustomHttpPattern

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method decodeDelimited

                                                                                                                                                                                                                                                                                                            static decodeDelimited: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                            ) => google.api.CustomHttpPattern;
                                                                                                                                                                                                                                                                                                            • Decodes a CustomHttpPattern message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              CustomHttpPattern

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method encode

                                                                                                                                                                                                                                                                                                            static encode: (message: google.api.ICustomHttpPattern, writer?: any) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified CustomHttpPattern message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              CustomHttpPattern message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method encodeDelimited

                                                                                                                                                                                                                                                                                                            static encodeDelimited: (
                                                                                                                                                                                                                                                                                                            message: google.api.ICustomHttpPattern,
                                                                                                                                                                                                                                                                                                            writer?: any
                                                                                                                                                                                                                                                                                                            ) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified CustomHttpPattern message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              CustomHttpPattern message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method fromObject

                                                                                                                                                                                                                                                                                                            static fromObject: (object: {
                                                                                                                                                                                                                                                                                                            [k: string]: any;
                                                                                                                                                                                                                                                                                                            }) => google.api.CustomHttpPattern;
                                                                                                                                                                                                                                                                                                            • Creates a CustomHttpPattern message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                              Parameter object

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              CustomHttpPattern

                                                                                                                                                                                                                                                                                                            method toJSON

                                                                                                                                                                                                                                                                                                            toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Converts this CustomHttpPattern to JSON.

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              JSON object

                                                                                                                                                                                                                                                                                                            method toObject

                                                                                                                                                                                                                                                                                                            static toObject: (
                                                                                                                                                                                                                                                                                                            message: google.api.CustomHttpPattern,
                                                                                                                                                                                                                                                                                                            options?: any
                                                                                                                                                                                                                                                                                                            ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Creates a plain object from a CustomHttpPattern message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              CustomHttpPattern

                                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                                              Conversion options

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                            method verify

                                                                                                                                                                                                                                                                                                            static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                            • Verifies a CustomHttpPattern message.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              Plain object to verify

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                            class Http

                                                                                                                                                                                                                                                                                                            class Http implements IHttp {}
                                                                                                                                                                                                                                                                                                            • Represents a Http.

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(properties?: IHttp);
                                                                                                                                                                                                                                                                                                            • Constructs a new Http.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                            property fullyDecodeReservedExpansion

                                                                                                                                                                                                                                                                                                            fullyDecodeReservedExpansion: boolean;
                                                                                                                                                                                                                                                                                                            • Http fullyDecodeReservedExpansion.

                                                                                                                                                                                                                                                                                                            property rules

                                                                                                                                                                                                                                                                                                            rules: IHttpRule[];
                                                                                                                                                                                                                                                                                                            • Http rules.

                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                            static create: (properties?: google.api.IHttp) => google.api.Http;
                                                                                                                                                                                                                                                                                                            • Creates a new Http instance using the specified properties.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Http instance

                                                                                                                                                                                                                                                                                                            method decode

                                                                                                                                                                                                                                                                                                            static decode: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                            length?: number
                                                                                                                                                                                                                                                                                                            ) => google.api.Http;
                                                                                                                                                                                                                                                                                                            • Decodes a Http message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Parameter length

                                                                                                                                                                                                                                                                                                              Message length if known beforehand

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Http

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method decodeDelimited

                                                                                                                                                                                                                                                                                                            static decodeDelimited: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                            ) => google.api.Http;
                                                                                                                                                                                                                                                                                                            • Decodes a Http message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Http

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method encode

                                                                                                                                                                                                                                                                                                            static encode: (message: google.api.IHttp, writer?: any) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified Http message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              Http message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method encodeDelimited

                                                                                                                                                                                                                                                                                                            static encodeDelimited: (message: google.api.IHttp, writer?: any) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified Http message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              Http message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method fromObject

                                                                                                                                                                                                                                                                                                            static fromObject: (object: { [k: string]: any }) => google.api.Http;
                                                                                                                                                                                                                                                                                                            • Creates a Http message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                              Parameter object

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Http

                                                                                                                                                                                                                                                                                                            method toJSON

                                                                                                                                                                                                                                                                                                            toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Converts this Http to JSON.

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              JSON object

                                                                                                                                                                                                                                                                                                            method toObject

                                                                                                                                                                                                                                                                                                            static toObject: (
                                                                                                                                                                                                                                                                                                            message: google.api.Http,
                                                                                                                                                                                                                                                                                                            options?: any
                                                                                                                                                                                                                                                                                                            ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Creates a plain object from a Http message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              Http

                                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                                              Conversion options

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                            method verify

                                                                                                                                                                                                                                                                                                            static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                            • Verifies a Http message.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              Plain object to verify

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                            class HttpRule

                                                                                                                                                                                                                                                                                                            class HttpRule implements IHttpRule {}
                                                                                                                                                                                                                                                                                                            • Represents a HttpRule.

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(properties?: IHttpRule);
                                                                                                                                                                                                                                                                                                            • Constructs a new HttpRule.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                            property additionalBindings

                                                                                                                                                                                                                                                                                                            additionalBindings: IHttpRule[];
                                                                                                                                                                                                                                                                                                            • HttpRule additionalBindings.

                                                                                                                                                                                                                                                                                                            property body

                                                                                                                                                                                                                                                                                                            body: string;
                                                                                                                                                                                                                                                                                                            • HttpRule body.

                                                                                                                                                                                                                                                                                                            property custom

                                                                                                                                                                                                                                                                                                            custom?: ICustomHttpPattern;
                                                                                                                                                                                                                                                                                                            • HttpRule custom.

                                                                                                                                                                                                                                                                                                            property delete

                                                                                                                                                                                                                                                                                                            delete?: string;
                                                                                                                                                                                                                                                                                                            • HttpRule delete.

                                                                                                                                                                                                                                                                                                            property get

                                                                                                                                                                                                                                                                                                            get?: string;
                                                                                                                                                                                                                                                                                                            • HttpRule get.

                                                                                                                                                                                                                                                                                                            property patch

                                                                                                                                                                                                                                                                                                            patch?: string;
                                                                                                                                                                                                                                                                                                            • HttpRule patch.

                                                                                                                                                                                                                                                                                                            property pattern

                                                                                                                                                                                                                                                                                                            pattern?: 'get' | 'put' | 'post' | 'delete' | 'patch' | 'custom';
                                                                                                                                                                                                                                                                                                            • HttpRule pattern.

                                                                                                                                                                                                                                                                                                            property post

                                                                                                                                                                                                                                                                                                            post?: string;
                                                                                                                                                                                                                                                                                                            • HttpRule post.

                                                                                                                                                                                                                                                                                                            property put

                                                                                                                                                                                                                                                                                                            put?: string;
                                                                                                                                                                                                                                                                                                            • HttpRule put.

                                                                                                                                                                                                                                                                                                            property responseBody

                                                                                                                                                                                                                                                                                                            responseBody: string;
                                                                                                                                                                                                                                                                                                            • HttpRule responseBody.

                                                                                                                                                                                                                                                                                                            property selector

                                                                                                                                                                                                                                                                                                            selector: string;
                                                                                                                                                                                                                                                                                                            • HttpRule selector.

                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                            static create: (properties?: google.api.IHttpRule) => google.api.HttpRule;
                                                                                                                                                                                                                                                                                                            • Creates a new HttpRule instance using the specified properties.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              HttpRule instance

                                                                                                                                                                                                                                                                                                            method decode

                                                                                                                                                                                                                                                                                                            static decode: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                            length?: number
                                                                                                                                                                                                                                                                                                            ) => google.api.HttpRule;
                                                                                                                                                                                                                                                                                                            • Decodes a HttpRule message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Parameter length

                                                                                                                                                                                                                                                                                                              Message length if known beforehand

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              HttpRule

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method decodeDelimited

                                                                                                                                                                                                                                                                                                            static decodeDelimited: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                            ) => google.api.HttpRule;
                                                                                                                                                                                                                                                                                                            • Decodes a HttpRule message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              HttpRule

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method encode

                                                                                                                                                                                                                                                                                                            static encode: (message: google.api.IHttpRule, writer?: any) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified HttpRule message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              HttpRule message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method encodeDelimited

                                                                                                                                                                                                                                                                                                            static encodeDelimited: (message: google.api.IHttpRule, writer?: any) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified HttpRule message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              HttpRule message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method fromObject

                                                                                                                                                                                                                                                                                                            static fromObject: (object: { [k: string]: any }) => google.api.HttpRule;
                                                                                                                                                                                                                                                                                                            • Creates a HttpRule message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                              Parameter object

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              HttpRule

                                                                                                                                                                                                                                                                                                            method toJSON

                                                                                                                                                                                                                                                                                                            toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Converts this HttpRule to JSON.

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              JSON object

                                                                                                                                                                                                                                                                                                            method toObject

                                                                                                                                                                                                                                                                                                            static toObject: (
                                                                                                                                                                                                                                                                                                            message: google.api.HttpRule,
                                                                                                                                                                                                                                                                                                            options?: any
                                                                                                                                                                                                                                                                                                            ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Creates a plain object from a HttpRule message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              HttpRule

                                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                                              Conversion options

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                            method verify

                                                                                                                                                                                                                                                                                                            static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                            • Verifies a HttpRule message.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              Plain object to verify

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                            class ResourceDescriptor

                                                                                                                                                                                                                                                                                                            class ResourceDescriptor implements IResourceDescriptor {}
                                                                                                                                                                                                                                                                                                            • Represents a ResourceDescriptor.

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(properties?: IResourceDescriptor);
                                                                                                                                                                                                                                                                                                            • Constructs a new ResourceDescriptor.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                            property history

                                                                                                                                                                                                                                                                                                            history:
                                                                                                                                                                                                                                                                                                            | ResourceDescriptor.History
                                                                                                                                                                                                                                                                                                            | 'HISTORY_UNSPECIFIED'
                                                                                                                                                                                                                                                                                                            | 'ORIGINALLY_SINGLE_PATTERN'
                                                                                                                                                                                                                                                                                                            | 'FUTURE_MULTI_PATTERN';
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor history.

                                                                                                                                                                                                                                                                                                            property nameField

                                                                                                                                                                                                                                                                                                            nameField: string;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor nameField.

                                                                                                                                                                                                                                                                                                            property pattern

                                                                                                                                                                                                                                                                                                            pattern: string[];
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor pattern.

                                                                                                                                                                                                                                                                                                            property plural

                                                                                                                                                                                                                                                                                                            plural: string;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor plural.

                                                                                                                                                                                                                                                                                                            property singular

                                                                                                                                                                                                                                                                                                            singular: string;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor singular.

                                                                                                                                                                                                                                                                                                            property style

                                                                                                                                                                                                                                                                                                            style: ResourceDescriptor.Style[];
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor style.

                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                            type: string;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor type.

                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                            static create: (
                                                                                                                                                                                                                                                                                                            properties?: google.api.IResourceDescriptor
                                                                                                                                                                                                                                                                                                            ) => google.api.ResourceDescriptor;
                                                                                                                                                                                                                                                                                                            • Creates a new ResourceDescriptor instance using the specified properties.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              ResourceDescriptor instance

                                                                                                                                                                                                                                                                                                            method decode

                                                                                                                                                                                                                                                                                                            static decode: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                            length?: number
                                                                                                                                                                                                                                                                                                            ) => google.api.ResourceDescriptor;
                                                                                                                                                                                                                                                                                                            • Decodes a ResourceDescriptor message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Parameter length

                                                                                                                                                                                                                                                                                                              Message length if known beforehand

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              ResourceDescriptor

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method decodeDelimited

                                                                                                                                                                                                                                                                                                            static decodeDelimited: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                            ) => google.api.ResourceDescriptor;
                                                                                                                                                                                                                                                                                                            • Decodes a ResourceDescriptor message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              ResourceDescriptor

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method encode

                                                                                                                                                                                                                                                                                                            static encode: (message: google.api.IResourceDescriptor, writer?: any) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified ResourceDescriptor message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              ResourceDescriptor message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method encodeDelimited

                                                                                                                                                                                                                                                                                                            static encodeDelimited: (
                                                                                                                                                                                                                                                                                                            message: google.api.IResourceDescriptor,
                                                                                                                                                                                                                                                                                                            writer?: any
                                                                                                                                                                                                                                                                                                            ) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified ResourceDescriptor message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              ResourceDescriptor message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method fromObject

                                                                                                                                                                                                                                                                                                            static fromObject: (object: {
                                                                                                                                                                                                                                                                                                            [k: string]: any;
                                                                                                                                                                                                                                                                                                            }) => google.api.ResourceDescriptor;
                                                                                                                                                                                                                                                                                                            • Creates a ResourceDescriptor message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                              Parameter object

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              ResourceDescriptor

                                                                                                                                                                                                                                                                                                            method toJSON

                                                                                                                                                                                                                                                                                                            toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Converts this ResourceDescriptor to JSON.

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              JSON object

                                                                                                                                                                                                                                                                                                            method toObject

                                                                                                                                                                                                                                                                                                            static toObject: (
                                                                                                                                                                                                                                                                                                            message: google.api.ResourceDescriptor,
                                                                                                                                                                                                                                                                                                            options?: any
                                                                                                                                                                                                                                                                                                            ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Creates a plain object from a ResourceDescriptor message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              ResourceDescriptor

                                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                                              Conversion options

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                            method verify

                                                                                                                                                                                                                                                                                                            static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                            • Verifies a ResourceDescriptor message.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              Plain object to verify

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                            class ResourceReference

                                                                                                                                                                                                                                                                                                            class ResourceReference implements IResourceReference {}
                                                                                                                                                                                                                                                                                                            • Represents a ResourceReference.

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(properties?: IResourceReference);
                                                                                                                                                                                                                                                                                                            • Constructs a new ResourceReference.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                            property childType

                                                                                                                                                                                                                                                                                                            childType: string;
                                                                                                                                                                                                                                                                                                            • ResourceReference childType.

                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                            type: string;
                                                                                                                                                                                                                                                                                                            • ResourceReference type.

                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                            static create: (
                                                                                                                                                                                                                                                                                                            properties?: google.api.IResourceReference
                                                                                                                                                                                                                                                                                                            ) => google.api.ResourceReference;
                                                                                                                                                                                                                                                                                                            • Creates a new ResourceReference instance using the specified properties.

                                                                                                                                                                                                                                                                                                              Parameter properties

                                                                                                                                                                                                                                                                                                              Properties to set

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              ResourceReference instance

                                                                                                                                                                                                                                                                                                            method decode

                                                                                                                                                                                                                                                                                                            static decode: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                            length?: number
                                                                                                                                                                                                                                                                                                            ) => google.api.ResourceReference;
                                                                                                                                                                                                                                                                                                            • Decodes a ResourceReference message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Parameter length

                                                                                                                                                                                                                                                                                                              Message length if known beforehand

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              ResourceReference

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method decodeDelimited

                                                                                                                                                                                                                                                                                                            static decodeDelimited: (
                                                                                                                                                                                                                                                                                                            reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                            ) => google.api.ResourceReference;
                                                                                                                                                                                                                                                                                                            • Decodes a ResourceReference message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                              Parameter reader

                                                                                                                                                                                                                                                                                                              Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              ResourceReference

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                              {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                            method encode

                                                                                                                                                                                                                                                                                                            static encode: (message: google.api.IResourceReference, writer?: any) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified ResourceReference message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              ResourceReference message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method encodeDelimited

                                                                                                                                                                                                                                                                                                            static encodeDelimited: (
                                                                                                                                                                                                                                                                                                            message: google.api.IResourceReference,
                                                                                                                                                                                                                                                                                                            writer?: any
                                                                                                                                                                                                                                                                                                            ) => any;
                                                                                                                                                                                                                                                                                                            • Encodes the specified ResourceReference message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              ResourceReference message or plain object to encode

                                                                                                                                                                                                                                                                                                              Parameter writer

                                                                                                                                                                                                                                                                                                              Writer to encode to

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Writer

                                                                                                                                                                                                                                                                                                            method fromObject

                                                                                                                                                                                                                                                                                                            static fromObject: (object: {
                                                                                                                                                                                                                                                                                                            [k: string]: any;
                                                                                                                                                                                                                                                                                                            }) => google.api.ResourceReference;
                                                                                                                                                                                                                                                                                                            • Creates a ResourceReference message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                              Parameter object

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              ResourceReference

                                                                                                                                                                                                                                                                                                            method toJSON

                                                                                                                                                                                                                                                                                                            toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Converts this ResourceReference to JSON.

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              JSON object

                                                                                                                                                                                                                                                                                                            method toObject

                                                                                                                                                                                                                                                                                                            static toObject: (
                                                                                                                                                                                                                                                                                                            message: google.api.ResourceReference,
                                                                                                                                                                                                                                                                                                            options?: any
                                                                                                                                                                                                                                                                                                            ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                            • Creates a plain object from a ResourceReference message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              ResourceReference

                                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                                              Conversion options

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              Plain object

                                                                                                                                                                                                                                                                                                            method verify

                                                                                                                                                                                                                                                                                                            static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                            • Verifies a ResourceReference message.

                                                                                                                                                                                                                                                                                                              Parameter message

                                                                                                                                                                                                                                                                                                              Plain object to verify

                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                              null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                            interface ICustomHttpPattern

                                                                                                                                                                                                                                                                                                            interface ICustomHttpPattern {}
                                                                                                                                                                                                                                                                                                            • Properties of a CustomHttpPattern.

                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                            kind?: string | null;
                                                                                                                                                                                                                                                                                                            • CustomHttpPattern kind

                                                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                                                            path?: string | null;
                                                                                                                                                                                                                                                                                                            • CustomHttpPattern path

                                                                                                                                                                                                                                                                                                            interface IHttp

                                                                                                                                                                                                                                                                                                            interface IHttp {}
                                                                                                                                                                                                                                                                                                            • Properties of a Http.

                                                                                                                                                                                                                                                                                                            property fullyDecodeReservedExpansion

                                                                                                                                                                                                                                                                                                            fullyDecodeReservedExpansion?: boolean | null;
                                                                                                                                                                                                                                                                                                            • Http fullyDecodeReservedExpansion

                                                                                                                                                                                                                                                                                                            property rules

                                                                                                                                                                                                                                                                                                            rules?: google.api.IHttpRule[] | null;
                                                                                                                                                                                                                                                                                                            • Http rules

                                                                                                                                                                                                                                                                                                            interface IHttpRule

                                                                                                                                                                                                                                                                                                            interface IHttpRule {}
                                                                                                                                                                                                                                                                                                            • Properties of a HttpRule.

                                                                                                                                                                                                                                                                                                            property "delete"

                                                                                                                                                                                                                                                                                                            delete?: string | null;
                                                                                                                                                                                                                                                                                                            • HttpRule delete

                                                                                                                                                                                                                                                                                                            property additionalBindings

                                                                                                                                                                                                                                                                                                            additionalBindings?: google.api.IHttpRule[] | null;
                                                                                                                                                                                                                                                                                                            • HttpRule additionalBindings

                                                                                                                                                                                                                                                                                                            property body

                                                                                                                                                                                                                                                                                                            body?: string | null;
                                                                                                                                                                                                                                                                                                            • HttpRule body

                                                                                                                                                                                                                                                                                                            property custom

                                                                                                                                                                                                                                                                                                            custom?: google.api.ICustomHttpPattern | null;
                                                                                                                                                                                                                                                                                                            • HttpRule custom

                                                                                                                                                                                                                                                                                                            property get

                                                                                                                                                                                                                                                                                                            get?: string | null;
                                                                                                                                                                                                                                                                                                            • HttpRule get

                                                                                                                                                                                                                                                                                                            property patch

                                                                                                                                                                                                                                                                                                            patch?: string | null;
                                                                                                                                                                                                                                                                                                            • HttpRule patch

                                                                                                                                                                                                                                                                                                            property post

                                                                                                                                                                                                                                                                                                            post?: string | null;
                                                                                                                                                                                                                                                                                                            • HttpRule post

                                                                                                                                                                                                                                                                                                            property put

                                                                                                                                                                                                                                                                                                            put?: string | null;
                                                                                                                                                                                                                                                                                                            • HttpRule put

                                                                                                                                                                                                                                                                                                            property responseBody

                                                                                                                                                                                                                                                                                                            responseBody?: string | null;
                                                                                                                                                                                                                                                                                                            • HttpRule responseBody

                                                                                                                                                                                                                                                                                                            property selector

                                                                                                                                                                                                                                                                                                            selector?: string | null;
                                                                                                                                                                                                                                                                                                            • HttpRule selector

                                                                                                                                                                                                                                                                                                            interface IResourceDescriptor

                                                                                                                                                                                                                                                                                                            interface IResourceDescriptor {}
                                                                                                                                                                                                                                                                                                            • Properties of a ResourceDescriptor.

                                                                                                                                                                                                                                                                                                            property history

                                                                                                                                                                                                                                                                                                            history?:
                                                                                                                                                                                                                                                                                                            | google.api.ResourceDescriptor.History
                                                                                                                                                                                                                                                                                                            | keyof typeof google.api.ResourceDescriptor.History
                                                                                                                                                                                                                                                                                                            | null;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor history

                                                                                                                                                                                                                                                                                                            property nameField

                                                                                                                                                                                                                                                                                                            nameField?: string | null;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor nameField

                                                                                                                                                                                                                                                                                                            property pattern

                                                                                                                                                                                                                                                                                                            pattern?: string[] | null;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor pattern

                                                                                                                                                                                                                                                                                                            property plural

                                                                                                                                                                                                                                                                                                            plural?: string | null;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor plural

                                                                                                                                                                                                                                                                                                            property singular

                                                                                                                                                                                                                                                                                                            singular?: string | null;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor singular

                                                                                                                                                                                                                                                                                                            property style

                                                                                                                                                                                                                                                                                                            style?: google.api.ResourceDescriptor.Style[] | null;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor style

                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                            type?: string | null;
                                                                                                                                                                                                                                                                                                            • ResourceDescriptor type

                                                                                                                                                                                                                                                                                                            interface IResourceReference

                                                                                                                                                                                                                                                                                                            interface IResourceReference {}
                                                                                                                                                                                                                                                                                                            • Properties of a ResourceReference.

                                                                                                                                                                                                                                                                                                            property childType

                                                                                                                                                                                                                                                                                                            childType?: string | null;
                                                                                                                                                                                                                                                                                                            • ResourceReference childType

                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                            type?: string | null;
                                                                                                                                                                                                                                                                                                            • ResourceReference type

                                                                                                                                                                                                                                                                                                            enum FieldBehavior

                                                                                                                                                                                                                                                                                                            enum FieldBehavior {
                                                                                                                                                                                                                                                                                                            FIELD_BEHAVIOR_UNSPECIFIED = 0,
                                                                                                                                                                                                                                                                                                            OPTIONAL = 1,
                                                                                                                                                                                                                                                                                                            REQUIRED = 2,
                                                                                                                                                                                                                                                                                                            OUTPUT_ONLY = 3,
                                                                                                                                                                                                                                                                                                            INPUT_ONLY = 4,
                                                                                                                                                                                                                                                                                                            IMMUTABLE = 5,
                                                                                                                                                                                                                                                                                                            UNORDERED_LIST = 6,
                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                            • FieldBehavior enum.

                                                                                                                                                                                                                                                                                                            member FIELD_BEHAVIOR_UNSPECIFIED

                                                                                                                                                                                                                                                                                                            FIELD_BEHAVIOR_UNSPECIFIED = 0

                                                                                                                                                                                                                                                                                                              member IMMUTABLE

                                                                                                                                                                                                                                                                                                              IMMUTABLE = 5

                                                                                                                                                                                                                                                                                                                member INPUT_ONLY

                                                                                                                                                                                                                                                                                                                INPUT_ONLY = 4

                                                                                                                                                                                                                                                                                                                  member OPTIONAL

                                                                                                                                                                                                                                                                                                                  OPTIONAL = 1

                                                                                                                                                                                                                                                                                                                    member OUTPUT_ONLY

                                                                                                                                                                                                                                                                                                                    OUTPUT_ONLY = 3

                                                                                                                                                                                                                                                                                                                      member REQUIRED

                                                                                                                                                                                                                                                                                                                      REQUIRED = 2

                                                                                                                                                                                                                                                                                                                        member UNORDERED_LIST

                                                                                                                                                                                                                                                                                                                        UNORDERED_LIST = 6

                                                                                                                                                                                                                                                                                                                          namespace protos.google.api.ResourceDescriptor

                                                                                                                                                                                                                                                                                                                          namespace protos.google.api.ResourceDescriptor {}

                                                                                                                                                                                                                                                                                                                            enum History

                                                                                                                                                                                                                                                                                                                            enum History {
                                                                                                                                                                                                                                                                                                                            HISTORY_UNSPECIFIED = 0,
                                                                                                                                                                                                                                                                                                                            ORIGINALLY_SINGLE_PATTERN = 1,
                                                                                                                                                                                                                                                                                                                            FUTURE_MULTI_PATTERN = 2,
                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                            • History enum.

                                                                                                                                                                                                                                                                                                                            member FUTURE_MULTI_PATTERN

                                                                                                                                                                                                                                                                                                                            FUTURE_MULTI_PATTERN = 2

                                                                                                                                                                                                                                                                                                                              member HISTORY_UNSPECIFIED

                                                                                                                                                                                                                                                                                                                              HISTORY_UNSPECIFIED = 0

                                                                                                                                                                                                                                                                                                                                member ORIGINALLY_SINGLE_PATTERN

                                                                                                                                                                                                                                                                                                                                ORIGINALLY_SINGLE_PATTERN = 1

                                                                                                                                                                                                                                                                                                                                  enum Style

                                                                                                                                                                                                                                                                                                                                  enum Style {
                                                                                                                                                                                                                                                                                                                                  STYLE_UNSPECIFIED = 0,
                                                                                                                                                                                                                                                                                                                                  DECLARATIVE_FRIENDLY = 1,
                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                  • Style enum.

                                                                                                                                                                                                                                                                                                                                  member DECLARATIVE_FRIENDLY

                                                                                                                                                                                                                                                                                                                                  DECLARATIVE_FRIENDLY = 1

                                                                                                                                                                                                                                                                                                                                    member STYLE_UNSPECIFIED

                                                                                                                                                                                                                                                                                                                                    STYLE_UNSPECIFIED = 0

                                                                                                                                                                                                                                                                                                                                      namespace protos.google.protobuf

                                                                                                                                                                                                                                                                                                                                      namespace protos.google.protobuf {}
                                                                                                                                                                                                                                                                                                                                      • Namespace protobuf.

                                                                                                                                                                                                                                                                                                                                      class DescriptorProto

                                                                                                                                                                                                                                                                                                                                      class DescriptorProto implements IDescriptorProto {}
                                                                                                                                                                                                                                                                                                                                      • Represents a DescriptorProto.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IDescriptorProto);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new DescriptorProto.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      property enumType

                                                                                                                                                                                                                                                                                                                                      enumType: IEnumDescriptorProto[];
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto enumType.

                                                                                                                                                                                                                                                                                                                                      property extension

                                                                                                                                                                                                                                                                                                                                      extension: IFieldDescriptorProto[];
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto extension.

                                                                                                                                                                                                                                                                                                                                      property extensionRange

                                                                                                                                                                                                                                                                                                                                      extensionRange: DescriptorProto.IExtensionRange[];
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto extensionRange.

                                                                                                                                                                                                                                                                                                                                      property field

                                                                                                                                                                                                                                                                                                                                      field: IFieldDescriptorProto[];
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto field.

                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto name.

                                                                                                                                                                                                                                                                                                                                      property nestedType

                                                                                                                                                                                                                                                                                                                                      nestedType: IDescriptorProto[];
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto nestedType.

                                                                                                                                                                                                                                                                                                                                      property oneofDecl

                                                                                                                                                                                                                                                                                                                                      oneofDecl: IOneofDescriptorProto[];
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto oneofDecl.

                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                      options?: IMessageOptions;
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto options.

                                                                                                                                                                                                                                                                                                                                      property reservedName

                                                                                                                                                                                                                                                                                                                                      reservedName: string[];
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto reservedName.

                                                                                                                                                                                                                                                                                                                                      property reservedRange

                                                                                                                                                                                                                                                                                                                                      reservedRange: DescriptorProto.IReservedRange[];
                                                                                                                                                                                                                                                                                                                                      • DescriptorProto reservedRange.

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (
                                                                                                                                                                                                                                                                                                                                      properties?: google.protobuf.IDescriptorProto
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.DescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Creates a new DescriptorProto instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        DescriptorProto instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.DescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Decodes a DescriptorProto message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        DescriptorProto

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.DescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Decodes a DescriptorProto message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        DescriptorProto

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (message: google.protobuf.IDescriptorProto, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified DescriptorProto message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        DescriptorProto message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified DescriptorProto message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        DescriptorProto message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: {
                                                                                                                                                                                                                                                                                                                                      [k: string]: any;
                                                                                                                                                                                                                                                                                                                                      }) => google.protobuf.DescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Creates a DescriptorProto message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        DescriptorProto

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this DescriptorProto to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.DescriptorProto,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from a DescriptorProto message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        DescriptorProto

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Conversion options

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                      method verify

                                                                                                                                                                                                                                                                                                                                      static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                      • Verifies a DescriptorProto message.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Plain object to verify

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                      class Duration

                                                                                                                                                                                                                                                                                                                                      class Duration implements IDuration {}
                                                                                                                                                                                                                                                                                                                                      • Represents a Duration.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IDuration);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new Duration.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      property nanos

                                                                                                                                                                                                                                                                                                                                      nanos: number;
                                                                                                                                                                                                                                                                                                                                      • Duration nanos.

                                                                                                                                                                                                                                                                                                                                      property seconds

                                                                                                                                                                                                                                                                                                                                      seconds: any;
                                                                                                                                                                                                                                                                                                                                      • Duration seconds.

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (
                                                                                                                                                                                                                                                                                                                                      properties?: google.protobuf.IDuration
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.Duration;
                                                                                                                                                                                                                                                                                                                                      • Creates a new Duration instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Duration instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.Duration;
                                                                                                                                                                                                                                                                                                                                      • Decodes a Duration message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Duration

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.Duration;
                                                                                                                                                                                                                                                                                                                                      • Decodes a Duration message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Duration

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (message: google.protobuf.IDuration, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified Duration message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Duration message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IDuration,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified Duration message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Duration message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: { [k: string]: any }) => google.protobuf.Duration;
                                                                                                                                                                                                                                                                                                                                      • Creates a Duration message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Duration

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this Duration to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.Duration,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from a Duration message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Duration

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Conversion options

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                      method verify

                                                                                                                                                                                                                                                                                                                                      static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                      • Verifies a Duration message.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Plain object to verify

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                      class Empty

                                                                                                                                                                                                                                                                                                                                      class Empty implements IEmpty {}
                                                                                                                                                                                                                                                                                                                                      • Represents an Empty.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IEmpty);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new Empty.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (properties?: google.protobuf.IEmpty) => google.protobuf.Empty;
                                                                                                                                                                                                                                                                                                                                      • Creates a new Empty instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Empty instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.Empty;
                                                                                                                                                                                                                                                                                                                                      • Decodes an Empty message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Empty

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.Empty;
                                                                                                                                                                                                                                                                                                                                      • Decodes an Empty message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Empty

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (message: google.protobuf.IEmpty, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified Empty message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Empty message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (message: google.protobuf.IEmpty, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified Empty message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Empty message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: { [k: string]: any }) => google.protobuf.Empty;
                                                                                                                                                                                                                                                                                                                                      • Creates an Empty message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Empty

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this Empty to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.Empty,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from an Empty message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Empty

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Conversion options

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                      method verify

                                                                                                                                                                                                                                                                                                                                      static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                      • Verifies an Empty message.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Plain object to verify

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                      class EnumDescriptorProto

                                                                                                                                                                                                                                                                                                                                      class EnumDescriptorProto implements IEnumDescriptorProto {}
                                                                                                                                                                                                                                                                                                                                      • Represents an EnumDescriptorProto.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IEnumDescriptorProto);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new EnumDescriptorProto.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                      • EnumDescriptorProto name.

                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                      options?: IEnumOptions;
                                                                                                                                                                                                                                                                                                                                      • EnumDescriptorProto options.

                                                                                                                                                                                                                                                                                                                                      property reservedName

                                                                                                                                                                                                                                                                                                                                      reservedName: string[];
                                                                                                                                                                                                                                                                                                                                      • EnumDescriptorProto reservedName.

                                                                                                                                                                                                                                                                                                                                      property reservedRange

                                                                                                                                                                                                                                                                                                                                      reservedRange: EnumDescriptorProto.IEnumReservedRange[];
                                                                                                                                                                                                                                                                                                                                      • EnumDescriptorProto reservedRange.

                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                      value: IEnumValueDescriptorProto[];
                                                                                                                                                                                                                                                                                                                                      • EnumDescriptorProto value.

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (
                                                                                                                                                                                                                                                                                                                                      properties?: google.protobuf.IEnumDescriptorProto
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Creates a new EnumDescriptorProto instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumDescriptorProto instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Decodes an EnumDescriptorProto message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Decodes an EnumDescriptorProto message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IEnumDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified EnumDescriptorProto message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumDescriptorProto message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IEnumDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified EnumDescriptorProto message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumDescriptorProto message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: {
                                                                                                                                                                                                                                                                                                                                      [k: string]: any;
                                                                                                                                                                                                                                                                                                                                      }) => google.protobuf.EnumDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Creates an EnumDescriptorProto message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumDescriptorProto

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this EnumDescriptorProto to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.EnumDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from an EnumDescriptorProto message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Conversion options

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                      method verify

                                                                                                                                                                                                                                                                                                                                      static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                      • Verifies an EnumDescriptorProto message.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Plain object to verify

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                      class EnumOptions

                                                                                                                                                                                                                                                                                                                                      class EnumOptions implements IEnumOptions {}
                                                                                                                                                                                                                                                                                                                                      • Represents an EnumOptions.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IEnumOptions);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new EnumOptions.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      property allowAlias

                                                                                                                                                                                                                                                                                                                                      allowAlias: boolean;
                                                                                                                                                                                                                                                                                                                                      • EnumOptions allowAlias.

                                                                                                                                                                                                                                                                                                                                      property deprecated

                                                                                                                                                                                                                                                                                                                                      deprecated: boolean;
                                                                                                                                                                                                                                                                                                                                      • EnumOptions deprecated.

                                                                                                                                                                                                                                                                                                                                      property uninterpretedOption

                                                                                                                                                                                                                                                                                                                                      uninterpretedOption: IUninterpretedOption[];
                                                                                                                                                                                                                                                                                                                                      • EnumOptions uninterpretedOption.

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (
                                                                                                                                                                                                                                                                                                                                      properties?: google.protobuf.IEnumOptions
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumOptions;
                                                                                                                                                                                                                                                                                                                                      • Creates a new EnumOptions instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumOptions instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumOptions;
                                                                                                                                                                                                                                                                                                                                      • Decodes an EnumOptions message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumOptions

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumOptions;
                                                                                                                                                                                                                                                                                                                                      • Decodes an EnumOptions message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumOptions

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (message: google.protobuf.IEnumOptions, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified EnumOptions message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumOptions message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IEnumOptions,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified EnumOptions message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumOptions message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: { [k: string]: any }) => google.protobuf.EnumOptions;
                                                                                                                                                                                                                                                                                                                                      • Creates an EnumOptions message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumOptions

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this EnumOptions to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.EnumOptions,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from an EnumOptions message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumOptions

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Conversion options

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                      method verify

                                                                                                                                                                                                                                                                                                                                      static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                      • Verifies an EnumOptions message.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Plain object to verify

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                      class EnumValueDescriptorProto

                                                                                                                                                                                                                                                                                                                                      class EnumValueDescriptorProto implements IEnumValueDescriptorProto {}
                                                                                                                                                                                                                                                                                                                                      • Represents an EnumValueDescriptorProto.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IEnumValueDescriptorProto);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new EnumValueDescriptorProto.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                      • EnumValueDescriptorProto name.

                                                                                                                                                                                                                                                                                                                                      property number

                                                                                                                                                                                                                                                                                                                                      number: number;
                                                                                                                                                                                                                                                                                                                                      • EnumValueDescriptorProto number.

                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                      options?: IEnumValueOptions;
                                                                                                                                                                                                                                                                                                                                      • EnumValueDescriptorProto options.

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (
                                                                                                                                                                                                                                                                                                                                      properties?: google.protobuf.IEnumValueDescriptorProto
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumValueDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Creates a new EnumValueDescriptorProto instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumValueDescriptorProto instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumValueDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Decodes an EnumValueDescriptorProto message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumValueDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumValueDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Decodes an EnumValueDescriptorProto message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumValueDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IEnumValueDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified EnumValueDescriptorProto message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumValueDescriptorProto message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IEnumValueDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified EnumValueDescriptorProto message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumValueDescriptorProto message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: {
                                                                                                                                                                                                                                                                                                                                      [k: string]: any;
                                                                                                                                                                                                                                                                                                                                      }) => google.protobuf.EnumValueDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Creates an EnumValueDescriptorProto message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumValueDescriptorProto

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this EnumValueDescriptorProto to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.EnumValueDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from an EnumValueDescriptorProto message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumValueDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Conversion options

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                      method verify

                                                                                                                                                                                                                                                                                                                                      static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                      • Verifies an EnumValueDescriptorProto message.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Plain object to verify

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                      class EnumValueOptions

                                                                                                                                                                                                                                                                                                                                      class EnumValueOptions implements IEnumValueOptions {}
                                                                                                                                                                                                                                                                                                                                      • Represents an EnumValueOptions.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IEnumValueOptions);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new EnumValueOptions.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      property deprecated

                                                                                                                                                                                                                                                                                                                                      deprecated: boolean;
                                                                                                                                                                                                                                                                                                                                      • EnumValueOptions deprecated.

                                                                                                                                                                                                                                                                                                                                      property uninterpretedOption

                                                                                                                                                                                                                                                                                                                                      uninterpretedOption: IUninterpretedOption[];
                                                                                                                                                                                                                                                                                                                                      • EnumValueOptions uninterpretedOption.

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (
                                                                                                                                                                                                                                                                                                                                      properties?: google.protobuf.IEnumValueOptions
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumValueOptions;
                                                                                                                                                                                                                                                                                                                                      • Creates a new EnumValueOptions instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumValueOptions instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumValueOptions;
                                                                                                                                                                                                                                                                                                                                      • Decodes an EnumValueOptions message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumValueOptions

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.EnumValueOptions;
                                                                                                                                                                                                                                                                                                                                      • Decodes an EnumValueOptions message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumValueOptions

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (message: google.protobuf.IEnumValueOptions, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified EnumValueOptions message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumValueOptions message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IEnumValueOptions,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified EnumValueOptions message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumValueOptions message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: {
                                                                                                                                                                                                                                                                                                                                      [k: string]: any;
                                                                                                                                                                                                                                                                                                                                      }) => google.protobuf.EnumValueOptions;
                                                                                                                                                                                                                                                                                                                                      • Creates an EnumValueOptions message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        EnumValueOptions

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this EnumValueOptions to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.EnumValueOptions,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from an EnumValueOptions message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        EnumValueOptions

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Conversion options

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                      method verify

                                                                                                                                                                                                                                                                                                                                      static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                      • Verifies an EnumValueOptions message.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Plain object to verify

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                      class ExtensionRangeOptions

                                                                                                                                                                                                                                                                                                                                      class ExtensionRangeOptions implements IExtensionRangeOptions {}
                                                                                                                                                                                                                                                                                                                                      • Represents an ExtensionRangeOptions.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IExtensionRangeOptions);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new ExtensionRangeOptions.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      property uninterpretedOption

                                                                                                                                                                                                                                                                                                                                      uninterpretedOption: IUninterpretedOption[];
                                                                                                                                                                                                                                                                                                                                      • ExtensionRangeOptions uninterpretedOption.

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (
                                                                                                                                                                                                                                                                                                                                      properties?: google.protobuf.IExtensionRangeOptions
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.ExtensionRangeOptions;
                                                                                                                                                                                                                                                                                                                                      • Creates a new ExtensionRangeOptions instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        ExtensionRangeOptions instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.ExtensionRangeOptions;
                                                                                                                                                                                                                                                                                                                                      • Decodes an ExtensionRangeOptions message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        ExtensionRangeOptions

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.ExtensionRangeOptions;
                                                                                                                                                                                                                                                                                                                                      • Decodes an ExtensionRangeOptions message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        ExtensionRangeOptions

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IExtensionRangeOptions,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified ExtensionRangeOptions message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        ExtensionRangeOptions message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IExtensionRangeOptions,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified ExtensionRangeOptions message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        ExtensionRangeOptions message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: {
                                                                                                                                                                                                                                                                                                                                      [k: string]: any;
                                                                                                                                                                                                                                                                                                                                      }) => google.protobuf.ExtensionRangeOptions;
                                                                                                                                                                                                                                                                                                                                      • Creates an ExtensionRangeOptions message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        ExtensionRangeOptions

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this ExtensionRangeOptions to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.ExtensionRangeOptions,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from an ExtensionRangeOptions message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        ExtensionRangeOptions

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Conversion options

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                      method verify

                                                                                                                                                                                                                                                                                                                                      static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                      • Verifies an ExtensionRangeOptions message.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        Plain object to verify

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                      class FieldDescriptorProto

                                                                                                                                                                                                                                                                                                                                      class FieldDescriptorProto implements IFieldDescriptorProto {}
                                                                                                                                                                                                                                                                                                                                      • Represents a FieldDescriptorProto.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(properties?: IFieldDescriptorProto);
                                                                                                                                                                                                                                                                                                                                      • Constructs a new FieldDescriptorProto.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                      property defaultValue

                                                                                                                                                                                                                                                                                                                                      defaultValue: string;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto defaultValue.

                                                                                                                                                                                                                                                                                                                                      property extendee

                                                                                                                                                                                                                                                                                                                                      extendee: string;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto extendee.

                                                                                                                                                                                                                                                                                                                                      property jsonName

                                                                                                                                                                                                                                                                                                                                      jsonName: string;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto jsonName.

                                                                                                                                                                                                                                                                                                                                      property label

                                                                                                                                                                                                                                                                                                                                      label:
                                                                                                                                                                                                                                                                                                                                      | FieldDescriptorProto.Label
                                                                                                                                                                                                                                                                                                                                      | 'LABEL_OPTIONAL'
                                                                                                                                                                                                                                                                                                                                      | 'LABEL_REQUIRED'
                                                                                                                                                                                                                                                                                                                                      | 'LABEL_REPEATED';
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto label.

                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto name.

                                                                                                                                                                                                                                                                                                                                      property number

                                                                                                                                                                                                                                                                                                                                      number: number;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto number.

                                                                                                                                                                                                                                                                                                                                      property oneofIndex

                                                                                                                                                                                                                                                                                                                                      oneofIndex: number;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto oneofIndex.

                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                      options?: IFieldOptions;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto options.

                                                                                                                                                                                                                                                                                                                                      property proto3Optional

                                                                                                                                                                                                                                                                                                                                      proto3Optional: boolean;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto proto3Optional.

                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                      type:
                                                                                                                                                                                                                                                                                                                                      | FieldDescriptorProto.Type
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_DOUBLE'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_FLOAT'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_INT64'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_UINT64'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_INT32'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_FIXED64'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_FIXED32'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_BOOL'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_STRING'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_GROUP'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_MESSAGE'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_BYTES'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_UINT32'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_ENUM'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_SFIXED32'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_SFIXED64'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_SINT32'
                                                                                                                                                                                                                                                                                                                                      | 'TYPE_SINT64';
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto type.

                                                                                                                                                                                                                                                                                                                                      property typeName

                                                                                                                                                                                                                                                                                                                                      typeName: string;
                                                                                                                                                                                                                                                                                                                                      • FieldDescriptorProto typeName.

                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                      static create: (
                                                                                                                                                                                                                                                                                                                                      properties?: google.protobuf.IFieldDescriptorProto
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.FieldDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Creates a new FieldDescriptorProto instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                        Parameter properties

                                                                                                                                                                                                                                                                                                                                        Properties to set

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        FieldDescriptorProto instance

                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                      static decode: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                      length?: number
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.FieldDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Decodes a FieldDescriptorProto message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Parameter length

                                                                                                                                                                                                                                                                                                                                        Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        FieldDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method decodeDelimited

                                                                                                                                                                                                                                                                                                                                      static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                      ) => google.protobuf.FieldDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Decodes a FieldDescriptorProto message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                        Parameter reader

                                                                                                                                                                                                                                                                                                                                        Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        FieldDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                        {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                      method encode

                                                                                                                                                                                                                                                                                                                                      static encode: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IFieldDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified FieldDescriptorProto message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        FieldDescriptorProto message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method encodeDelimited

                                                                                                                                                                                                                                                                                                                                      static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.IFieldDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      writer?: any
                                                                                                                                                                                                                                                                                                                                      ) => any;
                                                                                                                                                                                                                                                                                                                                      • Encodes the specified FieldDescriptorProto message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        FieldDescriptorProto message or plain object to encode

                                                                                                                                                                                                                                                                                                                                        Parameter writer

                                                                                                                                                                                                                                                                                                                                        Writer to encode to

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        Writer

                                                                                                                                                                                                                                                                                                                                      method fromObject

                                                                                                                                                                                                                                                                                                                                      static fromObject: (object: {
                                                                                                                                                                                                                                                                                                                                      [k: string]: any;
                                                                                                                                                                                                                                                                                                                                      }) => google.protobuf.FieldDescriptorProto;
                                                                                                                                                                                                                                                                                                                                      • Creates a FieldDescriptorProto message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                        Parameter object

                                                                                                                                                                                                                                                                                                                                        Plain object

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        FieldDescriptorProto

                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                      toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Converts this FieldDescriptorProto to JSON.

                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                        JSON object

                                                                                                                                                                                                                                                                                                                                      method toObject

                                                                                                                                                                                                                                                                                                                                      static toObject: (
                                                                                                                                                                                                                                                                                                                                      message: google.protobuf.FieldDescriptorProto,
                                                                                                                                                                                                                                                                                                                                      options?: any
                                                                                                                                                                                                                                                                                                                                      ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                      • Creates a plain object from a FieldDescriptorProto message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                        FieldDescriptorProto

                                                                                                                                                                                                                                                                                                                                        Parameter options