// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Migration Center API Client for Deno
 * ====================================
 * 
 * A unified platform that helps you accelerate your end-to-end cloud journey from your current on-premises or cloud environments to Google Cloud.
 * 
 * Docs: https://cloud.google.com/migration-center
 * Source: https://googleapis.deno.dev/v1/migrationcenter:v1.ts
 */

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

/**
 * A unified platform that helps you accelerate your end-to-end cloud journey
 * from your current on-premises or cloud environments to Google Cloud.
 */
export class MigrationCenter {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

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

  /**
   * Aggregates the requested fields based on provided function.
   *
   * @param parent Required. Parent value for `AggregateAssetsValuesRequest`.
   */
  async projectsLocationsAssetsAggregateValues(parent: string, req: AggregateAssetsValuesRequest): Promise<AggregateAssetsValuesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/assets:aggregateValues`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeAggregateAssetsValuesResponse(data);
  }

  /**
   * Deletes list of Assets.
   *
   * @param parent Required. Parent value for batch asset delete.
   */
  async projectsLocationsAssetsBatchDelete(parent: string, req: BatchDeleteAssetsRequest): Promise<Empty> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/assets:batchDelete`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Empty;
  }

  /**
   * Updates the parameters of a list of assets.
   *
   * @param parent Required. Parent value for batch asset update.
   */
  async projectsLocationsAssetsBatchUpdate(parent: string, req: BatchUpdateAssetsRequest): Promise<BatchUpdateAssetsResponse> {
    req = serializeBatchUpdateAssetsRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/assets:batchUpdate`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as BatchUpdateAssetsResponse;
  }

  /**
   * Deletes an asset.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsAssetsDelete(name: string, opts: ProjectsLocationsAssetsDeleteOptions = {}): Promise<Empty> {
    const url = new URL(`${this.#baseUrl}v1/${ 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 Empty;
  }

  /**
   * Gets the details of an asset.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsAssetsGet(name: string, opts: ProjectsLocationsAssetsGetOptions = {}): Promise<Asset> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.view !== undefined) {
      url.searchParams.append("view", String(opts.view));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Asset;
  }

  /**
   * Lists all the assets in a given project and location.
   *
   * @param parent Required. Parent value for `ListAssetsRequest`.
   */
  async projectsLocationsAssetsList(parent: string, opts: ProjectsLocationsAssetsListOptions = {}): Promise<ListAssetsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/assets`);
    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));
    }
    if (opts.view !== undefined) {
      url.searchParams.append("view", String(opts.view));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListAssetsResponse;
  }

  /**
   * Updates the parameters of an asset.
   *
   * @param name Output only. The full name of the asset.
   */
  async projectsLocationsAssetsPatch(name: string, req: Asset, opts: ProjectsLocationsAssetsPatchOptions = {}): Promise<Asset> {
    opts = serializeProjectsLocationsAssetsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ 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 Asset;
  }

  /**
   * Reports a set of frames.
   *
   * @param parent Required. Parent of the resource.
   */
  async projectsLocationsAssetsReportAssetFrames(parent: string, req: Frames, opts: ProjectsLocationsAssetsReportAssetFramesOptions = {}): Promise<ReportAssetFramesResponse> {
    req = serializeFrames(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/assets:reportAssetFrames`);
    if (opts.source !== undefined) {
      url.searchParams.append("source", String(opts.source));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as ReportAssetFramesResponse;
  }

  /**
   * Creates a new discovery client.
   *
   * @param parent Required. Parent resource.
   */
  async projectsLocationsDiscoveryClientsCreate(parent: string, req: DiscoveryClient, opts: ProjectsLocationsDiscoveryClientsCreateOptions = {}): Promise<Operation> {
    req = serializeDiscoveryClient(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/discoveryClients`);
    if (opts.discoveryClientId !== undefined) {
      url.searchParams.append("discoveryClientId", String(opts.discoveryClientId));
    }
    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 discovery client.
   *
   * @param name Required. The discovery client name.
   */
  async projectsLocationsDiscoveryClientsDelete(name: string, opts: ProjectsLocationsDiscoveryClientsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Gets the details of a discovery client.
   *
   * @param name Required. The discovery client name.
   */
  async projectsLocationsDiscoveryClientsGet(name: string): Promise<DiscoveryClient> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeDiscoveryClient(data);
  }

  /**
   * Lists all the discovery clients in a given project and location.
   *
   * @param parent Required. Parent resource.
   */
  async projectsLocationsDiscoveryClientsList(parent: string, opts: ProjectsLocationsDiscoveryClientsListOptions = {}): Promise<ListDiscoveryClientsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/discoveryClients`);
    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 deserializeListDiscoveryClientsResponse(data);
  }

  /**
   * Updates a discovery client.
   *
   * @param name Output only. Identifier. Full name of this discovery client.
   */
  async projectsLocationsDiscoveryClientsPatch(name: string, req: DiscoveryClient, opts: ProjectsLocationsDiscoveryClientsPatchOptions = {}): Promise<Operation> {
    req = serializeDiscoveryClient(req);
    opts = serializeProjectsLocationsDiscoveryClientsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Sends a discovery client heartbeat. Healthy clients are expected to send
   * heartbeats regularly (normally every few minutes).
   *
   * @param name Required. The discovery client name.
   */
  async projectsLocationsDiscoveryClientsSendHeartbeat(name: string, req: SendDiscoveryClientHeartbeatRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:sendHeartbeat`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

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

  /**
   * Gets the details of regional settings.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsGetSettings(name: string): Promise<Settings> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Settings;
  }

  /**
   * Adds assets to a group.
   *
   * @param group Required. Group reference.
   */
  async projectsLocationsGroupsAddAssets(group: string, req: AddAssetsToGroupRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ group }:addAssets`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Creates a new group in a given project and location.
   *
   * @param parent Required. Value for parent.
   */
  async projectsLocationsGroupsCreate(parent: string, req: Group, opts: ProjectsLocationsGroupsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/groups`);
    if (opts.groupId !== undefined) {
      url.searchParams.append("groupId", String(opts.groupId));
    }
    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 group.
   *
   * @param name Required. Name of the group resource.
   */
  async projectsLocationsGroupsDelete(name: string, opts: ProjectsLocationsGroupsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Gets the details of a group.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsGroupsGet(name: string): Promise<Group> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Group;
  }

  /**
   * Lists all groups in a given project and location.
   *
   * @param parent Required. Parent value for `ListGroupsRequest`.
   */
  async projectsLocationsGroupsList(parent: string, opts: ProjectsLocationsGroupsListOptions = {}): Promise<ListGroupsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/groups`);
    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 data as ListGroupsResponse;
  }

  /**
   * Updates the parameters of a group.
   *
   * @param name Output only. The name of the group.
   */
  async projectsLocationsGroupsPatch(name: string, req: Group, opts: ProjectsLocationsGroupsPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsGroupsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Removes assets from a group.
   *
   * @param group Required. Group reference.
   */
  async projectsLocationsGroupsRemoveAssets(group: string, req: RemoveAssetsFromGroupRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ group }:removeAssets`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Creates an import job.
   *
   * @param parent Required. Value for parent.
   */
  async projectsLocationsImportJobsCreate(parent: string, req: ImportJob, opts: ProjectsLocationsImportJobsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/importJobs`);
    if (opts.importJobId !== undefined) {
      url.searchParams.append("importJobId", String(opts.importJobId));
    }
    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 an import job.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsImportJobsDelete(name: string, opts: ProjectsLocationsImportJobsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.force !== undefined) {
      url.searchParams.append("force", String(opts.force));
    }
    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;
  }

  /**
   * Gets the details of an import job.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsImportJobsGet(name: string, opts: ProjectsLocationsImportJobsGetOptions = {}): Promise<ImportJob> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.view !== undefined) {
      url.searchParams.append("view", String(opts.view));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ImportJob;
  }

  /**
   * Creates an import data file.
   *
   * @param parent Required. Name of the parent of the ImportDataFile.
   */
  async projectsLocationsImportJobsImportDataFilesCreate(parent: string, req: ImportDataFile, opts: ProjectsLocationsImportJobsImportDataFilesCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/importDataFiles`);
    if (opts.importDataFileId !== undefined) {
      url.searchParams.append("importDataFileId", String(opts.importDataFileId));
    }
    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;
  }

  /**
   * Delete an import data file.
   *
   * @param name Required. Name of the ImportDataFile to delete.
   */
  async projectsLocationsImportJobsImportDataFilesDelete(name: string, opts: ProjectsLocationsImportJobsImportDataFilesDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Gets an import data file.
   *
   * @param name Required. Name of the ImportDataFile.
   */
  async projectsLocationsImportJobsImportDataFilesGet(name: string): Promise<ImportDataFile> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ImportDataFile;
  }

  /**
   * List import data files.
   *
   * @param parent Required. Name of the parent of the `ImportDataFiles` resource.
   */
  async projectsLocationsImportJobsImportDataFilesList(parent: string, opts: ProjectsLocationsImportJobsImportDataFilesListOptions = {}): Promise<ListImportDataFilesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/importDataFiles`);
    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 data as ListImportDataFilesResponse;
  }

  /**
   * Lists all import jobs.
   *
   * @param parent Required. Parent value for `ListImportJobsRequest`.
   */
  async projectsLocationsImportJobsList(parent: string, opts: ProjectsLocationsImportJobsListOptions = {}): Promise<ListImportJobsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/importJobs`);
    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));
    }
    if (opts.view !== undefined) {
      url.searchParams.append("view", String(opts.view));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListImportJobsResponse;
  }

  /**
   * Updates an import job.
   *
   * @param name Output only. The full name of the import job.
   */
  async projectsLocationsImportJobsPatch(name: string, req: ImportJob, opts: ProjectsLocationsImportJobsPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsImportJobsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Runs an import job.
   *
   * @param name Required. The name of the import job to run.
   */
  async projectsLocationsImportJobsRun(name: string, req: RunImportJobRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:run`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Validates an import job.
   *
   * @param name Required. The name of the import job to validate.
   */
  async projectsLocationsImportJobsValidate(name: string, req: ValidateImportJobRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:validate`);
    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;
  }

  /**
   * Creates a new preference set in a given project and location.
   *
   * @param parent Required. Value for parent.
   */
  async projectsLocationsPreferenceSetsCreate(parent: string, req: PreferenceSet, opts: ProjectsLocationsPreferenceSetsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/preferenceSets`);
    if (opts.preferenceSetId !== undefined) {
      url.searchParams.append("preferenceSetId", String(opts.preferenceSetId));
    }
    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 preference set.
   *
   * @param name Required. Name of the group resource.
   */
  async projectsLocationsPreferenceSetsDelete(name: string, opts: ProjectsLocationsPreferenceSetsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Gets the details of a preference set.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsPreferenceSetsGet(name: string): Promise<PreferenceSet> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as PreferenceSet;
  }

  /**
   * Lists all the preference sets in a given project and location.
   *
   * @param parent Required. Parent value for `ListPreferenceSetsRequest`.
   */
  async projectsLocationsPreferenceSetsList(parent: string, opts: ProjectsLocationsPreferenceSetsListOptions = {}): Promise<ListPreferenceSetsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/preferenceSets`);
    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 data as ListPreferenceSetsResponse;
  }

  /**
   * Updates the parameters of a preference set.
   *
   * @param name Output only. Name of the preference set.
   */
  async projectsLocationsPreferenceSetsPatch(name: string, req: PreferenceSet, opts: ProjectsLocationsPreferenceSetsPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsPreferenceSetsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Creates a report configuration.
   *
   * @param parent Required. Value for parent.
   */
  async projectsLocationsReportConfigsCreate(parent: string, req: ReportConfig, opts: ProjectsLocationsReportConfigsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/reportConfigs`);
    if (opts.reportConfigId !== undefined) {
      url.searchParams.append("reportConfigId", String(opts.reportConfigId));
    }
    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 ReportConfig.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsReportConfigsDelete(name: string, opts: ProjectsLocationsReportConfigsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.force !== undefined) {
      url.searchParams.append("force", String(opts.force));
    }
    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;
  }

  /**
   * Gets details of a single ReportConfig.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsReportConfigsGet(name: string): Promise<ReportConfig> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ReportConfig;
  }

  /**
   * Lists ReportConfigs in a given project and location.
   *
   * @param parent Required. Parent value for `ListReportConfigsRequest`.
   */
  async projectsLocationsReportConfigsList(parent: string, opts: ProjectsLocationsReportConfigsListOptions = {}): Promise<ListReportConfigsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/reportConfigs`);
    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 data as ListReportConfigsResponse;
  }

  /**
   * Creates a report.
   *
   * @param parent Required. Value for parent.
   */
  async projectsLocationsReportConfigsReportsCreate(parent: string, req: Report, opts: ProjectsLocationsReportConfigsReportsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/reports`);
    if (opts.reportId !== undefined) {
      url.searchParams.append("reportId", String(opts.reportId));
    }
    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 Report.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsReportConfigsReportsDelete(name: string, opts: ProjectsLocationsReportConfigsReportsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Gets details of a single Report.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsReportConfigsReportsGet(name: string, opts: ProjectsLocationsReportConfigsReportsGetOptions = {}): Promise<Report> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.view !== undefined) {
      url.searchParams.append("view", String(opts.view));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Report;
  }

  /**
   * Lists Reports in a given ReportConfig.
   *
   * @param parent Required. Parent value for `ListReportsRequest`.
   */
  async projectsLocationsReportConfigsReportsList(parent: string, opts: ProjectsLocationsReportConfigsReportsListOptions = {}): Promise<ListReportsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/reports`);
    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));
    }
    if (opts.view !== undefined) {
      url.searchParams.append("view", String(opts.view));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListReportsResponse;
  }

  /**
   * Creates a new source in a given project and location.
   *
   * @param parent Required. Value for parent.
   */
  async projectsLocationsSourcesCreate(parent: string, req: Source, opts: ProjectsLocationsSourcesCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/sources`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.sourceId !== undefined) {
      url.searchParams.append("sourceId", String(opts.sourceId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a source.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsSourcesDelete(name: string, opts: ProjectsLocationsSourcesDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Gets the details of an error frame.
   *
   * @param name Required. The name of the frame to retrieve. Format: projects/{project}/locations/{location}/sources/{source}/errorFrames/{error_frame}
   */
  async projectsLocationsSourcesErrorFramesGet(name: string, opts: ProjectsLocationsSourcesErrorFramesGetOptions = {}): Promise<ErrorFrame> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.view !== undefined) {
      url.searchParams.append("view", String(opts.view));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ErrorFrame;
  }

  /**
   * Lists all error frames in a given source and location.
   *
   * @param parent Required. Parent value (the source) for `ListErrorFramesRequest`.
   */
  async projectsLocationsSourcesErrorFramesList(parent: string, opts: ProjectsLocationsSourcesErrorFramesListOptions = {}): Promise<ListErrorFramesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/errorFrames`);
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    if (opts.view !== undefined) {
      url.searchParams.append("view", String(opts.view));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListErrorFramesResponse;
  }

  /**
   * Gets the details of a source.
   *
   * @param name Required. Name of the resource.
   */
  async projectsLocationsSourcesGet(name: string): Promise<Source> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Source;
  }

  /**
   * Lists all the sources in a given project and location.
   *
   * @param parent Required. Parent value for `ListSourcesRequest`.
   */
  async projectsLocationsSourcesList(parent: string, opts: ProjectsLocationsSourcesListOptions = {}): Promise<ListSourcesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/sources`);
    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 data as ListSourcesResponse;
  }

  /**
   * Updates the parameters of a source.
   *
   * @param name Output only. The full name of the source.
   */
  async projectsLocationsSourcesPatch(name: string, req: Source, opts: ProjectsLocationsSourcesPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsSourcesPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }

  /**
   * Updates the regional-level project settings.
   *
   * @param name Output only. The name of the resource.
   */
  async projectsLocationsUpdateSettings(name: string, req: Settings, opts: ProjectsLocationsUpdateSettingsOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsUpdateSettingsOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ 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;
  }
}

/**
 * A request to add assets to a group.
 */
export interface AddAssetsToGroupRequest {
  /**
   * Optional. When this value is set to `false` and one of the given assets is
   * already an existing member of the group, the operation fails with an
   * `Already Exists` error. When set to `true` this situation is silently
   * ignored by the server. Default value is `false`.
   */
  allowExisting?: boolean;
  /**
   * Required. List of assets to be added. The maximum number of assets that
   * can be added in a single request is 1000.
   */
  assets?: AssetList;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * A request to aggregate one or more values.
 */
export interface AggregateAssetsValuesRequest {
  /**
   * Array of aggregations to perform. Up to 25 aggregations can be defined.
   */
  aggregations?: Aggregation[];
  /**
   * Optional. The aggregation will be performed on assets that match the
   * provided filter.
   */
  filter?: string;
}

/**
 * A response to a request to aggregated assets values.
 */
export interface AggregateAssetsValuesResponse {
  /**
   * The aggregation results.
   */
  results?: AggregationResult[];
}

function serializeAggregateAssetsValuesResponse(data: any): AggregateAssetsValuesResponse {
  return {
    ...data,
    results: data["results"] !== undefined ? data["results"].map((item: any) => (serializeAggregationResult(item))) : undefined,
  };
}

function deserializeAggregateAssetsValuesResponse(data: any): AggregateAssetsValuesResponse {
  return {
    ...data,
    results: data["results"] !== undefined ? data["results"].map((item: any) => (deserializeAggregationResult(item))) : undefined,
  };
}

/**
 * Message describing an aggregation. The message includes the aggregation
 * type, parameters, and the field on which to perform the aggregation.
 */
export interface Aggregation {
  /**
   * Count the number of matching objects.
   */
  count?: AggregationCount;
  /**
   * The name of the field on which to aggregate.
   */
  field?: string;
  /**
   * Creates a frequency distribution of all field values.
   */
  frequency?: AggregationFrequency;
  /**
   * Creates a bucketed histogram of field values.
   */
  histogram?: AggregationHistogram;
  /**
   * Sum over a numeric field.
   */
  sum?: AggregationSum;
}

/**
 * Object count.
 */
export interface AggregationCount {
}

/**
 * Frequency distribution of all field values.
 */
export interface AggregationFrequency {
}

/**
 * Histogram of bucketed assets counts by field value.
 */
export interface AggregationHistogram {
  /**
   * Lower bounds of buckets. The response will contain `n+1` buckets for `n`
   * bounds. The first bucket will count all assets for which the field value is
   * smaller than the first bound. Subsequent buckets will count assets for
   * which the field value is greater or equal to a lower bound and smaller than
   * the next one. The last bucket will count assets for which the field value
   * is greater or equal to the final lower bound. You can define up to 20 lower
   * bounds.
   */
  lowerBounds?: number[];
}

/**
 * Message describing a result of an aggregation.
 */
export interface AggregationResult {
  count?: AggregationResultCount;
  field?: string;
  frequency?: AggregationResultFrequency;
  histogram?: AggregationResultHistogram;
  sum?: AggregationResultSum;
}

function serializeAggregationResult(data: any): AggregationResult {
  return {
    ...data,
    count: data["count"] !== undefined ? serializeAggregationResultCount(data["count"]) : undefined,
    frequency: data["frequency"] !== undefined ? serializeAggregationResultFrequency(data["frequency"]) : undefined,
    histogram: data["histogram"] !== undefined ? serializeAggregationResultHistogram(data["histogram"]) : undefined,
  };
}

function deserializeAggregationResult(data: any): AggregationResult {
  return {
    ...data,
    count: data["count"] !== undefined ? deserializeAggregationResultCount(data["count"]) : undefined,
    frequency: data["frequency"] !== undefined ? deserializeAggregationResultFrequency(data["frequency"]) : undefined,
    histogram: data["histogram"] !== undefined ? deserializeAggregationResultHistogram(data["histogram"]) : undefined,
  };
}

/**
 * The result of a count aggregation.
 */
export interface AggregationResultCount {
  value?: bigint;
}

function serializeAggregationResultCount(data: any): AggregationResultCount {
  return {
    ...data,
    value: data["value"] !== undefined ? String(data["value"]) : undefined,
  };
}

function deserializeAggregationResultCount(data: any): AggregationResultCount {
  return {
    ...data,
    value: data["value"] !== undefined ? BigInt(data["value"]) : undefined,
  };
}

/**
 * The result of a frequency distribution aggregation.
 */
export interface AggregationResultFrequency {
  values?: {
    [key: string]: bigint
  };
}

function serializeAggregationResultFrequency(data: any): AggregationResultFrequency {
  return {
    ...data,
    values: data["values"] !== undefined ? Object.fromEntries(Object.entries(data["values"]).map(([k, v]: [string, any]) => ([k, String(v)]))) : undefined,
  };
}

function deserializeAggregationResultFrequency(data: any): AggregationResultFrequency {
  return {
    ...data,
    values: data["values"] !== undefined ? Object.fromEntries(Object.entries(data["values"]).map(([k, v]: [string, any]) => ([k, BigInt(v)]))) : undefined,
  };
}

/**
 * The result of a bucketed histogram aggregation.
 */
export interface AggregationResultHistogram {
  /**
   * Buckets in the histogram. There will be `n+1` buckets matching `n` lower
   * bounds in the request. The first bucket will be from -infinity to the first
   * bound. Subsequent buckets will be between one bound and the next. The final
   * bucket will be from the final bound to infinity.
   */
  buckets?: AggregationResultHistogramBucket[];
}

function serializeAggregationResultHistogram(data: any): AggregationResultHistogram {
  return {
    ...data,
    buckets: data["buckets"] !== undefined ? data["buckets"].map((item: any) => (serializeAggregationResultHistogramBucket(item))) : undefined,
  };
}

function deserializeAggregationResultHistogram(data: any): AggregationResultHistogram {
  return {
    ...data,
    buckets: data["buckets"] !== undefined ? data["buckets"].map((item: any) => (deserializeAggregationResultHistogramBucket(item))) : undefined,
  };
}

/**
 * A histogram bucket with a lower and upper bound, and a count of items with a
 * field value between those bounds. The lower bound is inclusive and the upper
 * bound is exclusive. Lower bound may be -infinity and upper bound may be
 * infinity.
 */
export interface AggregationResultHistogramBucket {
  /**
   * Count of items in the bucket.
   */
  count?: bigint;
  /**
   * Lower bound - inclusive.
   */
  lowerBound?: number;
  /**
   * Upper bound - exclusive.
   */
  upperBound?: number;
}

function serializeAggregationResultHistogramBucket(data: any): AggregationResultHistogramBucket {
  return {
    ...data,
    count: data["count"] !== undefined ? String(data["count"]) : undefined,
  };
}

function deserializeAggregationResultHistogramBucket(data: any): AggregationResultHistogramBucket {
  return {
    ...data,
    count: data["count"] !== undefined ? BigInt(data["count"]) : undefined,
  };
}

/**
 * The result of a sum aggregation.
 */
export interface AggregationResultSum {
  value?: number;
}

/**
 * Sum of field values.
 */
export interface AggregationSum {
}

/**
 * An asset represents a resource in your environment. Asset types include
 * virtual machines and databases.
 */
export interface Asset {
  /**
   * Output only. The list of groups that the asset is assigned to.
   */
  readonly assignedGroups?: string[];
  /**
   * Generic asset attributes.
   */
  attributes?: {
    [key: string]: string
  };
  /**
   * Output only. The timestamp when the asset was created.
   */
  readonly createTime?: Date;
  /**
   * Output only. Asset information specific for database deployments.
   */
  readonly databaseDeploymentDetails?: DatabaseDeploymentDetails;
  /**
   * Output only. Asset information specific for logical databases.
   */
  readonly databaseDetails?: DatabaseDetails;
  /**
   * Output only. The list of insights associated with the asset.
   */
  readonly insightList?: InsightList;
  /**
   * Labels as key value pairs.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. Asset information specific for virtual and physical machines.
   */
  readonly machineDetails?: MachineDetails;
  /**
   * Output only. The full name of the asset.
   */
  readonly name?: string;
  /**
   * Output only. Performance data for the asset.
   */
  readonly performanceData?: AssetPerformanceData;
  /**
   * Output only. The list of sources contributing to the asset.
   */
  readonly sources?: string[];
  /**
   * Output only. Server generated human readable name of the asset.
   */
  readonly title?: string;
  /**
   * Output only. The timestamp when the asset was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * Contains data reported from an inventory source on an asset.
 */
export interface AssetFrame {
  /**
   * Generic asset attributes.
   */
  attributes?: {
    [key: string]: string
  };
  /**
   * Optional. Frame collection type, if not specified the collection type will
   * be based on the source type of the source the frame was reported on.
   */
  collectionType?:  | "SOURCE_TYPE_UNKNOWN" | "SOURCE_TYPE_UPLOAD" | "SOURCE_TYPE_GUEST_OS_SCAN" | "SOURCE_TYPE_INVENTORY_SCAN" | "SOURCE_TYPE_CUSTOM" | "SOURCE_TYPE_DISCOVERY_CLIENT";
  /**
   * Asset information specific for database deployments.
   */
  databaseDeploymentDetails?: DatabaseDeploymentDetails;
  /**
   * Asset information specific for logical databases.
   */
  databaseDetails?: DatabaseDetails;
  /**
   * Labels as key value pairs.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Asset information specific for virtual machines.
   */
  machineDetails?: MachineDetails;
  /**
   * Asset performance data samples. Samples that are from more than 40 days
   * ago or after tomorrow are ignored.
   */
  performanceSamples?: PerformanceSample[];
  /**
   * The time the data was reported.
   */
  reportTime?: Date;
  /**
   * Optional. Trace token is optionally provided to assist with debugging and
   * traceability.
   */
  traceToken?: string;
}

function serializeAssetFrame(data: any): AssetFrame {
  return {
    ...data,
    databaseDeploymentDetails: data["databaseDeploymentDetails"] !== undefined ? serializeDatabaseDeploymentDetails(data["databaseDeploymentDetails"]) : undefined,
    databaseDetails: data["databaseDetails"] !== undefined ? serializeDatabaseDetails(data["databaseDetails"]) : undefined,
    machineDetails: data["machineDetails"] !== undefined ? serializeMachineDetails(data["machineDetails"]) : undefined,
    performanceSamples: data["performanceSamples"] !== undefined ? data["performanceSamples"].map((item: any) => (serializePerformanceSample(item))) : undefined,
    reportTime: data["reportTime"] !== undefined ? data["reportTime"].toISOString() : undefined,
  };
}

function deserializeAssetFrame(data: any): AssetFrame {
  return {
    ...data,
    databaseDeploymentDetails: data["databaseDeploymentDetails"] !== undefined ? deserializeDatabaseDeploymentDetails(data["databaseDeploymentDetails"]) : undefined,
    databaseDetails: data["databaseDetails"] !== undefined ? deserializeDatabaseDetails(data["databaseDetails"]) : undefined,
    machineDetails: data["machineDetails"] !== undefined ? deserializeMachineDetails(data["machineDetails"]) : undefined,
    performanceSamples: data["performanceSamples"] !== undefined ? data["performanceSamples"].map((item: any) => (deserializePerformanceSample(item))) : undefined,
    reportTime: data["reportTime"] !== undefined ? new Date(data["reportTime"]) : undefined,
  };
}

/**
 * Lists the asset IDs of all assets.
 */
export interface AssetList {
  /**
   * Required. A list of asset IDs
   */
  assetIds?: string[];
}

/**
 * Performance data for an asset.
 */
export interface AssetPerformanceData {
  /**
   * Daily resource usage aggregations. Contains all of the data available for
   * an asset, up to the last 420 days. Aggregations are sorted from oldest to
   * most recent.
   */
  dailyResourceUsageAggregations?: DailyResourceUsageAggregation[];
}

/**
 * AWS EC2 specific details.
 */
export interface AwsEc2PlatformDetails {
  /**
   * Optional. Whether the machine is hyperthreaded.
   */
  hyperthreading?:  | "HYPERTHREADING_STATUS_UNSPECIFIED" | "HYPERTHREADING_STATUS_DISABLED" | "HYPERTHREADING_STATUS_ENABLED";
  /**
   * The location of the machine in the AWS format.
   */
  location?: string;
  /**
   * AWS platform's machine type label.
   */
  machineTypeLabel?: string;
}

/**
 * Azure VM specific details.
 */
export interface AzureVmPlatformDetails {
  /**
   * Whether the machine is hyperthreaded.
   */
  hyperthreading?:  | "HYPERTHREADING_STATUS_UNSPECIFIED" | "HYPERTHREADING_STATUS_DISABLED" | "HYPERTHREADING_STATUS_ENABLED";
  /**
   * The location of the machine in the Azure format.
   */
  location?: string;
  /**
   * Azure platform's machine type label.
   */
  machineTypeLabel?: string;
  /**
   * Azure platform's provisioning state.
   */
  provisioningState?: string;
}

/**
 * A request to delete a list of asset.
 */
export interface BatchDeleteAssetsRequest {
  /**
   * Optional. When this value is set to `true` the request is a no-op for
   * non-existing assets. See https://google.aip.dev/135#delete-if-existing for
   * additional details. Default value is `false`.
   */
  allowMissing?: boolean;
  /**
   * Required. The IDs of the assets to delete. A maximum of 1000 assets can be
   * deleted in a batch. Format:
   * projects/{project}/locations/{location}/assets/{name}.
   */
  names?: string[];
}

/**
 * A request to update a list of assets.
 */
export interface BatchUpdateAssetsRequest {
  /**
   * Required. The request message specifying the resources to update. A
   * maximum of 1000 assets can be modified in a batch.
   */
  requests?: UpdateAssetRequest[];
}

function serializeBatchUpdateAssetsRequest(data: any): BatchUpdateAssetsRequest {
  return {
    ...data,
    requests: data["requests"] !== undefined ? data["requests"].map((item: any) => (serializeUpdateAssetRequest(item))) : undefined,
  };
}

function deserializeBatchUpdateAssetsRequest(data: any): BatchUpdateAssetsRequest {
  return {
    ...data,
    requests: data["requests"] !== undefined ? data["requests"].map((item: any) => (deserializeUpdateAssetRequest(item))) : undefined,
  };
}

/**
 * Response for updating a list of assets.
 */
export interface BatchUpdateAssetsResponse {
  /**
   * Update asset content. The content only includes values after field mask
   * being applied.
   */
  assets?: Asset[];
}

/**
 * Details about the BIOS.
 */
export interface BiosDetails {
  /**
   * BIOS name. This fields is deprecated. Please use the `id` field instead.
   */
  biosName?: string;
  /**
   * BIOS ID.
   */
  id?: string;
  /**
   * BIOS manufacturer.
   */
  manufacturer?: string;
  /**
   * BIOS release date.
   */
  releaseDate?: Date;
  /**
   * SMBIOS UUID.
   */
  smbiosUuid?: string;
  /**
   * BIOS version.
   */
  version?: string;
}

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

/**
 * Compute engine migration target.
 */
export interface ComputeEngineMigrationTarget {
  /**
   * Description of the suggested shape for the migration target.
   */
  shape?: ComputeEngineShapeDescriptor;
}

/**
 * The user preferences relating to Compute Engine target platform.
 */
export interface ComputeEnginePreferences {
  /**
   * License type to consider when calculating costs for virtual machine
   * insights and recommendations. If unspecified, costs are calculated based on
   * the default licensing plan.
   */
  licenseType?:  | "LICENSE_TYPE_UNSPECIFIED" | "LICENSE_TYPE_DEFAULT" | "LICENSE_TYPE_BRING_YOUR_OWN_LICENSE";
  /**
   * Preferences concerning the machine types to consider on Compute Engine.
   */
  machinePreferences?: MachinePreferences;
  /**
   * Persistent disk type to use. If unspecified (default), all types are
   * considered, based on available usage data.
   */
  persistentDiskType?:  | "PERSISTENT_DISK_TYPE_UNSPECIFIED" | "PERSISTENT_DISK_TYPE_STANDARD" | "PERSISTENT_DISK_TYPE_BALANCED" | "PERSISTENT_DISK_TYPE_SSD";
}

/**
 * Compute Engine target shape descriptor.
 */
export interface ComputeEngineShapeDescriptor {
  /**
   * Output only. Number of logical cores.
   */
  readonly logicalCoreCount?: number;
  /**
   * Output only. Compute Engine machine type.
   */
  readonly machineType?: string;
  /**
   * Memory in mebibytes.
   */
  memoryMb?: number;
  /**
   * Number of physical cores.
   */
  physicalCoreCount?: number;
  /**
   * Output only. Compute Engine machine series.
   */
  readonly series?: string;
  /**
   * Output only. Compute Engine storage. Never empty.
   */
  readonly storage?: ComputeStorageDescriptor[];
}

/**
 * Compute Engine storage option descriptor.
 */
export interface ComputeStorageDescriptor {
  /**
   * Output only. Disk size in GiB.
   */
  readonly sizeGb?: number;
  /**
   * Output only. Disk type backing the storage.
   */
  readonly type?:  | "PERSISTENT_DISK_TYPE_UNSPECIFIED" | "PERSISTENT_DISK_TYPE_STANDARD" | "PERSISTENT_DISK_TYPE_BALANCED" | "PERSISTENT_DISK_TYPE_SSD";
}

/**
 * CPU usage sample.
 */
export interface CpuUsageSample {
  /**
   * Percentage of total CPU capacity utilized. Must be in the interval [0,
   * 100]. On most systems can be calculated using 100 - idle percentage.
   */
  utilizedPercentage?: number;
}

/**
 * Usage data aggregation for a single day.
 */
export interface DailyResourceUsageAggregation {
  /**
   * CPU usage.
   */
  cpu?: DailyResourceUsageAggregationCPU;
  /**
   * Aggregation date. Day boundaries are at midnight UTC.
   */
  date?: Date;
  /**
   * Disk usage.
   */
  disk?: DailyResourceUsageAggregationDisk;
  /**
   * Memory usage.
   */
  memory?: DailyResourceUsageAggregationMemory;
  /**
   * Network usage.
   */
  network?: DailyResourceUsageAggregationNetwork;
}

/**
 * Statistical aggregation of CPU usage.
 */
export interface DailyResourceUsageAggregationCPU {
  /**
   * CPU utilization percentage.
   */
  utilizationPercentage?: DailyResourceUsageAggregationStats;
}

/**
 * Statistical aggregation of disk usage.
 */
export interface DailyResourceUsageAggregationDisk {
  /**
   * Optional. Disk I/O operations per second.
   */
  iops?: DailyResourceUsageAggregationStats;
  /**
   * Optional. Disk read I/O operations per second.
   */
  readIops?: DailyResourceUsageAggregationStats;
  /**
   * Optional. Disk write I/O operations per second.
   */
  writeIops?: DailyResourceUsageAggregationStats;
}

/**
 * Statistical aggregation of memory usage.
 */
export interface DailyResourceUsageAggregationMemory {
  /**
   * Memory utilization percentage.
   */
  utilizationPercentage?: DailyResourceUsageAggregationStats;
}

/**
 * Statistical aggregation of network usage.
 */
export interface DailyResourceUsageAggregationNetwork {
  /**
   * Network egress in B/s.
   */
  egressBps?: DailyResourceUsageAggregationStats;
  /**
   * Network ingress in B/s.
   */
  ingressBps?: DailyResourceUsageAggregationStats;
}

/**
 * Statistical aggregation of samples for a single resource usage.
 */
export interface DailyResourceUsageAggregationStats {
  /**
   * Average usage value.
   */
  average?: number;
  /**
   * Median usage value.
   */
  median?: number;
  /**
   * 95th percentile usage value.
   */
  ninteyFifthPercentile?: number;
  /**
   * Peak usage value.
   */
  peak?: number;
}

/**
 * The details of a database deployment asset.
 */
export interface DatabaseDeploymentDetails {
  /**
   * Output only. Aggregated stats for the database deployment.
   */
  readonly aggregatedStats?: DatabaseDeploymentDetailsAggregatedStats;
  /**
   * Optional. The database deployment edition.
   */
  edition?: string;
  /**
   * Optional. The database deployment generated ID.
   */
  generatedId?: string;
  /**
   * Optional. A manual unique ID set by the user.
   */
  manualUniqueId?: string;
  /**
   * Optional. Details of a MYSQL database deployment.
   */
  mysql?: MysqlDatabaseDeployment;
  /**
   * Optional. Details of a PostgreSQL database deployment.
   */
  postgresql?: PostgreSqlDatabaseDeployment;
  /**
   * Optional. Details of a Microsoft SQL Server database deployment.
   */
  sqlServer?: SqlServerDatabaseDeployment;
  /**
   * Optional. Details of the database deployment topology.
   */
  topology?: DatabaseDeploymentTopology;
  /**
   * Optional. The database deployment version.
   */
  version?: string;
}

function serializeDatabaseDeploymentDetails(data: any): DatabaseDeploymentDetails {
  return {
    ...data,
    mysql: data["mysql"] !== undefined ? serializeMysqlDatabaseDeployment(data["mysql"]) : undefined,
    postgresql: data["postgresql"] !== undefined ? serializePostgreSqlDatabaseDeployment(data["postgresql"]) : undefined,
    topology: data["topology"] !== undefined ? serializeDatabaseDeploymentTopology(data["topology"]) : undefined,
  };
}

function deserializeDatabaseDeploymentDetails(data: any): DatabaseDeploymentDetails {
  return {
    ...data,
    mysql: data["mysql"] !== undefined ? deserializeMysqlDatabaseDeployment(data["mysql"]) : undefined,
    postgresql: data["postgresql"] !== undefined ? deserializePostgreSqlDatabaseDeployment(data["postgresql"]) : undefined,
    topology: data["topology"] !== undefined ? deserializeDatabaseDeploymentTopology(data["topology"]) : undefined,
  };
}

/**
 * Aggregated stats for the database deployment.
 */
export interface DatabaseDeploymentDetailsAggregatedStats {
  /**
   * Output only. The number of databases in the deployment.
   */
  readonly databaseCount?: number;
}

/**
 * Details of database deployment's topology.
 */
export interface DatabaseDeploymentTopology {
  /**
   * Optional. Number of total logical cores.
   */
  coreCount?: number;
  /**
   * Optional. Number of total logical cores limited by db deployment.
   */
  coreLimit?: number;
  /**
   * Optional. Disk allocated in bytes.
   */
  diskAllocatedBytes?: bigint;
  /**
   * Optional. Disk used in bytes.
   */
  diskUsedBytes?: bigint;
  /**
   * Optional. List of database instances.
   */
  instances?: DatabaseInstance[];
  /**
   * Optional. Total memory in bytes.
   */
  memoryBytes?: bigint;
  /**
   * Optional. Total memory in bytes limited by db deployment.
   */
  memoryLimitBytes?: bigint;
  /**
   * Optional. Number of total physical cores.
   */
  physicalCoreCount?: number;
  /**
   * Optional. Number of total physical cores limited by db deployment.
   */
  physicalCoreLimit?: number;
}

function serializeDatabaseDeploymentTopology(data: any): DatabaseDeploymentTopology {
  return {
    ...data,
    diskAllocatedBytes: data["diskAllocatedBytes"] !== undefined ? String(data["diskAllocatedBytes"]) : undefined,
    diskUsedBytes: data["diskUsedBytes"] !== undefined ? String(data["diskUsedBytes"]) : undefined,
    memoryBytes: data["memoryBytes"] !== undefined ? String(data["memoryBytes"]) : undefined,
    memoryLimitBytes: data["memoryLimitBytes"] !== undefined ? String(data["memoryLimitBytes"]) : undefined,
  };
}

function deserializeDatabaseDeploymentTopology(data: any): DatabaseDeploymentTopology {
  return {
    ...data,
    diskAllocatedBytes: data["diskAllocatedBytes"] !== undefined ? BigInt(data["diskAllocatedBytes"]) : undefined,
    diskUsedBytes: data["diskUsedBytes"] !== undefined ? BigInt(data["diskUsedBytes"]) : undefined,
    memoryBytes: data["memoryBytes"] !== undefined ? BigInt(data["memoryBytes"]) : undefined,
    memoryLimitBytes: data["memoryLimitBytes"] !== undefined ? BigInt(data["memoryLimitBytes"]) : undefined,
  };
}

/**
 * Details of a logical database.
 */
export interface DatabaseDetails {
  /**
   * Optional. The allocated storage for the database in bytes.
   */
  allocatedStorageBytes?: bigint;
  /**
   * Required. The name of the database.
   */
  databaseName?: string;
  /**
   * Required. The parent database deployment that contains the logical
   * database.
   */
  parentDatabaseDeployment?: DatabaseDetailsParentDatabaseDeployment;
  /**
   * Optional. The database schemas.
   */
  schemas?: DatabaseSchema[];
}

function serializeDatabaseDetails(data: any): DatabaseDetails {
  return {
    ...data,
    allocatedStorageBytes: data["allocatedStorageBytes"] !== undefined ? String(data["allocatedStorageBytes"]) : undefined,
    schemas: data["schemas"] !== undefined ? data["schemas"].map((item: any) => (serializeDatabaseSchema(item))) : undefined,
  };
}

function deserializeDatabaseDetails(data: any): DatabaseDetails {
  return {
    ...data,
    allocatedStorageBytes: data["allocatedStorageBytes"] !== undefined ? BigInt(data["allocatedStorageBytes"]) : undefined,
    schemas: data["schemas"] !== undefined ? data["schemas"].map((item: any) => (deserializeDatabaseSchema(item))) : undefined,
  };
}

/**
 * The identifiers of the parent database deployment.
 */
export interface DatabaseDetailsParentDatabaseDeployment {
  /**
   * Optional. The parent database deployment generated ID.
   */
  generatedId?: string;
  /**
   * Optional. The parent database deployment optional manual unique ID set by
   * the user.
   */
  manualUniqueId?: string;
}

/**
 * Details of a database instance.
 */
export interface DatabaseInstance {
  /**
   * Optional. The instance's name.
   */
  instanceName?: string;
  /**
   * Optional. Networking details.
   */
  network?: DatabaseInstanceNetwork;
  /**
   * Optional. The instance role in the database engine.
   */
  role?:  | "ROLE_UNSPECIFIED" | "PRIMARY" | "SECONDARY" | "ARBITER";
}

/**
 * Network details of a database instance.
 */
export interface DatabaseInstanceNetwork {
  /**
   * Optional. The instance's host names.
   */
  hostNames?: string[];
  /**
   * Optional. The instance's IP addresses.
   */
  ipAddresses?: string[];
  /**
   * Optional. The instance's primary MAC address.
   */
  primaryMacAddress?: string;
}

/**
 * Details of a group of database objects.
 */
export interface DatabaseObjects {
  /**
   * Optional. The category of the objects.
   */
  category?:  | "CATEGORY_UNSPECIFIED" | "TABLE" | "INDEX" | "CONSTRAINTS" | "VIEWS" | "SOURCE_CODE" | "OTHER";
  /**
   * Optional. The number of objects.
   */
  count?: bigint;
}

function serializeDatabaseObjects(data: any): DatabaseObjects {
  return {
    ...data,
    count: data["count"] !== undefined ? String(data["count"]) : undefined,
  };
}

function deserializeDatabaseObjects(data: any): DatabaseObjects {
  return {
    ...data,
    count: data["count"] !== undefined ? BigInt(data["count"]) : undefined,
  };
}

/**
 * Details of a database schema.
 */
export interface DatabaseSchema {
  /**
   * Optional. Details of a Mysql schema.
   */
  mysql?: MySqlSchemaDetails;
  /**
   * Optional. List of details of objects by category.
   */
  objects?: DatabaseObjects[];
  /**
   * Optional. Details of a PostgreSql schema.
   */
  postgresql?: PostgreSqlSchemaDetails;
  /**
   * Required. The name of the schema.
   */
  schemaName?: string;
  /**
   * Optional. Details of a SqlServer schema.
   */
  sqlServer?: SqlServerSchemaDetails;
  /**
   * Optional. The total size of tables in bytes.
   */
  tablesSizeBytes?: bigint;
}

function serializeDatabaseSchema(data: any): DatabaseSchema {
  return {
    ...data,
    objects: data["objects"] !== undefined ? data["objects"].map((item: any) => (serializeDatabaseObjects(item))) : undefined,
    tablesSizeBytes: data["tablesSizeBytes"] !== undefined ? String(data["tablesSizeBytes"]) : undefined,
  };
}

function deserializeDatabaseSchema(data: any): DatabaseSchema {
  return {
    ...data,
    objects: data["objects"] !== undefined ? data["objects"].map((item: any) => (deserializeDatabaseObjects(item))) : undefined,
    tablesSizeBytes: data["tablesSizeBytes"] !== undefined ? BigInt(data["tablesSizeBytes"]) : undefined,
  };
}

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

/**
 * Represents an installed Migration Center Discovery Client instance.
 */
export interface DiscoveryClient {
  /**
   * Output only. Time when the discovery client was first created.
   */
  readonly createTime?: Date;
  /**
   * Optional. Free text description. Maximum length is 1000 characters.
   */
  description?: string;
  /**
   * Optional. Free text display name. Maximum length is 63 characters.
   */
  displayName?: string;
  /**
   * Output only. Errors affecting client functionality.
   */
  readonly errors?: Status[];
  /**
   * Optional. Client expiration time in UTC. If specified, the backend will
   * not accept new frames after this time.
   */
  expireTime?: Date;
  /**
   * Output only. Last heartbeat time. Healthy clients are expected to send
   * heartbeats regularly (normally every few minutes).
   */
  readonly heartbeatTime?: Date;
  /**
   * Optional. Labels as key value pairs.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. Identifier. Full name of this discovery client.
   */
  readonly name?: string;
  /**
   * Required. Service account used by the discovery client for various
   * operation.
   */
  serviceAccount?: string;
  /**
   * Output only. This field is intended for internal use.
   */
  readonly signalsEndpoint?: string;
  /**
   * Required. Immutable. Full name of the source object associated with this
   * discovery client.
   */
  source?: string;
  /**
   * Output only. Current state of the discovery client.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "OFFLINE" | "DEGRADED" | "EXPIRED";
  /**
   * Optional. Input only. Client time-to-live. If specified, the backend will
   * not accept new frames after this time. This field is input only. The
   * derived expiration time is provided as output through the `expire_time`
   * field.
   */
  ttl?: number /* Duration */;
  /**
   * Output only. Time when the discovery client was last updated. This value
   * is not updated by heartbeats, to view the last heartbeat time please refer
   * to the `heartbeat_time` field.
   */
  readonly updateTime?: Date;
  /**
   * Output only. Client version, as reported in recent heartbeat.
   */
  readonly version?: string;
}

function serializeDiscoveryClient(data: any): DiscoveryClient {
  return {
    ...data,
    expireTime: data["expireTime"] !== undefined ? data["expireTime"].toISOString() : undefined,
    ttl: data["ttl"] !== undefined ? data["ttl"] : undefined,
  };
}

function deserializeDiscoveryClient(data: any): DiscoveryClient {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    expireTime: data["expireTime"] !== undefined ? new Date(data["expireTime"]) : undefined,
    heartbeatTime: data["heartbeatTime"] !== undefined ? new Date(data["heartbeatTime"]) : undefined,
    ttl: data["ttl"] !== undefined ? data["ttl"] : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
  };
}

/**
 * Single disk entry.
 */
export interface DiskEntry {
  /**
   * Disk capacity.
   */
  capacityBytes?: bigint;
  /**
   * Disk label.
   */
  diskLabel?: string;
  /**
   * Disk label type (e.g. BIOS/GPT)
   */
  diskLabelType?: string;
  /**
   * Disk free space.
   */
  freeBytes?: bigint;
  /**
   * Disk hardware address (e.g. 0:1 for SCSI).
   */
  hwAddress?: string;
  /**
   * Disks interface type.
   */
  interfaceType?:  | "INTERFACE_TYPE_UNSPECIFIED" | "IDE" | "SATA" | "SAS" | "SCSI" | "NVME" | "FC" | "ISCSI";
  /**
   * Partition layout.
   */
  partitions?: DiskPartitionList;
  /**
   * VMware disk details.
   */
  vmware?: VmwareDiskConfig;
}

function serializeDiskEntry(data: any): DiskEntry {
  return {
    ...data,
    capacityBytes: data["capacityBytes"] !== undefined ? String(data["capacityBytes"]) : undefined,
    freeBytes: data["freeBytes"] !== undefined ? String(data["freeBytes"]) : undefined,
    partitions: data["partitions"] !== undefined ? serializeDiskPartitionList(data["partitions"]) : undefined,
  };
}

function deserializeDiskEntry(data: any): DiskEntry {
  return {
    ...data,
    capacityBytes: data["capacityBytes"] !== undefined ? BigInt(data["capacityBytes"]) : undefined,
    freeBytes: data["freeBytes"] !== undefined ? BigInt(data["freeBytes"]) : undefined,
    partitions: data["partitions"] !== undefined ? deserializeDiskPartitionList(data["partitions"]) : undefined,
  };
}

/**
 * VM disks.
 */
export interface DiskEntryList {
  /**
   * Disk entries.
   */
  entries?: DiskEntry[];
}

function serializeDiskEntryList(data: any): DiskEntryList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (serializeDiskEntry(item))) : undefined,
  };
}

function deserializeDiskEntryList(data: any): DiskEntryList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (deserializeDiskEntry(item))) : undefined,
  };
}

/**
 * Disk Partition details.
 */
export interface DiskPartition {
  /**
   * Partition capacity.
   */
  capacityBytes?: bigint;
  /**
   * Partition file system.
   */
  fileSystem?: string;
  /**
   * Partition free space.
   */
  freeBytes?: bigint;
  /**
   * Mount pount (Linux/Windows) or drive letter (Windows).
   */
  mountPoint?: string;
  /**
   * Sub-partitions.
   */
  subPartitions?: DiskPartitionList;
  /**
   * Partition type.
   */
  type?: string;
  /**
   * Partition UUID.
   */
  uuid?: string;
}

function serializeDiskPartition(data: any): DiskPartition {
  return {
    ...data,
    capacityBytes: data["capacityBytes"] !== undefined ? String(data["capacityBytes"]) : undefined,
    freeBytes: data["freeBytes"] !== undefined ? String(data["freeBytes"]) : undefined,
    subPartitions: data["subPartitions"] !== undefined ? serializeDiskPartitionList(data["subPartitions"]) : undefined,
  };
}

function deserializeDiskPartition(data: any): DiskPartition {
  return {
    ...data,
    capacityBytes: data["capacityBytes"] !== undefined ? BigInt(data["capacityBytes"]) : undefined,
    freeBytes: data["freeBytes"] !== undefined ? BigInt(data["freeBytes"]) : undefined,
    subPartitions: data["subPartitions"] !== undefined ? deserializeDiskPartitionList(data["subPartitions"]) : undefined,
  };
}

/**
 * Disk partition list.
 */
export interface DiskPartitionList {
  /**
   * Partition entries.
   */
  entries?: DiskPartition[];
}

function serializeDiskPartitionList(data: any): DiskPartitionList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (serializeDiskPartition(item))) : undefined,
  };
}

function deserializeDiskPartitionList(data: any): DiskPartitionList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (deserializeDiskPartition(item))) : undefined,
  };
}

/**
 * Disk usage sample. Values are across all disks.
 */
export interface DiskUsageSample {
  /**
   * Optional. Average IOPS sampled over a short window. Must be non-negative.
   * Must be equal to the sum of read and write if one of them is positive. if
   * both read and write are zero they are ignored.
   */
  averageIops?: number;
  /**
   * Optional. Average read IOPS sampled over a short window. Must be
   * non-negative.
   */
  averageReadIops?: number;
  /**
   * Optional. Average write IOPS sampled over a short window. Must be
   * non-negative.
   */
  averageWriteIops?: number;
}

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

/**
 * Message representing a frame which failed to be processed due to an error.
 */
export interface ErrorFrame {
  /**
   * Output only. Frame ingestion time.
   */
  readonly ingestionTime?: Date;
  /**
   * Output only. The identifier of the ErrorFrame.
   */
  readonly name?: string;
  /**
   * Output only. The frame that was originally reported.
   */
  readonly originalFrame?: AssetFrame;
  /**
   * Output only. All the violations that were detected for the frame.
   */
  readonly violations?: FrameViolationEntry[];
}

/**
 * A resource that reports result of the import job execution.
 */
export interface ExecutionReport {
  /**
   * Validation errors encountered during the execution of the import job.
   */
  executionErrors?: ValidationReport;
  /**
   * Total number of asset frames reported for the import job.
   */
  framesReported?: number;
  /**
   * Output only. Total number of rows in the import job.
   */
  readonly totalRowsCount?: number;
}

/**
 * A resource that aggregates the validation errors found in an import job
 * file.
 */
export interface FileValidationReport {
  /**
   * List of file level errors.
   */
  fileErrors?: ImportError[];
  /**
   * The name of the file.
   */
  fileName?: string;
  /**
   * Flag indicating that processing was aborted due to maximum number of
   * errors.
   */
  partialReport?: boolean;
  /**
   * Partial list of rows that encountered validation error.
   */
  rowErrors?: ImportRowError[];
}

/**
 * Describes the fit level of an asset for migration to a specific target.
 */
export interface FitDescriptor {
  /**
   * Output only. Fit level.
   */
  readonly fitLevel?:  | "FIT_LEVEL_UNSPECIFIED" | "FIT" | "NO_FIT" | "REQUIRES_EFFORT";
}

/**
 * Collection of frame data.
 */
export interface Frames {
  /**
   * A repeated field of asset data.
   */
  framesData?: AssetFrame[];
}

function serializeFrames(data: any): Frames {
  return {
    ...data,
    framesData: data["framesData"] !== undefined ? data["framesData"].map((item: any) => (serializeAssetFrame(item))) : undefined,
  };
}

function deserializeFrames(data: any): Frames {
  return {
    ...data,
    framesData: data["framesData"] !== undefined ? data["framesData"].map((item: any) => (deserializeAssetFrame(item))) : undefined,
  };
}

/**
 * A resource that contains a single violation of a reported `AssetFrame`
 * resource.
 */
export interface FrameViolationEntry {
  /**
   * The field of the original frame where the violation occurred.
   */
  field?: string;
  /**
   * A message describing the violation.
   */
  violation?: string;
}

/**
 * Single fstab entry.
 */
export interface FstabEntry {
  /**
   * The mount point for the filesystem.
   */
  file?: string;
  /**
   * Used by dump to determine which filesystems need to be dumped.
   */
  freq?: number;
  /**
   * Mount options associated with the filesystem.
   */
  mntops?: string;
  /**
   * Used by the fsck(8) program to determine the order in which filesystem
   * checks are done at reboot time.
   */
  passno?: number;
  /**
   * The block special device or remote filesystem to be mounted.
   */
  spec?: string;
  /**
   * The type of the filesystem.
   */
  vfstype?: string;
}

/**
 * Fstab content.
 */
export interface FstabEntryList {
  /**
   * Fstab entries.
   */
  entries?: FstabEntry[];
}

/**
 * A generic insight about an asset.
 */
export interface GenericInsight {
  /**
   * Output only. Additional information about the insight, each entry can be a
   * logical entry and must make sense if it is displayed with line breaks
   * between each entry. Text can contain md style links.
   */
  readonly additionalInformation?: string[];
  /**
   * Output only. In case message_code is not yet known by the client
   * default_message will be the message to be used instead.
   */
  readonly defaultMessage?: string;
  /**
   * Output only. Represents a globally unique message id for this insight, can
   * be used for localization purposes, in case message_code is not yet known by
   * the client use default_message instead.
   */
  readonly messageId?: bigint;
}

/**
 * Generic platform details.
 */
export interface GenericPlatformDetails {
  /**
   * Whether the machine is hyperthreaded.
   */
  hyperthreading?:  | "HYPERTHREADING_STATUS_UNSPECIFIED" | "HYPERTHREADING_STATUS_DISABLED" | "HYPERTHREADING_STATUS_ENABLED";
  /**
   * Free text representation of the machine location. The format of this field
   * should not be relied on. Different VMs in the same location may have
   * different string values for this field.
   */
  location?: string;
}

/**
 * A resource that represents an asset group. The purpose of an asset group is
 * to bundle a set of assets that have something in common, while allowing users
 * to add annotations to the group. An asset can belong to multiple groups.
 */
export interface Group {
  /**
   * Output only. The timestamp when the group was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. The description of the group.
   */
  description?: string;
  /**
   * Optional. User-friendly display name.
   */
  displayName?: string;
  /**
   * Labels as key value pairs.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. The name of the group.
   */
  readonly name?: string;
  /**
   * Output only. The timestamp when the group was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * Guest OS config information.
 */
export interface GuestConfigDetails {
  /**
   * Mount list (Linux fstab).
   */
  fstab?: FstabEntryList;
  /**
   * Hosts file (/etc/hosts).
   */
  hosts?: HostsEntryList;
  /**
   * OS issue (typically /etc/issue in Linux).
   */
  issue?: string;
  /**
   * NFS exports.
   */
  nfsExports?: NfsExportList;
  /**
   * Security-Enhanced Linux (SELinux) mode.
   */
  selinuxMode?:  | "SE_LINUX_MODE_UNSPECIFIED" | "SE_LINUX_MODE_DISABLED" | "SE_LINUX_MODE_PERMISSIVE" | "SE_LINUX_MODE_ENFORCING";
}

/**
 * Guest installed application information.
 */
export interface GuestInstalledApplication {
  /**
   * Installed application name.
   */
  applicationName?: string;
  /**
   * The time when the application was installed.
   */
  installTime?: Date;
  /**
   * License strings associated with the installed application.
   */
  licenses?: string[];
  /**
   * Source path.
   */
  path?: string;
  /**
   * Installed application vendor.
   */
  vendor?: string;
  /**
   * Installed application version.
   */
  version?: string;
}

function serializeGuestInstalledApplication(data: any): GuestInstalledApplication {
  return {
    ...data,
    installTime: data["installTime"] !== undefined ? data["installTime"].toISOString() : undefined,
  };
}

function deserializeGuestInstalledApplication(data: any): GuestInstalledApplication {
  return {
    ...data,
    installTime: data["installTime"] !== undefined ? new Date(data["installTime"]) : undefined,
  };
}

/**
 * Guest installed application list.
 */
export interface GuestInstalledApplicationList {
  /**
   * Application entries.
   */
  entries?: GuestInstalledApplication[];
}

function serializeGuestInstalledApplicationList(data: any): GuestInstalledApplicationList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (serializeGuestInstalledApplication(item))) : undefined,
  };
}

function deserializeGuestInstalledApplicationList(data: any): GuestInstalledApplicationList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (deserializeGuestInstalledApplication(item))) : undefined,
  };
}

/**
 * Information from Guest-level collections.
 */
export interface GuestOsDetails {
  /**
   * OS and app configuration.
   */
  config?: GuestConfigDetails;
  /**
   * What family the OS belong to, if known.
   */
  family?:  | "OS_FAMILY_UNKNOWN" | "OS_FAMILY_WINDOWS" | "OS_FAMILY_LINUX" | "OS_FAMILY_UNIX";
  /**
   * The name of the operating system.
   */
  osName?: string;
  /**
   * Runtime information.
   */
  runtime?: GuestRuntimeDetails;
  /**
   * The version of the operating system.
   */
  version?: string;
}

function serializeGuestOsDetails(data: any): GuestOsDetails {
  return {
    ...data,
    runtime: data["runtime"] !== undefined ? serializeGuestRuntimeDetails(data["runtime"]) : undefined,
  };
}

function deserializeGuestOsDetails(data: any): GuestOsDetails {
  return {
    ...data,
    runtime: data["runtime"] !== undefined ? deserializeGuestRuntimeDetails(data["runtime"]) : undefined,
  };
}

/**
 * Guest OS runtime information.
 */
export interface GuestRuntimeDetails {
  /**
   * Domain, e.g. c.stratozone-development.internal.
   */
  domain?: string;
  /**
   * Installed applications information.
   */
  installedApps?: GuestInstalledApplicationList;
  /**
   * Last time the OS was booted.
   */
  lastBootTime?: Date;
  /**
   * Machine name.
   */
  machineName?: string;
  /**
   * Runtime network information (connections, ports).
   */
  network?: RuntimeNetworkInfo;
  /**
   * Open files information.
   */
  openFileList?: OpenFileList;
  /**
   * Running processes.
   */
  processes?: RunningProcessList;
  /**
   * Running background services.
   */
  services?: RunningServiceList;
}

function serializeGuestRuntimeDetails(data: any): GuestRuntimeDetails {
  return {
    ...data,
    installedApps: data["installedApps"] !== undefined ? serializeGuestInstalledApplicationList(data["installedApps"]) : undefined,
    lastBootTime: data["lastBootTime"] !== undefined ? data["lastBootTime"].toISOString() : undefined,
    network: data["network"] !== undefined ? serializeRuntimeNetworkInfo(data["network"]) : undefined,
    processes: data["processes"] !== undefined ? serializeRunningProcessList(data["processes"]) : undefined,
    services: data["services"] !== undefined ? serializeRunningServiceList(data["services"]) : undefined,
  };
}

function deserializeGuestRuntimeDetails(data: any): GuestRuntimeDetails {
  return {
    ...data,
    installedApps: data["installedApps"] !== undefined ? deserializeGuestInstalledApplicationList(data["installedApps"]) : undefined,
    lastBootTime: data["lastBootTime"] !== undefined ? new Date(data["lastBootTime"]) : undefined,
    network: data["network"] !== undefined ? deserializeRuntimeNetworkInfo(data["network"]) : undefined,
    processes: data["processes"] !== undefined ? deserializeRunningProcessList(data["processes"]) : undefined,
    services: data["services"] !== undefined ? deserializeRunningServiceList(data["services"]) : undefined,
  };
}

/**
 * Single /etc/hosts entry.
 */
export interface HostsEntry {
  /**
   * List of host names / aliases.
   */
  hostNames?: string[];
  /**
   * IP (raw, IPv4/6 agnostic).
   */
  ip?: string;
}

/**
 * Hosts content.
 */
export interface HostsEntryList {
  /**
   * Hosts entries.
   */
  entries?: HostsEntry[];
}

/**
 * A resource that represents a payload file in an import job.
 */
export interface ImportDataFile {
  /**
   * Output only. The timestamp when the file was created.
   */
  readonly createTime?: Date;
  /**
   * User-friendly display name. Maximum length is 63 characters.
   */
  displayName?: string;
  /**
   * Required. The payload format.
   */
  format?:  | "IMPORT_JOB_FORMAT_UNSPECIFIED" | "IMPORT_JOB_FORMAT_RVTOOLS_XLSX" | "IMPORT_JOB_FORMAT_RVTOOLS_CSV" | "IMPORT_JOB_FORMAT_EXPORTED_AWS_CSV" | "IMPORT_JOB_FORMAT_EXPORTED_AZURE_CSV" | "IMPORT_JOB_FORMAT_STRATOZONE_CSV" | "IMPORT_JOB_FORMAT_DATABASE_ZIP";
  /**
   * Output only. The name of the file.
   */
  readonly name?: string;
  /**
   * Output only. The state of the import data file.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE";
  /**
   * Information about a file that is uploaded to a storage service.
   */
  uploadFileInfo?: UploadFileInfo;
}

/**
 * A resource that reports the errors encountered while processing an import
 * job.
 */
export interface ImportError {
  /**
   * The error information.
   */
  errorDetails?: string;
  /**
   * The severity of the error.
   */
  severity?:  | "SEVERITY_UNSPECIFIED" | "ERROR" | "WARNING" | "INFO";
}

/**
 * A resource that represents the background job that imports asset frames.
 */
export interface ImportJob {
  /**
   * Required. Reference to a source.
   */
  assetSource?: string;
  /**
   * Output only. The timestamp when the import job was completed.
   */
  readonly completeTime?: Date;
  /**
   * Output only. The timestamp when the import job was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. User-friendly display name. Maximum length is 256 characters.
   */
  displayName?: string;
  /**
   * Output only. The report with the results of running the import job.
   */
  readonly executionReport?: ExecutionReport;
  /**
   * Labels as key value pairs.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. The full name of the import job.
   */
  readonly name?: string;
  /**
   * Output only. The state of the import job.
   */
  readonly state?:  | "IMPORT_JOB_STATE_UNSPECIFIED" | "IMPORT_JOB_STATE_PENDING" | "IMPORT_JOB_STATE_RUNNING" | "IMPORT_JOB_STATE_COMPLETED" | "IMPORT_JOB_STATE_FAILED" | "IMPORT_JOB_STATE_VALIDATING" | "IMPORT_JOB_STATE_FAILED_VALIDATION" | "IMPORT_JOB_STATE_READY";
  /**
   * Output only. The timestamp when the import job was last updated.
   */
  readonly updateTime?: Date;
  /**
   * Output only. The report with the validation results of the import job.
   */
  readonly validationReport?: ValidationReport;
}

/**
 * A resource that reports the import job errors at row level.
 */
export interface ImportRowError {
  /**
   * Error details for an archive file.
   */
  archiveError?: ImportRowErrorArchiveErrorDetails;
  /**
   * Output only. The asset title.
   */
  readonly assetTitle?: string;
  /**
   * Error details for a CSV file.
   */
  csvError?: ImportRowErrorCsvErrorDetails;
  /**
   * The list of errors detected in the row.
   */
  errors?: ImportError[];
  /**
   * The row number where the error was detected.
   */
  rowNumber?: number;
  /**
   * The name of the VM in the row.
   */
  vmName?: string;
  /**
   * The VM UUID.
   */
  vmUuid?: string;
  /**
   * Error details for an XLSX file.
   */
  xlsxError?: ImportRowErrorXlsxErrorDetails;
}

/**
 * Error details for an archive file.
 */
export interface ImportRowErrorArchiveErrorDetails {
  /**
   * Error details for a CSV file.
   */
  csvError?: ImportRowErrorCsvErrorDetails;
  /**
   * Output only. The file path inside the archive where the error was
   * detected.
   */
  readonly filePath?: string;
}

/**
 * Error details for a CSV file.
 */
export interface ImportRowErrorCsvErrorDetails {
  /**
   * The row number where the error was detected.
   */
  rowNumber?: number;
}

/**
 * Error details for an XLSX file.
 */
export interface ImportRowErrorXlsxErrorDetails {
  /**
   * The row number where the error was detected.
   */
  rowNumber?: number;
  /**
   * The name of the sheet where the error was detected.
   */
  sheet?: string;
}

/**
 * An insight about an asset.
 */
export interface Insight {
  /**
   * Output only. A generic insight about an asset.
   */
  readonly genericInsight?: GenericInsight;
  /**
   * Output only. An insight about potential migrations for an asset.
   */
  readonly migrationInsight?: MigrationInsight;
}

/**
 * Message containing insights list.
 */
export interface InsightList {
  /**
   * Output only. Insights of the list.
   */
  readonly insights?: Insight[];
  /**
   * Output only. Update timestamp.
   */
  readonly updateTime?: Date;
}

/**
 * Response message for listing assets.
 */
export interface ListAssetsResponse {
  /**
   * A list of assets.
   */
  assets?: Asset[];
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response message for listing discovery clients.
 */
export interface ListDiscoveryClientsResponse {
  /**
   * List of discovery clients.
   */
  discoveryClients?: DiscoveryClient[];
  /**
   * A token that can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

function serializeListDiscoveryClientsResponse(data: any): ListDiscoveryClientsResponse {
  return {
    ...data,
    discoveryClients: data["discoveryClients"] !== undefined ? data["discoveryClients"].map((item: any) => (serializeDiscoveryClient(item))) : undefined,
  };
}

function deserializeListDiscoveryClientsResponse(data: any): ListDiscoveryClientsResponse {
  return {
    ...data,
    discoveryClients: data["discoveryClients"] !== undefined ? data["discoveryClients"].map((item: any) => (deserializeDiscoveryClient(item))) : undefined,
  };
}

/**
 * A response for listing error frames.
 */
export interface ListErrorFramesResponse {
  /**
   * The list of error frames.
   */
  errorFrames?: ErrorFrame[];
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * A response for listing groups.
 */
export interface ListGroupsResponse {
  /**
   * The list of Group
   */
  groups?: Group[];
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for listing payload files of an import job.
 */
export interface ListImportDataFilesResponse {
  /**
   * The list of import data files.
   */
  importDataFiles?: ImportDataFile[];
  /**
   * A token that can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * A response for listing import jobs.
 */
export interface ListImportJobsResponse {
  /**
   * The list of import jobs.
   */
  importJobs?: ImportJob[];
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

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

/**
 * Response message for listing preference sets.
 */
export interface ListPreferenceSetsResponse {
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * The list of PreferenceSets
   */
  preferenceSets?: PreferenceSet[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response message for listing report configs.
 */
export interface ListReportConfigsResponse {
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * A list of report configs.
   */
  reportConfigs?: ReportConfig[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response message for listing Reports.
 */
export interface ListReportsResponse {
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * The list of Reports.
   */
  reports?: Report[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response message for listing sources.
 */
export interface ListSourcesResponse {
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * The list of sources.
   */
  sources?: Source[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

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

/**
 * Details of the machine architecture.
 */
export interface MachineArchitectureDetails {
  /**
   * BIOS Details.
   */
  bios?: BiosDetails;
  /**
   * CPU architecture, e.g., "x64-based PC", "x86_64", "i686" etc.
   */
  cpuArchitecture?: string;
  /**
   * CPU name, e.g., "Intel Xeon E5-2690", "AMD EPYC 7571" etc.
   */
  cpuName?: string;
  /**
   * Number of processor sockets allocated to the machine.
   */
  cpuSocketCount?: number;
  /**
   * Deprecated: use MachineDetails.core_count instead. Number of CPU threads
   * allocated to the machine.
   */
  cpuThreadCount?: number;
  /**
   * Firmware type.
   */
  firmwareType?:  | "FIRMWARE_TYPE_UNSPECIFIED" | "BIOS" | "EFI";
  /**
   * CPU hyper-threading support.
   */
  hyperthreading?:  | "CPU_HYPER_THREADING_UNSPECIFIED" | "DISABLED" | "ENABLED";
  /**
   * Hardware vendor.
   */
  vendor?: string;
}

/**
 * Details of a machine.
 */
export interface MachineDetails {
  /**
   * Architecture details (vendor, CPU architecture).
   */
  architecture?: MachineArchitectureDetails;
  /**
   * Number of logical CPU cores in the machine. Must be non-negative.
   */
  coreCount?: number;
  /**
   * Machine creation time.
   */
  createTime?: Date;
  /**
   * Disk details.
   */
  disks?: MachineDiskDetails;
  /**
   * Guest OS information.
   */
  guestOs?: GuestOsDetails;
  /**
   * Machine name.
   */
  machineName?: string;
  /**
   * The amount of memory in the machine. Must be non-negative.
   */
  memoryMb?: number;
  /**
   * Network details.
   */
  network?: MachineNetworkDetails;
  /**
   * Platform specific information.
   */
  platform?: PlatformDetails;
  /**
   * Power state of the machine.
   */
  powerState?:  | "POWER_STATE_UNSPECIFIED" | "PENDING" | "ACTIVE" | "SUSPENDING" | "SUSPENDED" | "DELETING" | "DELETED";
  /**
   * Machine unique identifier.
   */
  uuid?: string;
}

function serializeMachineDetails(data: any): MachineDetails {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? data["createTime"].toISOString() : undefined,
    disks: data["disks"] !== undefined ? serializeMachineDiskDetails(data["disks"]) : undefined,
    guestOs: data["guestOs"] !== undefined ? serializeGuestOsDetails(data["guestOs"]) : undefined,
  };
}

function deserializeMachineDetails(data: any): MachineDetails {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    disks: data["disks"] !== undefined ? deserializeMachineDiskDetails(data["disks"]) : undefined,
    guestOs: data["guestOs"] !== undefined ? deserializeGuestOsDetails(data["guestOs"]) : undefined,
  };
}

/**
 * Details of machine disks.
 */
export interface MachineDiskDetails {
  /**
   * List of disks.
   */
  disks?: DiskEntryList;
  /**
   * Disk total Capacity.
   */
  totalCapacityBytes?: bigint;
  /**
   * Total disk free space.
   */
  totalFreeBytes?: bigint;
}

function serializeMachineDiskDetails(data: any): MachineDiskDetails {
  return {
    ...data,
    disks: data["disks"] !== undefined ? serializeDiskEntryList(data["disks"]) : undefined,
    totalCapacityBytes: data["totalCapacityBytes"] !== undefined ? String(data["totalCapacityBytes"]) : undefined,
    totalFreeBytes: data["totalFreeBytes"] !== undefined ? String(data["totalFreeBytes"]) : undefined,
  };
}

function deserializeMachineDiskDetails(data: any): MachineDiskDetails {
  return {
    ...data,
    disks: data["disks"] !== undefined ? deserializeDiskEntryList(data["disks"]) : undefined,
    totalCapacityBytes: data["totalCapacityBytes"] !== undefined ? BigInt(data["totalCapacityBytes"]) : undefined,
    totalFreeBytes: data["totalFreeBytes"] !== undefined ? BigInt(data["totalFreeBytes"]) : undefined,
  };
}

/**
 * Details of network adapters and settings.
 */
export interface MachineNetworkDetails {
  /**
   * List of network adapters.
   */
  adapters?: NetworkAdapterList;
  /**
   * The primary IP address of the machine.
   */
  primaryIpAddress?: string;
  /**
   * MAC address of the machine. This property is used to uniqly identify the
   * machine.
   */
  primaryMacAddress?: string;
  /**
   * The public IP address of the machine.
   */
  publicIpAddress?: string;
}

/**
 * The type of machines to consider when calculating virtual machine migration
 * insights and recommendations. Not all machine types are available in all
 * zones and regions.
 */
export interface MachinePreferences {
  /**
   * Compute Engine machine series to consider for insights and
   * recommendations. If empty, no restriction is applied on the machine series.
   */
  allowedMachineSeries?: MachineSeries[];
}

/**
 * A machine series, for a target product (e.g. Compute Engine, Google Cloud
 * VMware Engine).
 */
export interface MachineSeries {
  /**
   * Code to identify a machine series. Consult this for more details on the
   * available series for Compute Engine:
   * https://cloud.google.com/compute/docs/machine-resource#machine_type_comparison
   * Consult this for more details on the available series for Google Cloud
   * VMware Engine: https://cloud.google.com/vmware-engine/pricing
   */
  code?: string;
}

/**
 * Memory usage sample.
 */
export interface MemoryUsageSample {
  /**
   * Percentage of system memory utilized. Must be in the interval [0, 100].
   */
  utilizedPercentage?: number;
}

/**
 * An insight about potential migrations for an asset.
 */
export interface MigrationInsight {
  /**
   * Output only. A Google Compute Engine target.
   */
  readonly computeEngineTarget?: ComputeEngineMigrationTarget;
  /**
   * Output only. Description of how well the asset this insight is associated
   * with fits the proposed migration.
   */
  readonly fit?: FitDescriptor;
}

/**
 * Represents an amount of money with its currency type.
 */
export interface Money {
  /**
   * The three-letter currency code defined in ISO 4217.
   */
  currencyCode?: string;
  /**
   * Number of nano (10^-9) units of the amount. The value must be between
   * -999,999,999 and +999,999,999 inclusive. If `units` is positive, `nanos`
   * must be positive or zero. If `units` is zero, `nanos` can be positive,
   * zero, or negative. If `units` is negative, `nanos` must be negative or
   * zero. For example $-1.75 is represented as `units`=-1 and
   * `nanos`=-750,000,000.
   */
  nanos?: number;
  /**
   * The whole units of the amount. For example if `currencyCode` is `"USD"`,
   * then 1 unit is one US dollar.
   */
  units?: bigint;
}

function serializeMoney(data: any): Money {
  return {
    ...data,
    units: data["units"] !== undefined ? String(data["units"]) : undefined,
  };
}

function deserializeMoney(data: any): Money {
  return {
    ...data,
    units: data["units"] !== undefined ? BigInt(data["units"]) : undefined,
  };
}

/**
 * Specific details for a Mysql database deployment.
 */
export interface MysqlDatabaseDeployment {
  /**
   * Optional. List of MySql plugins.
   */
  plugins?: MySqlPlugin[];
  /**
   * Optional. List of MySql properties.
   */
  properties?: MySqlProperty[];
  /**
   * Optional. Number of resource groups.
   */
  resourceGroupsCount?: number;
  /**
   * Optional. List of MySql variables.
   */
  variables?: MySqlVariable[];
}

function serializeMysqlDatabaseDeployment(data: any): MysqlDatabaseDeployment {
  return {
    ...data,
    properties: data["properties"] !== undefined ? data["properties"].map((item: any) => (serializeMySqlProperty(item))) : undefined,
  };
}

function deserializeMysqlDatabaseDeployment(data: any): MysqlDatabaseDeployment {
  return {
    ...data,
    properties: data["properties"] !== undefined ? data["properties"].map((item: any) => (deserializeMySqlProperty(item))) : undefined,
  };
}

/**
 * MySql plugin.
 */
export interface MySqlPlugin {
  /**
   * Required. The plugin is active.
   */
  enabled?: boolean;
  /**
   * Required. The plugin name.
   */
  plugin?: string;
  /**
   * Required. The plugin version.
   */
  version?: string;
}

/**
 * MySql property.
 */
export interface MySqlProperty {
  /**
   * Required. The property is enabled.
   */
  enabled?: boolean;
  /**
   * Required. The property numeric value.
   */
  numericValue?: bigint;
  /**
   * Required. The property name.
   */
  property?: string;
}

function serializeMySqlProperty(data: any): MySqlProperty {
  return {
    ...data,
    numericValue: data["numericValue"] !== undefined ? String(data["numericValue"]) : undefined,
  };
}

function deserializeMySqlProperty(data: any): MySqlProperty {
  return {
    ...data,
    numericValue: data["numericValue"] !== undefined ? BigInt(data["numericValue"]) : undefined,
  };
}

/**
 * Specific details for a Mysql database.
 */
export interface MySqlSchemaDetails {
  /**
   * Optional. Mysql storage engine tables.
   */
  storageEngines?: MySqlStorageEngineDetails[];
}

/**
 * Mysql storage engine tables.
 */
export interface MySqlStorageEngineDetails {
  /**
   * Optional. The number of encrypted tables.
   */
  encryptedTableCount?: number;
  /**
   * Required. The storage engine.
   */
  engine?:  | "ENGINE_UNSPECIFIED" | "INNODB" | "MYISAM" | "MEMORY" | "CSV" | "ARCHIVE" | "BLACKHOLE" | "NDB" | "MERGE" | "FEDERATED" | "EXAMPLE" | "OTHER";
  /**
   * Optional. The number of tables.
   */
  tableCount?: number;
}

/**
 * MySql variable.
 */
export interface MySqlVariable {
  /**
   * Required. The variable category.
   */
  category?: string;
  /**
   * Required. The variable value.
   */
  value?: string;
  /**
   * Required. The variable name.
   */
  variable?: string;
}

/**
 * Details of network adapter.
 */
export interface NetworkAdapterDetails {
  /**
   * Network adapter type (e.g. VMXNET3).
   */
  adapterType?: string;
  /**
   * NetworkAddressList
   */
  addresses?: NetworkAddressList;
  /**
   * MAC address.
   */
  macAddress?: string;
}

/**
 * List of network adapters.
 */
export interface NetworkAdapterList {
  /**
   * Network adapter entries.
   */
  entries?: NetworkAdapterDetails[];
}

/**
 * Details of network address.
 */
export interface NetworkAddress {
  /**
   * Whether DHCP is used to assign addresses.
   */
  assignment?:  | "ADDRESS_ASSIGNMENT_UNSPECIFIED" | "ADDRESS_ASSIGNMENT_STATIC" | "ADDRESS_ASSIGNMENT_DHCP";
  /**
   * Broadcast address.
   */
  bcast?: string;
  /**
   * Fully qualified domain name.
   */
  fqdn?: string;
  /**
   * Assigned or configured IP Address.
   */
  ipAddress?: string;
  /**
   * Subnet mask.
   */
  subnetMask?: string;
}

/**
 * List of allocated/assigned network addresses.
 */
export interface NetworkAddressList {
  /**
   * Network address entries.
   */
  entries?: NetworkAddress[];
}

export interface NetworkConnection {
  /**
   * Local IP address.
   */
  localIpAddress?: string;
  /**
   * Local port.
   */
  localPort?: number;
  /**
   * Process ID.
   */
  pid?: bigint;
  /**
   * Process or service name.
   */
  processName?: string;
  /**
   * Connection protocol (e.g. TCP/UDP).
   */
  protocol?: string;
  /**
   * Remote IP address.
   */
  remoteIpAddress?: string;
  /**
   * Remote port.
   */
  remotePort?: number;
  /**
   * Network connection state.
   */
  state?:  | "STATE_UNSPECIFIED" | "OPENING" | "OPEN" | "LISTEN" | "CLOSING" | "CLOSED";
}

function serializeNetworkConnection(data: any): NetworkConnection {
  return {
    ...data,
    pid: data["pid"] !== undefined ? String(data["pid"]) : undefined,
  };
}

function deserializeNetworkConnection(data: any): NetworkConnection {
  return {
    ...data,
    pid: data["pid"] !== undefined ? BigInt(data["pid"]) : undefined,
  };
}

/**
 * Network connection list.
 */
export interface NetworkConnectionList {
  /**
   * Network connection entries.
   */
  entries?: NetworkConnection[];
}

function serializeNetworkConnectionList(data: any): NetworkConnectionList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (serializeNetworkConnection(item))) : undefined,
  };
}

function deserializeNetworkConnectionList(data: any): NetworkConnectionList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (deserializeNetworkConnection(item))) : undefined,
  };
}

/**
 * Network usage sample. Values are across all network interfaces.
 */
export interface NetworkUsageSample {
  /**
   * Average network egress in B/s sampled over a short window. Must be
   * non-negative.
   */
  averageEgressBps?: number;
  /**
   * Average network ingress in B/s sampled over a short window. Must be
   * non-negative.
   */
  averageIngressBps?: number;
}

/**
 * NFS export.
 */
export interface NfsExport {
  /**
   * The directory being exported.
   */
  exportDirectory?: string;
  /**
   * The hosts or networks to which the export is being shared.
   */
  hosts?: string[];
}

/**
 * NFS exports.
 */
export interface NfsExportList {
  /**
   * NFS export entries.
   */
  entries?: NfsExport[];
}

/**
 * Open file Information.
 */
export interface OpenFileDetails {
  /**
   * Opened file command.
   */
  command?: string;
  /**
   * Opened file file path.
   */
  filePath?: string;
  /**
   * Opened file file type.
   */
  fileType?: string;
  /**
   * Opened file user.
   */
  user?: string;
}

/**
 * Open file list.
 */
export interface OpenFileList {
  /**
   * Open file details entries.
   */
  entries?: OpenFileDetails[];
}

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

/**
 * Performance data sample.
 */
export interface PerformanceSample {
  /**
   * CPU usage sample.
   */
  cpu?: CpuUsageSample;
  /**
   * Disk usage sample.
   */
  disk?: DiskUsageSample;
  /**
   * Memory usage sample.
   */
  memory?: MemoryUsageSample;
  /**
   * Network usage sample.
   */
  network?: NetworkUsageSample;
  /**
   * Time the sample was collected. If omitted, the frame report time will be
   * used.
   */
  sampleTime?: Date;
}

function serializePerformanceSample(data: any): PerformanceSample {
  return {
    ...data,
    sampleTime: data["sampleTime"] !== undefined ? data["sampleTime"].toISOString() : undefined,
  };
}

function deserializePerformanceSample(data: any): PerformanceSample {
  return {
    ...data,
    sampleTime: data["sampleTime"] !== undefined ? new Date(data["sampleTime"]) : undefined,
  };
}

/**
 * Platform specific details for Physical Machines.
 */
export interface PhysicalPlatformDetails {
  /**
   * Whether the machine is hyperthreaded.
   */
  hyperthreading?:  | "HYPERTHREADING_STATUS_UNSPECIFIED" | "HYPERTHREADING_STATUS_DISABLED" | "HYPERTHREADING_STATUS_ENABLED";
  /**
   * Free text representation of the machine location. The format of this field
   * should not be relied on. Different machines in the same location may have
   * different string values for this field.
   */
  location?: string;
}

/**
 * Information about the platform.
 */
export interface PlatformDetails {
  /**
   * AWS EC2 specific details.
   */
  awsEc2Details?: AwsEc2PlatformDetails;
  /**
   * Azure VM specific details.
   */
  azureVmDetails?: AzureVmPlatformDetails;
  /**
   * Generic platform details.
   */
  genericDetails?: GenericPlatformDetails;
  /**
   * Physical machines platform details.
   */
  physicalDetails?: PhysicalPlatformDetails;
  /**
   * VMware specific details.
   */
  vmwareDetails?: VmwarePlatformDetails;
}

/**
 * Specific details for a PostgreSQL database deployment.
 */
export interface PostgreSqlDatabaseDeployment {
  /**
   * Optional. List of PostgreSql properties.
   */
  properties?: PostgreSqlProperty[];
  /**
   * Optional. List of PostgreSql settings.
   */
  settings?: PostgreSqlSetting[];
}

function serializePostgreSqlDatabaseDeployment(data: any): PostgreSqlDatabaseDeployment {
  return {
    ...data,
    properties: data["properties"] !== undefined ? data["properties"].map((item: any) => (serializePostgreSqlProperty(item))) : undefined,
    settings: data["settings"] !== undefined ? data["settings"].map((item: any) => (serializePostgreSqlSetting(item))) : undefined,
  };
}

function deserializePostgreSqlDatabaseDeployment(data: any): PostgreSqlDatabaseDeployment {
  return {
    ...data,
    properties: data["properties"] !== undefined ? data["properties"].map((item: any) => (deserializePostgreSqlProperty(item))) : undefined,
    settings: data["settings"] !== undefined ? data["settings"].map((item: any) => (deserializePostgreSqlSetting(item))) : undefined,
  };
}

/**
 * PostgreSql extension.
 */
export interface PostgreSqlExtension {
  /**
   * Required. The extension name.
   */
  extension?: string;
  /**
   * Required. The extension version.
   */
  version?: string;
}

/**
 * PostgreSql property.
 */
export interface PostgreSqlProperty {
  /**
   * Required. The property is enabled.
   */
  enabled?: boolean;
  /**
   * Required. The property numeric value.
   */
  numericValue?: bigint;
  /**
   * Required. The property name.
   */
  property?: string;
}

function serializePostgreSqlProperty(data: any): PostgreSqlProperty {
  return {
    ...data,
    numericValue: data["numericValue"] !== undefined ? String(data["numericValue"]) : undefined,
  };
}

function deserializePostgreSqlProperty(data: any): PostgreSqlProperty {
  return {
    ...data,
    numericValue: data["numericValue"] !== undefined ? BigInt(data["numericValue"]) : undefined,
  };
}

/**
 * Specific details for a PostgreSql schema.
 */
export interface PostgreSqlSchemaDetails {
  /**
   * Optional. PostgreSql foreign tables.
   */
  foreignTablesCount?: number;
  /**
   * Optional. PostgreSql extensions.
   */
  postgresqlExtensions?: PostgreSqlExtension[];
}

/**
 * PostgreSql setting.
 */
export interface PostgreSqlSetting {
  /**
   * Required. The setting boolean value.
   */
  boolValue?: boolean;
  /**
   * Required. The setting int value.
   */
  intValue?: bigint;
  /**
   * Required. The setting real value.
   */
  realValue?: number;
  /**
   * Required. The setting name.
   */
  setting?: string;
  /**
   * Required. The setting source.
   */
  source?: string;
  /**
   * Required. The setting string value. Notice that enum values are stored as
   * strings.
   */
  stringValue?: string;
  /**
   * Optional. The setting unit.
   */
  unit?: string;
}

function serializePostgreSqlSetting(data: any): PostgreSqlSetting {
  return {
    ...data,
    intValue: data["intValue"] !== undefined ? String(data["intValue"]) : undefined,
  };
}

function deserializePostgreSqlSetting(data: any): PostgreSqlSetting {
  return {
    ...data,
    intValue: data["intValue"] !== undefined ? BigInt(data["intValue"]) : undefined,
  };
}

/**
 * The preferences that apply to all assets in a given context.
 */
export interface PreferenceSet {
  /**
   * Output only. The timestamp when the preference set was created.
   */
  readonly createTime?: Date;
  /**
   * A description of the preference set.
   */
  description?: string;
  /**
   * User-friendly display name. Maximum length is 63 characters.
   */
  displayName?: string;
  /**
   * Output only. Name of the preference set.
   */
  readonly name?: string;
  /**
   * Output only. The timestamp when the preference set was last updated.
   */
  readonly updateTime?: Date;
  /**
   * Optional. A set of preferences that applies to all virtual machines in the
   * context.
   */
  virtualMachinePreferences?: VirtualMachinePreferences;
}

/**
 * Additional options for MigrationCenter#projectsLocationsAssetsDelete.
 */
export interface ProjectsLocationsAssetsDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsAssetsGet.
 */
export interface ProjectsLocationsAssetsGetOptions {
  /**
   * View of the assets. Defaults to BASIC.
   */
  view?:  | "ASSET_VIEW_UNSPECIFIED" | "ASSET_VIEW_BASIC" | "ASSET_VIEW_FULL";
}

/**
 * Additional options for MigrationCenter#projectsLocationsAssetsList.
 */
export interface ProjectsLocationsAssetsListOptions {
  /**
   * Filtering results.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * Requested page size. Server may return fewer items than requested. If
   * unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * A token identifying a page of results the server should return.
   */
  pageToken?: string;
  /**
   * View of the assets. Defaults to BASIC.
   */
  view?:  | "ASSET_VIEW_UNSPECIFIED" | "ASSET_VIEW_BASIC" | "ASSET_VIEW_FULL";
}

/**
 * Additional options for MigrationCenter#projectsLocationsAssetsPatch.
 */
export interface ProjectsLocationsAssetsPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the `Asset` resource by the update. The values specified in the
   * `update_mask` field are relative to the resource, not the full request. A
   * field will be overwritten if it is in the mask. A single * value in the
   * mask lets you to overwrite all fields.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for
 * MigrationCenter#projectsLocationsAssetsReportAssetFrames.
 */
export interface ProjectsLocationsAssetsReportAssetFramesOptions {
  /**
   * Required. Reference to a source.
   */
  source?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsDiscoveryClientsCreate.
 */
export interface ProjectsLocationsDiscoveryClientsCreateOptions {
  /**
   * Required. User specified ID for the discovery client. It will become the
   * last component of the discovery client name. The ID must be unique within
   * the project, is restricted to lower-cased letters and has a maximum length
   * of 63 characters. The ID must match the regular expression:
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  discoveryClientId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsDiscoveryClientsDelete.
 */
export interface ProjectsLocationsDiscoveryClientsDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsDiscoveryClientsList.
 */
export interface ProjectsLocationsDiscoveryClientsListOptions {
  /**
   * Optional. Filter expression to filter results by.
   */
  filter?: string;
  /**
   * Optional. Field to sort by.
   */
  orderBy?: string;
  /**
   * Optional. The maximum number of items to return. The server may return
   * fewer items than requested. If unspecified, the server will pick an
   * appropriate default value.
   */
  pageSize?: number;
  /**
   * Optional. A page token, received from a previous `ListDiscoveryClients`
   * call. Provide this to retrieve the subsequent page. When paginating, all
   * other parameters provided to `ListDiscoveryClients` must match the call
   * that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsDiscoveryClientsPatch.
 */
export interface ProjectsLocationsDiscoveryClientsPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Update mask is used to specify the fields to be overwritten in
   * the `DiscoveryClient` resource by the update. The values specified in the
   * `update_mask` field are relative to the resource, not the full request. A
   * field will be overwritten if it is in the mask. A single * value in the
   * mask lets you to overwrite all fields.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for MigrationCenter#projectsLocationsGroupsCreate.
 */
export interface ProjectsLocationsGroupsCreateOptions {
  /**
   * Required. User specified ID for the group. It will become the last
   * component of the group name. The ID must be unique within the project, must
   * conform with RFC-1034, is restricted to lower-cased letters, and has a
   * maximum length of 63 characters. The ID must match the regular expression:
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  groupId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsGroupsDelete.
 */
export interface ProjectsLocationsGroupsDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsGroupsList.
 */
export interface ProjectsLocationsGroupsListOptions {
  /**
   * Filtering results.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * Requested page size. Server may return fewer items than requested. If
   * unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsGroupsPatch.
 */
export interface ProjectsLocationsGroupsPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the `Group` resource by the update. The values specified in the
   * `update_mask` are relative to the resource, not the full request. A field
   * will be overwritten if it is in the mask. A single * value in the mask lets
   * you to overwrite all fields.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for MigrationCenter#projectsLocationsImportJobsCreate.
 */
export interface ProjectsLocationsImportJobsCreateOptions {
  /**
   * Required. ID of the import job.
   */
  importJobId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsImportJobsDelete.
 */
export interface ProjectsLocationsImportJobsDeleteOptions {
  /**
   * Optional. If set to `true`, any `ImportDataFiles` of this job will also be
   * deleted If set to `false`, the request only works if the job has no data
   * files.
   */
  force?: boolean;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsImportJobsGet.
 */
export interface ProjectsLocationsImportJobsGetOptions {
  /**
   * Optional. The level of details of the import job. Default value is FULL.
   */
  view?:  | "IMPORT_JOB_VIEW_UNSPECIFIED" | "IMPORT_JOB_VIEW_BASIC" | "IMPORT_JOB_VIEW_FULL";
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsImportJobsImportDataFilesCreate.
 */
export interface ProjectsLocationsImportJobsImportDataFilesCreateOptions {
  /**
   * Required. The ID of the new data file.
   */
  importDataFileId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsImportJobsImportDataFilesDelete.
 */
export interface ProjectsLocationsImportJobsImportDataFilesDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsImportJobsImportDataFilesList.
 */
export interface ProjectsLocationsImportJobsImportDataFilesListOptions {
  /**
   * Filtering results.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * The maximum number of data files to return. The service may return fewer
   * than this value. If unspecified, at most 500 data files will be returned.
   * The maximum value is 1000; values above 1000 will be coerced to 1000.
   */
  pageSize?: number;
  /**
   * A page token, received from a previous `ListImportDataFiles` call. Provide
   * this to retrieve the subsequent page. When paginating, all other parameters
   * provided to `ListImportDataFiles` must match the call that provided the
   * page token.
   */
  pageToken?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsImportJobsList.
 */
export interface ProjectsLocationsImportJobsListOptions {
  /**
   * Filtering results.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * Requested page size. Server may return fewer items than requested. If
   * unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * A token identifying a page of results the server should return.
   */
  pageToken?: string;
  /**
   * Optional. The level of details of each import job. Default value is BASIC.
   */
  view?:  | "IMPORT_JOB_VIEW_UNSPECIFIED" | "IMPORT_JOB_VIEW_BASIC" | "IMPORT_JOB_VIEW_FULL";
}

/**
 * Additional options for MigrationCenter#projectsLocationsImportJobsPatch.
 */
export interface ProjectsLocationsImportJobsPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the `Asset` resource by the update. The values specified in the
   * `update_mask` field are relative to the resource, not the full request. A
   * field will be overwritten if it is in the mask. A single * value in the
   * mask lets you to overwrite all fields.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for MigrationCenter#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 MigrationCenter#projectsLocationsOperationsList.
 */
export interface ProjectsLocationsOperationsListOptions {
  /**
   * The standard list filter.
   */
  filter?: string;
  /**
   * The standard list page size.
   */
  pageSize?: number;
  /**
   * The standard list page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsPreferenceSetsCreate.
 */
export interface ProjectsLocationsPreferenceSetsCreateOptions {
  /**
   * Required. User specified ID for the preference set. It will become the
   * last component of the preference set name. The ID must be unique within the
   * project, must conform with RFC-1034, is restricted to lower-cased letters,
   * and has a maximum length of 63 characters. The ID must match the regular
   * expression `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  preferenceSetId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsPreferenceSetsDelete.
 */
export interface ProjectsLocationsPreferenceSetsDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsPreferenceSetsList.
 */
export interface ProjectsLocationsPreferenceSetsListOptions {
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * Requested page size. Server may return fewer items than requested. If
   * unspecified, at most 500 preference sets will be returned. The maximum
   * value is 1000; values above 1000 will be coerced to 1000.
   */
  pageSize?: number;
  /**
   * A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsPreferenceSetsPatch.
 */
export interface ProjectsLocationsPreferenceSetsPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the `PreferenceSet` resource by the update. The values specified in the
   * `update_mask` field are relative to the resource, not the full request. A
   * field will be overwritten if it is in the mask. A single * value in the
   * mask lets you to overwrite all fields.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for MigrationCenter#projectsLocationsReportConfigsCreate.
 */
export interface ProjectsLocationsReportConfigsCreateOptions {
  /**
   * Required. User specified ID for the report config. It will become the last
   * component of the report config name. The ID must be unique within the
   * project, must conform with RFC-1034, is restricted to lower-cased letters,
   * and has a maximum length of 63 characters. The ID must match the regular
   * expression: [a-z]([a-z0-9-]{0,61}[a-z0-9])?.
   */
  reportConfigId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsReportConfigsDelete.
 */
export interface ProjectsLocationsReportConfigsDeleteOptions {
  /**
   * Optional. If set to `true`, any child `Reports` of this entity will also
   * be deleted. If set to `false`, the request only works if the resource has
   * no children.
   */
  force?: boolean;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsReportConfigsList.
 */
export interface ProjectsLocationsReportConfigsListOptions {
  /**
   * Filtering results.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * Requested page size. Server may return fewer items than requested. If
   * unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsReportConfigsReportsCreate.
 */
export interface ProjectsLocationsReportConfigsReportsCreateOptions {
  /**
   * Required. User specified id for the report. It will become the last
   * component of the report name. The id must be unique within the project,
   * must conform with RFC-1034, is restricted to lower-cased letters, and has a
   * maximum length of 63 characters. The id must match the regular expression:
   * [a-z]([a-z0-9-]{0,61}[a-z0-9])?.
   */
  reportId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsReportConfigsReportsDelete.
 */
export interface ProjectsLocationsReportConfigsReportsDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsReportConfigsReportsGet.
 */
export interface ProjectsLocationsReportConfigsReportsGetOptions {
  /**
   * Determines what information to retrieve for the Report.
   */
  view?:  | "REPORT_VIEW_UNSPECIFIED" | "REPORT_VIEW_BASIC" | "REPORT_VIEW_FULL" | "REPORT_VIEW_STANDARD";
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsReportConfigsReportsList.
 */
export interface ProjectsLocationsReportConfigsReportsListOptions {
  /**
   * Filtering results.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * Requested page size. The server may return fewer items than requested. If
   * unspecified, the server will pick an appropriate default value.
   */
  pageSize?: number;
  /**
   * A token identifying a page of results that the server should return.
   */
  pageToken?: string;
  /**
   * Determines what information to retrieve for each Report.
   */
  view?:  | "REPORT_VIEW_UNSPECIFIED" | "REPORT_VIEW_BASIC" | "REPORT_VIEW_FULL" | "REPORT_VIEW_STANDARD";
}

/**
 * Additional options for MigrationCenter#projectsLocationsSourcesCreate.
 */
export interface ProjectsLocationsSourcesCreateOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. User specified ID for the source. It will become the last
   * component of the source name. The ID must be unique within the project,
   * must conform with RFC-1034, is restricted to lower-cased letters, and has a
   * maximum length of 63 characters. The ID must match the regular expression:
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  sourceId?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsSourcesDelete.
 */
export interface ProjectsLocationsSourcesDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsSourcesErrorFramesGet.
 */
export interface ProjectsLocationsSourcesErrorFramesGetOptions {
  /**
   * Optional. An optional view mode to control the level of details for the
   * frame. The default is a basic frame view.
   */
  view?:  | "ERROR_FRAME_VIEW_UNSPECIFIED" | "ERROR_FRAME_VIEW_BASIC" | "ERROR_FRAME_VIEW_FULL";
}

/**
 * Additional options for
 * MigrationCenter#projectsLocationsSourcesErrorFramesList.
 */
export interface ProjectsLocationsSourcesErrorFramesListOptions {
  /**
   * Requested page size. Server may return fewer items than requested. If
   * unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * A token identifying a page of results the server should return.
   */
  pageToken?: string;
  /**
   * Optional. An optional view mode to control the level of details of each
   * error frame. The default is a BASIC frame view.
   */
  view?:  | "ERROR_FRAME_VIEW_UNSPECIFIED" | "ERROR_FRAME_VIEW_BASIC" | "ERROR_FRAME_VIEW_FULL";
}

/**
 * Additional options for MigrationCenter#projectsLocationsSourcesList.
 */
export interface ProjectsLocationsSourcesListOptions {
  /**
   * Filtering results.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * Requested page size. The server may return fewer items than requested. If
   * unspecified, the server will pick an appropriate default value.
   */
  pageSize?: number;
  /**
   * A token identifying a page of results that the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for MigrationCenter#projectsLocationsSourcesPatch.
 */
export interface ProjectsLocationsSourcesPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the `Source` resource by the update. The values specified in the
   * `update_mask` field are relative to the resource, not the full request. A
   * field will be overwritten if it is in the mask. A single * value in the
   * mask lets you to overwrite all fields.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for MigrationCenter#projectsLocationsUpdateSettings.
 */
export interface ProjectsLocationsUpdateSettingsOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the `Settings` resource by the update. The values specified in the
   * `update_mask` field are relative to the resource, not the full request. A
   * field will be overwritten if it is in the mask. A single * value in the
   * mask lets you to overwrite all fields.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * The user preferences relating to target regions.
 */
export interface RegionPreferences {
  /**
   * A list of preferred regions, ordered by the most preferred region first.
   * Set only valid Google Cloud region names. See
   * https://cloud.google.com/compute/docs/regions-zones for available regions.
   */
  preferredRegions?: string[];
}

/**
 * A request to remove assets from a group.
 */
export interface RemoveAssetsFromGroupRequest {
  /**
   * Optional. When this value is set to `false` and one of the given assets is
   * not an existing member of the group, the operation fails with a `Not Found`
   * error. When set to `true` this situation is silently ignored by the server.
   * Default value is `false`.
   */
  allowMissing?: boolean;
  /**
   * Required. List of assets to be removed. The maximum number of assets that
   * can be removed in a single request is 1000.
   */
  assets?: AssetList;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Report represents a point-in-time rendering of the ReportConfig results.
 */
export interface Report {
  /**
   * Output only. Creation timestamp.
   */
  readonly createTime?: Date;
  /**
   * Free-text description.
   */
  description?: string;
  /**
   * User-friendly display name. Maximum length is 63 characters.
   */
  displayName?: string;
  /**
   * Output only. Name of resource.
   */
  readonly name?: string;
  /**
   * Report creation state.
   */
  state?:  | "STATE_UNSPECIFIED" | "PENDING" | "SUCCEEDED" | "FAILED";
  /**
   * Output only. Summary view of the Report.
   */
  readonly summary?: ReportSummary;
  /**
   * Report type.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TOTAL_COST_OF_OWNERSHIP";
  /**
   * Output only. Last update timestamp.
   */
  readonly updateTime?: Date;
}

/**
 * A response to a call to `ReportAssetFrame`.
 */
export interface ReportAssetFramesResponse {
}

/**
 * The groups and associated preference sets on which we can generate reports.
 */
export interface ReportConfig {
  /**
   * Output only. The timestamp when the resource was created.
   */
  readonly createTime?: Date;
  /**
   * Free-text description.
   */
  description?: string;
  /**
   * User-friendly display name. Maximum length is 63 characters.
   */
  displayName?: string;
  /**
   * Required. Collection of combinations of groups and preference sets.
   */
  groupPreferencesetAssignments?: ReportConfigGroupPreferenceSetAssignment[];
  /**
   * Output only. Name of resource.
   */
  readonly name?: string;
  /**
   * Output only. The timestamp when the resource was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * Represents a combination of a group with a preference set.
 */
export interface ReportConfigGroupPreferenceSetAssignment {
  /**
   * Required. Name of the group.
   */
  group?: string;
  /**
   * Required. Name of the Preference Set.
   */
  preferenceSet?: string;
}

/**
 * Describes the Summary view of a Report, which contains aggregated values for
 * all the groups and preference sets included in this Report.
 */
export interface ReportSummary {
  /**
   * Aggregate statistics for all the assets across all the groups.
   */
  allAssetsStats?: ReportSummaryAssetAggregateStats;
  /**
   * Findings for each Group included in this report.
   */
  groupFindings?: ReportSummaryGroupFinding[];
}

function serializeReportSummary(data: any): ReportSummary {
  return {
    ...data,
    allAssetsStats: data["allAssetsStats"] !== undefined ? serializeReportSummaryAssetAggregateStats(data["allAssetsStats"]) : undefined,
    groupFindings: data["groupFindings"] !== undefined ? data["groupFindings"].map((item: any) => (serializeReportSummaryGroupFinding(item))) : undefined,
  };
}

function deserializeReportSummary(data: any): ReportSummary {
  return {
    ...data,
    allAssetsStats: data["allAssetsStats"] !== undefined ? deserializeReportSummaryAssetAggregateStats(data["allAssetsStats"]) : undefined,
    groupFindings: data["groupFindings"] !== undefined ? data["groupFindings"].map((item: any) => (deserializeReportSummaryGroupFinding(item))) : undefined,
  };
}

/**
 * Aggregate statistics for a collection of assets.
 */
export interface ReportSummaryAssetAggregateStats {
  /**
   * Histogram showing a distribution of logical CPU core counts.
   */
  coreCountHistogram?: ReportSummaryHistogramChartData;
  /**
   * Histogram showing a distribution of memory sizes.
   */
  memoryBytesHistogram?: ReportSummaryHistogramChartData;
  /**
   * Total memory split into Used/Free buckets.
   */
  memoryUtilizationChart?: ReportSummaryUtilizationChartData;
  /**
   * Count of assets grouped by Operating System families.
   */
  operatingSystem?: ReportSummaryChartData;
  /**
   * Histogram showing a distribution of storage sizes.
   */
  storageBytesHistogram?: ReportSummaryHistogramChartData;
  /**
   * Total memory split into Used/Free buckets.
   */
  storageUtilizationChart?: ReportSummaryUtilizationChartData;
  /**
   * Count of the number of unique assets in this collection.
   */
  totalAssets?: bigint;
  /**
   * Sum of the CPU core count of all the assets in this collection.
   */
  totalCores?: bigint;
  /**
   * Sum of the memory in bytes of all the assets in this collection.
   */
  totalMemoryBytes?: bigint;
  /**
   * Sum of persistent storage in bytes of all the assets in this collection.
   */
  totalStorageBytes?: bigint;
}

function serializeReportSummaryAssetAggregateStats(data: any): ReportSummaryAssetAggregateStats {
  return {
    ...data,
    coreCountHistogram: data["coreCountHistogram"] !== undefined ? serializeReportSummaryHistogramChartData(data["coreCountHistogram"]) : undefined,
    memoryBytesHistogram: data["memoryBytesHistogram"] !== undefined ? serializeReportSummaryHistogramChartData(data["memoryBytesHistogram"]) : undefined,
    memoryUtilizationChart: data["memoryUtilizationChart"] !== undefined ? serializeReportSummaryUtilizationChartData(data["memoryUtilizationChart"]) : undefined,
    storageBytesHistogram: data["storageBytesHistogram"] !== undefined ? serializeReportSummaryHistogramChartData(data["storageBytesHistogram"]) : undefined,
    storageUtilizationChart: data["storageUtilizationChart"] !== undefined ? serializeReportSummaryUtilizationChartData(data["storageUtilizationChart"]) : undefined,
    totalAssets: data["totalAssets"] !== undefined ? String(data["totalAssets"]) : undefined,
    totalCores: data["totalCores"] !== undefined ? String(data["totalCores"]) : undefined,
    totalMemoryBytes: data["totalMemoryBytes"] !== undefined ? String(data["totalMemoryBytes"]) : undefined,
    totalStorageBytes: data["totalStorageBytes"] !== undefined ? String(data["totalStorageBytes"]) : undefined,
  };
}

function deserializeReportSummaryAssetAggregateStats(data: any): ReportSummaryAssetAggregateStats {
  return {
    ...data,
    coreCountHistogram: data["coreCountHistogram"] !== undefined ? deserializeReportSummaryHistogramChartData(data["coreCountHistogram"]) : undefined,
    memoryBytesHistogram: data["memoryBytesHistogram"] !== undefined ? deserializeReportSummaryHistogramChartData(data["memoryBytesHistogram"]) : undefined,
    memoryUtilizationChart: data["memoryUtilizationChart"] !== undefined ? deserializeReportSummaryUtilizationChartData(data["memoryUtilizationChart"]) : undefined,
    storageBytesHistogram: data["storageBytesHistogram"] !== undefined ? deserializeReportSummaryHistogramChartData(data["storageBytesHistogram"]) : undefined,
    storageUtilizationChart: data["storageUtilizationChart"] !== undefined ? deserializeReportSummaryUtilizationChartData(data["storageUtilizationChart"]) : undefined,
    totalAssets: data["totalAssets"] !== undefined ? BigInt(data["totalAssets"]) : undefined,
    totalCores: data["totalCores"] !== undefined ? BigInt(data["totalCores"]) : undefined,
    totalMemoryBytes: data["totalMemoryBytes"] !== undefined ? BigInt(data["totalMemoryBytes"]) : undefined,
    totalStorageBytes: data["totalStorageBytes"] !== undefined ? BigInt(data["totalStorageBytes"]) : undefined,
  };
}

/**
 * Describes a collection of data points rendered as a Chart.
 */
export interface ReportSummaryChartData {
  /**
   * Each data point in the chart is represented as a name-value pair with the
   * name being the x-axis label, and the value being the y-axis value.
   */
  dataPoints?: ReportSummaryChartDataDataPoint[];
}

/**
 * Describes a single data point in the Chart.
 */
export interface ReportSummaryChartDataDataPoint {
  /**
   * The X-axis label for this data point.
   */
  label?: string;
  /**
   * The Y-axis value for this data point.
   */
  value?: number;
}

/**
 * A set of findings that applies to assets destined for Compute Engine.
 */
export interface ReportSummaryComputeEngineFinding {
  /**
   * Count of assets which were allocated.
   */
  allocatedAssetCount?: bigint;
  /**
   * Set of disk types allocated to assets.
   */
  allocatedDiskTypes?:  | "PERSISTENT_DISK_TYPE_UNSPECIFIED" | "PERSISTENT_DISK_TYPE_STANDARD" | "PERSISTENT_DISK_TYPE_BALANCED" | "PERSISTENT_DISK_TYPE_SSD"[];
  /**
   * Set of regions in which the assets were allocated.
   */
  allocatedRegions?: string[];
  /**
   * Distribution of assets based on the Machine Series.
   */
  machineSeriesAllocations?: ReportSummaryMachineSeriesAllocation[];
}

function serializeReportSummaryComputeEngineFinding(data: any): ReportSummaryComputeEngineFinding {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? String(data["allocatedAssetCount"]) : undefined,
    machineSeriesAllocations: data["machineSeriesAllocations"] !== undefined ? data["machineSeriesAllocations"].map((item: any) => (serializeReportSummaryMachineSeriesAllocation(item))) : undefined,
  };
}

function deserializeReportSummaryComputeEngineFinding(data: any): ReportSummaryComputeEngineFinding {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? BigInt(data["allocatedAssetCount"]) : undefined,
    machineSeriesAllocations: data["machineSeriesAllocations"] !== undefined ? data["machineSeriesAllocations"].map((item: any) => (deserializeReportSummaryMachineSeriesAllocation(item))) : undefined,
  };
}

/**
 * Summary Findings for a specific Group.
 */
export interface ReportSummaryGroupFinding {
  /**
   * Summary statistics for all the assets in this group.
   */
  assetAggregateStats?: ReportSummaryAssetAggregateStats;
  /**
   * Description for the Group.
   */
  description?: string;
  /**
   * Display Name for the Group.
   */
  displayName?: string;
  /**
   * This field is deprecated, do not rely on it having a value.
   */
  overlappingAssetCount?: bigint;
  /**
   * Findings for each of the PreferenceSets for this group.
   */
  preferenceSetFindings?: ReportSummaryGroupPreferenceSetFinding[];
}

function serializeReportSummaryGroupFinding(data: any): ReportSummaryGroupFinding {
  return {
    ...data,
    assetAggregateStats: data["assetAggregateStats"] !== undefined ? serializeReportSummaryAssetAggregateStats(data["assetAggregateStats"]) : undefined,
    overlappingAssetCount: data["overlappingAssetCount"] !== undefined ? String(data["overlappingAssetCount"]) : undefined,
    preferenceSetFindings: data["preferenceSetFindings"] !== undefined ? data["preferenceSetFindings"].map((item: any) => (serializeReportSummaryGroupPreferenceSetFinding(item))) : undefined,
  };
}

function deserializeReportSummaryGroupFinding(data: any): ReportSummaryGroupFinding {
  return {
    ...data,
    assetAggregateStats: data["assetAggregateStats"] !== undefined ? deserializeReportSummaryAssetAggregateStats(data["assetAggregateStats"]) : undefined,
    overlappingAssetCount: data["overlappingAssetCount"] !== undefined ? BigInt(data["overlappingAssetCount"]) : undefined,
    preferenceSetFindings: data["preferenceSetFindings"] !== undefined ? data["preferenceSetFindings"].map((item: any) => (deserializeReportSummaryGroupPreferenceSetFinding(item))) : undefined,
  };
}

/**
 * Summary Findings for a specific Group/PreferenceSet combination.
 */
export interface ReportSummaryGroupPreferenceSetFinding {
  /**
   * A set of findings that applies to Compute Engine machines in the input.
   */
  computeEngineFinding?: ReportSummaryComputeEngineFinding;
  /**
   * Description for the Preference Set.
   */
  description?: string;
  /**
   * Display Name of the Preference Set
   */
  displayName?: string;
  /**
   * A set of preferences that applies to all machines in the context.
   */
  machinePreferences?: VirtualMachinePreferences;
  /**
   * Compute monthly cost for this preference set.
   */
  monthlyCostCompute?: Money;
  /**
   * Network Egress monthly cost for this preference set.
   */
  monthlyCostNetworkEgress?: Money;
  /**
   * Licensing monthly cost for this preference set.
   */
  monthlyCostOsLicense?: Money;
  /**
   * Miscellaneous monthly cost for this preference set.
   */
  monthlyCostOther?: Money;
  /**
   * Storage monthly cost for this preference set.
   */
  monthlyCostStorage?: Money;
  /**
   * Total monthly cost for this preference set.
   */
  monthlyCostTotal?: Money;
  /**
   * A set of findings that applies to Sole-Tenant machines in the input.
   */
  soleTenantFinding?: ReportSummarySoleTenantFinding;
  /**
   * A set of findings that applies to VMWare machines in the input.
   */
  vmwareEngineFinding?: ReportSummaryVmwareEngineFinding;
}

function serializeReportSummaryGroupPreferenceSetFinding(data: any): ReportSummaryGroupPreferenceSetFinding {
  return {
    ...data,
    computeEngineFinding: data["computeEngineFinding"] !== undefined ? serializeReportSummaryComputeEngineFinding(data["computeEngineFinding"]) : undefined,
    monthlyCostCompute: data["monthlyCostCompute"] !== undefined ? serializeMoney(data["monthlyCostCompute"]) : undefined,
    monthlyCostNetworkEgress: data["monthlyCostNetworkEgress"] !== undefined ? serializeMoney(data["monthlyCostNetworkEgress"]) : undefined,
    monthlyCostOsLicense: data["monthlyCostOsLicense"] !== undefined ? serializeMoney(data["monthlyCostOsLicense"]) : undefined,
    monthlyCostOther: data["monthlyCostOther"] !== undefined ? serializeMoney(data["monthlyCostOther"]) : undefined,
    monthlyCostStorage: data["monthlyCostStorage"] !== undefined ? serializeMoney(data["monthlyCostStorage"]) : undefined,
    monthlyCostTotal: data["monthlyCostTotal"] !== undefined ? serializeMoney(data["monthlyCostTotal"]) : undefined,
    soleTenantFinding: data["soleTenantFinding"] !== undefined ? serializeReportSummarySoleTenantFinding(data["soleTenantFinding"]) : undefined,
    vmwareEngineFinding: data["vmwareEngineFinding"] !== undefined ? serializeReportSummaryVmwareEngineFinding(data["vmwareEngineFinding"]) : undefined,
  };
}

function deserializeReportSummaryGroupPreferenceSetFinding(data: any): ReportSummaryGroupPreferenceSetFinding {
  return {
    ...data,
    computeEngineFinding: data["computeEngineFinding"] !== undefined ? deserializeReportSummaryComputeEngineFinding(data["computeEngineFinding"]) : undefined,
    monthlyCostCompute: data["monthlyCostCompute"] !== undefined ? deserializeMoney(data["monthlyCostCompute"]) : undefined,
    monthlyCostNetworkEgress: data["monthlyCostNetworkEgress"] !== undefined ? deserializeMoney(data["monthlyCostNetworkEgress"]) : undefined,
    monthlyCostOsLicense: data["monthlyCostOsLicense"] !== undefined ? deserializeMoney(data["monthlyCostOsLicense"]) : undefined,
    monthlyCostOther: data["monthlyCostOther"] !== undefined ? deserializeMoney(data["monthlyCostOther"]) : undefined,
    monthlyCostStorage: data["monthlyCostStorage"] !== undefined ? deserializeMoney(data["monthlyCostStorage"]) : undefined,
    monthlyCostTotal: data["monthlyCostTotal"] !== undefined ? deserializeMoney(data["monthlyCostTotal"]) : undefined,
    soleTenantFinding: data["soleTenantFinding"] !== undefined ? deserializeReportSummarySoleTenantFinding(data["soleTenantFinding"]) : undefined,
    vmwareEngineFinding: data["vmwareEngineFinding"] !== undefined ? deserializeReportSummaryVmwareEngineFinding(data["vmwareEngineFinding"]) : undefined,
  };
}

/**
 * A Histogram Chart shows a distribution of values into buckets, showing a
 * count of values which fall into a bucket.
 */
export interface ReportSummaryHistogramChartData {
  /**
   * Buckets in the histogram. There will be `n+1` buckets matching `n` lower
   * bounds in the request. The first bucket will be from -infinity to the first
   * bound. Subsequent buckets will be between one bound and the next. The final
   * bucket will be from the final bound to infinity.
   */
  buckets?: ReportSummaryHistogramChartDataBucket[];
}

function serializeReportSummaryHistogramChartData(data: any): ReportSummaryHistogramChartData {
  return {
    ...data,
    buckets: data["buckets"] !== undefined ? data["buckets"].map((item: any) => (serializeReportSummaryHistogramChartDataBucket(item))) : undefined,
  };
}

function deserializeReportSummaryHistogramChartData(data: any): ReportSummaryHistogramChartData {
  return {
    ...data,
    buckets: data["buckets"] !== undefined ? data["buckets"].map((item: any) => (deserializeReportSummaryHistogramChartDataBucket(item))) : undefined,
  };
}

/**
 * A histogram bucket with a lower and upper bound, and a count of items with a
 * field value between those bounds. The lower bound is inclusive and the upper
 * bound is exclusive. Lower bound may be -infinity and upper bound may be
 * infinity.
 */
export interface ReportSummaryHistogramChartDataBucket {
  /**
   * Count of items in the bucket.
   */
  count?: bigint;
  /**
   * Lower bound - inclusive.
   */
  lowerBound?: bigint;
  /**
   * Upper bound - exclusive.
   */
  upperBound?: bigint;
}

function serializeReportSummaryHistogramChartDataBucket(data: any): ReportSummaryHistogramChartDataBucket {
  return {
    ...data,
    count: data["count"] !== undefined ? String(data["count"]) : undefined,
    lowerBound: data["lowerBound"] !== undefined ? String(data["lowerBound"]) : undefined,
    upperBound: data["upperBound"] !== undefined ? String(data["upperBound"]) : undefined,
  };
}

function deserializeReportSummaryHistogramChartDataBucket(data: any): ReportSummaryHistogramChartDataBucket {
  return {
    ...data,
    count: data["count"] !== undefined ? BigInt(data["count"]) : undefined,
    lowerBound: data["lowerBound"] !== undefined ? BigInt(data["lowerBound"]) : undefined,
    upperBound: data["upperBound"] !== undefined ? BigInt(data["upperBound"]) : undefined,
  };
}

/**
 * Represents a data point tracking the count of assets allocated for a
 * specific Machine Series.
 */
export interface ReportSummaryMachineSeriesAllocation {
  /**
   * Count of assets allocated to this machine series.
   */
  allocatedAssetCount?: bigint;
  /**
   * The Machine Series (e.g. "E2", "N2")
   */
  machineSeries?: MachineSeries;
}

function serializeReportSummaryMachineSeriesAllocation(data: any): ReportSummaryMachineSeriesAllocation {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? String(data["allocatedAssetCount"]) : undefined,
  };
}

function deserializeReportSummaryMachineSeriesAllocation(data: any): ReportSummaryMachineSeriesAllocation {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? BigInt(data["allocatedAssetCount"]) : undefined,
  };
}

/**
 * A set of findings that applies to assets destined for Sole-Tenant nodes.
 */
export interface ReportSummarySoleTenantFinding {
  /**
   * Count of assets which are allocated
   */
  allocatedAssetCount?: bigint;
  /**
   * Set of regions in which the assets are allocated
   */
  allocatedRegions?: string[];
  /**
   * Set of per-nodetype allocation records
   */
  nodeAllocations?: ReportSummarySoleTenantNodeAllocation[];
}

function serializeReportSummarySoleTenantFinding(data: any): ReportSummarySoleTenantFinding {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? String(data["allocatedAssetCount"]) : undefined,
    nodeAllocations: data["nodeAllocations"] !== undefined ? data["nodeAllocations"].map((item: any) => (serializeReportSummarySoleTenantNodeAllocation(item))) : undefined,
  };
}

function deserializeReportSummarySoleTenantFinding(data: any): ReportSummarySoleTenantFinding {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? BigInt(data["allocatedAssetCount"]) : undefined,
    nodeAllocations: data["nodeAllocations"] !== undefined ? data["nodeAllocations"].map((item: any) => (deserializeReportSummarySoleTenantNodeAllocation(item))) : undefined,
  };
}

/**
 * Represents the assets allocated to a specific Sole-Tenant node type.
 */
export interface ReportSummarySoleTenantNodeAllocation {
  /**
   * Count of assets allocated to these nodes
   */
  allocatedAssetCount?: bigint;
  /**
   * Sole Tenant node type, e.g. "m3-node-128-3904"
   */
  node?: SoleTenantNodeType;
  /**
   * Count of this node type to be provisioned
   */
  nodeCount?: bigint;
}

function serializeReportSummarySoleTenantNodeAllocation(data: any): ReportSummarySoleTenantNodeAllocation {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? String(data["allocatedAssetCount"]) : undefined,
    nodeCount: data["nodeCount"] !== undefined ? String(data["nodeCount"]) : undefined,
  };
}

function deserializeReportSummarySoleTenantNodeAllocation(data: any): ReportSummarySoleTenantNodeAllocation {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? BigInt(data["allocatedAssetCount"]) : undefined,
    nodeCount: data["nodeCount"] !== undefined ? BigInt(data["nodeCount"]) : undefined,
  };
}

/**
 * Utilization Chart is a specific type of visualization which displays a
 * metric classified into "Used" and "Free" buckets.
 */
export interface ReportSummaryUtilizationChartData {
  /**
   * Aggregate value which falls into the "Free" bucket.
   */
  free?: bigint;
  /**
   * Aggregate value which falls into the "Used" bucket.
   */
  used?: bigint;
}

function serializeReportSummaryUtilizationChartData(data: any): ReportSummaryUtilizationChartData {
  return {
    ...data,
    free: data["free"] !== undefined ? String(data["free"]) : undefined,
    used: data["used"] !== undefined ? String(data["used"]) : undefined,
  };
}

function deserializeReportSummaryUtilizationChartData(data: any): ReportSummaryUtilizationChartData {
  return {
    ...data,
    free: data["free"] !== undefined ? BigInt(data["free"]) : undefined,
    used: data["used"] !== undefined ? BigInt(data["used"]) : undefined,
  };
}

/**
 * A set of findings that applies to assets destined for VMWare Engine.
 */
export interface ReportSummaryVmwareEngineFinding {
  /**
   * Count of assets which are allocated
   */
  allocatedAssetCount?: bigint;
  /**
   * Set of regions in which the assets were allocated
   */
  allocatedRegions?: string[];
  /**
   * Set of per-nodetype allocation records
   */
  nodeAllocations?: ReportSummaryVmwareNodeAllocation[];
}

function serializeReportSummaryVmwareEngineFinding(data: any): ReportSummaryVmwareEngineFinding {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? String(data["allocatedAssetCount"]) : undefined,
    nodeAllocations: data["nodeAllocations"] !== undefined ? data["nodeAllocations"].map((item: any) => (serializeReportSummaryVmwareNodeAllocation(item))) : undefined,
  };
}

function deserializeReportSummaryVmwareEngineFinding(data: any): ReportSummaryVmwareEngineFinding {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? BigInt(data["allocatedAssetCount"]) : undefined,
    nodeAllocations: data["nodeAllocations"] !== undefined ? data["nodeAllocations"].map((item: any) => (deserializeReportSummaryVmwareNodeAllocation(item))) : undefined,
  };
}

/**
 * A VMWare Engine Node
 */
export interface ReportSummaryVmwareNode {
  /**
   * Code to identify VMware Engine node series, e.g. "ve1-standard-72". Based
   * on the displayName of
   * cloud.google.com/vmware-engine/docs/reference/rest/v1/projects.locations.nodeTypes
   */
  code?: string;
}

/**
 * Represents assets allocated to a specific VMWare Node type.
 */
export interface ReportSummaryVmwareNodeAllocation {
  /**
   * Count of assets allocated to these nodes
   */
  allocatedAssetCount?: bigint;
  /**
   * Count of this node type to be provisioned
   */
  nodeCount?: bigint;
  /**
   * VMWare node type, e.g. "ve1-standard-72"
   */
  vmwareNode?: ReportSummaryVmwareNode;
}

function serializeReportSummaryVmwareNodeAllocation(data: any): ReportSummaryVmwareNodeAllocation {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? String(data["allocatedAssetCount"]) : undefined,
    nodeCount: data["nodeCount"] !== undefined ? String(data["nodeCount"]) : undefined,
  };
}

function deserializeReportSummaryVmwareNodeAllocation(data: any): ReportSummaryVmwareNodeAllocation {
  return {
    ...data,
    allocatedAssetCount: data["allocatedAssetCount"] !== undefined ? BigInt(data["allocatedAssetCount"]) : undefined,
    nodeCount: data["nodeCount"] !== undefined ? BigInt(data["nodeCount"]) : undefined,
  };
}

/**
 * A request to run an import job.
 */
export interface RunImportJobRequest {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * Guest OS running process details.
 */
export interface RunningProcess {
  /**
   * Process extended attributes.
   */
  attributes?: {
    [key: string]: string
  };
  /**
   * Process full command line.
   */
  cmdline?: string;
  /**
   * Process binary path.
   */
  exePath?: string;
  /**
   * Process ID.
   */
  pid?: bigint;
  /**
   * User running the process.
   */
  user?: string;
}

function serializeRunningProcess(data: any): RunningProcess {
  return {
    ...data,
    pid: data["pid"] !== undefined ? String(data["pid"]) : undefined,
  };
}

function deserializeRunningProcess(data: any): RunningProcess {
  return {
    ...data,
    pid: data["pid"] !== undefined ? BigInt(data["pid"]) : undefined,
  };
}

/**
 * List of running guest OS processes.
 */
export interface RunningProcessList {
  /**
   * Running process entries.
   */
  entries?: RunningProcess[];
}

function serializeRunningProcessList(data: any): RunningProcessList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (serializeRunningProcess(item))) : undefined,
  };
}

function deserializeRunningProcessList(data: any): RunningProcessList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (deserializeRunningProcess(item))) : undefined,
  };
}

/**
 * Guest OS running service details.
 */
export interface RunningService {
  /**
   * Service command line.
   */
  cmdline?: string;
  /**
   * Service binary path.
   */
  exePath?: string;
  /**
   * Service pid.
   */
  pid?: bigint;
  /**
   * Service name.
   */
  serviceName?: string;
  /**
   * Service start mode (OS-agnostic).
   */
  startMode?:  | "START_MODE_UNSPECIFIED" | "BOOT" | "SYSTEM" | "AUTO" | "MANUAL" | "DISABLED";
  /**
   * Service state (OS-agnostic).
   */
  state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "PAUSED" | "STOPPED";
}

function serializeRunningService(data: any): RunningService {
  return {
    ...data,
    pid: data["pid"] !== undefined ? String(data["pid"]) : undefined,
  };
}

function deserializeRunningService(data: any): RunningService {
  return {
    ...data,
    pid: data["pid"] !== undefined ? BigInt(data["pid"]) : undefined,
  };
}

/**
 * List of running guest OS services.
 */
export interface RunningServiceList {
  /**
   * Running service entries.
   */
  entries?: RunningService[];
}

function serializeRunningServiceList(data: any): RunningServiceList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (serializeRunningService(item))) : undefined,
  };
}

function deserializeRunningServiceList(data: any): RunningServiceList {
  return {
    ...data,
    entries: data["entries"] !== undefined ? data["entries"].map((item: any) => (deserializeRunningService(item))) : undefined,
  };
}

/**
 * Runtime networking information.
 */
export interface RuntimeNetworkInfo {
  /**
   * Network connections.
   */
  connections?: NetworkConnectionList;
  /**
   * Time of the last network scan.
   */
  scanTime?: Date;
}

function serializeRuntimeNetworkInfo(data: any): RuntimeNetworkInfo {
  return {
    ...data,
    connections: data["connections"] !== undefined ? serializeNetworkConnectionList(data["connections"]) : undefined,
    scanTime: data["scanTime"] !== undefined ? data["scanTime"].toISOString() : undefined,
  };
}

function deserializeRuntimeNetworkInfo(data: any): RuntimeNetworkInfo {
  return {
    ...data,
    connections: data["connections"] !== undefined ? deserializeNetworkConnectionList(data["connections"]) : undefined,
    scanTime: data["scanTime"] !== undefined ? new Date(data["scanTime"]) : undefined,
  };
}

/**
 * A request to send a discovery client heartbeat.
 */
export interface SendDiscoveryClientHeartbeatRequest {
  /**
   * Optional. Errors affecting client functionality.
   */
  errors?: Status[];
  /**
   * Optional. Client application version.
   */
  version?: string;
}

/**
 * Describes the Migration Center settings related to the project.
 */
export interface Settings {
  /**
   * Disable Cloud Logging for the Migration Center API. Users are billed for
   * the logs.
   */
  disableCloudLogging?: boolean;
  /**
   * Output only. The name of the resource.
   */
  readonly name?: string;
  /**
   * The preference set used by default for a project.
   */
  preferenceSet?: string;
}

/**
 * Preferences concerning Sole Tenancy nodes and VMs.
 */
export interface SoleTenancyPreferences {
  /**
   * Commitment plan to consider when calculating costs for virtual machine
   * insights and recommendations. If you are unsure which value to set, a 3
   * year commitment plan is often a good value to start with.
   */
  commitmentPlan?:  | "COMMITMENT_PLAN_UNSPECIFIED" | "ON_DEMAND" | "COMMITMENT_1_YEAR" | "COMMITMENT_3_YEAR";
  /**
   * CPU overcommit ratio. Acceptable values are between 1.0 and 2.0 inclusive.
   */
  cpuOvercommitRatio?: number;
  /**
   * Sole Tenancy nodes maintenance policy.
   */
  hostMaintenancePolicy?:  | "HOST_MAINTENANCE_POLICY_UNSPECIFIED" | "HOST_MAINTENANCE_POLICY_DEFAULT" | "HOST_MAINTENANCE_POLICY_RESTART_IN_PLACE" | "HOST_MAINTENANCE_POLICY_MIGRATE_WITHIN_NODE_GROUP";
  /**
   * A list of sole tenant node types. An empty list means that all possible
   * node types will be considered.
   */
  nodeTypes?: SoleTenantNodeType[];
}

/**
 * A Sole Tenant node type.
 */
export interface SoleTenantNodeType {
  /**
   * Name of the Sole Tenant node. Consult
   * https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes
   */
  nodeName?: string;
}

/**
 * Source represents an object from which asset information is streamed to
 * Migration Center.
 */
export interface Source {
  /**
   * Output only. The timestamp when the source was created.
   */
  readonly createTime?: Date;
  /**
   * Free-text description.
   */
  description?: string;
  /**
   * User-friendly display name.
   */
  displayName?: string;
  /**
   * Output only. The number of frames that were reported by the source and
   * contained errors.
   */
  readonly errorFrameCount?: number;
  /**
   * If `true`, the source is managed by other service(s).
   */
  managed?: boolean;
  /**
   * Output only. The full name of the source.
   */
  readonly name?: string;
  /**
   * Output only. Number of frames that are still being processed.
   */
  readonly pendingFrameCount?: number;
  /**
   * The information confidence of the source. The higher the value, the higher
   * the confidence.
   */
  priority?: number;
  /**
   * Output only. The state of the source.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "DELETING" | "INVALID";
  /**
   * Data source type.
   */
  type?:  | "SOURCE_TYPE_UNKNOWN" | "SOURCE_TYPE_UPLOAD" | "SOURCE_TYPE_GUEST_OS_SCAN" | "SOURCE_TYPE_INVENTORY_SCAN" | "SOURCE_TYPE_CUSTOM" | "SOURCE_TYPE_DISCOVERY_CLIENT";
  /**
   * Output only. The timestamp when the source was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * Specific details for a Microsoft SQL Server database deployment.
 */
export interface SqlServerDatabaseDeployment {
  /**
   * Optional. List of SQL Server features.
   */
  features?: SqlServerFeature[];
  /**
   * Optional. List of SQL Server server flags.
   */
  serverFlags?: SqlServerServerFlag[];
  /**
   * Optional. List of SQL Server trace flags.
   */
  traceFlags?: SqlServerTraceFlag[];
}

/**
 * SQL Server feature details.
 */
export interface SqlServerFeature {
  /**
   * Required. Field enabled is set when a feature is used on the source
   * deployment.
   */
  enabled?: boolean;
  /**
   * Required. The feature name.
   */
  featureName?: string;
}

/**
 * Specific details for a SqlServer database.
 */
export interface SqlServerSchemaDetails {
  /**
   * Optional. SqlServer number of CLR objects.
   */
  clrObjectCount?: number;
}

/**
 * SQL Server server flag details.
 */
export interface SqlServerServerFlag {
  /**
   * Required. The server flag name.
   */
  serverFlagName?: string;
  /**
   * Required. The server flag value set by the user.
   */
  value?: string;
  /**
   * Required. The server flag actual value. If `value_in_use` is different
   * from `value` it means that either the configuration change was not applied
   * or it is an expected behavior. See SQL Server documentation for more
   * details.
   */
  valueInUse?: string;
}

/**
 * SQL Server trace flag details.
 */
export interface SqlServerTraceFlag {
  /**
   * Required. The trace flag scope.
   */
  scope?:  | "SCOPE_UNSPECIFIED" | "OFF" | "GLOBAL" | "SESSION";
  /**
   * Required. The trace flag name.
   */
  traceFlagName?: 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;
}

/**
 * A request to update an asset.
 */
export interface UpdateAssetRequest {
  /**
   * Required. The resource being updated.
   */
  asset?: Asset;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the `Asset` resource by the update. The values specified in the
   * `update_mask` field are relative to the resource, not the full request. A
   * field will be overwritten if it is in the mask. A single * value in the
   * mask lets you to overwrite all fields.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * A resource that contains a URI to which a data file can be uploaded.
 */
export interface UploadFileInfo {
  /**
   * Output only. The headers that were used to sign the URI.
   */
  readonly headers?: {
    [key: string]: string
  };
  /**
   * Output only. Upload URI for the file.
   */
  readonly signedUri?: string;
  /**
   * Output only. Expiration time of the upload URI.
   */
  readonly uriExpirationTime?: Date;
}

/**
 * A request to validate an import job.
 */
export interface ValidateImportJobRequest {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes after the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
}

/**
 * A resource that aggregates errors across import job files.
 */
export interface ValidationReport {
  /**
   * List of errors found in files.
   */
  fileValidations?: FileValidationReport[];
  /**
   * List of job level errors.
   */
  jobErrors?: ImportError[];
}

/**
 * VirtualMachinePreferences enables you to create sets of assumptions, for
 * example, a geographical location and pricing track, for your migrated virtual
 * machines. The set of preferences influence recommendations for migrating
 * virtual machine assets.
 */
export interface VirtualMachinePreferences {
  /**
   * Commitment plan to consider when calculating costs for virtual machine
   * insights and recommendations. If you are unsure which value to set, a 3
   * year commitment plan is often a good value to start with.
   */
  commitmentPlan?:  | "COMMITMENT_PLAN_UNSPECIFIED" | "COMMITMENT_PLAN_NONE" | "COMMITMENT_PLAN_ONE_YEAR" | "COMMITMENT_PLAN_THREE_YEARS";
  /**
   * Compute Engine preferences concern insights and recommendations for
   * Compute Engine target.
   */
  computeEnginePreferences?: ComputeEnginePreferences;
  /**
   * Region preferences for assets using this preference set. If you are unsure
   * which value to set, the migration service API region is often a good value
   * to start with.
   */
  regionPreferences?: RegionPreferences;
  /**
   * Sizing optimization strategy specifies the preferred strategy used when
   * extrapolating usage data to calculate insights and recommendations for a
   * virtual machine. If you are unsure which value to set, a moderate sizing
   * optimization strategy is often a good value to start with.
   */
  sizingOptimizationStrategy?:  | "SIZING_OPTIMIZATION_STRATEGY_UNSPECIFIED" | "SIZING_OPTIMIZATION_STRATEGY_SAME_AS_SOURCE" | "SIZING_OPTIMIZATION_STRATEGY_MODERATE" | "SIZING_OPTIMIZATION_STRATEGY_AGGRESSIVE";
  /**
   * Preferences concerning Sole Tenant nodes and virtual machines.
   */
  soleTenancyPreferences?: SoleTenancyPreferences;
  /**
   * Target product for assets using this preference set. Specify either target
   * product or business goal, but not both.
   */
  targetProduct?:  | "COMPUTE_MIGRATION_TARGET_PRODUCT_UNSPECIFIED" | "COMPUTE_MIGRATION_TARGET_PRODUCT_COMPUTE_ENGINE" | "COMPUTE_MIGRATION_TARGET_PRODUCT_VMWARE_ENGINE" | "COMPUTE_MIGRATION_TARGET_PRODUCT_SOLE_TENANCY";
  /**
   * Preferences concerning insights and recommendations for Google Cloud
   * VMware Engine.
   */
  vmwareEnginePreferences?: VmwareEnginePreferences;
}

/**
 * VMware disk config details.
 */
export interface VmwareDiskConfig {
  /**
   * VMDK backing type.
   */
  backingType?:  | "BACKING_TYPE_UNSPECIFIED" | "BACKING_TYPE_FLAT_V1" | "BACKING_TYPE_FLAT_V2" | "BACKING_TYPE_PMEM" | "BACKING_TYPE_RDM_V1" | "BACKING_TYPE_RDM_V2" | "BACKING_TYPE_SESPARSE" | "BACKING_TYPE_SESPARSE_V1" | "BACKING_TYPE_SESPARSE_V2";
  /**
   * RDM compatibility mode.
   */
  rdmCompatibility?:  | "RDM_COMPATIBILITY_UNSPECIFIED" | "PHYSICAL_COMPATIBILITY" | "VIRTUAL_COMPATIBILITY";
  /**
   * Is VMDK shared with other VMs.
   */
  shared?: boolean;
  /**
   * VMDK disk mode.
   */
  vmdkMode?:  | "VMDK_MODE_UNSPECIFIED" | "DEPENDENT" | "INDEPENDENT_PERSISTENT" | "INDEPENDENT_NONPERSISTENT";
}

/**
 * The user preferences relating to Google Cloud VMware Engine target platform.
 */
export interface VmwareEnginePreferences {
  /**
   * Commitment plan to consider when calculating costs for virtual machine
   * insights and recommendations. If you are unsure which value to set, a 3
   * year commitment plan is often a good value to start with.
   */
  commitmentPlan?:  | "COMMITMENT_PLAN_UNSPECIFIED" | "ON_DEMAND" | "COMMITMENT_1_YEAR_MONTHLY_PAYMENTS" | "COMMITMENT_3_YEAR_MONTHLY_PAYMENTS" | "COMMITMENT_1_YEAR_UPFRONT_PAYMENT" | "COMMITMENT_3_YEAR_UPFRONT_PAYMENT";
  /**
   * CPU overcommit ratio. Acceptable values are between 1.0 and 8.0, with 0.1
   * increment.
   */
  cpuOvercommitRatio?: number;
  /**
   * Memory overcommit ratio. Acceptable values are 1.0, 1.25, 1.5, 1.75 and
   * 2.0.
   */
  memoryOvercommitRatio?: number;
  /**
   * The Deduplication and Compression ratio is based on the logical (Used
   * Before) space required to store data before applying deduplication and
   * compression, in relation to the physical (Used After) space required after
   * applying deduplication and compression. Specifically, the ratio is the Used
   * Before space divided by the Used After space. For example, if the Used
   * Before space is 3 GB, but the physical Used After space is 1 GB, the
   * deduplication and compression ratio is 3x. Acceptable values are between
   * 1.0 and 4.0.
   */
  storageDeduplicationCompressionRatio?: number;
}

/**
 * VMware specific details.
 */
export interface VmwarePlatformDetails {
  /**
   * Whether the ESX is hyperthreaded.
   */
  esxHyperthreading?:  | "HYPERTHREADING_STATUS_UNSPECIFIED" | "HYPERTHREADING_STATUS_DISABLED" | "HYPERTHREADING_STATUS_ENABLED";
  /**
   * ESX version.
   */
  esxVersion?: string;
  /**
   * VMware os enum -
   * https://vdc-repo.vmware.com/vmwb-repository/dcr-public/da47f910-60ac-438b-8b9b-6122f4d14524/16b7274a-bf8b-4b4c-a05e-746f2aa93c8c/doc/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html.
   */
  osid?: string;
  /**
   * Folder name in vCenter where asset resides.
   */
  vcenterFolder?: string;
  /**
   * vCenter URI used in collection.
   */
  vcenterUri?: string;
  /**
   * vCenter version.
   */
  vcenterVersion?: string;
  /**
   * vCenter VM ID.
   */
  vcenterVmId?: string;
}