// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Looker (Google Cloud core) API Client for Deno
 * ==============================================
 * 
 * 
 * 
 * Docs: https://cloud.google.com/looker/docs/reference/rest/
 * Source: https://googleapis.deno.dev/v1/looker:v1.ts
 */

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

export class Looker {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

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

  /**
   * Gets information about a location.
   *
   * @param name Resource name for the location.
   */
  async projectsLocationsGet(name: string): Promise<Location> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Location;
  }

  /**
   * Creates a new Instance in a given project and location.
   *
   * @param parent Required. Format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsInstancesCreate(parent: string, req: Instance, opts: ProjectsLocationsInstancesCreateOptions = {}): Promise<Operation> {
    req = serializeInstance(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/instances`);
    if (opts.instanceId !== undefined) {
      url.searchParams.append("instanceId", String(opts.instanceId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Delete instance.
   *
   * @param name Required. Format: `projects/{project}/locations/{location}/instances/{instance}`.
   */
  async projectsLocationsInstancesDelete(name: string, opts: ProjectsLocationsInstancesDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.force !== undefined) {
      url.searchParams.append("force", String(opts.force));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Export instance.
   *
   * @param name Required. Format: `projects/{project}/locations/{location}/instances/{instance}`.
   */
  async projectsLocationsInstancesExport(name: string, req: ExportInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:export`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Gets details of a single Instance.
   *
   * @param name Required. Format: `projects/{project}/locations/{location}/instances/{instance}`.
   */
  async projectsLocationsInstancesGet(name: string): Promise<Instance> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeInstance(data);
  }

  /**
   * Import instance.
   *
   * @param name Required. Format: `projects/{project}/locations/{location}/instances/{instance}`.
   */
  async projectsLocationsInstancesImport(name: string, req: ImportInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:import`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Lists Instances in a given project and location.
   *
   * @param parent Required. Format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsInstancesList(parent: string, opts: ProjectsLocationsInstancesListOptions = {}): Promise<ListInstancesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/instances`);
    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 deserializeListInstancesResponse(data);
  }

  /**
   * Update Instance.
   *
   * @param name Output only. Format: `projects/{project}/locations/{location}/instances/{instance}`.
   */
  async projectsLocationsInstancesPatch(name: string, req: Instance, opts: ProjectsLocationsInstancesPatchOptions = {}): Promise<Operation> {
    req = serializeInstance(req);
    opts = serializeProjectsLocationsInstancesPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

  /**
   * Restart instance.
   *
   * @param name Required. Format: `projects/{project}/locations/{location}/instances/{instance}`.
   */
  async projectsLocationsInstancesRestart(name: string, req: RestartInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:restart`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Lists information about the supported locations for this service.
   *
   * @param name The resource that owns the locations collection, if applicable.
   */
  async projectsLocationsList(name: string, opts: ProjectsLocationsListOptions = {}): Promise<ListLocationsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }/locations`);
    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 data as ListLocationsResponse;
  }

  /**
   * Starts asynchronous cancellation on a long-running operation. The server
   * makes a best effort to cancel the operation, but success is not guaranteed.
   * If the server doesn't support this method, it returns
   * `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or
   * other methods to check whether the cancellation succeeded or whether the
   * operation completed despite cancellation. On successful cancellation, the
   * operation is not deleted; instead, it becomes an operation with an
   * Operation.error value with a google.rpc.Status.code of `1`, corresponding
   * to `Code.CANCELLED`.
   *
   * @param name The name of the operation resource to be cancelled.
   */
  async projectsLocationsOperationsCancel(name: string, req: CancelOperationRequest): Promise<Empty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:cancel`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Empty;
  }

  /**
   * Deletes a long-running operation. This method indicates that the client is
   * no longer interested in the operation result. It does not cancel the
   * operation. If the server doesn't support this method, it returns
   * `google.rpc.Code.UNIMPLEMENTED`.
   *
   * @param name The name of the operation resource to be deleted.
   */
  async projectsLocationsOperationsDelete(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;
  }

  /**
   * 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 projectsLocationsOperationsGet(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;
  }

  /**
   * Lists operations that match the specified filter in the request. If the
   * server doesn't support this method, it returns `UNIMPLEMENTED`.
   *
   * @param name The name of the operation's parent resource.
   */
  async projectsLocationsOperationsList(name: string, opts: ProjectsLocationsOperationsListOptions = {}): Promise<ListOperationsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }/operations`);
    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 data as ListOperationsResponse;
  }
}

/**
 * Looker instance Admin settings fields.
 */
export interface AdminSettings {
  /**
   * Email domain allowlist for the instance.
   */
  allowedEmailDomains?: string[];
}

/**
 * The request message for Operations.CancelOperation.
 */
export interface CancelOperationRequest {
}

/**
 * Custom domain information.
 */
export interface CustomDomain {
  /**
   * Domain name.
   */
  domain?: string;
  /**
   * Domain state.
   */
  state?:  | "CUSTOM_DOMAIN_STATE_UNSPECIFIED" | "UNVERIFIED" | "VERIFIED" | "MODIFYING" | "AVAILABLE" | "UNAVAILABLE" | "UNKNOWN";
}

/**
 * Represents a whole or partial calendar date, such as a birthday. The time of
 * day and time zone are either specified elsewhere or are insignificant. The
 * date is relative to the Gregorian Calendar. This can represent one of the
 * following: * A full date, with non-zero year, month, and day values. * A
 * month and day, with a zero year (for example, an anniversary). * A year on
 * its own, with a zero month and a zero day. * A year and month, with a zero
 * day (for example, a credit card expiration date). Related types: *
 * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp
 */
export interface Date {
  /**
   * Day of a month. Must be from 1 to 31 and valid for the year and month, or
   * 0 to specify a year by itself or a year and month where the day isn't
   * significant.
   */
  day?: number;
  /**
   * Month of a year. Must be from 1 to 12, or 0 to specify a year without a
   * month and day.
   */
  month?: number;
  /**
   * Year of the date. Must be from 1 to 9999, or 0 to specify a date without a
   * year.
   */
  year?: number;
}

/**
 * Specifies the maintenance denial period.
 */
export interface DenyMaintenancePeriod {
  /**
   * Required. End date of the deny maintenance period.
   */
  endDate?: Date;
  /**
   * Required. Start date of the deny maintenance period.
   */
  startDate?: Date;
  /**
   * Required. Time in UTC when the period starts and ends.
   */
  time?: TimeOfDay;
}

/**
 * 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 {
}

/**
 * Encryption configuration (i.e. CMEK).
 */
export interface EncryptionConfig {
  /**
   * Name of the CMEK key in KMS (input parameter).
   */
  kmsKeyName?: string;
  /**
   * Output only. Full name and version of the CMEK key currently in use to
   * encrypt Looker data. Format:
   * `projects/{project}/locations/{location}/keyRings/{ring}/cryptoKeys/{key}/cryptoKeyVersions/{version}`.
   * Empty if CMEK is not configured in this instance.
   */
  readonly kmsKeyNameVersion?: string;
  /**
   * Output only. Status of the CMEK key.
   */
  readonly kmsKeyState?:  | "KMS_KEY_STATE_UNSPECIFIED" | "VALID" | "REVOKED";
}

/**
 * Configuration for Encryption - e.g. CMEK.
 */
export interface ExportEncryptionConfig {
  /**
   * Required. Name of the CMEK key in KMS.
   */
  kmsKeyName?: string;
}

/**
 * Request options for exporting data of an Instance.
 */
export interface ExportInstanceRequest {
  /**
   * Required. Encryption configuration (CMEK). For CMEK enabled instances it
   * should be same as looker CMEK.
   */
  encryptionConfig?: ExportEncryptionConfig;
  /**
   * The path to the folder in Google Cloud Storage where the export will be
   * stored. The URI is in the form `gs://bucketName/folderName`.
   */
  gcsUri?: string;
}

/**
 * ExportMetadata represents the metadata of the exported artifacts. The
 * metadata.json file in export artifact can be parsed as this message
 */
export interface ExportMetadata {
  /**
   * Encryption key that was used to encrypt the export artifacts.
   */
  exportEncryptionKey?: ExportMetadataEncryptionKey;
  /**
   * List of files created as part of export artifact (excluding the metadata).
   * The paths are relative to the folder containing the metadata.
   */
  filePaths?: string[];
  /**
   * Looker encryption key, encrypted with the provided export encryption key.
   * This value will only be populated if the looker instance uses Looker
   * managed encryption instead of CMEK.
   */
  lookerEncryptionKey?: string;
  /**
   * Name of the exported instance. Format:
   * projects/{project}/locations/{location}/instances/{instance}
   */
  lookerInstance?: string;
  /**
   * Platform edition of the exported instance.
   */
  lookerPlatformEdition?: string;
  /**
   * Version of instance when the export was created.
   */
  lookerVersion?: string;
  /**
   * The source type of the migration.
   */
  source?:  | "SOURCE_UNSPECIFIED" | "LOOKER_CORE" | "LOOKER_ORIGINAL";
}

/**
 * Encryption key details for the exported artifact.
 */
export interface ExportMetadataEncryptionKey {
  /**
   * Name of the CMEK.
   */
  cmek?: string;
  /**
   * Version of the CMEK.
   */
  version?: string;
}

/**
 * Requestion options for importing looker data to an Instance
 */
export interface ImportInstanceRequest {
  /**
   * Path to the import folder in Google Cloud Storage, in the form
   * `gs://bucketName/folderName`.
   */
  gcsUri?: string;
}

/**
 * A Looker instance.
 */
export interface Instance {
  /**
   * Looker Instance Admin settings.
   */
  adminSettings?: AdminSettings;
  /**
   * Network name in the consumer project. Format:
   * `projects/{project}/global/networks/{network}`. Note that the consumer
   * network may be in a different GCP project than the consumer project that is
   * hosting the Looker Instance.
   */
  consumerNetwork?: string;
  /**
   * Output only. The time when the Looker instance provisioning was first
   * requested.
   */
  readonly createTime?: Date;
  /**
   * Custom domain configuration for the instance.
   */
  customDomain?: CustomDomain;
  /**
   * Maintenance denial period for this instance.
   */
  denyMaintenancePeriod?: DenyMaintenancePeriod;
  /**
   * Output only. Public Egress IP (IPv4).
   */
  readonly egressPublicIp?: string;
  /**
   * Encryption configuration (CMEK). Only set if CMEK has been enabled on the
   * instance.
   */
  encryptionConfig?: EncryptionConfig;
  /**
   * Optional. Whether FIPS is enabled on the Looker instance.
   */
  fipsEnabled?: boolean;
  /**
   * Optional. Whether Gemini feature is enabled on the Looker instance or not.
   */
  geminiEnabled?: boolean;
  /**
   * Output only. Private Ingress IP (IPv4).
   */
  readonly ingressPrivateIp?: string;
  /**
   * Output only. Public Ingress IP (IPv4).
   */
  readonly ingressPublicIp?: string;
  /**
   * Output only. Last computed maintenance denial period for this instance.
   */
  readonly lastDenyMaintenancePeriod?: DenyMaintenancePeriod;
  /**
   * Optional. Linked Google Cloud Project Number for Looker Studio Pro.
   */
  linkedLspProjectNumber?: bigint;
  /**
   * Output only. Looker instance URI which can be used to access the Looker
   * Instance UI.
   */
  readonly lookerUri?: string;
  /**
   * Output only. The Looker version that the instance is using.
   */
  readonly lookerVersion?: string;
  /**
   * Maintenance schedule for this instance.
   */
  maintenanceSchedule?: MaintenanceSchedule;
  /**
   * Maintenance window for this instance.
   */
  maintenanceWindow?: MaintenanceWindow;
  /**
   * Output only. Format:
   * `projects/{project}/locations/{location}/instances/{instance}`.
   */
  readonly name?: string;
  /**
   * Looker instance OAuth login settings.
   */
  oauthConfig?: OAuthConfig;
  /**
   * Platform edition.
   */
  platformEdition?:  | "PLATFORM_EDITION_UNSPECIFIED" | "LOOKER_CORE_TRIAL" | "LOOKER_CORE_STANDARD" | "LOOKER_CORE_STANDARD_ANNUAL" | "LOOKER_CORE_ENTERPRISE_ANNUAL" | "LOOKER_CORE_EMBED_ANNUAL" | "LOOKER_CORE_NONPROD_STANDARD_ANNUAL" | "LOOKER_CORE_NONPROD_ENTERPRISE_ANNUAL" | "LOOKER_CORE_NONPROD_EMBED_ANNUAL";
  /**
   * Whether private IP is enabled on the Looker instance.
   */
  privateIpEnabled?: boolean;
  /**
   * Optional. PSC configuration. Used when `psc_enabled` is true.
   */
  pscConfig?: PscConfig;
  /**
   * Optional. Whether to use Private Service Connect (PSC) for private IP
   * connectivity. If true, neither `public_ip_enabled` nor `private_ip_enabled`
   * can be true.
   */
  pscEnabled?: boolean;
  /**
   * Whether public IP is enabled on the Looker instance.
   */
  publicIpEnabled?: boolean;
  /**
   * Name of a reserved IP address range within the Instance.consumer_network,
   * to be used for private services access connection. May or may not be
   * specified in a create request.
   */
  reservedRange?: string;
  /**
   * Output only. Reserved for future use.
   */
  readonly satisfiesPzi?: boolean;
  /**
   * Output only. Reserved for future use.
   */
  readonly satisfiesPzs?: boolean;
  /**
   * Output only. The state of the instance.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "CREATING" | "FAILED" | "SUSPENDED" | "UPDATING" | "DELETING" | "EXPORTING" | "IMPORTING";
  /**
   * Output only. The time when the Looker instance was last updated.
   */
  readonly updateTime?: Date;
  /**
   * Optional. User metadata.
   */
  userMetadata?: UserMetadata;
}

function serializeInstance(data: any): Instance {
  return {
    ...data,
    linkedLspProjectNumber: data["linkedLspProjectNumber"] !== undefined ? String(data["linkedLspProjectNumber"]) : undefined,
    maintenanceSchedule: data["maintenanceSchedule"] !== undefined ? serializeMaintenanceSchedule(data["maintenanceSchedule"]) : undefined,
  };
}

function deserializeInstance(data: any): Instance {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    linkedLspProjectNumber: data["linkedLspProjectNumber"] !== undefined ? BigInt(data["linkedLspProjectNumber"]) : undefined,
    maintenanceSchedule: data["maintenanceSchedule"] !== undefined ? deserializeMaintenanceSchedule(data["maintenanceSchedule"]) : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
  };
}

/**
 * Response from ListInstances.
 */
export interface ListInstancesResponse {
  /**
   * The list of instances matching the request filters, up to the requested
   * ListInstancesRequest.pageSize.
   */
  instances?: Instance[];
  /**
   * If provided, a page token that can look up the next
   * ListInstancesRequest.pageSize results. If empty, the results list is
   * exhausted.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

function serializeListInstancesResponse(data: any): ListInstancesResponse {
  return {
    ...data,
    instances: data["instances"] !== undefined ? data["instances"].map((item: any) => (serializeInstance(item))) : undefined,
  };
}

function deserializeListInstancesResponse(data: any): ListInstancesResponse {
  return {
    ...data,
    instances: data["instances"] !== undefined ? data["instances"].map((item: any) => (deserializeInstance(item))) : undefined,
  };
}

/**
 * The response message for Locations.ListLocations.
 */
export interface ListLocationsResponse {
  /**
   * A list of locations that matches the specified filter in the request.
   */
  locations?: Location[];
  /**
   * The standard List next-page token.
   */
  nextPageToken?: string;
}

/**
 * The response message for Operations.ListOperations.
 */
export interface ListOperationsResponse {
  /**
   * The standard List next-page token.
   */
  nextPageToken?: string;
  /**
   * A list of operations that matches the specified filter in the request.
   */
  operations?: Operation[];
}

/**
 * A resource that represents a Google Cloud location.
 */
export interface Location {
  /**
   * The friendly name for this location, typically a nearby city name. For
   * example, "Tokyo".
   */
  displayName?: string;
  /**
   * Cross-service attributes for the location. For example
   * {"cloud.googleapis.com/region": "us-east1"}
   */
  labels?: {
    [key: string]: string
  };
  /**
   * The canonical id for this location. For example: `"us-east1"`.
   */
  locationId?: string;
  /**
   * Service-specific metadata. For example the available capacity at the given
   * location.
   */
  metadata?: {
    [key: string]: any
  };
  /**
   * Resource name for the location, which may vary between implementations.
   * For example: `"projects/example-project/locations/us-east1"`
   */
  name?: string;
}

/**
 * Published upcoming future maintenance schedule.
 */
export interface MaintenanceSchedule {
  /**
   * The scheduled end time for the maintenance.
   */
  endTime?: Date;
  /**
   * The scheduled start time for the maintenance.
   */
  startTime?: Date;
}

function serializeMaintenanceSchedule(data: any): MaintenanceSchedule {
  return {
    ...data,
    endTime: data["endTime"] !== undefined ? data["endTime"].toISOString() : undefined,
    startTime: data["startTime"] !== undefined ? data["startTime"].toISOString() : undefined,
  };
}

function deserializeMaintenanceSchedule(data: any): MaintenanceSchedule {
  return {
    ...data,
    endTime: data["endTime"] !== undefined ? new Date(data["endTime"]) : undefined,
    startTime: data["startTime"] !== undefined ? new Date(data["startTime"]) : undefined,
  };
}

/**
 * Specifies the recurring maintenance window.
 */
export interface MaintenanceWindow {
  /**
   * Required. Day of the week for this MaintenanceWindow (in UTC).
   */
  dayOfWeek?:  | "DAY_OF_WEEK_UNSPECIFIED" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY";
  /**
   * Required. Time in UTC when the period starts. Maintenance will be
   * scheduled within 60 minutes.
   */
  startTime?: TimeOfDay;
}

/**
 * Looker instance OAuth login settings.
 */
export interface OAuthConfig {
  /**
   * Input only. Client ID from an external OAuth application. This is an
   * input-only field, and thus will not be set in any responses.
   */
  clientId?: string;
  /**
   * Input only. Client secret from an external OAuth application. This is an
   * input-only field, and thus will not be set in any responses.
   */
  clientSecret?: 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
  };
}

/**
 * Represents the metadata of the long-running operation.
 */
export interface OperationMetadata {
  /**
   * API version used to start the operation.
   */
  apiVersion?: string;
  /**
   * The time the operation was created.
   */
  createTime?: Date;
  /**
   * The time the operation finished running.
   */
  endTime?: Date;
  /**
   * Identifies whether the user has requested cancellation of the operation.
   * Operations that have successfully been cancelled have Operation.error value
   * with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.
   */
  requestedCancellation?: boolean;
  /**
   * Human-readable status of the operation, if any.
   */
  statusMessage?: string;
  /**
   * Server-defined resource path for the target of the operation.
   */
  target?: string;
  /**
   * Name of the verb executed by the operation.
   */
  verb?: string;
}

function serializeOperationMetadata(data: any): OperationMetadata {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? data["createTime"].toISOString() : undefined,
    endTime: data["endTime"] !== undefined ? data["endTime"].toISOString() : undefined,
  };
}

function deserializeOperationMetadata(data: any): OperationMetadata {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    endTime: data["endTime"] !== undefined ? new Date(data["endTime"]) : undefined,
  };
}

/**
 * Additional options for Looker#projectsLocationsInstancesCreate.
 */
export interface ProjectsLocationsInstancesCreateOptions {
  /**
   * Required. The unique instance identifier. Must contain only lowercase
   * letters, numbers, or hyphens, with the first character a letter and the
   * last a letter or a number. 63 characters maximum.
   */
  instanceId?: string;
}

/**
 * Additional options for Looker#projectsLocationsInstancesDelete.
 */
export interface ProjectsLocationsInstancesDeleteOptions {
  /**
   * Whether to force cascading delete.
   */
  force?: boolean;
}

/**
 * Additional options for Looker#projectsLocationsInstancesList.
 */
export interface ProjectsLocationsInstancesListOptions {
  /**
   * The maximum number of instances to return. If unspecified at most 256 will
   * be returned. The maximum possible value is 2048.
   */
  pageSize?: number;
  /**
   * A page token received from a previous ListInstancesRequest.
   */
  pageToken?: string;
}

/**
 * Additional options for Looker#projectsLocationsInstancesPatch.
 */
export interface ProjectsLocationsInstancesPatchOptions {
  /**
   * Required. Field mask used to specify the fields to be overwritten in the
   * Instance resource by the update. The fields specified in the mask are
   * relative to the resource, not the full request. A field will be overwritten
   * if it is in the mask.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for Looker#projectsLocationsList.
 */
export interface ProjectsLocationsListOptions {
  /**
   * A filter to narrow down results to a preferred subset. The filtering
   * language accepts strings like `"displayName=tokyo"`, and is documented in
   * more detail in [AIP-160](https://google.aip.dev/160).
   */
  filter?: string;
  /**
   * The maximum number of results to return. If not set, the service selects a
   * default.
   */
  pageSize?: number;
  /**
   * A page token received from the `next_page_token` field in the response.
   * Send that page token to receive the subsequent page.
   */
  pageToken?: string;
}

/**
 * Additional options for Looker#projectsLocationsOperationsList.
 */
export interface ProjectsLocationsOperationsListOptions {
  /**
   * The standard list filter.
   */
  filter?: string;
  /**
   * The standard list page size.
   */
  pageSize?: number;
  /**
   * The standard list page token.
   */
  pageToken?: string;
}

/**
 * Information for Private Service Connect (PSC) setup for a Looker instance.
 */
export interface PscConfig {
  /**
   * Optional. List of VPCs that are allowed ingress into looker. Format:
   * projects/{project}/global/networks/{network}
   */
  allowedVpcs?: string[];
  /**
   * Output only. URI of the Looker service attachment.
   */
  readonly lookerServiceAttachmentUri?: string;
  /**
   * Optional. List of egress service attachment configurations.
   */
  serviceAttachments?: ServiceAttachment[];
}

/**
 * Request options for restarting an instance.
 */
export interface RestartInstanceRequest {
}

/**
 * Service attachment configuration.
 */
export interface ServiceAttachment {
  /**
   * Output only. Connection status.
   */
  readonly connectionStatus?:  | "UNKNOWN" | "ACCEPTED" | "PENDING" | "REJECTED" | "NEEDS_ATTENTION" | "CLOSED";
  /**
   * Required. Fully qualified domain name that will be used in the private DNS
   * record created for the service attachment.
   */
  localFqdn?: string;
  /**
   * Required. URI of the service attachment to connect to. Format:
   * projects/{project}/regions/{region}/serviceAttachments/{service_attachment}
   */
  targetServiceAttachmentUri?: string;
}

/**
 * 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;
}

/**
 * Represents a time of day. The date and time zone are either not significant
 * or are specified elsewhere. An API may choose to allow leap seconds. Related
 * types are google.type.Date and `google.protobuf.Timestamp`.
 */
export interface TimeOfDay {
  /**
   * Hours of a day in 24 hour format. Must be greater than or equal to 0 and
   * typically must be less than or equal to 23. An API may choose to allow the
   * value "24:00:00" for scenarios like business closing time.
   */
  hours?: number;
  /**
   * Minutes of an hour. Must be greater than or equal to 0 and less than or
   * equal to 59.
   */
  minutes?: number;
  /**
   * Fractions of seconds, in nanoseconds. Must be greater than or equal to 0
   * and less than or equal to 999,999,999.
   */
  nanos?: number;
  /**
   * Seconds of a minute. Must be greater than or equal to 0 and typically must
   * be less than or equal to 59. An API may allow the value 60 if it allows
   * leap-seconds.
   */
  seconds?: number;
}

/**
 * Metadata about users for a Looker instance.
 */
export interface UserMetadata {
  /**
   * Optional. The number of additional developer users the instance owner has
   * purchased.
   */
  additionalDeveloperUserCount?: number;
  /**
   * Optional. The number of additional standard users the instance owner has
   * purchased.
   */
  additionalStandardUserCount?: number;
  /**
   * Optional. The number of additional viewer users the instance owner has
   * purchased.
   */
  additionalViewerUserCount?: number;
}