/*!
* Copyright 2014 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
///
import { GoogleAuth } from 'google-auth-library';
import * as gax from 'google-gax';
import { Schema, SchemaType, ISchema, SchemaView } from './schema';
import { Snapshot } from './snapshot';
import { Subscription, SubscriptionOptions, CreateSubscriptionOptions, CreateSubscriptionCallback, CreateSubscriptionResponse, DetachSubscriptionCallback, DetachSubscriptionResponse } from './subscription';
import { Topic, GetTopicSubscriptionsCallback, GetTopicSubscriptionsResponse, CreateTopicCallback, CreateTopicResponse, TopicMetadata } from './topic';
import { PublishOptions } from './publisher';
import { CallOptions } from 'google-gax';
import { Transform } from 'stream';
import { google } from '../protos/protos';
import { SchemaServiceClient } from './v1';
export declare type Omit = Pick>;
export interface ClientConfig extends gax.GrpcClientOptions {
apiEndpoint?: string;
servicePath?: string;
port?: string | number;
sslCreds?: gax.grpc.ChannelCredentials;
}
export interface PageOptions {
gaxOpts?: CallOptions;
pageSize?: number;
pageToken?: string;
autoPaginate?: boolean;
}
export declare type GetSnapshotsCallback = RequestCallback;
export declare type GetSnapshotsResponse = PagedResponse;
export declare type GetSubscriptionsOptions = PageOptions & {
topic?: string | Topic;
};
declare type GetAllSubscriptionsCallback = RequestCallback;
declare type GetAllSubscriptionsResponse = PagedResponse;
export declare type GetSubscriptionsCallback = GetAllSubscriptionsCallback | GetTopicSubscriptionsCallback;
export declare type GetSubscriptionsResponse = GetAllSubscriptionsResponse | GetTopicSubscriptionsResponse;
export declare type GetTopicsCallback = RequestCallback;
export declare type GetTopicsResponse = PagedResponse;
export declare type EmptyCallback = RequestCallback;
export declare type EmptyResponse = [google.protobuf.IEmpty];
export declare type ExistsCallback = RequestCallback;
export declare type ExistsResponse = [boolean];
export declare type DetachedCallback = RequestCallback;
export declare type DetachedResponse = [boolean];
export interface GetClientConfig {
client: 'PublisherClient' | 'SubscriberClient';
}
export interface RequestConfig extends GetClientConfig {
method: string;
reqOpts?: object;
gaxOpts?: CallOptions;
}
export interface ResourceCallback {
(err: gax.grpc.ServiceError | null, resource?: Resource | null, response?: Response | null): void;
}
export declare type RequestCallback = R extends void ? NormalCallback : PagedCallback;
export interface NormalCallback {
(err: gax.grpc.ServiceError | null, res?: TResponse | null): void;
}
export interface PagedCallback- {
(err: gax.grpc.ServiceError | null, results?: Item[] | null, nextQuery?: {} | null, response?: Response | null): void;
}
export declare type PagedResponse
- = [Item[]] | [Item[], {} | null, Response];
export declare type ObjectStream = {
addListener(event: 'data', listener: (data: O) => void): ObjectStream;
emit(event: 'data', data: O): boolean;
on(event: 'data', listener: (data: O) => void): ObjectStream;
once(event: 'data', listener: (data: O) => void): ObjectStream;
prependListener(event: 'data', listener: (data: O) => void): ObjectStream;
prependOnceListener(event: 'data', listener: (data: O) => void): ObjectStream;
} & Transform;
interface GetClientCallback {
(err: Error | null, gaxClient?: gax.ClientStub): void;
}
/**
* @typedef {object} ClientConfig
* @property {string} [projectId] The project ID from the Google Developer's
* Console, e.g. 'grape-spaceship-123'. We will also check the environment
* variable `GCLOUD_PROJECT` for your project ID. If your app is running in
* an environment which supports {@link
* https://cloud.google.com/docs/authentication/production#providing_credentials_to_your_application
* Application Default Credentials}, your project ID will be detected
* automatically.
* @property {string} [keyFilename] Full path to the a .json, .pem, or .p12 key
* downloaded from the Google Developers Console. If you provide a path to a
* JSON file, the `projectId` option above is not necessary. NOTE: .pem and
* .p12 require you to specify the `email` option as well.
* @property {string} [apiEndpoint] The `apiEndpoint` from options will set the
* host. If not set, the `PUBSUB_EMULATOR_HOST` environment variable from the
* gcloud SDK is honored. We also check the `CLOUD_API_ENDPOINT_OVERRIDES_PUBSUB`
* environment variable used by `gcloud alpha pubsub`. Otherwise the actual API
* endpoint will be 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.
* @property {string} [email] Account email address. Required when using a .pem
* or .p12 keyFilename.
* @property {object} [credentials] Credentials object.
* @property {string} [credentials.client_email]
* @property {string} [credentials.private_key]
* @property {boolean} [autoRetry=true] Automatically retry requests if the
* response is related to rate limits or certain intermittent server errors.
* We will exponentially backoff subsequent requests by default.
* @property {Constructor} [promise] Custom promise module to use instead of
* native Promises.
*/
/**
* [Cloud Pub/Sub](https://developers.google.com/pubsub/overview) is a
* reliable, many-to-many, asynchronous messaging service from Cloud
* Platform.
*
* @class
*
* @see [Cloud Pub/Sub overview]{@link https://developers.google.com/pubsub/overview}
*
* @param {ClientConfig} [options] Configuration options.
*
* @example Import the client library
* ```
* const {PubSub} = require('@google-cloud/pubsub');
*
* ```
* @example Create a client that uses Application Default Credentials (ADC):
* ```
* const pubsub = new PubSub();
*
* ```
* @example Create a client with explicit credentials:
* ```
* const pubsub = new PubSub({
* projectId: 'your-project-id',
* keyFilename: '/path/to/keyfile.json'
* });
*
* ```
* @example include:samples/quickstart.js
* region_tag:pubsub_quickstart_create_topic
* Full quickstart example:
*/
export declare class PubSub {
options: ClientConfig;
isEmulator: boolean;
api: {
[key: string]: gax.ClientStub;
};
auth: GoogleAuth;
projectId: string;
name?: string;
Promise?: PromiseConstructor;
getSubscriptionsStream: () => ObjectStream;
getSnapshotsStream: () => ObjectStream;
getTopicsStream: () => ObjectStream;
isOpen: boolean;
private schemaClient?;
constructor(options?: ClientConfig);
/**
* Returns true if we have actually resolved the full project name.
*
* @returns {boolean} true if the name is resolved.
*/
get isIdResolved(): boolean;
/**
* Closes out this object, releasing any server connections. Note that once
* you close a PubSub object, it may not be used again. Any pending operations
* (e.g. queued publish messages) will fail. If you have topic or subscription
* objects that may have pending operations, you should call close() on those
* first if you want any pending messages to be delivered correctly. The
* PubSub class doesn't track those.
*
* @callback EmptyCallback
* @returns {Promise}
*/
close(): Promise;
close(callback: EmptyCallback): void;
/**
* Create a schema in the project.
*
* @see [Schemas: create API Documentation]{@link https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.schemas/create}
* @see {@link Schema#create}
*
* @throws {Error} If a schema ID or name is not provided.
* @throws {Error} If an invalid SchemaType is provided.
* @throws {Error} If an invalid schema definition is provided.
*
* @param {string} schemaId The name or ID of the subscription.
* @param {SchemaType} type The type of the schema (Protobuf, Avro, etc).
* @param {string} definition The text describing the schema in terms of the type.
* @param {object} [options] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @returns {Promise}
*
* @example Create a schema.
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* await pubsub.createSchema(
* 'messageType',
* SchemaTypes.Avro,
* '{...avro definition...}'
* );
* ```
*/
createSchema(schemaId: string, type: SchemaType, definition: string, gaxOpts?: CallOptions): Promise;
/**
* @typedef {array} CreateSubscriptionResponse
* @property {Subscription} 0 The new {@link Subscription}.
* @property {object} 1 The full API response.
*/
/**
* @callback CreateSubscriptionCallback
* @param {?Error} err Request error, if any.
* @param {Subscription} Subscription
* @param {object} apiResponse The full API response.
*/
/**
* Options for creating a subscription.
*
* See a [Subscription
* resource](https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.subscriptions).
*
* @typedef {object} CreateSubscriptionRequest
* @property {DeadLetterPolicy} [deadLetterPolicy] A policy that specifies the
* conditions for dead lettering messages in this subscription.
* @property {object} [flowControl] Flow control configurations for
* receiving messages. Note that these options do not persist across
* subscription instances.
* @property {number} [flowControl.maxBytes] The maximum number of bytes
* in un-acked messages to allow before the subscription pauses incoming
* messages. Defaults to 20% of free memory.
* @property {number} [flowControl.maxMessages=Infinity] The maximum number
* of un-acked messages to allow before the subscription pauses incoming
* messages.
* @property {object} [gaxOpts] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @property {number|google.protobuf.Duration} [messageRetentionDuration] Set
* this to override the default duration of 7 days. This value is expected
* in seconds. Acceptable values are in the range of 10 minutes and 7
* days.
* @property {string} [pushEndpoint] A URL to a custom endpoint that
* messages should be pushed to.
* @property {object} [oidcToken] If specified, Pub/Sub will generate and
* attach an OIDC JWT token as an `Authorization` header in the HTTP
* request for every pushed message. This object should have the same
* structure as [OidcToken]{@link google.pubsub.v1.OidcToken}
* @property {boolean} [retainAckedMessages=false] If set, acked messages
* are retained in the subscription's backlog for the length of time
* specified by `options.messageRetentionDuration`.
* @property {ExpirationPolicy} [expirationPolicy] A policy that specifies
* the conditions for this subscription's expiration.
*/
/**
* Create a subscription to a topic.
*
* @see [Subscriptions: create API Documentation]{@link https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.subscriptions/create}
* @see {@link Topic#createSubscription}
*
* @throws {Error} If a Topic instance or topic name is not provided.
* @throws {Error} If a subscription name is not provided.
*
* @param {Topic|string} topic The Topic to create a subscription to.
* @param {string} name The name of the subscription.
* @param {CreateSubscriptionRequest} [options] See a [Subscription resource](https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.subscriptions).
* @param {CreateSubscriptionCallback} [callback] Callback function.
* @returns {Promise}
*
* @example Subscribe to a topic.
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* const topic = 'messageCenter';
* const name = 'newMessages';
*
* const callback = function(err, subscription, apiResponse) {};
*
* pubsub.createSubscription(topic, name, callback);
*
* ```
* @example If the callback is omitted, we'll return a Promise.
* ```
* pubsub.createSubscription(topic, name)
* .then(function(data) {
* const subscription = data[0];
* const apiResponse = data[1];
* });
* ```
*/
createSubscription(topic: Topic | string, name: string, options?: CreateSubscriptionOptions): Promise;
createSubscription(topic: Topic | string, name: string, callback: CreateSubscriptionCallback): void;
createSubscription(topic: Topic | string, name: string, options: CreateSubscriptionOptions, callback: CreateSubscriptionCallback): void;
/**
* @typedef {array} CreateTopicResponse
* @property {Topic} 0 The new {@link Topic}.
* @property {object} 1 The full API response.
*/
/**
* @callback CreateTopicCallback
* @param {?Error} err Request error, if any.
* @param {Topic} topic The new {@link Topic}.
* @param {object} apiResponse The full API response.
*/
/**
* Create a topic with the given name.
*
* @see [Topics: create API Documentation]{@link https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.topics/create}
*
* @param {string} name Name of the topic.
* @param {object} [gaxOpts] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @param {CreateTopicCallback} [callback] Callback function.
* @returns {Promise}
*
* @example
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* pubsub.createTopic('my-new-topic', function(err, topic, apiResponse) {
* if (!err) {
* // The topic was created successfully.
* }
* });
*
* //-
* // If the callback is omitted, we'll return a Promise.
* //-
* pubsub.createTopic('my-new-topic').then(function(data) {
* const topic = data[0];
* const apiResponse = data[1];
* });
* ```
*/
createTopic(name: string | TopicMetadata, gaxOpts?: CallOptions): Promise;
createTopic(name: string | TopicMetadata, callback: CreateTopicCallback): void;
createTopic(name: string | TopicMetadata, gaxOpts: CallOptions, callback: CreateTopicCallback): void;
/**
* Detach a subscription with the given name.
*
* @see [Admin: Pub/Sub administration API Documentation]{@link https://cloud.google.com/pubsub/docs/admin}
*
* @param {string} name Name of the subscription.
* @param {object} [gaxOpts] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @param {DetachSubscriptionCallback} [callback] Callback function.
* @returns {Promise}
*
* @example
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* pubsub.detachSubscription('my-sub', (err, topic, apiResponse) => {
* if (!err) {
* // The topic was created successfully.
* }
* });
*
* //-
* // If the callback is omitted, we'll return a Promise.
* //-
* pubsub.detachSubscription('my-sub').then(data => {
* const apiResponse = data[0];
* });
* ```
*/
detachSubscription(name: string, gaxOpts?: CallOptions): Promise;
detachSubscription(name: string, callback: DetachSubscriptionCallback): void;
detachSubscription(name: string, gaxOpts: CallOptions, callback: DetachSubscriptionCallback): 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.
*
* @private
*/
determineBaseUrl_(): void;
/**
* Get a list of schemas associated with your project.
*
* The returned AsyncIterable will resolve to {@link google.pubsub.v1.ISchema} objects.
*
* This method returns an async iterable. These objects can be adapted
* to work in a Promise/then framework, as well as with callbacks, but
* this discussion is considered out of scope for these docs.
*
* @see [Schemas: list API Documentation]{@link https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.schemas/list}
* @see [More about async iterators]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of}
*
* @param {google.pubsub.v1.SchemaView} [view] The type of schema objects
* requested, which should be an enum value from {@link SchemaViews}. Defaults
* to Full.
* @param {object} [options] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @returns {AsyncIterable}
*
* @example
* ```
* for await (const s of pubsub.listSchemas()) {
* const moreInfo = await s.get();
* }
* ```
*/
listSchemas(view?: SchemaView, options?: CallOptions): AsyncIterable;
/**
* Query object for listing snapshots.
*
* @typedef {object} GetSnapshotsRequest
* @property {boolean} [autoPaginate=true] Have pagination handled
* automatically.
* @property {object} [options.gaxOpts] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @property {number} [options.pageSize] Maximum number of results to return.
* @property {string} [options.pageToken] Page token.
*/
/**
* @typedef {array} GetSnapshotsResponse
* @property {Snapshot[]} 0 Array of {@link Snapshot} instances.
* @property {object} 1 The full API response.
*/
/**
* @callback GetSnapshotsCallback
* @param {?Error} err Request error, if any.
* @param {Snapshot[]} snapshots Array of {@link Snapshot} instances.
* @param {object} apiResponse The full API response.
*/
/**
* Get a list of snapshots.
*
* @param {GetSnapshotsRequest} [query] Query object for listing snapshots.
* @param {GetSnapshotsCallback} [callback] Callback function.
* @returns {Promise}
*
* @example
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* pubsub.getSnapshots(function(err, snapshots) {
* if (!err) {
* // snapshots is an array of Snapshot objects.
* }
* });
*
* //-
* // If the callback is omitted, we'll return a Promise.
* //-
* pubsub.getSnapshots().then(function(data) {
* const snapshots = data[0];
* });
* ```
*/
getSnapshots(options?: PageOptions): Promise;
getSnapshots(callback: GetSnapshotsCallback): void;
getSnapshots(options: PageOptions, callback: GetSnapshotsCallback): void;
/**
* Query object for listing subscriptions.
*
* @typedef {object} GetSubscriptionsRequest
* @property {boolean} [autoPaginate=true] Have pagination handled
* automatically.
* @property {object} [options.gaxOpts] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @property {number} [options.pageSize] Maximum number of results to return.
* @property {string} [options.pageToken] Page token.
* @param {string|Topic} options.topic - The name of the topic to
* list subscriptions from.
*/
/**
* @typedef {array} GetSubscriptionsResponse
* @property {Subscription[]} 0 Array of {@link Subscription} instances.
* @property {object} 1 The full API response.
*/
/**
* @callback GetSubscriptionsCallback
* @param {?Error} err Request error, if any.
* @param {Subscription[]} subscriptions Array of {@link Subscription} instances.
* @param {object} apiResponse The full API response.
*/
/**
* Get a list of the subscriptions registered to all of your project's topics.
* You may optionally provide a query object as the first argument to
* customize the response.
*
* Your provided callback will be invoked with an error object if an API error
* occurred or an array of {@link Subscription} objects.
*
* To get subscriptions for a topic, see {@link Topic}.
*
* @see [Subscriptions: list API Documentation]{@link https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.subscriptions/list}
*
* @param {GetSubscriptionsRequest} [query] Query object for listing subscriptions.
* @param {GetSubscriptionsCallback} [callback] Callback function.
* @returns {Promise}
*
* @example
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* pubsub.getSubscriptions(function(err, subscriptions) {
* if (!err) {
* // subscriptions is an array of Subscription objects.
* }
* });
*
* //-
* // If the callback is omitted, we'll return a Promise.
* //-
* pubsub.getSubscriptions().then(function(data) {
* const subscriptions = data[0];
* });
* ```
*/
getSubscriptions(options?: GetSubscriptionsOptions): Promise;
getSubscriptions(callback: GetSubscriptionsCallback): void;
getSubscriptions(options: GetSubscriptionsOptions, callback: GetSubscriptionsCallback): void;
/**
* Query object for listing topics.
*
* @typedef {object} GetTopicsRequest
* @property {boolean} [autoPaginate=true] Have pagination handled
* automatically.
* @property {object} [options.gaxOpts] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @property {number} [options.pageSize] Maximum number of results to return.
* @property {string} [options.pageToken] Page token.
*/
/**
* @typedef {array} GetTopicsResponse
* @property {Topic[]} 0 Array of {@link Topic} instances.
* @property {object} 1 The full API response.
*/
/**
* @callback GetTopicsCallback
* @param {?Error} err Request error, if any.
* @param {Topic[]} topics Array of {@link Topic} instances.
* @param {object} apiResponse The full API response.
*/
/**
* Get a list of the topics registered to your project. You may optionally
* provide a query object as the first argument to customize the response.
*
* @see [Topics: list API Documentation]{@link https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.topics/list}
*
* @param {GetTopicsRequest} [query] Query object for listing topics.
* @param {GetTopicsCallback} [callback] Callback function.
* @returns {Promise}
*
* @example
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* pubsub.getTopics(function(err, topics) {
* if (!err) {
* // topics is an array of Topic objects.
* }
* });
*
* //-
* // Customize the query.
* //-
* pubsub.getTopics({
* pageSize: 3
* }, function(err, topics) {});
*
* //-
* // If the callback is omitted, we'll return a Promise.
* //-
* pubsub.getTopics().then(function(data) {
* const topics = data[0];
* });
* ```
*/
getTopics(options?: PageOptions): Promise;
getTopics(callback: GetTopicsCallback): void;
getTopics(options: PageOptions, callback: GetTopicsCallback): void;
/**
* Retrieve a client configuration, suitable for passing into a GAPIC
* 'v1' class constructor. This will fill out projectId, emulator URLs,
* and so forth.
*
* @returns {Promise} the filled client configuration.
*/
getClientConfig(): Promise;
/**
* Gets a schema client, creating one if needed.
* @private
*/
getSchemaClient_(): Promise;
/**
* Callback function to PubSub.getClient_().
* @private
* @callback GetClientCallback
* @param err - Error, if any.
* @param gaxClient - The gax client specified in RequestConfig.client.
* Typed any since it's importing Javascript source.
*/
/**
* Get the PubSub client object.
*
* @private
*
* @param {object} config Configuration object.
* @param {object} config.gaxOpts GAX options.
* @param {function} config.method The gax method to call.
* @param {object} config.reqOpts Request options.
* @param {function} [callback] The callback function.
*/
getClient_(config: GetClientConfig, callback: GetClientCallback): void;
/**
* Get the PubSub client object.
*
* @private
*
* @param {object} config Configuration object.
* @param {object} config.gaxOpts GAX options.
* @param {function} config.method The gax method to call.
* @param {object} config.reqOpts Request options.
* @returns {Promise}
*/
getClientAsync_(config: GetClientConfig): Promise;
/**
* Close all open client objects.
*
* @private
*
* @returns {Promise}
*/
closeAllClients_(): Promise;
/**
* Funnel all API requests through this method, to be sure we have a project
* ID.
*
* @private
*
* @param {object} config Configuration object.
* @param {object} config.gaxOpts GAX options.
* @param {function} config.method The gax method to call.
* @param {object} config.reqOpts Request options.
* @param {function} [callback] The callback function.
*/
request(config: RequestConfig, callback: RequestCallback): void;
/**
* Create a Schema object, representing a schema within the project.
* See {@link PubSub#createSchema} or {@link Schema#create} to create a schema.
*
* @throws {Error} If a name is not provided.
*
* @param {string} name The ID or name of the schema.
* @returns {Schema} A {@link Schema} instance.
*
* @example
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* const schema = pubsub.schema('my-schema');
* ```
*/
schema(idOrName: string): Schema;
/**
* Create a Snapshot object. See {@link Subscription#createSnapshot} to
* create a snapshot.
*
* @throws {Error} If a name is not provided.
*
* @param {string} name The name of the snapshot.
* @returns {Snapshot} A {@link Snapshot} instance.
*
* @example
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* const snapshot = pubsub.snapshot('my-snapshot');
* ```
*/
snapshot(name: string): Snapshot;
/**
* Create a Subscription object. This command by itself will not run any API
* requests. You will receive a {@link Subscription} object,
* which will allow you to interact with a subscription.
*
* @throws {Error} If subscription name is omitted.
*
* @param {string} name Name of the subscription.
* @param {SubscriberOptions} [options] Configuration object.
* @returns {Subscription} A {@link Subscription} instance.
*
* @example
* ```
* 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.
* });
* ```
*/
subscription(name: string, options?: SubscriptionOptions): Subscription;
/**
* Create a Topic object. See {@link PubSub#createTopic} to create a topic.
*
* @throws {Error} If a name is not provided.
*
* @param {string} name The name of the topic.
* @param {PublishOptions} [options] Publisher configuration object.
* @returns {Topic} A {@link Topic} instance.
*
* @example
* ```
* const {PubSub} = require('@google-cloud/pubsub');
* const pubsub = new PubSub();
*
* const topic = pubsub.topic('my-topic');
* ```
*/
topic(name: string, options?: PublishOptions): Topic;
/**
* Validate a schema definition.
*
* @see [Schemas: validateSchema API Documentation]{@link https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.schemas/validate}
*
* @throws {Error} if the validation fails.
*
* @param {ISchema} schema The schema definition you wish to validate.
* @param {object} [options] Request configuration options, outlined
* here: https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html.
* @returns {Promise}
*/
validateSchema(schema: ISchema, gaxOpts?: CallOptions): Promise;
/*!
* Format the name of a project. A project's full name is in the
* format of projects/{projectId}.
*
* The GAPIC client should do this for us, but since we maintain
* names rather than IDs, this is simpler.
*
* @private
*/
static formatName_(name: string): string;
}
export {};