// 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<Schema> {
    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<Schema> {
    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<Empty> {
    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<Schema> {
    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<Schema> {
    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<Policy> {
    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<ListSchemasResponse> {
    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<ListSchemaRevisionsResponse> {
    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<Schema> {
    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<Policy> {
    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<TestIamPermissionsResponse> {
    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<ValidateSchemaResponse> {
    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<ValidateMessageResponse> {
    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/pubsub-basics#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/pubsub-basics#resource_names). Format is `projects/{project}/snapshots/{snap}`.
   */
  async projectsSnapshotsCreate(name: string, req: CreateSnapshotRequest): Promise<Snapshot> {
    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<Empty> {
    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<Snapshot> {
    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<Policy> {
    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<ListSnapshotsResponse> {
    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 by updating the fields specified in the
   * update mask. 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 Optional. The name of the snapshot.
   */
  async projectsSnapshotsPatch(name: string, req: UpdateSnapshotRequest): Promise<Snapshot> {
    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<Policy> {
    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<TestIamPermissionsResponse> {
    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<Empty> {
    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/pubsub-basics#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/pubsub-basics#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<Subscription> {
    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<Empty> {
    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<DetachSubscriptionResponse> {
    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<Subscription> {
    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<Policy> {
    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<ListSubscriptionsResponse> {
    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<Empty> {
    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<Empty> {
    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 by updating the fields specified in the
   * update mask. 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<Subscription> {
    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<PullResponse> {
    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<SeekResponse> {
    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<Policy> {
    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<TestIamPermissionsResponse> {
    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/pubsub-basics#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<Topic> {
    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<Empty> {
    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<Topic> {
    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<Policy> {
    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<ListTopicsResponse> {
    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 by updating the fields specified in the update
   * mask. 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<Topic> {
    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<PublishResponse> {
    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<Policy> {
    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<ListTopicSnapshotsResponse> {
    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<ListTopicSubscriptionsResponse> {
    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<TestIamPermissionsResponse> {
    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[];
}

/**
 * Information about an associated [Analytics Hub
 * subscription](https://cloud.google.com/bigquery/docs/analytics-hub-manage-subscriptions).
 */
export interface AnalyticsHubSubscriptionInfo {
  /**
   * Optional. The name of the associated Analytics Hub listing resource.
   * Pattern:
   * "projects/{project}/locations/{location}/dataExchanges/{data_exchange}/listings/{listing}"
   */
  listing?: string;
  /**
   * Optional. The name of the associated Analytics Hub subscription resource.
   * Pattern:
   * "projects/{project}/locations/{location}/subscriptions/{subscription}"
   */
  subscription?: 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 {
  /**
   * Optional. When true, the output Cloud Storage file will be serialized
   * using the topic schema, if it exists.
   */
  useTopicSchema?: boolean;
  /**
   * Optional. When true, write the subscription name, message_id,
   * publish_time, attributes, and ordering_key as additional fields in the
   * output. The subscription name, message_id, and publish_time fields are put
   * in their own fields while all other message properties other than data (for
   * example, an ordering_key, if present) are added as entries in the
   * attributes map.
   */
  writeMetadata?: boolean;
}

/**
 * Configuration for reading Cloud Storage data in Avro binary format. The
 * bytes of each object will be set to the `data` field of a Pub/Sub message.
 */
export interface AvroFormat {
}

/**
 * Ingestion settings for Amazon Kinesis Data Streams.
 */
export interface AwsKinesis {
  /**
   * Required. AWS role ARN to be used for Federated Identity authentication
   * with Kinesis. Check the Pub/Sub docs for how to set up this role and the
   * required permissions that need to be attached to it.
   */
  awsRoleArn?: string;
  /**
   * Required. The Kinesis consumer ARN to used for ingestion in Enhanced
   * Fan-Out mode. The consumer must be already created and ready to be used.
   */
  consumerArn?: string;
  /**
   * Required. The GCP service account to be used for Federated Identity
   * authentication with Kinesis (via a `AssumeRoleWithWebIdentity` call for the
   * provided role). The `aws_role_arn` must be set up with
   * `accounts.google.com:sub` equals to this service account number.
   */
  gcpServiceAccount?: string;
  /**
   * Output only. An output-only field that indicates the state of the Kinesis
   * ingestion source.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "KINESIS_PERMISSION_DENIED" | "PUBLISH_PERMISSION_DENIED" | "STREAM_NOT_FOUND" | "CONSUMER_NOT_FOUND";
  /**
   * Required. The Kinesis stream ARN to ingest data from.
   */
  streamArn?: string;
}

/**
 * Ingestion settings for Amazon MSK.
 */
export interface AwsMsk {
  /**
   * Required. AWS role ARN to be used for Federated Identity authentication
   * with Amazon MSK. Check the Pub/Sub docs for how to set up this role and the
   * required permissions that need to be attached to it.
   */
  awsRoleArn?: string;
  /**
   * Required. The Amazon Resource Name (ARN) that uniquely identifies the
   * cluster.
   */
  clusterArn?: string;
  /**
   * Required. The GCP service account to be used for Federated Identity
   * authentication with Amazon MSK (via a `AssumeRoleWithWebIdentity` call for
   * the provided role). The `aws_role_arn` must be set up with
   * `accounts.google.com:sub` equals to this service account number.
   */
  gcpServiceAccount?: string;
  /**
   * Output only. An output-only field that indicates the state of the Amazon
   * MSK ingestion source.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "MSK_PERMISSION_DENIED" | "PUBLISH_PERMISSION_DENIED" | "CLUSTER_NOT_FOUND" | "TOPIC_NOT_FOUND";
  /**
   * Required. The name of the topic in the Amazon MSK cluster that Pub/Sub
   * will import from.
   */
  topic?: string;
}

/**
 * Ingestion settings for Azure Event Hubs.
 */
export interface AzureEventHubs {
  /**
   * Optional. The client id of the Azure application that is being used to
   * authenticate Pub/Sub.
   */
  clientId?: string;
  /**
   * Optional. The name of the Event Hub.
   */
  eventHub?: string;
  /**
   * Optional. The GCP service account to be used for Federated Identity
   * authentication.
   */
  gcpServiceAccount?: string;
  /**
   * Optional. The name of the Event Hubs namespace.
   */
  namespace?: string;
  /**
   * Optional. Name of the resource group within the azure subscription.
   */
  resourceGroup?: string;
  /**
   * Output only. An output-only field that indicates the state of the Event
   * Hubs ingestion source.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "EVENT_HUBS_PERMISSION_DENIED" | "PUBLISH_PERMISSION_DENIED" | "NAMESPACE_NOT_FOUND" | "EVENT_HUB_NOT_FOUND" | "SUBSCRIPTION_NOT_FOUND" | "RESOURCE_GROUP_NOT_FOUND";
  /**
   * Optional. The Azure subscription id.
   */
  subscriptionId?: string;
  /**
   * Optional. The tenant id of the Azure application that is being used to
   * authenticate Pub/Sub.
   */
  tenantId?: string;
}

/**
 * Configuration for a BigQuery subscription.
 */
export interface BigQueryConfig {
  /**
   * Optional. 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;
  /**
   * Optional. The service account to use to write to BigQuery. The
   * subscription creator or updater that specifies this field must have
   * `iam.serviceAccounts.actAs` permission on the service account. If not
   * specified, the Pub/Sub [service
   * agent](https://cloud.google.com/iam/docs/service-agents),
   * service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
   */
  serviceAccountEmail?: string;
  /**
   * 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" | "IN_TRANSIT_LOCATION_RESTRICTION";
  /**
   * Optional. The name of the table to which to write data, of the form
   * {projectId}.{datasetId}.{tableId}
   */
  table?: string;
  /**
   * Optional. When true, use the BigQuery table's schema as the columns to
   * write to in BigQuery. `use_table_schema` and `use_topic_schema` cannot be
   * enabled at the same time.
   */
  useTableSchema?: boolean;
  /**
   * Optional. When true, use the topic's schema as the columns to write to in
   * BigQuery, if it exists. `use_topic_schema` and `use_table_schema` cannot be
   * enabled at the same time.
   */
  useTopicSchema?: boolean;
  /**
   * Optional. 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`. *
   * `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`:
   * A single identity in a workforce identity pool. *
   * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/group/{group_id}`:
   * All workforce identities in a group. *
   * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/attribute.{attribute_name}/{attribute_value}`:
   * All workforce identities with a specific attribute value. *
   * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/*`:
   * All identities in a workforce identity pool. *
   * `principal://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/subject/{subject_attribute_value}`:
   * A single identity in a workload identity pool. *
   * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/group/{group_id}`:
   * A workload identity pool group. *
   * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/attribute.{attribute_name}/{attribute_value}`:
   * All identities in a workload identity pool with a certain attribute. *
   * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/*`:
   * All identities in a workload identity pool. *
   * `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. *
   * `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`:
   * Deleted single identity in a workforce identity pool. For example,
   * `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-pool-id/subject/my-subject-attribute-value`.
   */
  members?: string[];
  /**
   * Role that is assigned to the list of `members`, or principals. For
   * example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview
   * of the IAM roles and permissions, see the [IAM
   * documentation](https://cloud.google.com/iam/docs/roles-overview). For a
   * list of the available pre-defined roles, see
   * [here](https://cloud.google.com/iam/docs/understanding-roles).
   */
  role?: string;
}

/**
 * Ingestion settings for Cloud Storage.
 */
export interface CloudStorage {
  /**
   * Optional. Data from Cloud Storage will be interpreted in Avro format.
   */
  avroFormat?: AvroFormat;
  /**
   * Optional. Cloud Storage bucket. 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;
  /**
   * Optional. Glob pattern used to match objects that will be ingested. If
   * unset, all objects will be ingested. See the [supported
   * patterns](https://cloud.google.com/storage/docs/json_api/v1/objects/list#list-objects-and-prefixes-using-glob).
   */
  matchGlob?: string;
  /**
   * Optional. Only objects with a larger or equal creation timestamp will be
   * ingested.
   */
  minimumObjectCreateTime?: Date;
  /**
   * Optional. It will be assumed data from Cloud Storage was written via
   * [Cloud Storage
   * subscriptions](https://cloud.google.com/pubsub/docs/cloudstorage).
   */
  pubsubAvroFormat?: PubSubAvroFormat;
  /**
   * Output only. An output-only field that indicates the state of the Cloud
   * Storage ingestion source.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "CLOUD_STORAGE_PERMISSION_DENIED" | "PUBLISH_PERMISSION_DENIED" | "BUCKET_NOT_FOUND" | "TOO_MANY_OBJECTS";
  /**
   * Optional. Data from Cloud Storage will be interpreted as text.
   */
  textFormat?: TextFormat;
}

function serializeCloudStorage(data: any): CloudStorage {
  return {
    ...data,
    minimumObjectCreateTime: data["minimumObjectCreateTime"] !== undefined ? data["minimumObjectCreateTime"].toISOString() : undefined,
  };
}

function deserializeCloudStorage(data: any): CloudStorage {
  return {
    ...data,
    minimumObjectCreateTime: data["minimumObjectCreateTime"] !== undefined ? new Date(data["minimumObjectCreateTime"]) : undefined,
  };
}

/**
 * Configuration for a Cloud Storage subscription.
 */
export interface CloudStorageConfig {
  /**
   * Optional. 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;
  /**
   * Optional. User-provided format string specifying how to represent
   * datetimes in Cloud Storage filenames. See the [datetime format
   * guidance](https://cloud.google.com/pubsub/docs/create-cloudstorage-subscription#file_names).
   */
  filenameDatetimeFormat?: string;
  /**
   * Optional. User-provided prefix for Cloud Storage filename. See the [object
   * naming requirements](https://cloud.google.com/storage/docs/objects#naming).
   */
  filenamePrefix?: string;
  /**
   * Optional. User-provided suffix for Cloud Storage filename. See the [object
   * naming requirements](https://cloud.google.com/storage/docs/objects#naming).
   * Must not end in "/".
   */
  filenameSuffix?: string;
  /**
   * Optional. 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;
  /**
   * Optional. 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 acknowledgment deadline.
   */
  maxDuration?: number /* Duration */;
  /**
   * Optional. The maximum number of messages that can be written to a Cloud
   * Storage file before a new file is created. Min 1000 messages.
   */
  maxMessages?: bigint;
  /**
   * Optional. The service account to use to write to Cloud Storage. The
   * subscription creator or updater that specifies this field must have
   * `iam.serviceAccounts.actAs` permission on the service account. If not
   * specified, the Pub/Sub [service
   * agent](https://cloud.google.com/iam/docs/service-agents),
   * service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used.
   */
  serviceAccountEmail?: string;
  /**
   * 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" | "IN_TRANSIT_LOCATION_RESTRICTION" | "SCHEMA_MISMATCH";
  /**
   * Optional. 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,
    maxMessages: data["maxMessages"] !== undefined ? String(data["maxMessages"]) : undefined,
  };
}

function deserializeCloudStorageConfig(data: any): CloudStorageConfig {
  return {
    ...data,
    maxBytes: data["maxBytes"] !== undefined ? BigInt(data["maxBytes"]) : undefined,
    maxDuration: data["maxDuration"] !== undefined ? data["maxDuration"] : undefined,
    maxMessages: data["maxMessages"] !== undefined ? BigInt(data["maxMessages"]) : undefined,
  };
}

/**
 * Request for CommitSchema method.
 */
export interface CommitSchemaRequest {
  /**
   * Required. The schema revision to commit.
   */
  schema?: Schema;
}

/**
 * Ingestion settings for Confluent Cloud.
 */
export interface ConfluentCloud {
  /**
   * Required. The address of the bootstrap server. The format is url:port.
   */
  bootstrapServer?: string;
  /**
   * Required. The id of the cluster.
   */
  clusterId?: string;
  /**
   * Required. The GCP service account to be used for Federated Identity
   * authentication with `identity_pool_id`.
   */
  gcpServiceAccount?: string;
  /**
   * Required. The id of the identity pool to be used for Federated Identity
   * authentication with Confluent Cloud. See
   * https://docs.confluent.io/cloud/current/security/authenticate/workload-identities/identity-providers/oauth/identity-pools.html#add-oauth-identity-pools.
   */
  identityPoolId?: string;
  /**
   * Output only. An output-only field that indicates the state of the
   * Confluent Cloud ingestion source.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "CONFLUENT_CLOUD_PERMISSION_DENIED" | "PUBLISH_PERMISSION_DENIED" | "UNREACHABLE_BOOTSTRAP_SERVER" | "CLUSTER_NOT_FOUND" | "TOPIC_NOT_FOUND";
  /**
   * Required. The name of the topic in the Confluent Cloud cluster that
   * Pub/Sub will import from.
   */
  topic?: string;
}

/**
 * Request for the `CreateSnapshot` method.
 */
export interface CreateSnapshotRequest {
  /**
   * Optional. 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 {
  /**
   * Optional. The name of the topic to which dead letter messages should be
   * published. Format is `projects/{project}/topics/{topic}`.The 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;
  /**
   * Optional. 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 acknowledgment
   * 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 {
  /**
   * Optional. 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;
}

/**
 * Settings for an ingestion data source on a topic.
 */
export interface IngestionDataSourceSettings {
  /**
   * Optional. Amazon Kinesis Data Streams.
   */
  awsKinesis?: AwsKinesis;
  /**
   * Optional. Amazon MSK.
   */
  awsMsk?: AwsMsk;
  /**
   * Optional. Azure Event Hubs.
   */
  azureEventHubs?: AzureEventHubs;
  /**
   * Optional. Cloud Storage.
   */
  cloudStorage?: CloudStorage;
  /**
   * Optional. Confluent Cloud.
   */
  confluentCloud?: ConfluentCloud;
  /**
   * Optional. Platform Logs settings. If unset, no Platform Logs will be
   * generated.
   */
  platformLogsSettings?: PlatformLogsSettings;
}

function serializeIngestionDataSourceSettings(data: any): IngestionDataSourceSettings {
  return {
    ...data,
    cloudStorage: data["cloudStorage"] !== undefined ? serializeCloudStorage(data["cloudStorage"]) : undefined,
  };
}

function deserializeIngestionDataSourceSettings(data: any): IngestionDataSourceSettings {
  return {
    ...data,
    cloudStorage: data["cloudStorage"] !== undefined ? deserializeCloudStorage(data["cloudStorage"]) : undefined,
  };
}

/**
 * User-defined JavaScript function that can transform or filter a Pub/Sub
 * message.
 */
export interface JavaScriptUDF {
  /**
   * Required. JavaScript code that contains a function `function_name` with
   * the below signature: ``` /** * Transforms a Pub/Sub message. * @return
   * {(Object)>|null)} - To * filter a message, return `null`. To transform a
   * message return a map * with the following keys: * - (required) 'data' :
   * {string} * - (optional) 'attributes' : {Object} * Returning empty
   * `attributes` will remove all attributes from the * message. * * @param
   * {(Object)>} Pub/Sub * message. Keys: * - (required) 'data' : {string} * -
   * (required) 'attributes' : {Object} * * @param {Object} metadata - Pub/Sub
   * message metadata. * Keys: * - (optional) 'message_id' : {string} * -
   * (optional) 'publish_time': {string} YYYY-MM-DDTHH:MM:SSZ format * -
   * (optional) 'ordering_key': {string} *\/ function (message, metadata) { }
   * ```
   */
  code?: string;
  /**
   * Required. Name of the JavasScript function that should applied to Pub/Sub
   * messages.
   */
  functionName?: 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 {
  /**
   * Optional. 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;
  /**
   * Optional. 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 {
  /**
   * Optional. 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;
  /**
   * Optional. 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 {
  /**
   * Optional. 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;
  /**
   * Optional. The names of the snapshots that match the request.
   */
  snapshots?: string[];
}

/**
 * Response for the `ListTopics` method.
 */
export interface ListTopicsResponse {
  /**
   * Optional. 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;
  /**
   * Optional. 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 {
  /**
   * Optional. 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;
  /**
   * Optional. 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 {
  /**
   * Optional. A list of IDs of Google Cloud regions where messages that are
   * published to the topic may be persisted in storage. Messages published by
   * publishers running in non-allowed Google Cloud regions (or running outside
   * of Google Cloud altogether) are 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[];
  /**
   * Optional. If true, `allowed_persistence_regions` is also used to enforce
   * in-transit guarantees for messages. That is, Pub/Sub will fail Publish
   * operations on this topic and subscribe operations on any subscription
   * attached to this topic in any region that is not in
   * `allowed_persistence_regions`.
   */
  enforceInTransit?: boolean;
}

/**
 * All supported message transforms types.
 */
export interface MessageTransform {
  /**
   * Optional. If true, the transform is disabled and will not be applied to
   * messages. Defaults to `false`.
   */
  disabled?: boolean;
  /**
   * Optional. This field is deprecated, use the `disabled` field to disable
   * transforms.
   */
  enabled?: boolean;
  /**
   * Optional. JavaScript User Defined Function. If multiple JavaScriptUDF's
   * are specified on a resource, each must have a unique `function_name`.
   */
  javascriptUdf?: JavaScriptUDF;
}

/**
 * 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 in a single request 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 {
  /**
   * Optional. 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 {
  /**
   * Optional. 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;
  /**
   * Optional. [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;
}

/**
 * Settings for Platform Logs produced by Pub/Sub.
 */
export interface PlatformLogsSettings {
  /**
   * Optional. The minimum severity level of Platform Logs that will be
   * written.
   */
  severity?:  | "SEVERITY_UNSPECIFIED" | "DISABLED" | "DEBUG" | "INFO" | "WARNING" | "ERROR";
}

/**
 * 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/pubsub-basics#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 {
  /**
   * Optional. Maximum number of snapshots to return.
   */
  pageSize?: number;
  /**
   * Optional. 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 {
  /**
   * Optional. Maximum number of subscriptions to return.
   */
  pageSize?: number;
  /**
   * Optional. 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 {
  /**
   * Optional. Maximum number of topics to return.
   */
  pageSize?: number;
  /**
   * Optional. 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 {
  /**
   * Optional. Maximum number of snapshot names to return.
   */
  pageSize?: number;
  /**
   * Optional. 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 {
  /**
   * Optional. Maximum number of subscription names to return.
   */
  pageSize?: number;
  /**
   * Optional. 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 {
  /**
   * Optional. 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[];
}

/**
 * Configuration for reading Cloud Storage data written via [Cloud Storage
 * subscriptions](https://cloud.google.com/pubsub/docs/cloudstorage). The data
 * and attributes fields of the originally exported Pub/Sub message will be
 * restored when publishing.
 */
export interface PubSubAvroFormat {
}

/**
 * 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 {
  /**
   * Optional. 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
  };
  /**
   * Optional. 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;
  /**
   * Optional. 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 {
  /**
   * Optional. 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 {
  /**
   * Optional. 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
  };
  /**
   * Optional. When set, the payload to the push endpoint is not wrapped.
   */
  noWrapper?: NoWrapper;
  /**
   * Optional. 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;
  /**
   * Optional. 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;
  /**
   * Optional. 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 {
  /**
   * Optional. This ID can be used to acknowledge the received message.
   */
  ackId?: string;
  /**
   * Optional. The approximate number of times that 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;
  /**
   * Optional. 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 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 acknowledgment 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 {
  /**
   * Optional. 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 */;
  /**
   * Optional. 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 {
  /**
   * Optional. The encoding of messages validated against `schema`.
   */
  encoding?:  | "ENCODING_UNSPECIFIED" | "JSON" | "BINARY";
  /**
   * Optional. 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;
  /**
   * Optional. 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 {
  /**
   * Optional. 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;
  /**
   * Optional. 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 {
  /**
   * Optional. 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;
  /**
   * Optional. See [Creating and managing labels]
   * (https://cloud.google.com/pubsub/docs/labels).
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. The name of the snapshot.
   */
  name?: string;
  /**
   * Optional. 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 {
  /**
   * Optional. 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;
  /**
   * Output only. Information about the associated Analytics Hub subscription.
   * Only set if the subscritpion is created by Analytics Hub.
   */
  readonly analyticsHubSubscriptionInfo?: AnalyticsHubSubscriptionInfo;
  /**
   * Optional. If delivery to BigQuery is used with this subscription, this
   * field is used to configure it.
   */
  bigqueryConfig?: BigQueryConfig;
  /**
   * Optional. If delivery to Google Cloud Storage is used with this
   * subscription, this field is used to configure it.
   */
  cloudStorageConfig?: CloudStorageConfig;
  /**
   * Optional. 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 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;
  /**
   * Optional. 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;
  /**
   * Optional. 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 acknowledgment 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;
  /**
   * Optional. 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;
  /**
   * Optional. 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;
  /**
   * Optional. 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;
  /**
   * Optional. See [Creating and managing
   * labels](https://cloud.google.com/pubsub/docs/labels).
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. 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 31 days or less than 10 minutes.
   */
  messageRetentionDuration?: number /* Duration */;
  /**
   * Optional. Transforms to be applied to messages before they are delivered
   * to subscribers. Transforms are applied in the order specified.
   */
  messageTransforms?: MessageTransform[];
  /**
   * 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;
  /**
   * Optional. If push delivery is used with this subscription, this field is
   * used to configure it.
   */
  pushConfig?: PushConfig;
  /**
   * Optional. 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;
  /**
   * Optional. 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
   * acknowledgment 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 {
}

/**
 * Configuration for reading Cloud Storage data in text format. Each line of
 * text as specified by the delimiter will be set to the `data` field of a
 * Pub/Sub message.
 */
export interface TextFormat {
  /**
   * Optional. When unset, '\n' is used.
   */
  delimiter?: string;
}

/**
 * A topic resource.
 */
export interface Topic {
  /**
   * Optional. Settings for ingestion from a data source into this topic.
   */
  ingestionDataSourceSettings?: IngestionDataSourceSettings;
  /**
   * Optional. 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;
  /**
   * Optional. See [Creating and managing labels]
   * (https://cloud.google.com/pubsub/docs/labels).
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. 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 */;
  /**
   * Optional. 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;
  /**
   * Optional. Transforms to be applied to messages published to the topic.
   * Transforms are applied in the order specified.
   */
  messageTransforms?: MessageTransform[];
  /**
   * 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;
  /**
   * Optional. 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;
  /**
   * Optional. Settings for validating messages published against a schema.
   */
  schemaSettings?: SchemaSettings;
  /**
   * Output only. An output-only field indicating the state of the topic.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "INGESTION_RESOURCE_ERROR";
}

function serializeTopic(data: any): Topic {
  return {
    ...data,
    ingestionDataSourceSettings: data["ingestionDataSourceSettings"] !== undefined ? serializeIngestionDataSourceSettings(data["ingestionDataSourceSettings"]) : undefined,
    messageRetentionDuration: data["messageRetentionDuration"] !== undefined ? data["messageRetentionDuration"] : undefined,
  };
}

function deserializeTopic(data: any): Topic {
  return {
    ...data,
    ingestionDataSourceSettings: data["ingestionDataSourceSettings"] !== undefined ? deserializeIngestionDataSourceSettings(data["ingestionDataSourceSettings"]) : undefined,
    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;
}