// Copyright 2022 Luca Casonato. All rights reserved. MIT license. /** * Cloud Pub/Sub API Client for Deno * ================================= * * Provides reliable, many-to-many, asynchronous messaging between applications. * * Docs: https://cloud.google.com/pubsub/docs * Source: https://googleapis.deno.dev/v1/pubsub:v1.ts */ import { auth, CredentialsClient, GoogleAuth, request } from "/_/base@v1/mod.ts"; export { auth, GoogleAuth }; export type { CredentialsClient }; /** * Provides reliable, many-to-many, asynchronous messaging between * applications. */ export class pubsub { #client: CredentialsClient | undefined; #baseUrl: string; constructor(client?: CredentialsClient, baseUrl: string = "https://pubsub.googleapis.com/") { this.#client = client; this.#baseUrl = baseUrl; } /** * Commits a new schema revision to an existing schema. * * @param name Required. The name of the schema we are revising. Format is `projects/{project}/schemas/{schema}`. */ async projectsSchemasCommit(name: string, req: CommitSchemaRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ name }:commit`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as Schema; } /** * Creates a schema. * * @param parent Required. The name of the project in which to create the schema. Format is `projects/{project-id}`. */ async projectsSchemasCreate(parent: string, req: Schema, opts: ProjectsSchemasCreateOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ parent }/schemas`); if (opts.schemaId !== undefined) { url.searchParams.append("schemaId", String(opts.schemaId)); } const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as Schema; } /** * Deletes a schema. * * @param name Required. Name of the schema to delete. Format is `projects/{project}/schemas/{schema}`. */ async projectsSchemasDelete(name: string): Promise { const url = new URL(`${this.#baseUrl}v1/${ name }`); const data = await request(url.href, { client: this.#client, method: "DELETE", }); return data as Empty; } /** * Deletes a specific schema revision. * * @param name Required. The name of the schema revision to be deleted, with a revision ID explicitly included. Example: `projects/123/schemas/my-schema@c7cfa2a8` */ async projectsSchemasDeleteRevision(name: string, opts: ProjectsSchemasDeleteRevisionOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ name }:deleteRevision`); if (opts.revisionId !== undefined) { url.searchParams.append("revisionId", String(opts.revisionId)); } const data = await request(url.href, { client: this.#client, method: "DELETE", }); return data as Schema; } /** * Gets a schema. * * @param name Required. The name of the schema to get. Format is `projects/{project}/schemas/{schema}`. */ async projectsSchemasGet(name: string, opts: ProjectsSchemasGetOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ name }`); if (opts.view !== undefined) { url.searchParams.append("view", String(opts.view)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return data as Schema; } /** * Gets the access control policy for a resource. Returns an empty policy if * the resource exists and does not have a policy set. * * @param resource REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSchemasGetIamPolicy(resource: string, opts: ProjectsSchemasGetIamPolicyOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ resource }:getIamPolicy`); if (opts["options.requestedPolicyVersion"] !== undefined) { url.searchParams.append("options.requestedPolicyVersion", String(opts["options.requestedPolicyVersion"])); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializePolicy(data); } /** * Lists schemas in a project. * * @param parent Required. The name of the project in which to list schemas. Format is `projects/{project-id}`. */ async projectsSchemasList(parent: string, opts: ProjectsSchemasListOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ parent }/schemas`); if (opts.pageSize !== undefined) { url.searchParams.append("pageSize", String(opts.pageSize)); } if (opts.pageToken !== undefined) { url.searchParams.append("pageToken", String(opts.pageToken)); } if (opts.view !== undefined) { url.searchParams.append("view", String(opts.view)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return data as ListSchemasResponse; } /** * Lists all schema revisions for the named schema. * * @param name Required. The name of the schema to list revisions for. */ async projectsSchemasListRevisions(name: string, opts: ProjectsSchemasListRevisionsOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ name }:listRevisions`); if (opts.pageSize !== undefined) { url.searchParams.append("pageSize", String(opts.pageSize)); } if (opts.pageToken !== undefined) { url.searchParams.append("pageToken", String(opts.pageToken)); } if (opts.view !== undefined) { url.searchParams.append("view", String(opts.view)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return data as ListSchemaRevisionsResponse; } /** * Creates a new schema revision that is a copy of the provided revision_id. * * @param name Required. The schema being rolled back with revision id. */ async projectsSchemasRollback(name: string, req: RollbackSchemaRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ name }:rollback`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as Schema; } /** * Sets the access control policy on the specified resource. Replaces any * existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and * `PERMISSION_DENIED` errors. * * @param resource REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSchemasSetIamPolicy(resource: string, req: SetIamPolicyRequest): Promise { req = serializeSetIamPolicyRequest(req); const url = new URL(`${this.#baseUrl}v1/${ resource }:setIamPolicy`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return deserializePolicy(data); } /** * Returns permissions that a caller has on the specified resource. If the * resource does not exist, this will return an empty set of permissions, not * a `NOT_FOUND` error. Note: This operation is designed to be used for * building permission-aware UIs and command-line tools, not for authorization * checking. This operation may "fail open" without warning. * * @param resource REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSchemasTestIamPermissions(resource: string, req: TestIamPermissionsRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ resource }:testIamPermissions`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as TestIamPermissionsResponse; } /** * Validates a schema. * * @param parent Required. The name of the project in which to validate schemas. Format is `projects/{project-id}`. */ async projectsSchemasValidate(parent: string, req: ValidateSchemaRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ parent }/schemas:validate`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as ValidateSchemaResponse; } /** * Validates a message against a schema. * * @param parent Required. The name of the project in which to validate schemas. Format is `projects/{project-id}`. */ async projectsSchemasValidateMessage(parent: string, req: ValidateMessageRequest): Promise { req = serializeValidateMessageRequest(req); const url = new URL(`${this.#baseUrl}v1/${ parent }/schemas:validateMessage`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as ValidateMessageResponse; } /** * Creates a snapshot from the requested subscription. Snapshots are used in * [Seek](https://cloud.google.com/pubsub/docs/replay-overview) operations, * which allow you to manage message acknowledgments in bulk. That is, you can * set the acknowledgment state of messages in an existing subscription to the * state captured by a snapshot. If the snapshot already exists, returns * `ALREADY_EXISTS`. If the requested subscription doesn't exist, returns * `NOT_FOUND`. If the backlog in the subscription is too old -- and the * resulting snapshot would expire in less than 1 hour -- then * `FAILED_PRECONDITION` is returned. See also the `Snapshot.expire_time` * field. If the name is not provided in the request, the server will assign a * random name for this snapshot on the same project as the subscription, * conforming to the [resource name format] * (https://cloud.google.com/pubsub/docs/admin#resource_names). The generated * name is populated in the returned Snapshot object. Note that for REST API * requests, you must specify a name in the request. * * @param name Required. User-provided name for this snapshot. If the name is not provided in the request, the server will assign a random name for this snapshot on the same project as the subscription. Note that for REST API requests, you must specify a name. See the [resource name rules](https://cloud.google.com/pubsub/docs/admin#resource_names). Format is `projects/{project}/snapshots/{snap}`. */ async projectsSnapshotsCreate(name: string, req: CreateSnapshotRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ name }`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "PUT", body, }); return deserializeSnapshot(data); } /** * Removes an existing snapshot. Snapshots are used in [Seek] * (https://cloud.google.com/pubsub/docs/replay-overview) operations, which * allow you to manage message acknowledgments in bulk. That is, you can set * the acknowledgment state of messages in an existing subscription to the * state captured by a snapshot. When the snapshot is deleted, all messages * retained in the snapshot are immediately dropped. After a snapshot is * deleted, a new one may be created with the same name, but the new one has * no association with the old snapshot or its subscription, unless the same * subscription is specified. * * @param snapshot Required. The name of the snapshot to delete. Format is `projects/{project}/snapshots/{snap}`. */ async projectsSnapshotsDelete(snapshot: string): Promise { const url = new URL(`${this.#baseUrl}v1/${ snapshot }`); const data = await request(url.href, { client: this.#client, method: "DELETE", }); return data as Empty; } /** * Gets the configuration details of a snapshot. Snapshots are used in * [Seek](https://cloud.google.com/pubsub/docs/replay-overview) operations, * which allow you to manage message acknowledgments in bulk. That is, you can * set the acknowledgment state of messages in an existing subscription to the * state captured by a snapshot. * * @param snapshot Required. The name of the snapshot to get. Format is `projects/{project}/snapshots/{snap}`. */ async projectsSnapshotsGet(snapshot: string): Promise { const url = new URL(`${this.#baseUrl}v1/${ snapshot }`); const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializeSnapshot(data); } /** * Gets the access control policy for a resource. Returns an empty policy if * the resource exists and does not have a policy set. * * @param resource REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSnapshotsGetIamPolicy(resource: string, opts: ProjectsSnapshotsGetIamPolicyOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ resource }:getIamPolicy`); if (opts["options.requestedPolicyVersion"] !== undefined) { url.searchParams.append("options.requestedPolicyVersion", String(opts["options.requestedPolicyVersion"])); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializePolicy(data); } /** * Lists the existing snapshots. Snapshots are used in [Seek]( * https://cloud.google.com/pubsub/docs/replay-overview) operations, which * allow you to manage message acknowledgments in bulk. That is, you can set * the acknowledgment state of messages in an existing subscription to the * state captured by a snapshot. * * @param project Required. The name of the project in which to list snapshots. Format is `projects/{project-id}`. */ async projectsSnapshotsList(project: string, opts: ProjectsSnapshotsListOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ project }/snapshots`); if (opts.pageSize !== undefined) { url.searchParams.append("pageSize", String(opts.pageSize)); } if (opts.pageToken !== undefined) { url.searchParams.append("pageToken", String(opts.pageToken)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializeListSnapshotsResponse(data); } /** * Updates an existing snapshot. Snapshots are used in * [Seek](https://cloud.google.com/pubsub/docs/replay-overview) operations, * which allow you to manage message acknowledgments in bulk. That is, you can * set the acknowledgment state of messages in an existing subscription to the * state captured by a snapshot. * * @param name The name of the snapshot. */ async projectsSnapshotsPatch(name: string, req: UpdateSnapshotRequest): Promise { req = serializeUpdateSnapshotRequest(req); const url = new URL(`${this.#baseUrl}v1/${ name }`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "PATCH", body, }); return deserializeSnapshot(data); } /** * Sets the access control policy on the specified resource. Replaces any * existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and * `PERMISSION_DENIED` errors. * * @param resource REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSnapshotsSetIamPolicy(resource: string, req: SetIamPolicyRequest): Promise { req = serializeSetIamPolicyRequest(req); const url = new URL(`${this.#baseUrl}v1/${ resource }:setIamPolicy`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return deserializePolicy(data); } /** * Returns permissions that a caller has on the specified resource. If the * resource does not exist, this will return an empty set of permissions, not * a `NOT_FOUND` error. Note: This operation is designed to be used for * building permission-aware UIs and command-line tools, not for authorization * checking. This operation may "fail open" without warning. * * @param resource REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSnapshotsTestIamPermissions(resource: string, req: TestIamPermissionsRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ resource }:testIamPermissions`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as TestIamPermissionsResponse; } /** * Acknowledges the messages associated with the `ack_ids` in the * `AcknowledgeRequest`. The Pub/Sub system can remove the relevant messages * from the subscription. Acknowledging a message whose ack deadline has * expired may succeed, but such a message may be redelivered later. * Acknowledging a message more than once will not result in an error. * * @param subscription Required. The subscription whose message is being acknowledged. Format is `projects/{project}/subscriptions/{sub}`. */ async projectsSubscriptionsAcknowledge(subscription: string, req: AcknowledgeRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ subscription }:acknowledge`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as Empty; } /** * Creates a subscription to a given topic. See the [resource name rules] * (https://cloud.google.com/pubsub/docs/admin#resource_names). If the * subscription already exists, returns `ALREADY_EXISTS`. If the corresponding * topic doesn't exist, returns `NOT_FOUND`. If the name is not provided in * the request, the server will assign a random name for this subscription on * the same project as the topic, conforming to the [resource name format] * (https://cloud.google.com/pubsub/docs/admin#resource_names). The generated * name is populated in the returned Subscription object. Note that for REST * API requests, you must specify a name in the request. * * @param name Required. The name of the subscription. It must have the format `"projects/{project}/subscriptions/{subscription}"`. `{subscription}` must start with a letter, and contain only letters (`[A-Za-z]`), numbers (`[0-9]`), dashes (`-`), underscores (`_`), periods (`.`), tildes (`~`), plus (`+`) or percent signs (`%`). It must be between 3 and 255 characters in length, and it must not start with `"goog"`. */ async projectsSubscriptionsCreate(name: string, req: Subscription): Promise { req = serializeSubscription(req); const url = new URL(`${this.#baseUrl}v1/${ name }`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "PUT", body, }); return deserializeSubscription(data); } /** * Deletes an existing subscription. All messages retained in the * subscription are immediately dropped. Calls to `Pull` after deletion will * return `NOT_FOUND`. After a subscription is deleted, a new one may be * created with the same name, but the new one has no association with the old * subscription or its topic unless the same topic is specified. * * @param subscription Required. The subscription to delete. Format is `projects/{project}/subscriptions/{sub}`. */ async projectsSubscriptionsDelete(subscription: string): Promise { const url = new URL(`${this.#baseUrl}v1/${ subscription }`); const data = await request(url.href, { client: this.#client, method: "DELETE", }); return data as Empty; } /** * Detaches a subscription from this topic. All messages retained in the * subscription are dropped. Subsequent `Pull` and `StreamingPull` requests * will return FAILED_PRECONDITION. If the subscription is a push * subscription, pushes to the endpoint will stop. * * @param subscription Required. The subscription to detach. Format is `projects/{project}/subscriptions/{subscription}`. */ async projectsSubscriptionsDetach(subscription: string): Promise { const url = new URL(`${this.#baseUrl}v1/${ subscription }:detach`); const data = await request(url.href, { client: this.#client, method: "POST", }); return data as DetachSubscriptionResponse; } /** * Gets the configuration details of a subscription. * * @param subscription Required. The name of the subscription to get. Format is `projects/{project}/subscriptions/{sub}`. */ async projectsSubscriptionsGet(subscription: string): Promise { const url = new URL(`${this.#baseUrl}v1/${ subscription }`); const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializeSubscription(data); } /** * Gets the access control policy for a resource. Returns an empty policy if * the resource exists and does not have a policy set. * * @param resource REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSubscriptionsGetIamPolicy(resource: string, opts: ProjectsSubscriptionsGetIamPolicyOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ resource }:getIamPolicy`); if (opts["options.requestedPolicyVersion"] !== undefined) { url.searchParams.append("options.requestedPolicyVersion", String(opts["options.requestedPolicyVersion"])); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializePolicy(data); } /** * Lists matching subscriptions. * * @param project Required. The name of the project in which to list subscriptions. Format is `projects/{project-id}`. */ async projectsSubscriptionsList(project: string, opts: ProjectsSubscriptionsListOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ project }/subscriptions`); if (opts.pageSize !== undefined) { url.searchParams.append("pageSize", String(opts.pageSize)); } if (opts.pageToken !== undefined) { url.searchParams.append("pageToken", String(opts.pageToken)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializeListSubscriptionsResponse(data); } /** * Modifies the ack deadline for a specific message. This method is useful to * indicate that more time is needed to process a message by the subscriber, * or to make the message available for redelivery if the processing was * interrupted. Note that this does not modify the subscription-level * `ackDeadlineSeconds` used for subsequent messages. * * @param subscription Required. The name of the subscription. Format is `projects/{project}/subscriptions/{sub}`. */ async projectsSubscriptionsModifyAckDeadline(subscription: string, req: ModifyAckDeadlineRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ subscription }:modifyAckDeadline`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as Empty; } /** * Modifies the `PushConfig` for a specified subscription. This may be used * to change a push subscription to a pull one (signified by an empty * `PushConfig`) or vice versa, or change the endpoint URL and other * attributes of a push subscription. Messages will accumulate for delivery * continuously through the call regardless of changes to the `PushConfig`. * * @param subscription Required. The name of the subscription. Format is `projects/{project}/subscriptions/{sub}`. */ async projectsSubscriptionsModifyPushConfig(subscription: string, req: ModifyPushConfigRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ subscription }:modifyPushConfig`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as Empty; } /** * Updates an existing subscription. Note that certain properties of a * subscription, such as its topic, are not modifiable. * * @param name Required. The name of the subscription. It must have the format `"projects/{project}/subscriptions/{subscription}"`. `{subscription}` must start with a letter, and contain only letters (`[A-Za-z]`), numbers (`[0-9]`), dashes (`-`), underscores (`_`), periods (`.`), tildes (`~`), plus (`+`) or percent signs (`%`). It must be between 3 and 255 characters in length, and it must not start with `"goog"`. */ async projectsSubscriptionsPatch(name: string, req: UpdateSubscriptionRequest): Promise { req = serializeUpdateSubscriptionRequest(req); const url = new URL(`${this.#baseUrl}v1/${ name }`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "PATCH", body, }); return deserializeSubscription(data); } /** * Pulls messages from the server. * * @param subscription Required. The subscription from which messages should be pulled. Format is `projects/{project}/subscriptions/{sub}`. */ async projectsSubscriptionsPull(subscription: string, req: PullRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ subscription }:pull`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return deserializePullResponse(data); } /** * Seeks an existing subscription to a point in time or to a given snapshot, * whichever is provided in the request. Snapshots are used in [Seek] * (https://cloud.google.com/pubsub/docs/replay-overview) operations, which * allow you to manage message acknowledgments in bulk. That is, you can set * the acknowledgment state of messages in an existing subscription to the * state captured by a snapshot. Note that both the subscription and the * snapshot must be on the same topic. * * @param subscription Required. The subscription to affect. */ async projectsSubscriptionsSeek(subscription: string, req: SeekRequest): Promise { req = serializeSeekRequest(req); const url = new URL(`${this.#baseUrl}v1/${ subscription }:seek`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as SeekResponse; } /** * Sets the access control policy on the specified resource. Replaces any * existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and * `PERMISSION_DENIED` errors. * * @param resource REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSubscriptionsSetIamPolicy(resource: string, req: SetIamPolicyRequest): Promise { req = serializeSetIamPolicyRequest(req); const url = new URL(`${this.#baseUrl}v1/${ resource }:setIamPolicy`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return deserializePolicy(data); } /** * Returns permissions that a caller has on the specified resource. If the * resource does not exist, this will return an empty set of permissions, not * a `NOT_FOUND` error. Note: This operation is designed to be used for * building permission-aware UIs and command-line tools, not for authorization * checking. This operation may "fail open" without warning. * * @param resource REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsSubscriptionsTestIamPermissions(resource: string, req: TestIamPermissionsRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ resource }:testIamPermissions`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as TestIamPermissionsResponse; } /** * Creates the given topic with the given name. See the [resource name rules] * (https://cloud.google.com/pubsub/docs/admin#resource_names). * * @param name Required. The name of the topic. It must have the format `"projects/{project}/topics/{topic}"`. `{topic}` must start with a letter, and contain only letters (`[A-Za-z]`), numbers (`[0-9]`), dashes (`-`), underscores (`_`), periods (`.`), tildes (`~`), plus (`+`) or percent signs (`%`). It must be between 3 and 255 characters in length, and it must not start with `"goog"`. */ async projectsTopicsCreate(name: string, req: Topic): Promise { req = serializeTopic(req); const url = new URL(`${this.#baseUrl}v1/${ name }`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "PUT", body, }); return deserializeTopic(data); } /** * Deletes the topic with the given name. Returns `NOT_FOUND` if the topic * does not exist. After a topic is deleted, a new topic may be created with * the same name; this is an entirely new topic with none of the old * configuration or subscriptions. Existing subscriptions to this topic are * not deleted, but their `topic` field is set to `_deleted-topic_`. * * @param topic Required. Name of the topic to delete. Format is `projects/{project}/topics/{topic}`. */ async projectsTopicsDelete(topic: string): Promise { const url = new URL(`${this.#baseUrl}v1/${ topic }`); const data = await request(url.href, { client: this.#client, method: "DELETE", }); return data as Empty; } /** * Gets the configuration of a topic. * * @param topic Required. The name of the topic to get. Format is `projects/{project}/topics/{topic}`. */ async projectsTopicsGet(topic: string): Promise { const url = new URL(`${this.#baseUrl}v1/${ topic }`); const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializeTopic(data); } /** * Gets the access control policy for a resource. Returns an empty policy if * the resource exists and does not have a policy set. * * @param resource REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsTopicsGetIamPolicy(resource: string, opts: ProjectsTopicsGetIamPolicyOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ resource }:getIamPolicy`); if (opts["options.requestedPolicyVersion"] !== undefined) { url.searchParams.append("options.requestedPolicyVersion", String(opts["options.requestedPolicyVersion"])); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializePolicy(data); } /** * Lists matching topics. * * @param project Required. The name of the project in which to list topics. Format is `projects/{project-id}`. */ async projectsTopicsList(project: string, opts: ProjectsTopicsListOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ project }/topics`); if (opts.pageSize !== undefined) { url.searchParams.append("pageSize", String(opts.pageSize)); } if (opts.pageToken !== undefined) { url.searchParams.append("pageToken", String(opts.pageToken)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializeListTopicsResponse(data); } /** * Updates an existing topic. Note that certain properties of a topic are not * modifiable. * * @param name Required. The name of the topic. It must have the format `"projects/{project}/topics/{topic}"`. `{topic}` must start with a letter, and contain only letters (`[A-Za-z]`), numbers (`[0-9]`), dashes (`-`), underscores (`_`), periods (`.`), tildes (`~`), plus (`+`) or percent signs (`%`). It must be between 3 and 255 characters in length, and it must not start with `"goog"`. */ async projectsTopicsPatch(name: string, req: UpdateTopicRequest): Promise { req = serializeUpdateTopicRequest(req); const url = new URL(`${this.#baseUrl}v1/${ name }`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "PATCH", body, }); return deserializeTopic(data); } /** * Adds one or more messages to the topic. Returns `NOT_FOUND` if the topic * does not exist. * * @param topic Required. The messages in the request will be published on this topic. Format is `projects/{project}/topics/{topic}`. */ async projectsTopicsPublish(topic: string, req: PublishRequest): Promise { req = serializePublishRequest(req); const url = new URL(`${this.#baseUrl}v1/${ topic }:publish`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as PublishResponse; } /** * Sets the access control policy on the specified resource. Replaces any * existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and * `PERMISSION_DENIED` errors. * * @param resource REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsTopicsSetIamPolicy(resource: string, req: SetIamPolicyRequest): Promise { req = serializeSetIamPolicyRequest(req); const url = new URL(`${this.#baseUrl}v1/${ resource }:setIamPolicy`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return deserializePolicy(data); } /** * Lists the names of the snapshots on this topic. Snapshots are used in * [Seek](https://cloud.google.com/pubsub/docs/replay-overview) operations, * which allow you to manage message acknowledgments in bulk. That is, you can * set the acknowledgment state of messages in an existing subscription to the * state captured by a snapshot. * * @param topic Required. The name of the topic that snapshots are attached to. Format is `projects/{project}/topics/{topic}`. */ async projectsTopicsSnapshotsList(topic: string, opts: ProjectsTopicsSnapshotsListOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ topic }/snapshots`); if (opts.pageSize !== undefined) { url.searchParams.append("pageSize", String(opts.pageSize)); } if (opts.pageToken !== undefined) { url.searchParams.append("pageToken", String(opts.pageToken)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return data as ListTopicSnapshotsResponse; } /** * Lists the names of the attached subscriptions on this topic. * * @param topic Required. The name of the topic that subscriptions are attached to. Format is `projects/{project}/topics/{topic}`. */ async projectsTopicsSubscriptionsList(topic: string, opts: ProjectsTopicsSubscriptionsListOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v1/${ topic }/subscriptions`); if (opts.pageSize !== undefined) { url.searchParams.append("pageSize", String(opts.pageSize)); } if (opts.pageToken !== undefined) { url.searchParams.append("pageToken", String(opts.pageToken)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return data as ListTopicSubscriptionsResponse; } /** * Returns permissions that a caller has on the specified resource. If the * resource does not exist, this will return an empty set of permissions, not * a `NOT_FOUND` error. Note: This operation is designed to be used for * building permission-aware UIs and command-line tools, not for authorization * checking. This operation may "fail open" without warning. * * @param resource REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field. */ async projectsTopicsTestIamPermissions(resource: string, req: TestIamPermissionsRequest): Promise { const url = new URL(`${this.#baseUrl}v1/${ resource }:testIamPermissions`); const body = JSON.stringify(req); const data = await request(url.href, { client: this.#client, method: "POST", body, }); return data as TestIamPermissionsResponse; } } /** * Request for the Acknowledge method. */ export interface AcknowledgeRequest { /** * Required. The acknowledgment ID for the messages being acknowledged that * was returned by the Pub/Sub system in the `Pull` response. Must not be * empty. */ ackIds?: string[]; } /** * Configuration for writing message data in Avro format. Message payloads and * metadata will be written to files as an Avro binary. */ export interface AvroConfig { /** * When true, write the subscription name, message_id, publish_time, * attributes, and ordering_key as additional fields in the output. */ writeMetadata?: boolean; } /** * Configuration for a BigQuery subscription. */ export interface BigQueryConfig { /** * When true and use_topic_schema is true, any fields that are a part of the * topic schema that are not part of the BigQuery table schema are dropped * when writing to BigQuery. Otherwise, the schemas must be kept in sync and * any messages with extra fields are not written and remain in the * subscription's backlog. */ dropUnknownFields?: boolean; /** * Output only. An output-only field that indicates whether or not the * subscription can receive messages. */ readonly state?: | "STATE_UNSPECIFIED" | "ACTIVE" | "PERMISSION_DENIED" | "NOT_FOUND" | "SCHEMA_MISMATCH"; /** * The name of the table to which to write data, of the form * {projectId}.{datasetId}.{tableId} */ table?: string; /** * When true, use the topic's schema as the columns to write to in BigQuery, * if it exists. */ useTopicSchema?: boolean; /** * When true, write the subscription name, message_id, publish_time, * attributes, and ordering_key to additional columns in the table. The * subscription name, message_id, and publish_time fields are put in their own * columns while all other message properties (other than data) are written to * a JSON object in the attributes column. */ writeMetadata?: boolean; } /** * Associates `members`, or principals, with a `role`. */ export interface Binding { /** * The condition that is associated with this binding. If the condition * evaluates to `true`, then this binding applies to the current request. If * the condition evaluates to `false`, then this binding does not apply to the * current request. However, a different role binding might grant the same * role to one or more of the principals in this binding. To learn which * resources support conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ condition?: Expr; /** * Specifies the principals requesting access for a Google Cloud resource. * `members` can have the following values: * `allUsers`: A special identifier * that represents anyone who is on the internet; with or without a Google * account. * `allAuthenticatedUsers`: A special identifier that represents * anyone who is authenticated with a Google account or a service account. * Does not include identities that come from external identity providers * (IdPs) through identity federation. * `user:{emailid}`: An email address * that represents a specific Google account. For example, `alice@example.com` * . * `serviceAccount:{emailid}`: An email address that represents a Google * service account. For example, `my-other-app@appspot.gserviceaccount.com`. * * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An * identifier for a [Kubernetes service * account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). * For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * * `group:{emailid}`: An email address that represents a Google group. For * example, `admins@example.com`. * `domain:{domain}`: The G Suite domain * (primary) that represents all the users of that domain. For example, * `google.com` or `example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: * An email address (plus unique identifier) representing a user that has been * recently deleted. For example, * `alice@example.com?uid=123456789012345678901`. If the user is recovered, * this value reverts to `user:{emailid}` and the recovered user retains the * role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: * An email address (plus unique identifier) representing a service account * that has been recently deleted. For example, * `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If * the service account is undeleted, this value reverts to * `serviceAccount:{emailid}` and the undeleted service account retains the * role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email * address (plus unique identifier) representing a Google group that has been * recently deleted. For example, * `admins@example.com?uid=123456789012345678901`. If the group is recovered, * this value reverts to `group:{emailid}` and the recovered group retains the * role in the binding. */ members?: string[]; /** * Role that is assigned to the list of `members`, or principals. For * example, `roles/viewer`, `roles/editor`, or `roles/owner`. */ role?: string; } /** * Configuration for a Cloud Storage subscription. */ export interface CloudStorageConfig { /** * If set, message data will be written to Cloud Storage in Avro format. */ avroConfig?: AvroConfig; /** * Required. User-provided name for the Cloud Storage bucket. The bucket must * be created by the user. The bucket name must be without any prefix like * "gs://". See the [bucket naming requirements] * (https://cloud.google.com/storage/docs/buckets#naming). */ bucket?: string; /** * User-provided prefix for Cloud Storage filename. See the [object naming * requirements](https://cloud.google.com/storage/docs/objects#naming). */ filenamePrefix?: string; /** * User-provided suffix for Cloud Storage filename. See the [object naming * requirements](https://cloud.google.com/storage/docs/objects#naming). */ filenameSuffix?: string; /** * The maximum bytes that can be written to a Cloud Storage file before a new * file is created. Min 1 KB, max 10 GiB. The max_bytes limit may be exceeded * in cases where messages are larger than the limit. */ maxBytes?: bigint; /** * The maximum duration that can elapse before a new Cloud Storage file is * created. Min 1 minute, max 10 minutes, default 5 minutes. May not exceed * the subscription's acknowledgement deadline. */ maxDuration?: number /* Duration */; /** * Output only. An output-only field that indicates whether or not the * subscription can receive messages. */ readonly state?: | "STATE_UNSPECIFIED" | "ACTIVE" | "PERMISSION_DENIED" | "NOT_FOUND"; /** * If set, message data will be written to Cloud Storage in text format. */ textConfig?: TextConfig; } function serializeCloudStorageConfig(data: any): CloudStorageConfig { return { ...data, maxBytes: data["maxBytes"] !== undefined ? String(data["maxBytes"]) : undefined, maxDuration: data["maxDuration"] !== undefined ? data["maxDuration"] : undefined, }; } function deserializeCloudStorageConfig(data: any): CloudStorageConfig { return { ...data, maxBytes: data["maxBytes"] !== undefined ? BigInt(data["maxBytes"]) : undefined, maxDuration: data["maxDuration"] !== undefined ? data["maxDuration"] : undefined, }; } /** * Request for CommitSchema method. */ export interface CommitSchemaRequest { /** * Required. The schema revision to commit. */ schema?: Schema; } /** * Request for the `CreateSnapshot` method. */ export interface CreateSnapshotRequest { /** * See [Creating and managing * labels](https://cloud.google.com/pubsub/docs/labels). */ labels?: { [key: string]: string }; /** * Required. The subscription whose backlog the snapshot retains. * Specifically, the created snapshot is guaranteed to retain: (a) The * existing backlog on the subscription. More precisely, this is defined as * the messages in the subscription's backlog that are unacknowledged upon the * successful completion of the `CreateSnapshot` request; as well as: (b) Any * messages published to the subscription's topic following the successful * completion of the CreateSnapshot request. Format is * `projects/{project}/subscriptions/{sub}`. */ subscription?: string; } /** * Dead lettering is done on a best effort basis. The same message might be * dead lettered multiple times. If validation on any of the fields fails at * subscription creation/updation, the create/update subscription request will * fail. */ export interface DeadLetterPolicy { /** * The name of the topic to which dead letter messages should be published. * Format is `projects/{project}/topics/{topic}`.The Cloud Pub/Sub service * account associated with the enclosing subscription's parent project (i.e., * service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com) must have * permission to Publish() to this topic. The operation will fail if the topic * does not exist. Users should ensure that there is a subscription attached * to this topic since messages published to a topic with no subscriptions are * lost. */ deadLetterTopic?: string; /** * The maximum number of delivery attempts for any message. The value must be * between 5 and 100. The number of delivery attempts is defined as 1 + (the * sum of number of NACKs and number of times the acknowledgement deadline has * been exceeded for the message). A NACK is any call to ModifyAckDeadline * with a 0 deadline. Note that client libraries may automatically extend * ack_deadlines. This field will be honored on a best effort basis. If this * parameter is 0, a default value of 5 is used. */ maxDeliveryAttempts?: number; } /** * Response for the DetachSubscription method. Reserved for future use. */ export interface DetachSubscriptionResponse { } /** * A generic empty message that you can re-use to avoid defining duplicated * empty messages in your APIs. A typical example is to use it as the request or * the response type of an API method. For instance: service Foo { rpc * Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } */ export interface Empty { } /** * A policy that specifies the conditions for resource expiration (i.e., * automatic resource deletion). */ export interface ExpirationPolicy { /** * Specifies the "time-to-live" duration for an associated resource. The * resource expires if it is not active for a period of `ttl`. The definition * of "activity" depends on the type of the associated resource. The minimum * and maximum allowed values for `ttl` depend on the type of the associated * resource, as well. If `ttl` is not set, the associated resource never * expires. */ ttl?: number /* Duration */; } function serializeExpirationPolicy(data: any): ExpirationPolicy { return { ...data, ttl: data["ttl"] !== undefined ? data["ttl"] : undefined, }; } function deserializeExpirationPolicy(data: any): ExpirationPolicy { return { ...data, ttl: data["ttl"] !== undefined ? data["ttl"] : undefined, }; } /** * Represents a textual expression in the Common Expression Language (CEL) * syntax. CEL is a C-like expression language. The syntax and semantics of CEL * are documented at https://github.com/google/cel-spec. Example (Comparison): * title: "Summary size limit" description: "Determines if a summary is less * than 100 chars" expression: "document.summary.size() < 100" Example * (Equality): title: "Requestor is owner" description: "Determines if requestor * is the document owner" expression: "document.owner == * request.auth.claims.email" Example (Logic): title: "Public documents" * description: "Determine whether the document should be publicly visible" * expression: "document.type != 'private' && document.type != 'internal'" * Example (Data Manipulation): title: "Notification string" description: * "Create a notification string with a timestamp." expression: "'New message * received at ' + string(document.create_time)" The exact variables and * functions that may be referenced within an expression are determined by the * service that evaluates it. See the service documentation for additional * information. */ export interface Expr { /** * Optional. Description of the expression. This is a longer text which * describes the expression, e.g. when hovered over it in a UI. */ description?: string; /** * Textual representation of an expression in Common Expression Language * syntax. */ expression?: string; /** * Optional. String indicating the location of the expression for error * reporting, e.g. a file name and a position in the file. */ location?: string; /** * Optional. Title for the expression, i.e. a short string describing its * purpose. This can be used e.g. in UIs which allow to enter the expression. */ title?: string; } /** * Response for the `ListSchemaRevisions` method. */ export interface ListSchemaRevisionsResponse { /** * A token that can be sent as `page_token` to retrieve the next page. If * this field is empty, there are no subsequent pages. */ nextPageToken?: string; /** * The revisions of the schema. */ schemas?: Schema[]; } /** * Response for the `ListSchemas` method. */ export interface ListSchemasResponse { /** * If not empty, indicates that there may be more schemas that match the * request; this value should be passed in a new `ListSchemasRequest`. */ nextPageToken?: string; /** * The resulting schemas. */ schemas?: Schema[]; } /** * Response for the `ListSnapshots` method. */ export interface ListSnapshotsResponse { /** * If not empty, indicates that there may be more snapshot that match the * request; this value should be passed in a new `ListSnapshotsRequest`. */ nextPageToken?: string; /** * The resulting snapshots. */ snapshots?: Snapshot[]; } function serializeListSnapshotsResponse(data: any): ListSnapshotsResponse { return { ...data, snapshots: data["snapshots"] !== undefined ? data["snapshots"].map((item: any) => (serializeSnapshot(item))) : undefined, }; } function deserializeListSnapshotsResponse(data: any): ListSnapshotsResponse { return { ...data, snapshots: data["snapshots"] !== undefined ? data["snapshots"].map((item: any) => (deserializeSnapshot(item))) : undefined, }; } /** * Response for the `ListSubscriptions` method. */ export interface ListSubscriptionsResponse { /** * If not empty, indicates that there may be more subscriptions that match * the request; this value should be passed in a new * `ListSubscriptionsRequest` to get more subscriptions. */ nextPageToken?: string; /** * The subscriptions that match the request. */ subscriptions?: Subscription[]; } function serializeListSubscriptionsResponse(data: any): ListSubscriptionsResponse { return { ...data, subscriptions: data["subscriptions"] !== undefined ? data["subscriptions"].map((item: any) => (serializeSubscription(item))) : undefined, }; } function deserializeListSubscriptionsResponse(data: any): ListSubscriptionsResponse { return { ...data, subscriptions: data["subscriptions"] !== undefined ? data["subscriptions"].map((item: any) => (deserializeSubscription(item))) : undefined, }; } /** * Response for the `ListTopicSnapshots` method. */ export interface ListTopicSnapshotsResponse { /** * If not empty, indicates that there may be more snapshots that match the * request; this value should be passed in a new `ListTopicSnapshotsRequest` * to get more snapshots. */ nextPageToken?: string; /** * The names of the snapshots that match the request. */ snapshots?: string[]; } /** * Response for the `ListTopics` method. */ export interface ListTopicsResponse { /** * If not empty, indicates that there may be more topics that match the * request; this value should be passed in a new `ListTopicsRequest`. */ nextPageToken?: string; /** * The resulting topics. */ topics?: Topic[]; } function serializeListTopicsResponse(data: any): ListTopicsResponse { return { ...data, topics: data["topics"] !== undefined ? data["topics"].map((item: any) => (serializeTopic(item))) : undefined, }; } function deserializeListTopicsResponse(data: any): ListTopicsResponse { return { ...data, topics: data["topics"] !== undefined ? data["topics"].map((item: any) => (deserializeTopic(item))) : undefined, }; } /** * Response for the `ListTopicSubscriptions` method. */ export interface ListTopicSubscriptionsResponse { /** * If not empty, indicates that there may be more subscriptions that match * the request; this value should be passed in a new * `ListTopicSubscriptionsRequest` to get more subscriptions. */ nextPageToken?: string; /** * The names of subscriptions attached to the topic specified in the request. */ subscriptions?: string[]; } /** * A policy constraining the storage of messages published to the topic. */ export interface MessageStoragePolicy { /** * A list of IDs of GCP regions where messages that are published to the * topic may be persisted in storage. Messages published by publishers running * in non-allowed GCP regions (or running outside of GCP altogether) will be * routed for storage in one of the allowed regions. An empty list means that * no regions are allowed, and is not a valid configuration. */ allowedPersistenceRegions?: string[]; } /** * Request for the ModifyAckDeadline method. */ export interface ModifyAckDeadlineRequest { /** * Required. The new ack deadline with respect to the time this request was * sent to the Pub/Sub system. For example, if the value is 10, the new ack * deadline will expire 10 seconds after the `ModifyAckDeadline` call was * made. Specifying zero might immediately make the message available for * delivery to another subscriber client. This typically results in an * increase in the rate of message redeliveries (that is, duplicates). The * minimum deadline you can specify is 0 seconds. The maximum deadline you can * specify is 600 seconds (10 minutes). */ ackDeadlineSeconds?: number; /** * Required. List of acknowledgment IDs. */ ackIds?: string[]; } /** * Request for the ModifyPushConfig method. */ export interface ModifyPushConfigRequest { /** * Required. The push configuration for future deliveries. An empty * `pushConfig` indicates that the Pub/Sub system should stop pushing messages * from the given subscription and allow messages to be pulled and * acknowledged - effectively pausing the subscription if `Pull` or * `StreamingPull` is not called. */ pushConfig?: PushConfig; } /** * Sets the `data` field as the HTTP body for delivery. */ export interface NoWrapper { /** * When true, writes the Pub/Sub message metadata to `x-goog-pubsub-:` * headers of the HTTP request. Writes the Pub/Sub message attributes to `:` * headers of the HTTP request. */ writeMetadata?: boolean; } /** * Contains information needed for generating an [OpenID Connect * token](https://developers.google.com/identity/protocols/OpenIDConnect). */ export interface OidcToken { /** * Audience to be used when generating OIDC token. The audience claim * identifies the recipients that the JWT is intended for. The audience value * is a single case-sensitive string. Having multiple values (array) for the * audience field is not supported. More info about the OIDC JWT token * audience here: https://tools.ietf.org/html/rfc7519#section-4.1.3 Note: if * not specified, the Push endpoint URL will be used. */ audience?: string; /** * [Service account * email](https://cloud.google.com/iam/docs/service-accounts) used for * generating the OIDC token. For more information on setting up * authentication, see [Push * subscriptions](https://cloud.google.com/pubsub/docs/push). */ serviceAccountEmail?: string; } /** * An Identity and Access Management (IAM) policy, which specifies access * controls for Google Cloud resources. A `Policy` is a collection of * `bindings`. A `binding` binds one or more `members`, or principals, to a * single `role`. Principals can be user accounts, service accounts, Google * groups, and domains (such as G Suite). A `role` is a named list of * permissions; each `role` can be an IAM predefined role or a user-created * custom role. For some types of Google Cloud resources, a `binding` can also * specify a `condition`, which is a logical expression that allows access to a * resource only if the expression evaluates to `true`. A condition can add * constraints based on attributes of the request, the resource, or both. To * learn which resources support conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). * **JSON example:** { "bindings": [ { "role": * "roles/resourcemanager.organizationAdmin", "members": [ * "user:mike@example.com", "group:admins@example.com", "domain:google.com", * "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role": * "roles/resourcemanager.organizationViewer", "members": [ * "user:eve@example.com" ], "condition": { "title": "expirable access", * "description": "Does not grant access after Sep 2020", "expression": * "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag": * "BwWWja0YfJA=", "version": 3 } **YAML example:** bindings: - members: - * user:mike@example.com - group:admins@example.com - domain:google.com - * serviceAccount:my-project-id@appspot.gserviceaccount.com role: * roles/resourcemanager.organizationAdmin - members: - user:eve@example.com * role: roles/resourcemanager.organizationViewer condition: title: expirable * access description: Does not grant access after Sep 2020 expression: * request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= * version: 3 For a description of IAM and its features, see the [IAM * documentation](https://cloud.google.com/iam/docs/). */ export interface Policy { /** * Associates a list of `members`, or principals, with a `role`. Optionally, * may specify a `condition` that determines how and when the `bindings` are * applied. Each of the `bindings` must contain at least one principal. The * `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of * these principals can be Google groups. Each occurrence of a principal * counts towards these limits. For example, if the `bindings` grant 50 * different roles to `user:alice@example.com`, and not to any other * principal, then you can add another 1,450 principals to the `bindings` in * the `Policy`. */ bindings?: Binding[]; /** * `etag` is used for optimistic concurrency control as a way to help prevent * simultaneous updates of a policy from overwriting each other. It is * strongly suggested that systems make use of the `etag` in the * read-modify-write cycle to perform policy updates in order to avoid race * conditions: An `etag` is returned in the response to `getIamPolicy`, and * systems are expected to put that etag in the request to `setIamPolicy` to * ensure that their change will be applied to the same version of the policy. * **Important:** If you use IAM Conditions, you must include the `etag` field * whenever you call `setIamPolicy`. If you omit this field, then IAM allows * you to overwrite a version `3` policy with a version `1` policy, and all of * the conditions in the version `3` policy are lost. */ etag?: Uint8Array; /** * Specifies the format of the policy. Valid values are `0`, `1`, and `3`. * Requests that specify an invalid value are rejected. Any operation that * affects conditional role bindings must specify version `3`. This * requirement applies to the following operations: * Getting a policy that * includes a conditional role binding * Adding a conditional role binding to * a policy * Changing a conditional role binding in a policy * Removing any * role binding, with or without a condition, from a policy that includes * conditions **Important:** If you use IAM Conditions, you must include the * `etag` field whenever you call `setIamPolicy`. If you omit this field, then * IAM allows you to overwrite a version `3` policy with a version `1` policy, * and all of the conditions in the version `3` policy are lost. If a policy * does not include any conditions, operations on that policy may specify any * valid version or leave the field unset. To learn which resources support * conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ version?: number; } function serializePolicy(data: any): Policy { return { ...data, etag: data["etag"] !== undefined ? encodeBase64(data["etag"]) : undefined, }; } function deserializePolicy(data: any): Policy { return { ...data, etag: data["etag"] !== undefined ? decodeBase64(data["etag"] as string) : undefined, }; } /** * Additional options for pubsub#projectsSchemasCreate. */ export interface ProjectsSchemasCreateOptions { /** * The ID to use for the schema, which will become the final component of the * schema's resource name. See * https://cloud.google.com/pubsub/docs/admin#resource_names for resource name * constraints. */ schemaId?: string; } /** * Additional options for pubsub#projectsSchemasDeleteRevision. */ export interface ProjectsSchemasDeleteRevisionOptions { /** * Optional. This field is deprecated and should not be used for specifying * the revision ID. The revision ID should be specified via the `name` * parameter. */ revisionId?: string; } /** * Additional options for pubsub#projectsSchemasGetIamPolicy. */ export interface ProjectsSchemasGetIamPolicyOptions { /** * Optional. The maximum policy version that will be used to format the * policy. Valid values are 0, 1, and 3. Requests specifying an invalid value * will be rejected. Requests for policies with any conditional role bindings * must specify version 3. Policies with no conditional role bindings may * specify any valid value or leave the field unset. The policy in the * response might use the policy version that you specified, or it might use a * lower policy version. For example, if you specify version 3, but the policy * has no conditional role bindings, the response uses version 1. To learn * which resources support conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ ["options.requestedPolicyVersion"]?: number; } /** * Additional options for pubsub#projectsSchemasGet. */ export interface ProjectsSchemasGetOptions { /** * The set of fields to return in the response. If not set, returns a Schema * with all fields filled out. Set to `BASIC` to omit the `definition`. */ view?: | "SCHEMA_VIEW_UNSPECIFIED" | "BASIC" | "FULL"; } /** * Additional options for pubsub#projectsSchemasList. */ export interface ProjectsSchemasListOptions { /** * Maximum number of schemas to return. */ pageSize?: number; /** * The value returned by the last `ListSchemasResponse`; indicates that this * is a continuation of a prior `ListSchemas` call, and that the system should * return the next page of data. */ pageToken?: string; /** * The set of Schema fields to return in the response. If not set, returns * Schemas with `name` and `type`, but not `definition`. Set to `FULL` to * retrieve all fields. */ view?: | "SCHEMA_VIEW_UNSPECIFIED" | "BASIC" | "FULL"; } /** * Additional options for pubsub#projectsSchemasListRevisions. */ export interface ProjectsSchemasListRevisionsOptions { /** * The maximum number of revisions to return per page. */ pageSize?: number; /** * The page token, received from a previous ListSchemaRevisions call. Provide * this to retrieve the subsequent page. */ pageToken?: string; /** * The set of Schema fields to return in the response. If not set, returns * Schemas with `name` and `type`, but not `definition`. Set to `FULL` to * retrieve all fields. */ view?: | "SCHEMA_VIEW_UNSPECIFIED" | "BASIC" | "FULL"; } /** * Additional options for pubsub#projectsSnapshotsGetIamPolicy. */ export interface ProjectsSnapshotsGetIamPolicyOptions { /** * Optional. The maximum policy version that will be used to format the * policy. Valid values are 0, 1, and 3. Requests specifying an invalid value * will be rejected. Requests for policies with any conditional role bindings * must specify version 3. Policies with no conditional role bindings may * specify any valid value or leave the field unset. The policy in the * response might use the policy version that you specified, or it might use a * lower policy version. For example, if you specify version 3, but the policy * has no conditional role bindings, the response uses version 1. To learn * which resources support conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ ["options.requestedPolicyVersion"]?: number; } /** * Additional options for pubsub#projectsSnapshotsList. */ export interface ProjectsSnapshotsListOptions { /** * Maximum number of snapshots to return. */ pageSize?: number; /** * The value returned by the last `ListSnapshotsResponse`; indicates that * this is a continuation of a prior `ListSnapshots` call, and that the system * should return the next page of data. */ pageToken?: string; } /** * Additional options for pubsub#projectsSubscriptionsGetIamPolicy. */ export interface ProjectsSubscriptionsGetIamPolicyOptions { /** * Optional. The maximum policy version that will be used to format the * policy. Valid values are 0, 1, and 3. Requests specifying an invalid value * will be rejected. Requests for policies with any conditional role bindings * must specify version 3. Policies with no conditional role bindings may * specify any valid value or leave the field unset. The policy in the * response might use the policy version that you specified, or it might use a * lower policy version. For example, if you specify version 3, but the policy * has no conditional role bindings, the response uses version 1. To learn * which resources support conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ ["options.requestedPolicyVersion"]?: number; } /** * Additional options for pubsub#projectsSubscriptionsList. */ export interface ProjectsSubscriptionsListOptions { /** * Maximum number of subscriptions to return. */ pageSize?: number; /** * The value returned by the last `ListSubscriptionsResponse`; indicates that * this is a continuation of a prior `ListSubscriptions` call, and that the * system should return the next page of data. */ pageToken?: string; } /** * Additional options for pubsub#projectsTopicsGetIamPolicy. */ export interface ProjectsTopicsGetIamPolicyOptions { /** * Optional. The maximum policy version that will be used to format the * policy. Valid values are 0, 1, and 3. Requests specifying an invalid value * will be rejected. Requests for policies with any conditional role bindings * must specify version 3. Policies with no conditional role bindings may * specify any valid value or leave the field unset. The policy in the * response might use the policy version that you specified, or it might use a * lower policy version. For example, if you specify version 3, but the policy * has no conditional role bindings, the response uses version 1. To learn * which resources support conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ ["options.requestedPolicyVersion"]?: number; } /** * Additional options for pubsub#projectsTopicsList. */ export interface ProjectsTopicsListOptions { /** * Maximum number of topics to return. */ pageSize?: number; /** * The value returned by the last `ListTopicsResponse`; indicates that this * is a continuation of a prior `ListTopics` call, and that the system should * return the next page of data. */ pageToken?: string; } /** * Additional options for pubsub#projectsTopicsSnapshotsList. */ export interface ProjectsTopicsSnapshotsListOptions { /** * Maximum number of snapshot names to return. */ pageSize?: number; /** * The value returned by the last `ListTopicSnapshotsResponse`; indicates * that this is a continuation of a prior `ListTopicSnapshots` call, and that * the system should return the next page of data. */ pageToken?: string; } /** * Additional options for pubsub#projectsTopicsSubscriptionsList. */ export interface ProjectsTopicsSubscriptionsListOptions { /** * Maximum number of subscription names to return. */ pageSize?: number; /** * The value returned by the last `ListTopicSubscriptionsResponse`; indicates * that this is a continuation of a prior `ListTopicSubscriptions` call, and * that the system should return the next page of data. */ pageToken?: string; } /** * Request for the Publish method. */ export interface PublishRequest { /** * Required. The messages to publish. */ messages?: PubsubMessage[]; } function serializePublishRequest(data: any): PublishRequest { return { ...data, messages: data["messages"] !== undefined ? data["messages"].map((item: any) => (serializePubsubMessage(item))) : undefined, }; } function deserializePublishRequest(data: any): PublishRequest { return { ...data, messages: data["messages"] !== undefined ? data["messages"].map((item: any) => (deserializePubsubMessage(item))) : undefined, }; } /** * Response for the `Publish` method. */ export interface PublishResponse { /** * The server-assigned ID of each published message, in the same order as the * messages in the request. IDs are guaranteed to be unique within the topic. */ messageIds?: string[]; } /** * A message that is published by publishers and consumed by subscribers. The * message must contain either a non-empty data field or at least one attribute. * Note that client libraries represent this object differently depending on the * language. See the corresponding [client library * documentation](https://cloud.google.com/pubsub/docs/reference/libraries) for * more information. See [quotas and limits] * (https://cloud.google.com/pubsub/quotas) for more information about message * limits. */ export interface PubsubMessage { /** * Attributes for this message. If this field is empty, the message must * contain non-empty data. This can be used to filter messages on the * subscription. */ attributes?: { [key: string]: string }; /** * The message data field. If this field is empty, the message must contain * at least one attribute. */ data?: Uint8Array; /** * ID of this message, assigned by the server when the message is published. * Guaranteed to be unique within the topic. This value may be read by a * subscriber that receives a `PubsubMessage` via a `Pull` call or a push * delivery. It must not be populated by the publisher in a `Publish` call. */ messageId?: string; /** * If non-empty, identifies related messages for which publish order should * be respected. If a `Subscription` has `enable_message_ordering` set to * `true`, messages published with the same non-empty `ordering_key` value * will be delivered to subscribers in the order in which they are received by * the Pub/Sub system. All `PubsubMessage`s published in a given * `PublishRequest` must specify the same `ordering_key` value. For more * information, see [ordering * messages](https://cloud.google.com/pubsub/docs/ordering). */ orderingKey?: string; /** * The time at which the message was published, populated by the server when * it receives the `Publish` call. It must not be populated by the publisher * in a `Publish` call. */ publishTime?: Date; } function serializePubsubMessage(data: any): PubsubMessage { return { ...data, data: data["data"] !== undefined ? encodeBase64(data["data"]) : undefined, publishTime: data["publishTime"] !== undefined ? data["publishTime"].toISOString() : undefined, }; } function deserializePubsubMessage(data: any): PubsubMessage { return { ...data, data: data["data"] !== undefined ? decodeBase64(data["data"] as string) : undefined, publishTime: data["publishTime"] !== undefined ? new Date(data["publishTime"]) : undefined, }; } /** * The payload to the push endpoint is in the form of the JSON representation * of a PubsubMessage * (https://cloud.google.com/pubsub/docs/reference/rpc/google.pubsub.v1#pubsubmessage). */ export interface PubsubWrapper { } /** * Request for the `Pull` method. */ export interface PullRequest { /** * Required. The maximum number of messages to return for this request. Must * be a positive integer. The Pub/Sub system may return fewer than the number * specified. */ maxMessages?: number; /** * Optional. If this field set to true, the system will respond immediately * even if it there are no messages available to return in the `Pull` * response. Otherwise, the system may wait (for a bounded amount of time) * until at least one message is available, rather than returning no messages. * Warning: setting this field to `true` is discouraged because it adversely * impacts the performance of `Pull` operations. We recommend that users do * not set this field. */ returnImmediately?: boolean; } /** * Response for the `Pull` method. */ export interface PullResponse { /** * Received Pub/Sub messages. The list will be empty if there are no more * messages available in the backlog, or if no messages could be returned * before the request timeout. For JSON, the response can be entirely empty. * The Pub/Sub system may return fewer than the `maxMessages` requested even * if there are more messages available in the backlog. */ receivedMessages?: ReceivedMessage[]; } function serializePullResponse(data: any): PullResponse { return { ...data, receivedMessages: data["receivedMessages"] !== undefined ? data["receivedMessages"].map((item: any) => (serializeReceivedMessage(item))) : undefined, }; } function deserializePullResponse(data: any): PullResponse { return { ...data, receivedMessages: data["receivedMessages"] !== undefined ? data["receivedMessages"].map((item: any) => (deserializeReceivedMessage(item))) : undefined, }; } /** * Configuration for a push delivery endpoint. */ export interface PushConfig { /** * Endpoint configuration attributes that can be used to control different * aspects of the message delivery. The only currently supported attribute is * `x-goog-version`, which you can use to change the format of the pushed * message. This attribute indicates the version of the data expected by the * endpoint. This controls the shape of the pushed message (i.e., its fields * and metadata). If not present during the `CreateSubscription` call, it will * default to the version of the Pub/Sub API used to make such call. If not * present in a `ModifyPushConfig` call, its value will not be changed. * `GetSubscription` calls will always return a valid version, even if the * subscription was created without this attribute. The only supported values * for the `x-goog-version` attribute are: * `v1beta1`: uses the push format * defined in the v1beta1 Pub/Sub API. * `v1` or `v1beta2`: uses the push * format defined in the v1 Pub/Sub API. For example: `attributes { * "x-goog-version": "v1" }` */ attributes?: { [key: string]: string }; /** * When set, the payload to the push endpoint is not wrapped. */ noWrapper?: NoWrapper; /** * If specified, Pub/Sub will generate and attach an OIDC JWT token as an * `Authorization` header in the HTTP request for every pushed message. */ oidcToken?: OidcToken; /** * When set, the payload to the push endpoint is in the form of the JSON * representation of a PubsubMessage * (https://cloud.google.com/pubsub/docs/reference/rpc/google.pubsub.v1#pubsubmessage). */ pubsubWrapper?: PubsubWrapper; /** * A URL locating the endpoint to which messages should be pushed. For * example, a Webhook endpoint might use `https://example.com/push`. */ pushEndpoint?: string; } /** * A message and its corresponding acknowledgment ID. */ export interface ReceivedMessage { /** * This ID can be used to acknowledge the received message. */ ackId?: string; /** * The approximate number of times that Cloud Pub/Sub has attempted to * deliver the associated message to a subscriber. More precisely, this is 1 + * (number of NACKs) + (number of ack_deadline exceeds) for this message. A * NACK is any call to ModifyAckDeadline with a 0 deadline. An ack_deadline * exceeds event is whenever a message is not acknowledged within * ack_deadline. Note that ack_deadline is initially * Subscription.ackDeadlineSeconds, but may get extended automatically by the * client library. Upon the first delivery of a given message, * `delivery_attempt` will have a value of 1. The value is calculated at best * effort and is approximate. If a DeadLetterPolicy is not set on the * subscription, this will be 0. */ deliveryAttempt?: number; /** * The message. */ message?: PubsubMessage; } function serializeReceivedMessage(data: any): ReceivedMessage { return { ...data, message: data["message"] !== undefined ? serializePubsubMessage(data["message"]) : undefined, }; } function deserializeReceivedMessage(data: any): ReceivedMessage { return { ...data, message: data["message"] !== undefined ? deserializePubsubMessage(data["message"]) : undefined, }; } /** * A policy that specifies how Cloud Pub/Sub retries message delivery. Retry * delay will be exponential based on provided minimum and maximum backoffs. * https://en.wikipedia.org/wiki/Exponential_backoff. RetryPolicy will be * triggered on NACKs or acknowledgement deadline exceeded events for a given * message. Retry Policy is implemented on a best effort basis. At times, the * delay between consecutive deliveries may not match the configuration. That * is, delay can be more or less than configured backoff. */ export interface RetryPolicy { /** * The maximum delay between consecutive deliveries of a given message. Value * should be between 0 and 600 seconds. Defaults to 600 seconds. */ maximumBackoff?: number /* Duration */; /** * The minimum delay between consecutive deliveries of a given message. Value * should be between 0 and 600 seconds. Defaults to 10 seconds. */ minimumBackoff?: number /* Duration */; } function serializeRetryPolicy(data: any): RetryPolicy { return { ...data, maximumBackoff: data["maximumBackoff"] !== undefined ? data["maximumBackoff"] : undefined, minimumBackoff: data["minimumBackoff"] !== undefined ? data["minimumBackoff"] : undefined, }; } function deserializeRetryPolicy(data: any): RetryPolicy { return { ...data, maximumBackoff: data["maximumBackoff"] !== undefined ? data["maximumBackoff"] : undefined, minimumBackoff: data["minimumBackoff"] !== undefined ? data["minimumBackoff"] : undefined, }; } /** * Request for the `RollbackSchema` method. */ export interface RollbackSchemaRequest { /** * Required. The revision ID to roll back to. It must be a revision of the * same schema. Example: c7cfa2a8 */ revisionId?: string; } /** * A schema resource. */ export interface Schema { /** * The definition of the schema. This should contain a string representing * the full definition of the schema that is a valid schema definition of the * type specified in `type`. */ definition?: string; /** * Required. Name of the schema. Format is * `projects/{project}/schemas/{schema}`. */ name?: string; /** * Output only. The timestamp that the revision was created. */ readonly revisionCreateTime?: Date; /** * Output only. Immutable. The revision ID of the schema. */ readonly revisionId?: string; /** * The type of the schema definition. */ type?: | "TYPE_UNSPECIFIED" | "PROTOCOL_BUFFER" | "AVRO"; } /** * Settings for validating messages published against a schema. */ export interface SchemaSettings { /** * The encoding of messages validated against `schema`. */ encoding?: | "ENCODING_UNSPECIFIED" | "JSON" | "BINARY"; /** * The minimum (inclusive) revision allowed for validating messages. If empty * or not present, allow any revision to be validated against last_revision or * any revision created before. */ firstRevisionId?: string; /** * The maximum (inclusive) revision allowed for validating messages. If empty * or not present, allow any revision to be validated against first_revision * or any revision created after. */ lastRevisionId?: string; /** * Required. The name of the schema that messages published should be * validated against. Format is `projects/{project}/schemas/{schema}`. The * value of this field will be `_deleted-schema_` if the schema has been * deleted. */ schema?: string; } /** * Request for the `Seek` method. */ export interface SeekRequest { /** * The snapshot to seek to. The snapshot's topic must be the same as that of * the provided subscription. Format is `projects/{project}/snapshots/{snap}`. */ snapshot?: string; /** * The time to seek to. Messages retained in the subscription that were * published before this time are marked as acknowledged, and messages * retained in the subscription that were published after this time are marked * as unacknowledged. Note that this operation affects only those messages * retained in the subscription (configured by the combination of * `message_retention_duration` and `retain_acked_messages`). For example, if * `time` corresponds to a point before the message retention window (or to a * point before the system's notion of the subscription creation time), only * retained messages will be marked as unacknowledged, and already-expunged * messages will not be restored. */ time?: Date; } function serializeSeekRequest(data: any): SeekRequest { return { ...data, time: data["time"] !== undefined ? data["time"].toISOString() : undefined, }; } function deserializeSeekRequest(data: any): SeekRequest { return { ...data, time: data["time"] !== undefined ? new Date(data["time"]) : undefined, }; } /** * Response for the `Seek` method (this response is empty). */ export interface SeekResponse { } /** * Request message for `SetIamPolicy` method. */ export interface SetIamPolicyRequest { /** * REQUIRED: The complete policy to be applied to the `resource`. The size of * the policy is limited to a few 10s of KB. An empty policy is a valid policy * but certain Google Cloud services (such as Projects) might reject them. */ policy?: Policy; } function serializeSetIamPolicyRequest(data: any): SetIamPolicyRequest { return { ...data, policy: data["policy"] !== undefined ? serializePolicy(data["policy"]) : undefined, }; } function deserializeSetIamPolicyRequest(data: any): SetIamPolicyRequest { return { ...data, policy: data["policy"] !== undefined ? deserializePolicy(data["policy"]) : undefined, }; } /** * A snapshot resource. Snapshots are used in * [Seek](https://cloud.google.com/pubsub/docs/replay-overview) operations, * which allow you to manage message acknowledgments in bulk. That is, you can * set the acknowledgment state of messages in an existing subscription to the * state captured by a snapshot. */ export interface Snapshot { /** * The snapshot is guaranteed to exist up until this time. A newly-created * snapshot expires no later than 7 days from the time of its creation. Its * exact lifetime is determined at creation by the existing backlog in the * source subscription. Specifically, the lifetime of the snapshot is `7 days * - (age of oldest unacked message in the subscription)`. For example, * consider a subscription whose oldest unacked message is 3 days old. If a * snapshot is created from this subscription, the snapshot -- which will * always capture this 3-day-old backlog as long as the snapshot exists -- * will expire in 4 days. The service will refuse to create a snapshot that * would expire in less than 1 hour after creation. */ expireTime?: Date; /** * See [Creating and managing labels] * (https://cloud.google.com/pubsub/docs/labels). */ labels?: { [key: string]: string }; /** * The name of the snapshot. */ name?: string; /** * The name of the topic from which this snapshot is retaining messages. */ topic?: string; } function serializeSnapshot(data: any): Snapshot { return { ...data, expireTime: data["expireTime"] !== undefined ? data["expireTime"].toISOString() : undefined, }; } function deserializeSnapshot(data: any): Snapshot { return { ...data, expireTime: data["expireTime"] !== undefined ? new Date(data["expireTime"]) : undefined, }; } /** * A subscription resource. If none of `push_config`, `bigquery_config`, or * `cloud_storage_config` is set, then the subscriber will pull and ack messages * using API methods. At most one of these fields may be set. */ export interface Subscription { /** * The approximate amount of time (on a best-effort basis) Pub/Sub waits for * the subscriber to acknowledge receipt before resending the message. In the * interval after the message is delivered and before it is acknowledged, it * is considered to be _outstanding_. During that time period, the message * will not be redelivered (on a best-effort basis). For pull subscriptions, * this value is used as the initial value for the ack deadline. To override * this value for a given message, call `ModifyAckDeadline` with the * corresponding `ack_id` if using non-streaming pull or send the `ack_id` in * a `StreamingModifyAckDeadlineRequest` if using streaming pull. The minimum * custom deadline you can specify is 10 seconds. The maximum custom deadline * you can specify is 600 seconds (10 minutes). If this parameter is 0, a * default value of 10 seconds is used. For push delivery, this value is also * used to set the request timeout for the call to the push endpoint. If the * subscriber never acknowledges the message, the Pub/Sub system will * eventually redeliver the message. */ ackDeadlineSeconds?: number; /** * If delivery to BigQuery is used with this subscription, this field is used * to configure it. */ bigqueryConfig?: BigQueryConfig; /** * If delivery to Google Cloud Storage is used with this subscription, this * field is used to configure it. */ cloudStorageConfig?: CloudStorageConfig; /** * A policy that specifies the conditions for dead lettering messages in this * subscription. If dead_letter_policy is not set, dead lettering is disabled. * The Cloud Pub/Sub service account associated with this subscriptions's * parent project (i.e., * service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com) must have * permission to Acknowledge() messages on this subscription. */ deadLetterPolicy?: DeadLetterPolicy; /** * Indicates whether the subscription is detached from its topic. Detached * subscriptions don't receive messages from their topic and don't retain any * backlog. `Pull` and `StreamingPull` requests will return * FAILED_PRECONDITION. If the subscription is a push subscription, pushes to * the endpoint will not be made. */ detached?: boolean; /** * If true, Pub/Sub provides the following guarantees for the delivery of a * message with a given value of `message_id` on this subscription: * The * message sent to a subscriber is guaranteed not to be resent before the * message's acknowledgement deadline expires. * An acknowledged message will * not be resent to a subscriber. Note that subscribers may still receive * multiple copies of a message when `enable_exactly_once_delivery` is true if * the message was published multiple times by a publisher client. These * copies are considered distinct by Pub/Sub and have distinct `message_id` * values. */ enableExactlyOnceDelivery?: boolean; /** * If true, messages published with the same `ordering_key` in * `PubsubMessage` will be delivered to the subscribers in the order in which * they are received by the Pub/Sub system. Otherwise, they may be delivered * in any order. */ enableMessageOrdering?: boolean; /** * A policy that specifies the conditions for this subscription's expiration. * A subscription is considered active as long as any connected subscriber is * successfully consuming messages from the subscription or is issuing * operations on the subscription. If `expiration_policy` is not set, a * *default policy* with `ttl` of 31 days will be used. The minimum allowed * value for `expiration_policy.ttl` is 1 day. If `expiration_policy` is set, * but `expiration_policy.ttl` is not set, the subscription never expires. */ expirationPolicy?: ExpirationPolicy; /** * An expression written in the Pub/Sub [filter * language](https://cloud.google.com/pubsub/docs/filtering). If non-empty, * then only `PubsubMessage`s whose `attributes` field matches the filter are * delivered on this subscription. If empty, then no messages are filtered * out. */ filter?: string; /** * See [Creating and managing * labels](https://cloud.google.com/pubsub/docs/labels). */ labels?: { [key: string]: string }; /** * How long to retain unacknowledged messages in the subscription's backlog, * from the moment a message is published. If `retain_acked_messages` is true, * then this also configures the retention of acknowledged messages, and thus * configures how far back in time a `Seek` can be done. Defaults to 7 days. * Cannot be more than 7 days or less than 10 minutes. */ messageRetentionDuration?: number /* Duration */; /** * Required. The name of the subscription. It must have the format * `"projects/{project}/subscriptions/{subscription}"`. `{subscription}` must * start with a letter, and contain only letters (`[A-Za-z]`), numbers * (`[0-9]`), dashes (`-`), underscores (`_`), periods (`.`), tildes (`~`), * plus (`+`) or percent signs (`%`). It must be between 3 and 255 characters * in length, and it must not start with `"goog"`. */ name?: string; /** * If push delivery is used with this subscription, this field is used to * configure it. */ pushConfig?: PushConfig; /** * Indicates whether to retain acknowledged messages. If true, then messages * are not expunged from the subscription's backlog, even if they are * acknowledged, until they fall out of the `message_retention_duration` * window. This must be true if you would like to [`Seek` to a timestamp] * (https://cloud.google.com/pubsub/docs/replay-overview#seek_to_a_time) in * the past to replay previously-acknowledged messages. */ retainAckedMessages?: boolean; /** * A policy that specifies how Pub/Sub retries message delivery for this * subscription. If not set, the default retry policy is applied. This * generally implies that messages will be retried as soon as possible for * healthy subscribers. RetryPolicy will be triggered on NACKs or * acknowledgement deadline exceeded events for a given message. */ retryPolicy?: RetryPolicy; /** * Output only. An output-only field indicating whether or not the * subscription can receive messages. */ readonly state?: | "STATE_UNSPECIFIED" | "ACTIVE" | "RESOURCE_ERROR"; /** * Required. The name of the topic from which this subscription is receiving * messages. Format is `projects/{project}/topics/{topic}`. The value of this * field will be `_deleted-topic_` if the topic has been deleted. */ topic?: string; /** * Output only. Indicates the minimum duration for which a message is * retained after it is published to the subscription's topic. If this field * is set, messages published to the subscription's topic in the last * `topic_message_retention_duration` are always available to subscribers. See * the `message_retention_duration` field in `Topic`. This field is set only * in responses from the server; it is ignored if it is set in any requests. */ readonly topicMessageRetentionDuration?: number /* Duration */; } function serializeSubscription(data: any): Subscription { return { ...data, cloudStorageConfig: data["cloudStorageConfig"] !== undefined ? serializeCloudStorageConfig(data["cloudStorageConfig"]) : undefined, expirationPolicy: data["expirationPolicy"] !== undefined ? serializeExpirationPolicy(data["expirationPolicy"]) : undefined, messageRetentionDuration: data["messageRetentionDuration"] !== undefined ? data["messageRetentionDuration"] : undefined, retryPolicy: data["retryPolicy"] !== undefined ? serializeRetryPolicy(data["retryPolicy"]) : undefined, }; } function deserializeSubscription(data: any): Subscription { return { ...data, cloudStorageConfig: data["cloudStorageConfig"] !== undefined ? deserializeCloudStorageConfig(data["cloudStorageConfig"]) : undefined, expirationPolicy: data["expirationPolicy"] !== undefined ? deserializeExpirationPolicy(data["expirationPolicy"]) : undefined, messageRetentionDuration: data["messageRetentionDuration"] !== undefined ? data["messageRetentionDuration"] : undefined, retryPolicy: data["retryPolicy"] !== undefined ? deserializeRetryPolicy(data["retryPolicy"]) : undefined, topicMessageRetentionDuration: data["topicMessageRetentionDuration"] !== undefined ? data["topicMessageRetentionDuration"] : undefined, }; } /** * Request message for `TestIamPermissions` method. */ export interface TestIamPermissionsRequest { /** * The set of permissions to check for the `resource`. Permissions with * wildcards (such as `*` or `storage.*`) are not allowed. For more * information see [IAM * Overview](https://cloud.google.com/iam/docs/overview#permissions). */ permissions?: string[]; } /** * Response message for `TestIamPermissions` method. */ export interface TestIamPermissionsResponse { /** * A subset of `TestPermissionsRequest.permissions` that the caller is * allowed. */ permissions?: string[]; } /** * Configuration for writing message data in text format. Message payloads will * be written to files as raw text, separated by a newline. */ export interface TextConfig { } /** * A topic resource. */ export interface Topic { /** * The resource name of the Cloud KMS CryptoKey to be used to protect access * to messages published on this topic. The expected format is * `projects/*\/locations/*\/keyRings/*\/cryptoKeys/*`. */ kmsKeyName?: string; /** * See [Creating and managing labels] * (https://cloud.google.com/pubsub/docs/labels). */ labels?: { [key: string]: string }; /** * Indicates the minimum duration to retain a message after it is published * to the topic. If this field is set, messages published to the topic in the * last `message_retention_duration` are always available to subscribers. For * instance, it allows any attached subscription to [seek to a * timestamp](https://cloud.google.com/pubsub/docs/replay-overview#seek_to_a_time) * that is up to `message_retention_duration` in the past. If this field is * not set, message retention is controlled by settings on individual * subscriptions. Cannot be more than 31 days or less than 10 minutes. */ messageRetentionDuration?: number /* Duration */; /** * Policy constraining the set of Google Cloud Platform regions where * messages published to the topic may be stored. If not present, then no * constraints are in effect. */ messageStoragePolicy?: MessageStoragePolicy; /** * Required. The name of the topic. It must have the format * `"projects/{project}/topics/{topic}"`. `{topic}` must start with a letter, * and contain only letters (`[A-Za-z]`), numbers (`[0-9]`), dashes (`-`), * underscores (`_`), periods (`.`), tildes (`~`), plus (`+`) or percent signs * (`%`). It must be between 3 and 255 characters in length, and it must not * start with `"goog"`. */ name?: string; /** * Reserved for future use. This field is set only in responses from the * server; it is ignored if it is set in any requests. */ satisfiesPzs?: boolean; /** * Settings for validating messages published against a schema. */ schemaSettings?: SchemaSettings; } function serializeTopic(data: any): Topic { return { ...data, messageRetentionDuration: data["messageRetentionDuration"] !== undefined ? data["messageRetentionDuration"] : undefined, }; } function deserializeTopic(data: any): Topic { return { ...data, messageRetentionDuration: data["messageRetentionDuration"] !== undefined ? data["messageRetentionDuration"] : undefined, }; } /** * Request for the UpdateSnapshot method. */ export interface UpdateSnapshotRequest { /** * Required. The updated snapshot object. */ snapshot?: Snapshot; /** * Required. Indicates which fields in the provided snapshot to update. Must * be specified and non-empty. */ updateMask?: string /* FieldMask */; } function serializeUpdateSnapshotRequest(data: any): UpdateSnapshotRequest { return { ...data, snapshot: data["snapshot"] !== undefined ? serializeSnapshot(data["snapshot"]) : undefined, updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined, }; } function deserializeUpdateSnapshotRequest(data: any): UpdateSnapshotRequest { return { ...data, snapshot: data["snapshot"] !== undefined ? deserializeSnapshot(data["snapshot"]) : undefined, updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined, }; } /** * Request for the UpdateSubscription method. */ export interface UpdateSubscriptionRequest { /** * Required. The updated subscription object. */ subscription?: Subscription; /** * Required. Indicates which fields in the provided subscription to update. * Must be specified and non-empty. */ updateMask?: string /* FieldMask */; } function serializeUpdateSubscriptionRequest(data: any): UpdateSubscriptionRequest { return { ...data, subscription: data["subscription"] !== undefined ? serializeSubscription(data["subscription"]) : undefined, updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined, }; } function deserializeUpdateSubscriptionRequest(data: any): UpdateSubscriptionRequest { return { ...data, subscription: data["subscription"] !== undefined ? deserializeSubscription(data["subscription"]) : undefined, updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined, }; } /** * Request for the UpdateTopic method. */ export interface UpdateTopicRequest { /** * Required. The updated topic object. */ topic?: Topic; /** * Required. Indicates which fields in the provided topic to update. Must be * specified and non-empty. Note that if `update_mask` contains * "message_storage_policy" but the `message_storage_policy` is not set in the * `topic` provided above, then the updated value is determined by the policy * configured at the project or organization level. */ updateMask?: string /* FieldMask */; } function serializeUpdateTopicRequest(data: any): UpdateTopicRequest { return { ...data, topic: data["topic"] !== undefined ? serializeTopic(data["topic"]) : undefined, updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined, }; } function deserializeUpdateTopicRequest(data: any): UpdateTopicRequest { return { ...data, topic: data["topic"] !== undefined ? deserializeTopic(data["topic"]) : undefined, updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined, }; } /** * Request for the `ValidateMessage` method. */ export interface ValidateMessageRequest { /** * The encoding expected for messages */ encoding?: | "ENCODING_UNSPECIFIED" | "JSON" | "BINARY"; /** * Message to validate against the provided `schema_spec`. */ message?: Uint8Array; /** * Name of the schema against which to validate. Format is * `projects/{project}/schemas/{schema}`. */ name?: string; /** * Ad-hoc schema against which to validate */ schema?: Schema; } function serializeValidateMessageRequest(data: any): ValidateMessageRequest { return { ...data, message: data["message"] !== undefined ? encodeBase64(data["message"]) : undefined, }; } function deserializeValidateMessageRequest(data: any): ValidateMessageRequest { return { ...data, message: data["message"] !== undefined ? decodeBase64(data["message"] as string) : undefined, }; } /** * Response for the `ValidateMessage` method. Empty for now. */ export interface ValidateMessageResponse { } /** * Request for the `ValidateSchema` method. */ export interface ValidateSchemaRequest { /** * Required. The schema object to validate. */ schema?: Schema; } /** * Response for the `ValidateSchema` method. Empty for now. */ export interface ValidateSchemaResponse { } function decodeBase64(b64: string): Uint8Array { const binString = atob(b64); const size = binString.length; const bytes = new Uint8Array(size); for (let i = 0; i < size; i++) { bytes[i] = binString.charCodeAt(i); } return bytes; } const base64abc = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9","+","/"]; /** * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727 * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation * @param data */ function encodeBase64(uint8: Uint8Array): string { let result = "", i; const l = uint8.length; for (i = 2; i < l; i += 3) { result += base64abc[uint8[i - 2] >> 2]; result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)]; result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)]; result += base64abc[uint8[i] & 0x3f]; } if (i === l + 1) { // 1 octet yet to write result += base64abc[uint8[i - 2] >> 2]; result += base64abc[(uint8[i - 2] & 0x03) << 4]; result += "=="; } if (i === l) { // 2 octets yet to write result += base64abc[uint8[i - 2] >> 2]; result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)]; result += base64abc[(uint8[i - 1] & 0x0f) << 2]; result += "="; } return result; }