// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Google Workspace Events API Client for Deno
 * ===========================================
 * 
 * The Google Workspace Events API lets you subscribe to events and manage change notifications across Google Workspace applications.
 * 
 * Docs: https://developers.google.com/workspace/events
 * Source: https://googleapis.deno.dev/v1/workspaceevents:v1.ts
 */

import { auth, CredentialsClient, GoogleAuth, request } from "/_/base@v1/mod.ts";
export { auth, GoogleAuth };
export type { CredentialsClient };

/**
 * The Google Workspace Events API lets you subscribe to events and manage
 * change notifications across Google Workspace applications.
 */
export class WorkspaceEvents {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

  constructor(client?: CredentialsClient, baseUrl: string = "https://workspaceevents.googleapis.com/") {
    this.#client = client;
    this.#baseUrl = baseUrl;
  }

  /**
   * Gets the latest state of a long-running operation. Clients can use this
   * method to poll the operation result at intervals as recommended by the API
   * service.
   *
   * @param name The name of the operation resource.
   */
  async operationsGet(name: string): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Operation;
  }

  /**
   * [Developer Preview](https://developers.google.com/workspace/preview):
   * Creates a Google Workspace subscription. To learn how to use this method,
   * see [Create a Google Workspace
   * subscription](https://developers.google.com/workspace/events/guides/create-subscription).
   *
   */
  async subscriptionsCreate(req: Subscription, opts: SubscriptionsCreateOptions = {}): Promise<Operation> {
    req = serializeSubscription(req);
    const url = new URL(`${this.#baseUrl}v1/subscriptions`);
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * [Developer Preview](https://developers.google.com/workspace/preview):
   * Deletes a Google Workspace subscription. To learn how to use this method,
   * see [Delete a Google Workspace
   * subscription](https://developers.google.com/workspace/events/guides/delete-subscription).
   *
   * @param name Required. Resource name of the subscription to delete. Format: `subscriptions/{subscription}`
   */
  async subscriptionsDelete(name: string, opts: SubscriptionsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * [Developer Preview](https://developers.google.com/workspace/preview): Gets
   * details about a Google Workspace subscription. To learn how to use this
   * method, see [Get details about a Google Workspace
   * subscription](https://developers.google.com/workspace/events/guides/get-subscription).
   *
   * @param name Required. Resource name of the subscription. Format: `subscriptions/{subscription}`
   */
  async subscriptionsGet(name: string): Promise<Subscription> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeSubscription(data);
  }

  /**
   * [Developer Preview](https://developers.google.com/workspace/preview):
   * Lists Google Workspace subscriptions. To learn how to use this method, see
   * [List Google Workspace
   * subscriptions](https://developers.google.com/workspace/events/guides/list-subscriptions).
   *
   */
  async subscriptionsList(opts: SubscriptionsListOptions = {}): Promise<ListSubscriptionsResponse> {
    const url = new URL(`${this.#baseUrl}v1/subscriptions`);
    if (opts.filter !== undefined) {
      url.searchParams.append("filter", String(opts.filter));
    }
    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);
  }

  /**
   * [Developer Preview](https://developers.google.com/workspace/preview):
   * Updates or renews a Google Workspace subscription. To learn how to use this
   * method, see [Update or renew a Google Workspace
   * subscription](https://developers.google.com/workspace/events/guides/update-subscription).
   *
   * @param name Identifier. Resource name of the subscription. Format: `subscriptions/{subscription}`
   */
  async subscriptionsPatch(name: string, req: Subscription, opts: SubscriptionsPatchOptions = {}): Promise<Operation> {
    req = serializeSubscription(req);
    opts = serializeSubscriptionsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

  /**
   * [Developer Preview](https://developers.google.com/workspace/preview):
   * Reactivates a suspended Google Workspace subscription. This method resets
   * your subscription's `State` field to `ACTIVE`. Before you use this method,
   * you must fix the error that suspended the subscription. This method will
   * ignore or reject any subscription that isn't currently in a suspended
   * state. To learn how to use this method, see [Reactivate a Google Workspace
   * subscription](https://developers.google.com/workspace/events/guides/reactivate-subscription).
   *
   * @param name Required. Resource name of the subscription. Format: `subscriptions/{subscription}`
   */
  async subscriptionsReactivate(name: string, req: ReactivateSubscriptionRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:reactivate`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }
}

/**
 * The response message for SubscriptionsService.ListSubscriptions.
 */
export interface ListSubscriptionsResponse {
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * List of subscriptions.
   */
  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,
  };
}

/**
 * The endpoint where the subscription delivers events.
 */
export interface NotificationEndpoint {
  /**
   * Immutable. The Cloud Pub/Sub topic that receives events for the
   * subscription. Format: `projects/{project}/topics/{topic}` You must create
   * the topic in the same Google Cloud project where you create this
   * subscription. When the topic receives events, the events are encoded as
   * Cloud Pub/Sub messages. For details, see the [Google Cloud Pub/Sub Protocol
   * Binding for
   * CloudEvents](https://github.com/googleapis/google-cloudevents/blob/main/docs/spec/pubsub.md).
   */
  pubsubTopic?: string;
}

/**
 * This resource represents a long-running operation that is the result of a
 * network API call.
 */
export interface Operation {
  /**
   * If the value is `false`, it means the operation is still in progress. If
   * `true`, the operation is completed, and either `error` or `response` is
   * available.
   */
  done?: boolean;
  /**
   * The error result of the operation in case of failure or cancellation.
   */
  error?: Status;
  /**
   * Service-specific metadata associated with the operation. It typically
   * contains progress information and common metadata such as create time. Some
   * services might not provide such metadata. Any method that returns a
   * long-running operation should document the metadata type, if any.
   */
  metadata?: {
    [key: string]: any
  };
  /**
   * The server-assigned name, which is only unique within the same service
   * that originally returns it. If you use the default HTTP mapping, the `name`
   * should be a resource name ending with `operations/{unique_id}`.
   */
  name?: string;
  /**
   * The normal, successful response of the operation. If the original method
   * returns no data on success, such as `Delete`, the response is
   * `google.protobuf.Empty`. If the original method is standard
   * `Get`/`Create`/`Update`, the response should be the resource. For other
   * methods, the response should have the type `XxxResponse`, where `Xxx` is
   * the original method name. For example, if the original method name is
   * `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
   */
  response?: {
    [key: string]: any
  };
}

/**
 * Options about what data to include in the event payload. Only supported for
 * Google Chat events.
 */
export interface PayloadOptions {
  /**
   * Optional. If `include_resource` is set to `true`, the list of fields to
   * include in the event payload. Separate fields with a comma. For example, to
   * include a Google Chat message's sender and create time, enter
   * `message.sender,message.createTime`. If omitted, the payload includes all
   * fields for the resource. If you specify a field that doesn't exist for the
   * resource, the system ignores the field.
   */
  fieldMask?: string /* FieldMask */;
  /**
   * Optional. Whether the event payload includes data about the resource that
   * changed. For example, for an event where a Google Chat message was created,
   * whether the payload contains data about the
   * [`Message`](https://developers.google.com/chat/api/reference/rest/v1/spaces.messages)
   * resource. If false, the event payload only includes the name of the changed
   * resource.
   */
  includeResource?: boolean;
}

function serializePayloadOptions(data: any): PayloadOptions {
  return {
    ...data,
    fieldMask: data["fieldMask"] !== undefined ? data["fieldMask"] : undefined,
  };
}

function deserializePayloadOptions(data: any): PayloadOptions {
  return {
    ...data,
    fieldMask: data["fieldMask"] !== undefined ? data["fieldMask"] : undefined,
  };
}

/**
 * The request message for SubscriptionsService.ReactivateSubscription.
 */
export interface ReactivateSubscriptionRequest {
}

/**
 * The `Status` type defines a logical error model that is suitable for
 * different programming environments, including REST APIs and RPC APIs. It is
 * used by [gRPC](https://github.com/grpc). Each `Status` message contains three
 * pieces of data: error code, error message, and error details. You can find
 * out more about this error model and how to work with it in the [API Design
 * Guide](https://cloud.google.com/apis/design/errors).
 */
export interface Status {
  /**
   * The status code, which should be an enum value of google.rpc.Code.
   */
  code?: number;
  /**
   * A list of messages that carry the error details. There is a common set of
   * message types for APIs to use.
   */
  details?: {
    [key: string]: any
  }[];
  /**
   * A developer-facing error message, which should be in English. Any
   * user-facing error message should be localized and sent in the
   * google.rpc.Status.details field, or localized by the client.
   */
  message?: string;
}

/**
 * [Developer Preview](https://developers.google.com/workspace/preview). A
 * subscription to receive events about a Google Workspace resource. To learn
 * more about subscriptions, see the [Google Workspace Events API
 * overview](https://developers.google.com/workspace/events).
 */
export interface Subscription {
  /**
   * Output only. The user who authorized the creation of the subscription.
   * Format: `users/{user}` For Google Workspace users, the `{user}` value is
   * the
   * [`user.id`](https://developers.google.com/admin-sdk/directory/reference/rest/v1/users#User.FIELDS.ids)
   * field from the Directory API.
   */
  readonly authority?: string;
  /**
   * Output only. The time when the subscription is created.
   */
  readonly createTime?: Date;
  /**
   * Optional. This checksum is computed by the server based on the value of
   * other fields, and might be sent on update requests to ensure the client has
   * an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Required. Unordered list. Input for creating a subscription. Otherwise,
   * output only. One or more types of events to receive about the target
   * resource. Formatted according to the CloudEvents specification. The
   * supported event types depend on the target resource of your subscription.
   * For details, see [Supported Google Workspace
   * events](https://developers.google.com/workspace/events/guides#supported-events).
   * By default, you also receive events about the [lifecycle of your
   * subscription](https://developers.google.com/workspace/events/guides/events-lifecycle).
   * You don't need to specify lifecycle events for this field. If you specify
   * an event type that doesn't exist for the target resource, the request
   * returns an HTTP `400 Bad Request` status code.
   */
  eventTypes?: string[];
  /**
   * Non-empty default. The timestamp in UTC when the subscription expires.
   * Always displayed on output, regardless of what was used on input.
   */
  expireTime?: Date;
  /**
   * Identifier. Resource name of the subscription. Format:
   * `subscriptions/{subscription}`
   */
  name?: string;
  /**
   * Required. Immutable. The endpoint where the subscription delivers events,
   * such as a Pub/Sub topic.
   */
  notificationEndpoint?: NotificationEndpoint;
  /**
   * Optional. Options about what data to include in the event payload. Only
   * supported for Google Chat events.
   */
  payloadOptions?: PayloadOptions;
  /**
   * Output only. If `true`, the subscription is in the process of being
   * updated.
   */
  readonly reconciling?: boolean;
  /**
   * Output only. The state of the subscription. Determines whether the
   * subscription can receive events and deliver them to the notification
   * endpoint.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "SUSPENDED" | "DELETED";
  /**
   * Output only. The error that suspended the subscription. To reactivate the
   * subscription, resolve the error and call the `ReactivateSubscription`
   * method.
   */
  readonly suspensionReason?:  | "ERROR_TYPE_UNSPECIFIED" | "USER_SCOPE_REVOKED" | "RESOURCE_DELETED" | "USER_AUTHORIZATION_FAILURE" | "ENDPOINT_PERMISSION_DENIED" | "ENDPOINT_NOT_FOUND" | "ENDPOINT_RESOURCE_EXHAUSTED" | "OTHER";
  /**
   * Required. Immutable. The Google Workspace resource that's monitored for
   * events, formatted as the [full resource
   * name](https://google.aip.dev/122#full-resource-names). To learn about
   * target resources and the events that they support, see [Supported Google
   * Workspace
   * events](https://developers.google.com/workspace/events#supported-events). A
   * user can only authorize your app to create one subscription for a given
   * target resource. If your app tries to create another subscription with the
   * same user credentials, the request returns an `ALREADY_EXISTS` error.
   */
  targetResource?: string;
  /**
   * Input only. The time-to-live (TTL) or duration for the subscription. If
   * unspecified or set to `0`, uses the maximum possible duration.
   */
  ttl?: number /* Duration */;
  /**
   * Output only. System-assigned unique identifier for the subscription.
   */
  readonly uid?: string;
  /**
   * Output only. The last time that the subscription is updated.
   */
  readonly updateTime?: Date;
}

function serializeSubscription(data: any): Subscription {
  return {
    ...data,
    expireTime: data["expireTime"] !== undefined ? data["expireTime"].toISOString() : undefined,
    payloadOptions: data["payloadOptions"] !== undefined ? serializePayloadOptions(data["payloadOptions"]) : undefined,
    ttl: data["ttl"] !== undefined ? data["ttl"] : undefined,
  };
}

function deserializeSubscription(data: any): Subscription {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    expireTime: data["expireTime"] !== undefined ? new Date(data["expireTime"]) : undefined,
    payloadOptions: data["payloadOptions"] !== undefined ? deserializePayloadOptions(data["payloadOptions"]) : undefined,
    ttl: data["ttl"] !== undefined ? data["ttl"] : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
  };
}

/**
 * Additional options for WorkspaceEvents#subscriptionsCreate.
 */
export interface SubscriptionsCreateOptions {
  /**
   * Optional. If set to `true`, validates and previews the request, but
   * doesn't create the subscription.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for WorkspaceEvents#subscriptionsDelete.
 */
export interface SubscriptionsDeleteOptions {
  /**
   * Optional. If set to `true` and the subscription isn't found, the request
   * succeeds but doesn't delete the subscription.
   */
  allowMissing?: boolean;
  /**
   * Optional. Etag of the subscription. If present, it must match with the
   * server's etag. Otherwise, request fails with the status `ABORTED`.
   */
  etag?: string;
  /**
   * Optional. If set to `true`, validates and previews the request, but
   * doesn't delete the subscription.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for WorkspaceEvents#subscriptionsList.
 */
export interface SubscriptionsListOptions {
  /**
   * Required. A query filter. You can filter subscriptions by event type
   * (`event_types`) and target resource (`target_resource`). You must specify
   * at least one event type in your query. To filter for multiple event types,
   * use the `OR` operator. To filter by both event type and target resource,
   * use the `AND` operator and specify the full resource name, such as
   * `//chat.googleapis.com/spaces/{space}`. For example, the following queries
   * are valid: ``` event_types:"google.workspace.chat.membership.v1.updated" OR
   * event_types:"google.workspace.chat.message.v1.created"
   * event_types:"google.workspace.chat.message.v1.created" AND
   * target_resource="//chat.googleapis.com/spaces/{space}" (
   * event_types:"google.workspace.chat.membership.v1.updated" OR
   * event_types:"google.workspace.chat.message.v1.created" ) AND
   * target_resource="//chat.googleapis.com/spaces/{space}" ``` The server
   * rejects invalid queries with an `INVALID_ARGUMENT` error.
   */
  filter?: string;
  /**
   * Optional. The maximum number of subscriptions to return. The service might
   * return fewer than this value. If unspecified or set to `0`, up to 50
   * subscriptions are returned. The maximum value is 100. If you specify a
   * value more than 100, the system only returns 100 subscriptions.
   */
  pageSize?: number;
  /**
   * Optional. A page token, received from a previous list subscriptions call.
   * Provide this parameter to retrieve the subsequent page. When paginating,
   * the filter value should match the call that provided the page token.
   * Passing a different value might lead to unexpected results.
   */
  pageToken?: string;
}

/**
 * Additional options for WorkspaceEvents#subscriptionsPatch.
 */
export interface SubscriptionsPatchOptions {
  /**
   * Optional. The field to update. If omitted, updates any fields included in
   * the request. You can update one of the following fields in a subscription:
   * * `expire_time`: The timestamp when the subscription expires. * `ttl`: The
   * time-to-live (TTL) or duration of the subscription. * `event_types`: The
   * list of event types to receive about the target resource. To fully replace
   * the subscription (the equivalent of `PUT`), use `*`. Any omitted fields are
   * updated with empty values.
   */
  updateMask?: string /* FieldMask */;
  /**
   * Optional. If set to `true`, validates and previews the request, but
   * doesn't update the subscription.
   */
  validateOnly?: boolean;
}

function serializeSubscriptionsPatchOptions(data: any): SubscriptionsPatchOptions {
  return {
    ...data,
    updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined,
  };
}

function deserializeSubscriptionsPatchOptions(data: any): SubscriptionsPatchOptions {
  return {
    ...data,
    updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined,
  };
}