// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Notebooks API Client for Deno
 * =============================
 * 
 * Notebooks API is used to manage notebook resources in Google Cloud.
 * 
 * Docs: https://cloud.google.com/notebooks/docs/
 * Source: https://googleapis.deno.dev/v1/notebooks:v2.ts
 */

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

/**
 * Notebooks API is used to manage notebook resources in Google Cloud.
 */
export class Notebooks {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

  constructor(client?: CredentialsClient, baseUrl: string = "https://notebooks.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}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Location;
  }

  /**
   * Checks whether a notebook instance is upgradable.
   *
   * @param notebookInstance Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesCheckUpgradability(notebookInstance: string): Promise<CheckInstanceUpgradabilityResponse> {
    const url = new URL(`${this.#baseUrl}v2/${ notebookInstance }:checkUpgradability`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as CheckInstanceUpgradabilityResponse;
  }

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

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

  /**
   * Creates a Diagnostic File and runs Diagnostic Tool given an Instance.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesDiagnose(name: string, req: DiagnoseInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:diagnose`);
    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_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesGet(name: string): Promise<Instance> {
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeInstance(data);
  }

  /**
   * Gets general backend configurations that might also affect the frontend.
   * Location is required by CCFE. Although we could bypass it to send location-
   * less request directly to the backend job, we would need CPE (go/cloud-cpe).
   * Having the location might also be useful depending on the query.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}`
   */
  async projectsLocationsInstancesGetConfig(name: string): Promise<Config> {
    const url = new URL(`${this.#baseUrl}v2/${ name }/instances:getConfig`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Config;
  }

  /**
   * 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 projectsLocationsInstancesGetIamPolicy(resource: string, opts: ProjectsLocationsInstancesGetIamPolicyOptions = {}): Promise<Policy> {
    const url = new URL(`${this.#baseUrl}v2/${ 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 instances in a given project and location.
   *
   * @param parent Required. Format: `parent=projects/{project_id}/locations/{location}`
   */
  async projectsLocationsInstancesList(parent: string, opts: ProjectsLocationsInstancesListOptions = {}): Promise<ListInstancesResponse> {
    const url = new URL(`${this.#baseUrl}v2/${ parent }/instances`);
    if (opts.filter !== undefined) {
      url.searchParams.append("filter", String(opts.filter));
    }
    if (opts.orderBy !== undefined) {
      url.searchParams.append("orderBy", String(opts.orderBy));
    }
    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);
  }

  /**
   * UpdateInstance updates an Instance.
   *
   * @param name Output only. The name of this notebook instance. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesPatch(name: string, req: Instance, opts: ProjectsLocationsInstancesPatchOptions = {}): Promise<Operation> {
    req = serializeInstance(req);
    opts = serializeProjectsLocationsInstancesPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    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;
  }

  /**
   * Allows notebook instances to report their latest instance information to
   * the Notebooks API server. The server will merge the reported information to
   * the instance metadata store. Do not use this method directly.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesReportInfoSystem(name: string, req: ReportInstanceInfoSystemRequest): Promise<Operation> {
    req = serializeReportInstanceInfoSystemRequest(req);
    const url = new URL(`${this.#baseUrl}v2/${ name }:reportInfoSystem`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Resets a notebook instance.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesReset(name: string, req: ResetInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:reset`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Resize a notebook instance disk to a higher capacity.
   *
   * @param notebookInstance Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesResizeDisk(notebookInstance: string, req: ResizeDiskRequest): Promise<Operation> {
    req = serializeResizeDiskRequest(req);
    const url = new URL(`${this.#baseUrl}v2/${ notebookInstance }:resizeDisk`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * RestoreInstance restores an Instance from a BackupSource.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesRestore(name: string, req: RestoreInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:restore`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Rollbacks a notebook instance to the previous version.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesRollback(name: string, req: RollbackInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:rollback`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * 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 projectsLocationsInstancesSetIamPolicy(resource: string, req: SetIamPolicyRequest): Promise<Policy> {
    req = serializeSetIamPolicyRequest(req);
    const url = new URL(`${this.#baseUrl}v2/${ resource }:setIamPolicy`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializePolicy(data);
  }

  /**
   * Starts a notebook instance.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesStart(name: string, req: StartInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:start`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Stops a notebook instance.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesStop(name: string, req: StopInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:stop`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * 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 projectsLocationsInstancesTestIamPermissions(resource: string, req: TestIamPermissionsRequest): Promise<TestIamPermissionsResponse> {
    const url = new URL(`${this.#baseUrl}v2/${ resource }:testIamPermissions`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as TestIamPermissionsResponse;
  }

  /**
   * Upgrades a notebook instance to the latest version.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesUpgrade(name: string, req: UpgradeInstanceRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:upgrade`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Allows notebook instances to upgrade themselves. Do not use this method
   * directly.
   *
   * @param name Required. Format: `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  async projectsLocationsInstancesUpgradeSystem(name: string, req: UpgradeInstanceSystemRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:upgradeSystem`);
    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}v2/${ 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}v2/${ 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}v2/${ 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}v2/${ 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}v2/${ 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;
  }
}

/**
 * An accelerator configuration for a VM instance Definition of a hardware
 * accelerator. Note that there is no check on `type` and `core_count`
 * combinations. TPUs are not supported. See [GPUs on Compute
 * Engine](https://cloud.google.com/compute/docs/gpus/#gpus-list) to find a
 * valid combination.
 */
export interface AcceleratorConfig {
  /**
   * Optional. Count of cores of this accelerator.
   */
  coreCount?: bigint;
  /**
   * Optional. Type of this accelerator.
   */
  type?:  | "ACCELERATOR_TYPE_UNSPECIFIED" | "NVIDIA_TESLA_P100" | "NVIDIA_TESLA_V100" | "NVIDIA_TESLA_P4" | "NVIDIA_TESLA_T4" | "NVIDIA_TESLA_A100" | "NVIDIA_A100_80GB" | "NVIDIA_L4" | "NVIDIA_TESLA_T4_VWS" | "NVIDIA_TESLA_P100_VWS" | "NVIDIA_TESLA_P4_VWS";
}

function serializeAcceleratorConfig(data: any): AcceleratorConfig {
  return {
    ...data,
    coreCount: data["coreCount"] !== undefined ? String(data["coreCount"]) : undefined,
  };
}

function deserializeAcceleratorConfig(data: any): AcceleratorConfig {
  return {
    ...data,
    coreCount: data["coreCount"] !== undefined ? BigInt(data["coreCount"]) : undefined,
  };
}

/**
 * An access configuration attached to an instance's network interface.
 */
export interface AccessConfig {
  /**
   * An external IP address associated with this instance. Specify an unused
   * static external IP address available to the project or leave this field
   * undefined to use an IP from a shared ephemeral IP address pool. If you
   * specify a static external IP address, it must live in the same region as
   * the zone of the instance.
   */
  externalIp?: string;
}

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

/**
 * The definition of a boot disk.
 */
export interface BootDisk {
  /**
   * Optional. Input only. Disk encryption method used on the boot and data
   * disks, defaults to GMEK.
   */
  diskEncryption?:  | "DISK_ENCRYPTION_UNSPECIFIED" | "GMEK" | "CMEK";
  /**
   * Optional. The size of the boot disk in GB attached to this instance, up to
   * a maximum of 64000 GB (64 TB). If not specified, this defaults to the
   * recommended value of 150GB.
   */
  diskSizeGb?: bigint;
  /**
   * Optional. Indicates the type of the disk.
   */
  diskType?:  | "DISK_TYPE_UNSPECIFIED" | "PD_STANDARD" | "PD_SSD" | "PD_BALANCED" | "PD_EXTREME";
  /**
   * Optional. Input only. The KMS key used to encrypt the disks, only
   * applicable if disk_encryption is CMEK. Format:
   * `projects/{project_id}/locations/{location}/keyRings/{key_ring_id}/cryptoKeys/{key_id}`
   * Learn more about using your own encryption keys.
   */
  kmsKey?: string;
}

function serializeBootDisk(data: any): BootDisk {
  return {
    ...data,
    diskSizeGb: data["diskSizeGb"] !== undefined ? String(data["diskSizeGb"]) : undefined,
  };
}

function deserializeBootDisk(data: any): BootDisk {
  return {
    ...data,
    diskSizeGb: data["diskSizeGb"] !== undefined ? BigInt(data["diskSizeGb"]) : undefined,
  };
}

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

/**
 * Response for checking if a notebook instance is upgradeable.
 */
export interface CheckInstanceUpgradabilityResponse {
  /**
   * If an instance is upgradeable.
   */
  upgradeable?: boolean;
  /**
   * The new image self link this instance will be upgraded to if calling the
   * upgrade endpoint. This field will only be populated if field upgradeable is
   * true.
   */
  upgradeImage?: string;
  /**
   * Additional information about upgrade.
   */
  upgradeInfo?: string;
  /**
   * The version this instance will be upgraded to if calling the upgrade
   * endpoint. This field will only be populated if field upgradeable is true.
   */
  upgradeVersion?: string;
}

/**
 * Response for getting WbI configurations in a location
 */
export interface Config {
  /**
   * Output only. The list of available images to create a WbI.
   */
  readonly availableImages?: ImageRelease[];
  /**
   * Output only. The default values for configuration.
   */
  readonly defaultValues?: DefaultValues;
  /**
   * Output only. The supported values for configuration.
   */
  readonly supportedValues?: SupportedValues;
}

/**
 * Definition of a container image for starting a notebook instance with the
 * environment installed in a container.
 */
export interface ContainerImage {
  /**
   * Required. The path to the container image repository. For example:
   * `gcr.io/{project_id}/{image_name}`
   */
  repository?: string;
  /**
   * Optional. The tag of the container image. If not specified, this defaults
   * to the latest tag.
   */
  tag?: string;
}

/**
 * An instance-attached disk resource.
 */
export interface DataDisk {
  /**
   * Optional. Input only. Disk encryption method used on the boot and data
   * disks, defaults to GMEK.
   */
  diskEncryption?:  | "DISK_ENCRYPTION_UNSPECIFIED" | "GMEK" | "CMEK";
  /**
   * Optional. The size of the disk in GB attached to this VM instance, up to a
   * maximum of 64000 GB (64 TB). If not specified, this defaults to 100.
   */
  diskSizeGb?: bigint;
  /**
   * Optional. Input only. Indicates the type of the disk.
   */
  diskType?:  | "DISK_TYPE_UNSPECIFIED" | "PD_STANDARD" | "PD_SSD" | "PD_BALANCED" | "PD_EXTREME";
  /**
   * Optional. Input only. The KMS key used to encrypt the disks, only
   * applicable if disk_encryption is CMEK. Format:
   * `projects/{project_id}/locations/{location}/keyRings/{key_ring_id}/cryptoKeys/{key_id}`
   * Learn more about using your own encryption keys.
   */
  kmsKey?: string;
}

function serializeDataDisk(data: any): DataDisk {
  return {
    ...data,
    diskSizeGb: data["diskSizeGb"] !== undefined ? String(data["diskSizeGb"]) : undefined,
  };
}

function deserializeDataDisk(data: any): DataDisk {
  return {
    ...data,
    diskSizeGb: data["diskSizeGb"] !== undefined ? BigInt(data["diskSizeGb"]) : undefined,
  };
}

/**
 * DefaultValues represents the default configuration values.
 */
export interface DefaultValues {
  /**
   * Output only. The default machine type used by the backend if not provided
   * by the user.
   */
  readonly machineType?: string;
}

/**
 * Request for creating a notebook instance diagnostic file.
 */
export interface DiagnoseInstanceRequest {
  /**
   * Required. Defines flags that are used to run the diagnostic tool
   */
  diagnosticConfig?: DiagnosticConfig;
  /**
   * Optional. Maximum amount of time in minutes before the operation times
   * out.
   */
  timeoutMinutes?: number;
}

/**
 * Defines flags that are used to run the diagnostic tool
 */
export interface DiagnosticConfig {
  /**
   * Optional. Enables flag to copy all `/home/jupyter` folder contents
   */
  enableCopyHomeFilesFlag?: boolean;
  /**
   * Optional. Enables flag to capture packets from the instance for 30 seconds
   */
  enablePacketCaptureFlag?: boolean;
  /**
   * Optional. Enables flag to repair service for instance
   */
  enableRepairFlag?: boolean;
  /**
   * Required. User Cloud Storage bucket location (REQUIRED). Must be formatted
   * with path prefix (`gs://$GCS_BUCKET`). Permissions: User Managed Notebooks:
   * - storage.buckets.writer: Must be given to the project's service account
   * attached to VM. Google Managed Notebooks: - storage.buckets.writer: Must be
   * given to the project's service account or user credentials attached to VM
   * depending on authentication mode. Cloud Storage bucket Log file will be
   * written to `gs://$GCS_BUCKET/$RELATIVE_PATH/$VM_DATE_$TIME.tar.gz`
   */
  gcsBucket?: string;
  /**
   * Optional. Defines the relative storage path in the Cloud Storage bucket
   * where the diagnostic logs will be written: Default path will be the root
   * directory of the Cloud Storage bucket
   * (`gs://$GCS_BUCKET/$DATE_$TIME.tar.gz`) Example of full path where Log file
   * will be written: `gs://$GCS_BUCKET/$RELATIVE_PATH/`
   */
  relativePath?: string;
}

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

/**
 * The definition of an Event for a managed / semi-managed notebook instance.
 */
export interface Event {
  /**
   * Optional. Event details. This field is used to pass event information.
   */
  details?: {
    [key: string]: string
  };
  /**
   * Optional. Event report time.
   */
  reportTime?: Date;
  /**
   * Optional. Event type.
   */
  type?:  | "EVENT_TYPE_UNSPECIFIED" | "IDLE" | "HEARTBEAT" | "HEALTH" | "MAINTENANCE" | "METADATA_CHANGE";
}

function serializeEvent(data: any): Event {
  return {
    ...data,
    reportTime: data["reportTime"] !== undefined ? data["reportTime"].toISOString() : undefined,
  };
}

function deserializeEvent(data: any): Event {
  return {
    ...data,
    reportTime: data["reportTime"] !== undefined ? new Date(data["reportTime"]) : 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;
}

/**
 * The definition of how to configure a VM instance outside of Resources and
 * Identity.
 */
export interface GceSetup {
  /**
   * Optional. The hardware accelerators used on this instance. If you use
   * accelerators, make sure that your configuration has [enough vCPUs and
   * memory to support the `machine_type` you have
   * selected](https://cloud.google.com/compute/docs/gpus/#gpus-list). Currently
   * supports only one accelerator configuration.
   */
  acceleratorConfigs?: AcceleratorConfig[];
  /**
   * Optional. The boot disk for the VM.
   */
  bootDisk?: BootDisk;
  /**
   * Optional. Use a container image to start the notebook instance.
   */
  containerImage?: ContainerImage;
  /**
   * Optional. Data disks attached to the VM instance. Currently supports only
   * one data disk.
   */
  dataDisks?: DataDisk[];
  /**
   * Optional. If true, no external IP will be assigned to this VM instance.
   */
  disablePublicIp?: boolean;
  /**
   * Optional. Flag to enable ip forwarding or not, default false/off.
   * https://cloud.google.com/vpc/docs/using-routes#canipforward
   */
  enableIpForwarding?: boolean;
  /**
   * Optional. Configuration for GPU drivers.
   */
  gpuDriverConfig?: GPUDriverConfig;
  /**
   * Optional. The machine type of the VM instance.
   * https://cloud.google.com/compute/docs/machine-resource
   */
  machineType?: string;
  /**
   * Optional. Custom metadata to apply to this instance.
   */
  metadata?: {
    [key: string]: string
  };
  /**
   * Optional. The minimum CPU platform to use for this instance. The list of
   * valid values can be found in
   * https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform#availablezones
   */
  minCpuPlatform?: string;
  /**
   * Optional. The network interfaces for the VM. Supports only one interface.
   */
  networkInterfaces?: NetworkInterface[];
  /**
   * Optional. The service account that serves as an identity for the VM
   * instance. Currently supports only one service account.
   */
  serviceAccounts?: ServiceAccount[];
  /**
   * Optional. Shielded VM configuration. [Images using supported Shielded VM
   * features](https://cloud.google.com/compute/docs/instances/modifying-shielded-vm).
   */
  shieldedInstanceConfig?: ShieldedInstanceConfig;
  /**
   * Optional. The Compute Engine network tags to add to runtime (see [Add
   * network tags](https://cloud.google.com/vpc/docs/add-remove-network-tags)).
   */
  tags?: string[];
  /**
   * Optional. Use a Compute Engine VM image to start the notebook instance.
   */
  vmImage?: VmImage;
}

function serializeGceSetup(data: any): GceSetup {
  return {
    ...data,
    acceleratorConfigs: data["acceleratorConfigs"] !== undefined ? data["acceleratorConfigs"].map((item: any) => (serializeAcceleratorConfig(item))) : undefined,
    bootDisk: data["bootDisk"] !== undefined ? serializeBootDisk(data["bootDisk"]) : undefined,
    dataDisks: data["dataDisks"] !== undefined ? data["dataDisks"].map((item: any) => (serializeDataDisk(item))) : undefined,
  };
}

function deserializeGceSetup(data: any): GceSetup {
  return {
    ...data,
    acceleratorConfigs: data["acceleratorConfigs"] !== undefined ? data["acceleratorConfigs"].map((item: any) => (deserializeAcceleratorConfig(item))) : undefined,
    bootDisk: data["bootDisk"] !== undefined ? deserializeBootDisk(data["bootDisk"]) : undefined,
    dataDisks: data["dataDisks"] !== undefined ? data["dataDisks"].map((item: any) => (deserializeDataDisk(item))) : undefined,
  };
}

/**
 * A GPU driver configuration
 */
export interface GPUDriverConfig {
  /**
   * Optional. Specify a custom Cloud Storage path where the GPU driver is
   * stored. If not specified, we'll automatically choose from official GPU
   * drivers.
   */
  customGpuDriverPath?: string;
  /**
   * Optional. Whether the end user authorizes Google Cloud to install GPU
   * driver on this VM instance. If this field is empty or set to false, the GPU
   * driver won't be installed. Only applicable to instances with GPUs.
   */
  enableGpuDriver?: boolean;
}

/**
 * ConfigImage represents an image release available to create a WbI
 */
export interface ImageRelease {
  /**
   * Output only. The name of the image of the form
   * workbench-instances-vYYYYmmdd--
   */
  readonly imageName?: string;
  /**
   * Output only. The release of the image of the form m123
   */
  readonly releaseName?: string;
}

/**
 * The definition of a notebook instance.
 */
export interface Instance {
  /**
   * Output only. Instance creation time.
   */
  readonly createTime?: Date;
  /**
   * Output only. Email address of entity that sent original CreateInstance
   * request.
   */
  readonly creator?: string;
  /**
   * Optional. If true, the notebook instance will not register with the proxy.
   */
  disableProxyAccess?: boolean;
  /**
   * Optional. Compute Engine setup for the notebook. Uses notebook-defined
   * fields.
   */
  gceSetup?: GceSetup;
  /**
   * Output only. Additional information about instance health. Example:
   * healthInfo": { "docker_proxy_agent_status": "1", "docker_status": "1",
   * "jupyterlab_api_status": "-1", "jupyterlab_status": "-1", "updated":
   * "2020-10-18 09:40:03.573409" }
   */
  readonly healthInfo?: {
    [key: string]: string
  };
  /**
   * Output only. Instance health_state.
   */
  readonly healthState?:  | "HEALTH_STATE_UNSPECIFIED" | "HEALTHY" | "UNHEALTHY" | "AGENT_NOT_INSTALLED" | "AGENT_NOT_RUNNING";
  /**
   * Output only. Unique ID of the resource.
   */
  readonly id?: string;
  /**
   * Optional. Input only. The owner of this instance after creation. Format:
   * `alias@example.com` Currently supports one owner only. If not specified,
   * all of the service account users of your VM instance's service account can
   * use the instance.
   */
  instanceOwners?: string[];
  /**
   * Optional. Labels to apply to this instance. These can be later modified by
   * the UpdateInstance method.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. The name of this notebook instance. Format:
   * `projects/{project_id}/locations/{location}/instances/{instance_id}`
   */
  readonly name?: string;
  /**
   * Output only. The proxy endpoint that is used to access the Jupyter
   * notebook.
   */
  readonly proxyUri?: string;
  /**
   * Output only. Reserved for future use for Zone Isolation.
   */
  readonly satisfiesPzi?: boolean;
  /**
   * Output only. Reserved for future use for Zone Separation.
   */
  readonly satisfiesPzs?: boolean;
  /**
   * Output only. The state of this instance.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "STARTING" | "PROVISIONING" | "ACTIVE" | "STOPPING" | "STOPPED" | "DELETED" | "UPGRADING" | "INITIALIZING" | "SUSPENDING" | "SUSPENDED";
  /**
   * Output only. The workforce pools proxy endpoint that is used to access the
   * Jupyter notebook.
   */
  readonly thirdPartyProxyUrl?: string;
  /**
   * Output only. Instance update time.
   */
  readonly updateTime?: Date;
  /**
   * Output only. The upgrade history of this instance.
   */
  readonly upgradeHistory?: UpgradeHistoryEntry[];
}

function serializeInstance(data: any): Instance {
  return {
    ...data,
    gceSetup: data["gceSetup"] !== undefined ? serializeGceSetup(data["gceSetup"]) : undefined,
  };
}

function deserializeInstance(data: any): Instance {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    gceSetup: data["gceSetup"] !== undefined ? deserializeGceSetup(data["gceSetup"]) : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
    upgradeHistory: data["upgradeHistory"] !== undefined ? data["upgradeHistory"].map((item: any) => (deserializeUpgradeHistoryEntry(item))) : undefined,
  };
}

/**
 * Response for listing notebook instances.
 */
export interface ListInstancesResponse {
  /**
   * A list of returned instances.
   */
  instances?: Instance[];
  /**
   * Page token that can be used to continue listing from the last result in
   * the next list call.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached. For example, ['us-west1-a',
   * 'us-central1-b']. A ListInstancesResponse will only contain either
   * instances or unreachables,
   */
  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;
}

/**
 * The definition of a network interface resource attached to a VM.
 */
export interface NetworkInterface {
  /**
   * Optional. An array of configurations for this interface. Currently, only
   * one access config, ONE_TO_ONE_NAT, is supported. If no accessConfigs
   * specified, the instance will have an external internet access through an
   * ephemeral external IP address.
   */
  accessConfigs?: AccessConfig[];
  /**
   * Optional. The name of the VPC that this VM instance is in. Format:
   * `projects/{project_id}/global/networks/{network_id}`
   */
  network?: string;
  /**
   * Optional. The type of vNIC to be used on this interface. This may be gVNIC
   * or VirtioNet.
   */
  nicType?:  | "NIC_TYPE_UNSPECIFIED" | "VIRTIO_NET" | "GVNIC";
  /**
   * Optional. The name of the subnet that this VM instance is in. Format:
   * `projects/{project_id}/regions/{region}/subnetworks/{subnetwork_id}`
   */
  subnet?: 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;
  /**
   * API endpoint name of this operation.
   */
  endpoint?: string;
  /**
   * 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
   * google.longrunning.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,
  };
}

/**
 * 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 Notebooks#projectsLocationsInstancesCreate.
 */
export interface ProjectsLocationsInstancesCreateOptions {
  /**
   * Required. User-defined unique ID of this instance.
   */
  instanceId?: string;
  /**
   * Optional. Idempotent request UUID.
   */
  requestId?: string;
}

/**
 * Additional options for Notebooks#projectsLocationsInstancesDelete.
 */
export interface ProjectsLocationsInstancesDeleteOptions {
  /**
   * Optional. Idempotent request UUID.
   */
  requestId?: string;
}

/**
 * Additional options for Notebooks#projectsLocationsInstancesGetIamPolicy.
 */
export interface ProjectsLocationsInstancesGetIamPolicyOptions {
  /**
   * 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 Notebooks#projectsLocationsInstancesList.
 */
export interface ProjectsLocationsInstancesListOptions {
  /**
   * Optional. List filter.
   */
  filter?: string;
  /**
   * Optional. Sort results. Supported values are "name", "name desc" or ""
   * (unsorted).
   */
  orderBy?: string;
  /**
   * Optional. Maximum return size of the list call.
   */
  pageSize?: number;
  /**
   * Optional. A previous returned page token that can be used to continue
   * listing from the last result.
   */
  pageToken?: string;
}

/**
 * Additional options for Notebooks#projectsLocationsInstancesPatch.
 */
export interface ProjectsLocationsInstancesPatchOptions {
  /**
   * Optional. Idempotent request UUID.
   */
  requestId?: string;
  /**
   * Required. Mask used to update an instance
   */
  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 Notebooks#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 Notebooks#projectsLocationsOperationsList.
 */
export interface ProjectsLocationsOperationsListOptions {
  /**
   * The standard list filter.
   */
  filter?: string;
  /**
   * The standard list page size.
   */
  pageSize?: number;
  /**
   * The standard list page token.
   */
  pageToken?: string;
}

/**
 * Request for notebook instances to report information to Notebooks API.
 */
export interface ReportInstanceInfoSystemRequest {
  /**
   * Required. The Event to be reported.
   */
  event?: Event;
  /**
   * Required. The VM hardware token for authenticating the VM.
   * https://cloud.google.com/compute/docs/instances/verifying-instance-identity
   */
  vmId?: string;
}

function serializeReportInstanceInfoSystemRequest(data: any): ReportInstanceInfoSystemRequest {
  return {
    ...data,
    event: data["event"] !== undefined ? serializeEvent(data["event"]) : undefined,
  };
}

function deserializeReportInstanceInfoSystemRequest(data: any): ReportInstanceInfoSystemRequest {
  return {
    ...data,
    event: data["event"] !== undefined ? deserializeEvent(data["event"]) : undefined,
  };
}

/**
 * Request for resetting a notebook instance
 */
export interface ResetInstanceRequest {
}

/**
 * Request for resizing the notebook instance disks
 */
export interface ResizeDiskRequest {
  /**
   * Required. The boot disk to be resized. Only disk_size_gb will be used.
   */
  bootDisk?: BootDisk;
  /**
   * Required. The data disk to be resized. Only disk_size_gb will be used.
   */
  dataDisk?: DataDisk;
}

function serializeResizeDiskRequest(data: any): ResizeDiskRequest {
  return {
    ...data,
    bootDisk: data["bootDisk"] !== undefined ? serializeBootDisk(data["bootDisk"]) : undefined,
    dataDisk: data["dataDisk"] !== undefined ? serializeDataDisk(data["dataDisk"]) : undefined,
  };
}

function deserializeResizeDiskRequest(data: any): ResizeDiskRequest {
  return {
    ...data,
    bootDisk: data["bootDisk"] !== undefined ? deserializeBootDisk(data["bootDisk"]) : undefined,
    dataDisk: data["dataDisk"] !== undefined ? deserializeDataDisk(data["dataDisk"]) : undefined,
  };
}

/**
 * Request for restoring the notebook instance from a BackupSource.
 */
export interface RestoreInstanceRequest {
  /**
   * Snapshot to be used for restore.
   */
  snapshot?: Snapshot;
}

/**
 * Request for rollbacking a notebook instance
 */
export interface RollbackInstanceRequest {
  /**
   * Required. Output only. Revision Id
   */
  readonly revisionId?: string;
  /**
   * Required. The snapshot for rollback. Example:
   * "projects/test-project/global/snapshots/krwlzipynril".
   */
  targetSnapshot?: string;
}

/**
 * A service account that acts as an identity.
 */
export interface ServiceAccount {
  /**
   * Optional. Email address of the service account.
   */
  email?: string;
  /**
   * Output only. The list of scopes to be made available for this service
   * account. Set by the CLH to https://www.googleapis.com/auth/cloud-platform
   */
  readonly scopes?: string[];
}

/**
 * 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 set of Shielded Instance options. See [Images using supported Shielded VM
 * features](https://cloud.google.com/compute/docs/instances/modifying-shielded-vm).
 * Not all combinations are valid.
 */
export interface ShieldedInstanceConfig {
  /**
   * Optional. Defines whether the VM instance has integrity monitoring
   * enabled. Enables monitoring and attestation of the boot integrity of the VM
   * instance. The attestation is performed against the integrity policy
   * baseline. This baseline is initially derived from the implicitly trusted
   * boot image when the VM instance is created. Enabled by default.
   */
  enableIntegrityMonitoring?: boolean;
  /**
   * Optional. Defines whether the VM instance has Secure Boot enabled. Secure
   * Boot helps ensure that the system only runs authentic software by verifying
   * the digital signature of all boot components, and halting the boot process
   * if signature verification fails. Disabled by default.
   */
  enableSecureBoot?: boolean;
  /**
   * Optional. Defines whether the VM instance has the vTPM enabled. Enabled by
   * default.
   */
  enableVtpm?: boolean;
}

/**
 * Snapshot represents the snapshot of the data disk used to restore the
 * Workbench Instance from. Refers to:
 * compute/v1/projects/{project_id}/global/snapshots/{snapshot_id}
 */
export interface Snapshot {
  /**
   * Required. The project ID of the snapshot.
   */
  projectId?: string;
  /**
   * Required. The ID of the snapshot.
   */
  snapshotId?: string;
}

/**
 * Request for starting a notebook instance
 */
export interface StartInstanceRequest {
}

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

/**
 * Request for stopping a notebook instance
 */
export interface StopInstanceRequest {
}

/**
 * SupportedValues represents the values supported by the configuration.
 */
export interface SupportedValues {
  /**
   * Output only. The accelerator types supported by WbI.
   */
  readonly acceleratorTypes?: string[];
  /**
   * Output only. The machine types supported by WbI.
   */
  readonly machineTypes?: string[];
}

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

/**
 * The entry of VM image upgrade history.
 */
export interface UpgradeHistoryEntry {
  /**
   * Optional. Action. Rolloback or Upgrade.
   */
  action?:  | "ACTION_UNSPECIFIED" | "UPGRADE" | "ROLLBACK";
  /**
   * Optional. The container image before this instance upgrade.
   */
  containerImage?: string;
  /**
   * Immutable. The time that this instance upgrade history entry is created.
   */
  createTime?: Date;
  /**
   * Optional. The framework of this notebook instance.
   */
  framework?: string;
  /**
   * Optional. The snapshot of the boot disk of this notebook instance before
   * upgrade.
   */
  snapshot?: string;
  /**
   * Output only. The state of this instance upgrade history entry.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "STARTED" | "SUCCEEDED" | "FAILED";
  /**
   * Optional. Target VM Version, like m63.
   */
  targetVersion?: string;
  /**
   * Optional. The version of the notebook instance before this upgrade.
   */
  version?: string;
  /**
   * Optional. The VM image before this instance upgrade.
   */
  vmImage?: string;
}

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

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

/**
 * Request for upgrading a notebook instance
 */
export interface UpgradeInstanceRequest {
}

/**
 * Request for upgrading a notebook instance from within the VM
 */
export interface UpgradeInstanceSystemRequest {
  /**
   * Required. The VM hardware token for authenticating the VM.
   * https://cloud.google.com/compute/docs/instances/verifying-instance-identity
   */
  vmId?: string;
}

/**
 * Definition of a custom Compute Engine virtual machine image for starting a
 * notebook instance with the environment installed directly on the VM.
 */
export interface VmImage {
  /**
   * Optional. Use this VM image family to find the image; the newest image in
   * this family will be used.
   */
  family?: string;
  /**
   * Optional. Use VM image name to find the image.
   */
  name?: string;
  /**
   * Required. The name of the Google Cloud project that this VM image belongs
   * to. Format: `{project_id}`
   */
  project?: string;
}

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