// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Network Management API Client for Deno
 * ======================================
 * 
 * The Network Management API provides a collection of network performance monitoring and diagnostic capabilities.
 * 
 * Docs: https://cloud.google.com/
 * Source: https://googleapis.deno.dev/v1/networkmanagement:v1.ts
 */

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

/**
 * The Network Management API provides a collection of network performance
 * monitoring and diagnostic capabilities.
 */
export class NetworkManagement {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

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

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

  /**
   * Creates a new Connectivity Test. After you create a test, the reachability
   * analysis is performed as part of the long running operation, which
   * completes when the analysis completes. If the endpoint specifications in
   * `ConnectivityTest` are invalid (for example, containing non-existent
   * resources in the network, or you don't have read permissions to the network
   * configurations of listed projects), then the reachability result returns a
   * value of `UNKNOWN`. If the endpoint specifications in `ConnectivityTest`
   * are incomplete, the reachability result returns a value of AMBIGUOUS. For
   * more information, see the Connectivity Test documentation.
   *
   * @param parent Required. The parent resource of the Connectivity Test to create: `projects/{project_id}/locations/global`
   */
  async projectsLocationsGlobalConnectivityTestsCreate(parent: string, req: ConnectivityTest, opts: ProjectsLocationsGlobalConnectivityTestsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/connectivityTests`);
    if (opts.testId !== undefined) {
      url.searchParams.append("testId", String(opts.testId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a specific `ConnectivityTest`.
   *
   * @param name Required. Connectivity Test resource name using the form: `projects/{project_id}/locations/global/connectivityTests/{test_id}`
   */
  async projectsLocationsGlobalConnectivityTestsDelete(name: string): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets the details of a specific Connectivity Test.
   *
   * @param name Required. `ConnectivityTest` resource name using the form: `projects/{project_id}/locations/global/connectivityTests/{test_id}`
   */
  async projectsLocationsGlobalConnectivityTestsGet(name: string): Promise<ConnectivityTest> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ConnectivityTest;
  }

  /**
   * Gets the access control policy for a resource. Returns an empty policy if
   * the resource exists and does not have a policy set.
   *
   * @param resource REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
   */
  async projectsLocationsGlobalConnectivityTestsGetIamPolicy(resource: string, opts: ProjectsLocationsGlobalConnectivityTestsGetIamPolicyOptions = {}): Promise<Policy> {
    const url = new URL(`${this.#baseUrl}v1/${ resource }:getIamPolicy`);
    if (opts["options.requestedPolicyVersion"] !== undefined) {
      url.searchParams.append("options.requestedPolicyVersion", String(opts["options.requestedPolicyVersion"]));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializePolicy(data);
  }

  /**
   * Lists all Connectivity Tests owned by a project.
   *
   * @param parent Required. The parent resource of the Connectivity Tests: `projects/{project_id}/locations/global`
   */
  async projectsLocationsGlobalConnectivityTestsList(parent: string, opts: ProjectsLocationsGlobalConnectivityTestsListOptions = {}): Promise<ListConnectivityTestsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/connectivityTests`);
    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 ListConnectivityTestsResponse;
  }

  /**
   * Updates the configuration of an existing `ConnectivityTest`. After you
   * update a test, the reachability analysis is performed as part of the long
   * running operation, which completes when the analysis completes. The
   * Reachability state in the test resource is updated with the new result. If
   * the endpoint specifications in `ConnectivityTest` are invalid (for example,
   * they contain non-existent resources in the network, or the user does not
   * have read permissions to the network configurations of listed projects),
   * then the reachability result returns a value of UNKNOWN. If the endpoint
   * specifications in `ConnectivityTest` are incomplete, the reachability
   * result returns a value of `AMBIGUOUS`. See the documentation in
   * `ConnectivityTest` for for more details.
   *
   * @param name Required. Unique name of the resource using the form: `projects/{project_id}/locations/global/connectivityTests/{test_id}`
   */
  async projectsLocationsGlobalConnectivityTestsPatch(name: string, req: ConnectivityTest, opts: ProjectsLocationsGlobalConnectivityTestsPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsGlobalConnectivityTestsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

  /**
   * Rerun an existing `ConnectivityTest`. After the user triggers the rerun,
   * the reachability analysis is performed as part of the long running
   * operation, which completes when the analysis completes. Even though the
   * test configuration remains the same, the reachability result may change due
   * to underlying network configuration changes. If the endpoint specifications
   * in `ConnectivityTest` become invalid (for example, specified resources are
   * deleted in the network, or you lost read permissions to the network
   * configurations of listed projects), then the reachability result returns a
   * value of `UNKNOWN`.
   *
   * @param name Required. Connectivity Test resource name using the form: `projects/{project_id}/locations/global/connectivityTests/{test_id}`
   */
  async projectsLocationsGlobalConnectivityTestsRerun(name: string, req: RerunConnectivityTestRequest): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:rerun`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Sets the access control policy on the specified resource. Replaces any
   * existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and
   * `PERMISSION_DENIED` errors.
   *
   * @param resource REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
   */
  async projectsLocationsGlobalConnectivityTestsSetIamPolicy(resource: string, req: SetIamPolicyRequest): Promise<Policy> {
    req = serializeSetIamPolicyRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ resource }:setIamPolicy`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializePolicy(data);
  }

  /**
   * Returns permissions that a caller has on the specified resource. If the
   * resource does not exist, this will return an empty set of permissions, not
   * a `NOT_FOUND` error. Note: This operation is designed to be used for
   * building permission-aware UIs and command-line tools, not for authorization
   * checking. This operation may "fail open" without warning.
   *
   * @param resource REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
   */
  async projectsLocationsGlobalConnectivityTestsTestIamPermissions(resource: string, req: TestIamPermissionsRequest): Promise<TestIamPermissionsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ resource }:testIamPermissions`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as TestIamPermissionsResponse;
  }

  /**
   * 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 projectsLocationsGlobalOperationsCancel(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 projectsLocationsGlobalOperationsDelete(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 projectsLocationsGlobalOperationsGet(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 projectsLocationsGlobalOperationsList(name: string, opts: ProjectsLocationsGlobalOperationsListOptions = {}): 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;
  }

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

/**
 * Details of the final state "abort" and associated resource.
 */
export interface AbortInfo {
  /**
   * Causes that the analysis is aborted.
   */
  cause?:  | "CAUSE_UNSPECIFIED" | "UNKNOWN_NETWORK" | "UNKNOWN_IP" | "UNKNOWN_PROJECT" | "PERMISSION_DENIED" | "NO_SOURCE_LOCATION" | "INVALID_ARGUMENT" | "NO_EXTERNAL_IP" | "UNINTENDED_DESTINATION" | "TRACE_TOO_LONG" | "INTERNAL_ERROR" | "SOURCE_ENDPOINT_NOT_FOUND" | "MISMATCHED_SOURCE_NETWORK" | "DESTINATION_ENDPOINT_NOT_FOUND" | "MISMATCHED_DESTINATION_NETWORK" | "UNSUPPORTED" | "MISMATCHED_IP_VERSION" | "GKE_KONNECTIVITY_PROXY_UNSUPPORTED" | "RESOURCE_CONFIG_NOT_FOUND";
  /**
   * List of project IDs that the user has specified in the request but does
   * not have permission to access network configs. Analysis is aborted in this
   * case with the PERMISSION_DENIED cause.
   */
  projectsMissingPermission?: string[];
  /**
   * URI of the resource that caused the abort.
   */
  resourceUri?: string;
}

/**
 * Wrapper for the App Engine service version attributes.
 */
export interface AppEngineVersionEndpoint {
  /**
   * An [App Engine](https://cloud.google.com/appengine) [service
   * version](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions)
   * name.
   */
  uri?: string;
}

/**
 * For display only. Metadata associated with an App Engine version.
 */
export interface AppEngineVersionInfo {
  /**
   * Name of an App Engine version.
   */
  displayName?: string;
  /**
   * App Engine execution environment for a version.
   */
  environment?: string;
  /**
   * Runtime of the App Engine version.
   */
  runtime?: string;
  /**
   * URI of an App Engine version.
   */
  uri?: string;
}

/**
 * Specifies the audit configuration for a service. The configuration
 * determines which permission types are logged, and what identities, if any,
 * are exempted from logging. An AuditConfig must have one or more
 * AuditLogConfigs. If there are AuditConfigs for both `allServices` and a
 * specific service, the union of the two AuditConfigs is used for that service:
 * the log_types specified in each AuditConfig are enabled, and the
 * exempted_members in each AuditLogConfig are exempted. Example Policy with
 * multiple AuditConfigs: { "audit_configs": [ { "service": "allServices",
 * "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [
 * "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type":
 * "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com",
 * "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type":
 * "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For
 * sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ
 * logging. It also exempts `jose@example.com` from DATA_READ logging, and
 * `aliya@example.com` from DATA_WRITE logging.
 */
export interface AuditConfig {
  /**
   * The configuration for logging of each type of permission.
   */
  auditLogConfigs?: AuditLogConfig[];
  /**
   * Specifies a service that will be enabled for audit logging. For example,
   * `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a
   * special value that covers all services.
   */
  service?: string;
}

/**
 * Provides the configuration for logging a type of permissions. Example: {
 * "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [
 * "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables
 * 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from
 * DATA_READ logging.
 */
export interface AuditLogConfig {
  /**
   * Specifies the identities that do not cause logging for this type of
   * permission. Follows the same format of Binding.members.
   */
  exemptedMembers?: string[];
  /**
   * The log type that this config enables.
   */
  logType?:  | "LOG_TYPE_UNSPECIFIED" | "ADMIN_READ" | "DATA_WRITE" | "DATA_READ";
}

/**
 * Associates `members`, or principals, with a `role`.
 */
export interface Binding {
  /**
   * The condition that is associated with this binding. If the condition
   * evaluates to `true`, then this binding applies to the current request. If
   * the condition evaluates to `false`, then this binding does not apply to the
   * current request. However, a different role binding might grant the same
   * role to one or more of the principals in this binding. To learn which
   * resources support conditions in their IAM policies, see the [IAM
   * documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
   */
  condition?: Expr;
  /**
   * Specifies the principals requesting access for a Google Cloud resource.
   * `members` can have the following values: * `allUsers`: A special identifier
   * that represents anyone who is on the internet; with or without a Google
   * account. * `allAuthenticatedUsers`: A special identifier that represents
   * anyone who is authenticated with a Google account or a service account.
   * Does not include identities that come from external identity providers
   * (IdPs) through identity federation. * `user:{emailid}`: An email address
   * that represents a specific Google account. For example, `alice@example.com`
   * . * `serviceAccount:{emailid}`: An email address that represents a Google
   * service account. For example, `my-other-app@appspot.gserviceaccount.com`. *
   * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An
   * identifier for a [Kubernetes service
   * account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts).
   * For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. *
   * `group:{emailid}`: An email address that represents a Google group. For
   * example, `admins@example.com`. * `domain:{domain}`: The G Suite domain
   * (primary) that represents all the users of that domain. For example,
   * `google.com` or `example.com`. * `deleted:user:{emailid}?uid={uniqueid}`:
   * An email address (plus unique identifier) representing a user that has been
   * recently deleted. For example,
   * `alice@example.com?uid=123456789012345678901`. If the user is recovered,
   * this value reverts to `user:{emailid}` and the recovered user retains the
   * role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`:
   * An email address (plus unique identifier) representing a service account
   * that has been recently deleted. For example,
   * `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If
   * the service account is undeleted, this value reverts to
   * `serviceAccount:{emailid}` and the undeleted service account retains the
   * role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email
   * address (plus unique identifier) representing a Google group that has been
   * recently deleted. For example,
   * `admins@example.com?uid=123456789012345678901`. If the group is recovered,
   * this value reverts to `group:{emailid}` and the recovered group retains the
   * role in the binding.
   */
  members?: string[];
  /**
   * Role that is assigned to the list of `members`, or principals. For
   * example, `roles/viewer`, `roles/editor`, or `roles/owner`.
   */
  role?: string;
}

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

/**
 * Wrapper for Cloud Function attributes.
 */
export interface CloudFunctionEndpoint {
  /**
   * A [Cloud Function](https://cloud.google.com/functions) name.
   */
  uri?: string;
}

/**
 * For display only. Metadata associated with a Cloud Function.
 */
export interface CloudFunctionInfo {
  /**
   * Name of a Cloud Function.
   */
  displayName?: string;
  /**
   * Location in which the Cloud Function is deployed.
   */
  location?: string;
  /**
   * URI of a Cloud Function.
   */
  uri?: string;
  /**
   * Latest successfully deployed version id of the Cloud Function.
   */
  versionId?: bigint;
}

function serializeCloudFunctionInfo(data: any): CloudFunctionInfo {
  return {
    ...data,
    versionId: data["versionId"] !== undefined ? String(data["versionId"]) : undefined,
  };
}

function deserializeCloudFunctionInfo(data: any): CloudFunctionInfo {
  return {
    ...data,
    versionId: data["versionId"] !== undefined ? BigInt(data["versionId"]) : undefined,
  };
}

/**
 * Wrapper for Cloud Run revision attributes.
 */
export interface CloudRunRevisionEndpoint {
  /**
   * A [Cloud Run](https://cloud.google.com/run)
   * [revision](https://cloud.google.com/run/docs/reference/rest/v1/namespaces.revisions/get)
   * URI. The format is:
   * projects/{project}/locations/{location}/revisions/{revision}
   */
  uri?: string;
}

/**
 * For display only. Metadata associated with a Cloud Run revision.
 */
export interface CloudRunRevisionInfo {
  /**
   * Name of a Cloud Run revision.
   */
  displayName?: string;
  /**
   * Location in which this revision is deployed.
   */
  location?: string;
  /**
   * URI of Cloud Run service this revision belongs to.
   */
  serviceUri?: string;
  /**
   * URI of a Cloud Run revision.
   */
  uri?: string;
}

/**
 * For display only. Metadata associated with a Cloud SQL instance.
 */
export interface CloudSQLInstanceInfo {
  /**
   * Name of a Cloud SQL instance.
   */
  displayName?: string;
  /**
   * External IP address of a Cloud SQL instance.
   */
  externalIp?: string;
  /**
   * Internal IP address of a Cloud SQL instance.
   */
  internalIp?: string;
  /**
   * URI of a Cloud SQL instance network or empty string if the instance does
   * not have one.
   */
  networkUri?: string;
  /**
   * Region in which the Cloud SQL instance is running.
   */
  region?: string;
  /**
   * URI of a Cloud SQL instance.
   */
  uri?: string;
}

/**
 * A Connectivity Test for a network reachability analysis.
 */
export interface ConnectivityTest {
  /**
   * Output only. The time the test was created.
   */
  readonly createTime?: Date;
  /**
   * The user-supplied description of the Connectivity Test. Maximum of 512
   * characters.
   */
  description?: string;
  /**
   * Required. Destination specification of the Connectivity Test. You can use
   * a combination of destination IP address, Compute Engine VM instance, or VPC
   * network to uniquely identify the destination location. Even if the
   * destination IP address is not unique, the source IP location is unique.
   * Usually, the analysis can infer the destination endpoint from route
   * information. If the destination you specify is a VM instance and the
   * instance has multiple network interfaces, then you must also specify either
   * a destination IP address or VPC network to identify the destination
   * interface. A reachability analysis proceeds even if the destination
   * location is ambiguous. However, the result can include endpoints that you
   * don't intend to test.
   */
  destination?: Endpoint;
  /**
   * Output only. The display name of a Connectivity Test.
   */
  readonly displayName?: string;
  /**
   * Resource labels to represent user-provided metadata.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Required. Unique name of the resource using the form:
   * `projects/{project_id}/locations/global/connectivityTests/{test_id}`
   */
  name?: string;
  /**
   * IP Protocol of the test. When not provided, "TCP" is assumed.
   */
  protocol?: string;
  /**
   * Output only. The reachability details of this test from the latest run.
   * The details are updated when creating a new test, updating an existing
   * test, or triggering a one-time rerun of an existing test.
   */
  readonly reachabilityDetails?: ReachabilityDetails;
  /**
   * Other projects that may be relevant for reachability analysis. This is
   * applicable to scenarios where a test can cross project boundaries.
   */
  relatedProjects?: string[];
  /**
   * Required. Source specification of the Connectivity Test. You can use a
   * combination of source IP address, virtual machine (VM) instance, or Compute
   * Engine network to uniquely identify the source location. Examples: If the
   * source IP address is an internal IP address within a Google Cloud Virtual
   * Private Cloud (VPC) network, then you must also specify the VPC network.
   * Otherwise, specify the VM instance, which already contains its internal IP
   * address and VPC network information. If the source of the test is within an
   * on-premises network, then you must provide the destination VPC network. If
   * the source endpoint is a Compute Engine VM instance with multiple network
   * interfaces, the instance itself is not sufficient to identify the endpoint.
   * So, you must also specify the source IP address or VPC network. A
   * reachability analysis proceeds even if the source location is ambiguous.
   * However, the test result may include endpoints that you don't intend to
   * test.
   */
  source?: Endpoint;
  /**
   * Output only. The time the test's configuration was updated.
   */
  readonly updateTime?: Date;
}

/**
 * Details of the final state "deliver" and associated resource.
 */
export interface DeliverInfo {
  /**
   * URI of the resource that the packet is delivered to.
   */
  resourceUri?: string;
  /**
   * Target type where the packet is delivered to.
   */
  target?:  | "TARGET_UNSPECIFIED" | "INSTANCE" | "INTERNET" | "GOOGLE_API" | "GKE_MASTER" | "CLOUD_SQL_INSTANCE" | "PSC_PUBLISHED_SERVICE" | "PSC_GOOGLE_API" | "PSC_VPC_SC";
}

/**
 * Details of the final state "drop" and associated resource.
 */
export interface DropInfo {
  /**
   * Cause that the packet is dropped.
   */
  cause?:  | "CAUSE_UNSPECIFIED" | "UNKNOWN_EXTERNAL_ADDRESS" | "FOREIGN_IP_DISALLOWED" | "FIREWALL_RULE" | "NO_ROUTE" | "ROUTE_BLACKHOLE" | "ROUTE_WRONG_NETWORK" | "PRIVATE_TRAFFIC_TO_INTERNET" | "PRIVATE_GOOGLE_ACCESS_DISALLOWED" | "NO_EXTERNAL_ADDRESS" | "UNKNOWN_INTERNAL_ADDRESS" | "FORWARDING_RULE_MISMATCH" | "FORWARDING_RULE_REGION_MISMATCH" | "FORWARDING_RULE_NO_INSTANCES" | "FIREWALL_BLOCKING_LOAD_BALANCER_BACKEND_HEALTH_CHECK" | "INSTANCE_NOT_RUNNING" | "GKE_CLUSTER_NOT_RUNNING" | "CLOUD_SQL_INSTANCE_NOT_RUNNING" | "TRAFFIC_TYPE_BLOCKED" | "GKE_MASTER_UNAUTHORIZED_ACCESS" | "CLOUD_SQL_INSTANCE_UNAUTHORIZED_ACCESS" | "DROPPED_INSIDE_GKE_SERVICE" | "DROPPED_INSIDE_CLOUD_SQL_SERVICE" | "GOOGLE_MANAGED_SERVICE_NO_PEERING" | "GOOGLE_MANAGED_SERVICE_NO_PSC_ENDPOINT" | "GKE_PSC_ENDPOINT_MISSING" | "CLOUD_SQL_INSTANCE_NO_IP_ADDRESS" | "GKE_CONTROL_PLANE_REGION_MISMATCH" | "PUBLIC_GKE_CONTROL_PLANE_TO_PRIVATE_DESTINATION" | "GKE_CONTROL_PLANE_NO_ROUTE" | "CLOUD_SQL_INSTANCE_NOT_CONFIGURED_FOR_EXTERNAL_TRAFFIC" | "PUBLIC_CLOUD_SQL_INSTANCE_TO_PRIVATE_DESTINATION" | "CLOUD_SQL_INSTANCE_NO_ROUTE" | "CLOUD_FUNCTION_NOT_ACTIVE" | "VPC_CONNECTOR_NOT_SET" | "VPC_CONNECTOR_NOT_RUNNING" | "PSC_CONNECTION_NOT_ACCEPTED" | "CLOUD_RUN_REVISION_NOT_READY" | "DROPPED_INSIDE_PSC_SERVICE_PRODUCER" | "LOAD_BALANCER_HAS_NO_PROXY_SUBNET";
  /**
   * URI of the resource that caused the drop.
   */
  resourceUri?: string;
}

/**
 * A generic empty message that you can re-use to avoid defining duplicated
 * empty messages in your APIs. A typical example is to use it as the request or
 * the response type of an API method. For instance: service Foo { rpc
 * Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
 */
export interface Empty {
}

/**
 * Source or destination of the Connectivity Test.
 */
export interface Endpoint {
  /**
   * An [App Engine](https://cloud.google.com/appengine) [service
   * version](https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions).
   */
  appEngineVersion?: AppEngineVersionEndpoint;
  /**
   * A [Cloud Function](https://cloud.google.com/functions).
   */
  cloudFunction?: CloudFunctionEndpoint;
  /**
   * A [Cloud Run](https://cloud.google.com/run)
   * [revision](https://cloud.google.com/run/docs/reference/rest/v1/namespaces.revisions/get)
   */
  cloudRunRevision?: CloudRunRevisionEndpoint;
  /**
   * A [Cloud SQL](https://cloud.google.com/sql) instance URI.
   */
  cloudSqlInstance?: string;
  /**
   * A cluster URI for [Google Kubernetes Engine
   * master](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture).
   */
  gkeMasterCluster?: string;
  /**
   * A Compute Engine instance URI.
   */
  instance?: string;
  /**
   * The IP address of the endpoint, which can be an external or internal IP.
   * An IPv6 address is only allowed when the test's destination is a [global
   * load balancer VIP](/load-balancing/docs/load-balancing-overview).
   */
  ipAddress?: string;
  /**
   * A Compute Engine network URI.
   */
  network?: string;
  /**
   * Type of the network where the endpoint is located. Applicable only to
   * source endpoint, as destination network type can be inferred from the
   * source.
   */
  networkType?:  | "NETWORK_TYPE_UNSPECIFIED" | "GCP_NETWORK" | "NON_GCP_NETWORK";
  /**
   * The IP protocol port of the endpoint. Only applicable when protocol is TCP
   * or UDP.
   */
  port?: number;
  /**
   * Project ID where the endpoint is located. The Project ID can be derived
   * from the URI if you provide a VM instance or network URI. The following are
   * two cases where you must provide the project ID: 1. Only the IP address is
   * specified, and the IP address is within a Google Cloud project. 2. When you
   * are using Shared VPC and the IP address that you provide is from the
   * service project. In this case, the network that the IP address resides in
   * is defined in the host project.
   */
  projectId?: string;
}

/**
 * For display only. The specification of the endpoints for the test.
 * EndpointInfo is derived from source and destination Endpoint and validated by
 * the backend data plane model.
 */
export interface EndpointInfo {
  /**
   * Destination IP address.
   */
  destinationIp?: string;
  /**
   * URI of the network where this packet is sent to.
   */
  destinationNetworkUri?: string;
  /**
   * Destination port. Only valid when protocol is TCP or UDP.
   */
  destinationPort?: number;
  /**
   * IP protocol in string format, for example: "TCP", "UDP", "ICMP".
   */
  protocol?: string;
  /**
   * Source IP address.
   */
  sourceIp?: string;
  /**
   * URI of the network where this packet originates from.
   */
  sourceNetworkUri?: string;
  /**
   * Source port. Only valid when protocol is TCP or UDP.
   */
  sourcePort?: number;
}

/**
 * Represents a textual expression in the Common Expression Language (CEL)
 * syntax. CEL is a C-like expression language. The syntax and semantics of CEL
 * are documented at https://github.com/google/cel-spec. Example (Comparison):
 * title: "Summary size limit" description: "Determines if a summary is less
 * than 100 chars" expression: "document.summary.size() < 100" Example
 * (Equality): title: "Requestor is owner" description: "Determines if requestor
 * is the document owner" expression: "document.owner ==
 * request.auth.claims.email" Example (Logic): title: "Public documents"
 * description: "Determine whether the document should be publicly visible"
 * expression: "document.type != 'private' && document.type != 'internal'"
 * Example (Data Manipulation): title: "Notification string" description:
 * "Create a notification string with a timestamp." expression: "'New message
 * received at ' + string(document.create_time)" The exact variables and
 * functions that may be referenced within an expression are determined by the
 * service that evaluates it. See the service documentation for additional
 * information.
 */
export interface Expr {
  /**
   * Optional. Description of the expression. This is a longer text which
   * describes the expression, e.g. when hovered over it in a UI.
   */
  description?: string;
  /**
   * Textual representation of an expression in Common Expression Language
   * syntax.
   */
  expression?: string;
  /**
   * Optional. String indicating the location of the expression for error
   * reporting, e.g. a file name and a position in the file.
   */
  location?: string;
  /**
   * Optional. Title for the expression, i.e. a short string describing its
   * purpose. This can be used e.g. in UIs which allow to enter the expression.
   */
  title?: string;
}

/**
 * For display only. Metadata associated with a VPC firewall rule, an implied
 * VPC firewall rule, or a hierarchical firewall policy rule.
 */
export interface FirewallInfo {
  /**
   * Possible values: ALLOW, DENY
   */
  action?: string;
  /**
   * Possible values: INGRESS, EGRESS
   */
  direction?: string;
  /**
   * The display name of the VPC firewall rule. This field is not applicable to
   * hierarchical firewall policy rules.
   */
  displayName?: string;
  /**
   * The firewall rule's type.
   */
  firewallRuleType?:  | "FIREWALL_RULE_TYPE_UNSPECIFIED" | "HIERARCHICAL_FIREWALL_POLICY_RULE" | "VPC_FIREWALL_RULE" | "IMPLIED_VPC_FIREWALL_RULE" | "SERVERLESS_VPC_ACCESS_MANAGED_FIREWALL_RULE" | "NETWORK_FIREWALL_POLICY_RULE";
  /**
   * The URI of the VPC network that the firewall rule is associated with. This
   * field is not applicable to hierarchical firewall policy rules.
   */
  networkUri?: string;
  /**
   * The hierarchical firewall policy that this rule is associated with. This
   * field is not applicable to VPC firewall rules.
   */
  policy?: string;
  /**
   * The priority of the firewall rule.
   */
  priority?: number;
  /**
   * The target service accounts specified by the firewall rule.
   */
  targetServiceAccounts?: string[];
  /**
   * The target tags defined by the VPC firewall rule. This field is not
   * applicable to hierarchical firewall policy rules.
   */
  targetTags?: string[];
  /**
   * The URI of the VPC firewall rule. This field is not applicable to implied
   * firewall rules or hierarchical firewall policy rules.
   */
  uri?: string;
}

/**
 * Details of the final state "forward" and associated resource.
 */
export interface ForwardInfo {
  /**
   * URI of the resource that the packet is forwarded to.
   */
  resourceUri?: string;
  /**
   * Target type where this packet is forwarded to.
   */
  target?:  | "TARGET_UNSPECIFIED" | "PEERING_VPC" | "VPN_GATEWAY" | "INTERCONNECT" | "GKE_MASTER" | "IMPORTED_CUSTOM_ROUTE_NEXT_HOP" | "CLOUD_SQL_INSTANCE" | "ANOTHER_PROJECT";
}

/**
 * For display only. Metadata associated with a Compute Engine forwarding rule.
 */
export interface ForwardingRuleInfo {
  /**
   * Name of a Compute Engine forwarding rule.
   */
  displayName?: string;
  /**
   * Port range defined in the forwarding rule that matches the test.
   */
  matchedPortRange?: string;
  /**
   * Protocol defined in the forwarding rule that matches the test.
   */
  matchedProtocol?: string;
  /**
   * Network URI. Only valid for Internal Load Balancer.
   */
  networkUri?: string;
  /**
   * Target type of the forwarding rule.
   */
  target?: string;
  /**
   * URI of a Compute Engine forwarding rule.
   */
  uri?: string;
  /**
   * VIP of the forwarding rule.
   */
  vip?: string;
}

/**
 * For display only. Metadata associated with a Google Kubernetes Engine (GKE)
 * cluster master.
 */
export interface GKEMasterInfo {
  /**
   * URI of a GKE cluster network.
   */
  clusterNetworkUri?: string;
  /**
   * URI of a GKE cluster.
   */
  clusterUri?: string;
  /**
   * External IP address of a GKE cluster master.
   */
  externalIp?: string;
  /**
   * Internal IP address of a GKE cluster master.
   */
  internalIp?: string;
}

/**
 * For display only. Details of a Google Service sending packets to a VPC
 * network. Although the source IP might be a publicly routable address, some
 * Google Services use special routes within Google production infrastructure to
 * reach Compute Engine Instances.
 * https://cloud.google.com/vpc/docs/routes#special_return_paths
 */
export interface GoogleServiceInfo {
  /**
   * Recognized type of a Google Service.
   */
  googleServiceType?:  | "GOOGLE_SERVICE_TYPE_UNSPECIFIED" | "IAP" | "GFE_PROXY_OR_HEALTH_CHECK_PROBER" | "CLOUD_DNS";
  /**
   * Source IP address.
   */
  sourceIp?: string;
}

/**
 * For display only. Metadata associated with a Compute Engine instance.
 */
export interface InstanceInfo {
  /**
   * Name of a Compute Engine instance.
   */
  displayName?: string;
  /**
   * External IP address of the network interface.
   */
  externalIp?: string;
  /**
   * Name of the network interface of a Compute Engine instance.
   */
  interface?: string;
  /**
   * Internal IP address of the network interface.
   */
  internalIp?: string;
  /**
   * Network tags configured on the instance.
   */
  networkTags?: string[];
  /**
   * URI of a Compute Engine network.
   */
  networkUri?: string;
  /**
   * Service account authorized for the instance.
   */
  serviceAccount?: string;
  /**
   * URI of a Compute Engine instance.
   */
  uri?: string;
}

/**
 * Response for the `ListConnectivityTests` method.
 */
export interface ListConnectivityTestsResponse {
  /**
   * Page token to fetch the next set of Connectivity Tests.
   */
  nextPageToken?: string;
  /**
   * List of Connectivity Tests.
   */
  resources?: ConnectivityTest[];
  /**
   * Locations that could not be reached (when querying all locations with
   * `-`).
   */
  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[];
}

/**
 * For display only. Metadata associated with a specific load balancer backend.
 */
export interface LoadBalancerBackend {
  /**
   * Name of a Compute Engine instance or network endpoint.
   */
  displayName?: string;
  /**
   * A list of firewall rule URIs allowing probes from health check IP ranges.
   */
  healthCheckAllowingFirewallRules?: string[];
  /**
   * A list of firewall rule URIs blocking probes from health check IP ranges.
   */
  healthCheckBlockingFirewallRules?: string[];
  /**
   * State of the health check firewall configuration.
   */
  healthCheckFirewallState?:  | "HEALTH_CHECK_FIREWALL_STATE_UNSPECIFIED" | "CONFIGURED" | "MISCONFIGURED";
  /**
   * URI of a Compute Engine instance or network endpoint.
   */
  uri?: string;
}

/**
 * For display only. Metadata associated with a load balancer.
 */
export interface LoadBalancerInfo {
  /**
   * Information for the loadbalancer backends.
   */
  backends?: LoadBalancerBackend[];
  /**
   * Type of load balancer's backend configuration.
   */
  backendType?:  | "BACKEND_TYPE_UNSPECIFIED" | "BACKEND_SERVICE" | "TARGET_POOL" | "TARGET_INSTANCE";
  /**
   * Backend configuration URI.
   */
  backendUri?: string;
  /**
   * URI of the health check for the load balancer.
   */
  healthCheckUri?: string;
  /**
   * Type of the load balancer.
   */
  loadBalancerType?:  | "LOAD_BALANCER_TYPE_UNSPECIFIED" | "INTERNAL_TCP_UDP" | "NETWORK_TCP_UDP" | "HTTP_PROXY" | "TCP_PROXY" | "SSL_PROXY";
}

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

/**
 * For display only. Metadata associated with a Compute Engine network.
 */
export interface NetworkInfo {
  /**
   * Name of a Compute Engine network.
   */
  displayName?: string;
  /**
   * The IP range that matches the test.
   */
  matchedIpRange?: string;
  /**
   * URI of a Compute Engine network.
   */
  uri?: string;
}

/**
 * This resource represents a long-running operation that is the result of a
 * network API call.
 */
export interface Operation {
  /**
   * If the value is `false`, it means the operation is still in progress. If
   * `true`, the operation is completed, and either `error` or `response` is
   * available.
   */
  done?: boolean;
  /**
   * The error result of the operation in case of failure or cancellation.
   */
  error?: Status;
  /**
   * Service-specific metadata associated with the operation. It typically
   * contains progress information and common metadata such as create time. Some
   * services might not provide such metadata. Any method that returns a
   * long-running operation should document the metadata type, if any.
   */
  metadata?: {
    [key: string]: any
  };
  /**
   * The server-assigned name, which is only unique within the same service
   * that originally returns it. If you use the default HTTP mapping, the `name`
   * should be a resource name ending with `operations/{unique_id}`.
   */
  name?: string;
  /**
   * The normal response of the operation in case of success. 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
  };
}

/**
 * Metadata describing an Operation
 */
export interface OperationMetadata {
  /**
   * API version.
   */
  apiVersion?: string;
  /**
   * Specifies if cancellation was requested for the operation.
   */
  cancelRequested?: boolean;
  /**
   * The time the operation was created.
   */
  createTime?: Date;
  /**
   * The time the operation finished running.
   */
  endTime?: Date;
  /**
   * Human-readable status of the operation, if any.
   */
  statusDetail?: string;
  /**
   * Target of the operation - for example
   * projects/project-1/locations/global/connectivityTests/test-1
   */
  target?: string;
  /**
   * Name of the verb executed by the operation.
   */
  verb?: string;
}

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

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

/**
 * An Identity and Access Management (IAM) policy, which specifies access
 * controls for Google Cloud resources. A `Policy` is a collection of
 * `bindings`. A `binding` binds one or more `members`, or principals, to a
 * single `role`. Principals can be user accounts, service accounts, Google
 * groups, and domains (such as G Suite). A `role` is a named list of
 * permissions; each `role` can be an IAM predefined role or a user-created
 * custom role. For some types of Google Cloud resources, a `binding` can also
 * specify a `condition`, which is a logical expression that allows access to a
 * resource only if the expression evaluates to `true`. A condition can add
 * constraints based on attributes of the request, the resource, or both. To
 * learn which resources support conditions in their IAM policies, see the [IAM
 * documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
 * **JSON example:** { "bindings": [ { "role":
 * "roles/resourcemanager.organizationAdmin", "members": [
 * "user:mike@example.com", "group:admins@example.com", "domain:google.com",
 * "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role":
 * "roles/resourcemanager.organizationViewer", "members": [
 * "user:eve@example.com" ], "condition": { "title": "expirable access",
 * "description": "Does not grant access after Sep 2020", "expression":
 * "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag":
 * "BwWWja0YfJA=", "version": 3 } **YAML example:** bindings: - members: -
 * user:mike@example.com - group:admins@example.com - domain:google.com -
 * serviceAccount:my-project-id@appspot.gserviceaccount.com role:
 * roles/resourcemanager.organizationAdmin - members: - user:eve@example.com
 * role: roles/resourcemanager.organizationViewer condition: title: expirable
 * access description: Does not grant access after Sep 2020 expression:
 * request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA=
 * version: 3 For a description of IAM and its features, see the [IAM
 * documentation](https://cloud.google.com/iam/docs/).
 */
export interface Policy {
  /**
   * Specifies cloud audit logging configuration for this policy.
   */
  auditConfigs?: AuditConfig[];
  /**
   * Associates a list of `members`, or principals, with a `role`. Optionally,
   * may specify a `condition` that determines how and when the `bindings` are
   * applied. Each of the `bindings` must contain at least one principal. The
   * `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of
   * these principals can be Google groups. Each occurrence of a principal
   * counts towards these limits. For example, if the `bindings` grant 50
   * different roles to `user:alice@example.com`, and not to any other
   * principal, then you can add another 1,450 principals to the `bindings` in
   * the `Policy`.
   */
  bindings?: Binding[];
  /**
   * `etag` is used for optimistic concurrency control as a way to help prevent
   * simultaneous updates of a policy from overwriting each other. It is
   * strongly suggested that systems make use of the `etag` in the
   * read-modify-write cycle to perform policy updates in order to avoid race
   * conditions: An `etag` is returned in the response to `getIamPolicy`, and
   * systems are expected to put that etag in the request to `setIamPolicy` to
   * ensure that their change will be applied to the same version of the policy.
   * **Important:** If you use IAM Conditions, you must include the `etag` field
   * whenever you call `setIamPolicy`. If you omit this field, then IAM allows
   * you to overwrite a version `3` policy with a version `1` policy, and all of
   * the conditions in the version `3` policy are lost.
   */
  etag?: Uint8Array;
  /**
   * Specifies the format of the policy. Valid values are `0`, `1`, and `3`.
   * Requests that specify an invalid value are rejected. Any operation that
   * affects conditional role bindings must specify version `3`. This
   * requirement applies to the following operations: * Getting a policy that
   * includes a conditional role binding * Adding a conditional role binding to
   * a policy * Changing a conditional role binding in a policy * Removing any
   * role binding, with or without a condition, from a policy that includes
   * conditions **Important:** If you use IAM Conditions, you must include the
   * `etag` field whenever you call `setIamPolicy`. If you omit this field, then
   * IAM allows you to overwrite a version `3` policy with a version `1` policy,
   * and all of the conditions in the version `3` policy are lost. If a policy
   * does not include any conditions, operations on that policy may specify any
   * valid version or leave the field unset. To learn which resources support
   * conditions in their IAM policies, see the [IAM
   * documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
   */
  version?: number;
}

function serializePolicy(data: any): Policy {
  return {
    ...data,
    etag: data["etag"] !== undefined ? encodeBase64(data["etag"]) : undefined,
  };
}

function deserializePolicy(data: any): Policy {
  return {
    ...data,
    etag: data["etag"] !== undefined ? decodeBase64(data["etag"] as string) : undefined,
  };
}

/**
 * Additional options for
 * NetworkManagement#projectsLocationsGlobalConnectivityTestsCreate.
 */
export interface ProjectsLocationsGlobalConnectivityTestsCreateOptions {
  /**
   * Required. The logical name of the Connectivity Test in your project with
   * the following restrictions: * Must contain only lowercase letters, numbers,
   * and hyphens. * Must start with a letter. * Must be between 1-40 characters.
   * * Must end with a number or a letter. * Must be unique within the customer
   * project
   */
  testId?: string;
}

/**
 * Additional options for
 * NetworkManagement#projectsLocationsGlobalConnectivityTestsGetIamPolicy.
 */
export interface ProjectsLocationsGlobalConnectivityTestsGetIamPolicyOptions {
  /**
   * Optional. The maximum policy version that will be used to format the
   * policy. Valid values are 0, 1, and 3. Requests specifying an invalid value
   * will be rejected. Requests for policies with any conditional role bindings
   * must specify version 3. Policies with no conditional role bindings may
   * specify any valid value or leave the field unset. The policy in the
   * response might use the policy version that you specified, or it might use a
   * lower policy version. For example, if you specify version 3, but the policy
   * has no conditional role bindings, the response uses version 1. To learn
   * which resources support conditions in their IAM policies, see the [IAM
   * documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
   */
  ["options.requestedPolicyVersion"]?: number;
}

/**
 * Additional options for
 * NetworkManagement#projectsLocationsGlobalConnectivityTestsList.
 */
export interface ProjectsLocationsGlobalConnectivityTestsListOptions {
  /**
   * Lists the `ConnectivityTests` that match the filter expression. A filter
   * expression filters the resources listed in the response. The expression
   * must be of the form ` ` where operators: `<`, `>`, `<=`, `>=`, `!=`, `=`,
   * `:` are supported (colon `:` represents a HAS operator which is roughly
   * synonymous with equality). can refer to a proto or JSON field, or a
   * synthetic field. Field names can be camelCase or snake_case. Examples: -
   * Filter by name: name =
   * "projects/proj-1/locations/global/connectivityTests/test-1 - Filter by
   * labels: - Resources that have a key called `foo` labels.foo:* - Resources
   * that have a key called `foo` whose value is `bar` labels.foo = bar
   */
  filter?: string;
  /**
   * Field to use to sort the list.
   */
  orderBy?: string;
  /**
   * Number of `ConnectivityTests` to return.
   */
  pageSize?: number;
  /**
   * Page token from an earlier query, as returned in `next_page_token`.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkManagement#projectsLocationsGlobalConnectivityTestsPatch.
 */
export interface ProjectsLocationsGlobalConnectivityTestsPatchOptions {
  /**
   * Required. Mask of fields to update. At least one path must be supplied in
   * this field.
   */
  updateMask?: string /* FieldMask */;
}

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

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

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

/**
 * Additional options for NetworkManagement#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;
}

/**
 * Results of the configuration analysis from the last run of the test.
 */
export interface ReachabilityDetails {
  /**
   * The details of a failure or a cancellation of reachability analysis.
   */
  error?: Status;
  /**
   * The overall result of the test's configuration analysis.
   */
  result?:  | "RESULT_UNSPECIFIED" | "REACHABLE" | "UNREACHABLE" | "AMBIGUOUS" | "UNDETERMINED";
  /**
   * Result may contain a list of traces if a test has multiple possible paths
   * in the network, such as when destination endpoint is a load balancer with
   * multiple backends.
   */
  traces?: Trace[];
  /**
   * The time of the configuration analysis.
   */
  verifyTime?: Date;
}

function serializeReachabilityDetails(data: any): ReachabilityDetails {
  return {
    ...data,
    traces: data["traces"] !== undefined ? data["traces"].map((item: any) => (serializeTrace(item))) : undefined,
    verifyTime: data["verifyTime"] !== undefined ? data["verifyTime"].toISOString() : undefined,
  };
}

function deserializeReachabilityDetails(data: any): ReachabilityDetails {
  return {
    ...data,
    traces: data["traces"] !== undefined ? data["traces"].map((item: any) => (deserializeTrace(item))) : undefined,
    verifyTime: data["verifyTime"] !== undefined ? new Date(data["verifyTime"]) : undefined,
  };
}

/**
 * Request for the `RerunConnectivityTest` method.
 */
export interface RerunConnectivityTestRequest {
}

/**
 * For display only. Metadata associated with a Compute Engine route.
 */
export interface RouteInfo {
  /**
   * Destination IP range of the route.
   */
  destIpRange?: string;
  /**
   * Destination port ranges of the route. Policy based routes only.
   */
  destPortRanges?: string[];
  /**
   * Name of a Compute Engine route.
   */
  displayName?: string;
  /**
   * Instance tags of the route.
   */
  instanceTags?: string[];
  /**
   * URI of a Compute Engine network.
   */
  networkUri?: string;
  /**
   * Next hop of the route.
   */
  nextHop?: string;
  /**
   * Type of next hop.
   */
  nextHopType?:  | "NEXT_HOP_TYPE_UNSPECIFIED" | "NEXT_HOP_IP" | "NEXT_HOP_INSTANCE" | "NEXT_HOP_NETWORK" | "NEXT_HOP_PEERING" | "NEXT_HOP_INTERCONNECT" | "NEXT_HOP_VPN_TUNNEL" | "NEXT_HOP_VPN_GATEWAY" | "NEXT_HOP_INTERNET_GATEWAY" | "NEXT_HOP_BLACKHOLE" | "NEXT_HOP_ILB" | "NEXT_HOP_ROUTER_APPLIANCE";
  /**
   * Priority of the route.
   */
  priority?: number;
  /**
   * Protocols of the route. Policy based routes only.
   */
  protocols?: string[];
  /**
   * Type of route.
   */
  routeType?:  | "ROUTE_TYPE_UNSPECIFIED" | "SUBNET" | "STATIC" | "DYNAMIC" | "PEERING_SUBNET" | "PEERING_STATIC" | "PEERING_DYNAMIC" | "POLICY_BASED";
  /**
   * Source IP address range of the route. Policy based routes only.
   */
  srcIpRange?: string;
  /**
   * Source port ranges of the route. Policy based routes only.
   */
  srcPortRanges?: string[];
  /**
   * URI of a Compute Engine route. Dynamic route from cloud router does not
   * have a URI. Advertised route from Google Cloud VPC to on-premises network
   * also does not have a URI.
   */
  uri?: string;
}

/**
 * Request message for `SetIamPolicy` method.
 */
export interface SetIamPolicyRequest {
  /**
   * REQUIRED: The complete policy to be applied to the `resource`. The size of
   * the policy is limited to a few 10s of KB. An empty policy is a valid policy
   * but certain Google Cloud services (such as Projects) might reject them.
   */
  policy?: Policy;
  /**
   * OPTIONAL: A FieldMask specifying which fields of the policy to modify.
   * Only the fields in the mask will be modified. If no mask is provided, the
   * following default mask is used: `paths: "bindings, etag"`
   */
  updateMask?: string /* FieldMask */;
}

function serializeSetIamPolicyRequest(data: any): SetIamPolicyRequest {
  return {
    ...data,
    policy: data["policy"] !== undefined ? serializePolicy(data["policy"]) : undefined,
    updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined,
  };
}

function deserializeSetIamPolicyRequest(data: any): SetIamPolicyRequest {
  return {
    ...data,
    policy: data["policy"] !== undefined ? deserializePolicy(data["policy"]) : undefined,
    updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined,
  };
}

/**
 * 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 simulated forwarding path is composed of multiple steps. Each step has a
 * well-defined state and an associated configuration.
 */
export interface Step {
  /**
   * Display information of the final state "abort" and reason.
   */
  abort?: AbortInfo;
  /**
   * Display information of an App Engine service version.
   */
  appEngineVersion?: AppEngineVersionInfo;
  /**
   * This is a step that leads to the final state Drop.
   */
  causesDrop?: boolean;
  /**
   * Display information of a Cloud Function.
   */
  cloudFunction?: CloudFunctionInfo;
  /**
   * Display information of a Cloud Run revision.
   */
  cloudRunRevision?: CloudRunRevisionInfo;
  /**
   * Display information of a Cloud SQL instance.
   */
  cloudSqlInstance?: CloudSQLInstanceInfo;
  /**
   * Display information of the final state "deliver" and reason.
   */
  deliver?: DeliverInfo;
  /**
   * A description of the step. Usually this is a summary of the state.
   */
  description?: string;
  /**
   * Display information of the final state "drop" and reason.
   */
  drop?: DropInfo;
  /**
   * Display information of the source and destination under analysis. The
   * endpoint information in an intermediate state may differ with the initial
   * input, as it might be modified by state like NAT, or Connection Proxy.
   */
  endpoint?: EndpointInfo;
  /**
   * Display information of a Compute Engine firewall rule.
   */
  firewall?: FirewallInfo;
  /**
   * Display information of the final state "forward" and reason.
   */
  forward?: ForwardInfo;
  /**
   * Display information of a Compute Engine forwarding rule.
   */
  forwardingRule?: ForwardingRuleInfo;
  /**
   * Display information of a Google Kubernetes Engine cluster master.
   */
  gkeMaster?: GKEMasterInfo;
  /**
   * Display information of a Google service
   */
  googleService?: GoogleServiceInfo;
  /**
   * Display information of a Compute Engine instance.
   */
  instance?: InstanceInfo;
  /**
   * Display information of the load balancers.
   */
  loadBalancer?: LoadBalancerInfo;
  /**
   * Display information of a Google Cloud network.
   */
  network?: NetworkInfo;
  /**
   * Project ID that contains the configuration this step is validating.
   */
  projectId?: string;
  /**
   * Display information of a Compute Engine route.
   */
  route?: RouteInfo;
  /**
   * Each step is in one of the pre-defined states.
   */
  state?:  | "STATE_UNSPECIFIED" | "START_FROM_INSTANCE" | "START_FROM_INTERNET" | "START_FROM_GOOGLE_SERVICE" | "START_FROM_PRIVATE_NETWORK" | "START_FROM_GKE_MASTER" | "START_FROM_CLOUD_SQL_INSTANCE" | "START_FROM_CLOUD_FUNCTION" | "START_FROM_APP_ENGINE_VERSION" | "START_FROM_CLOUD_RUN_REVISION" | "APPLY_INGRESS_FIREWALL_RULE" | "APPLY_EGRESS_FIREWALL_RULE" | "APPLY_ROUTE" | "APPLY_FORWARDING_RULE" | "SPOOFING_APPROVED" | "ARRIVE_AT_INSTANCE" | "ARRIVE_AT_INTERNAL_LOAD_BALANCER" | "ARRIVE_AT_EXTERNAL_LOAD_BALANCER" | "ARRIVE_AT_VPN_GATEWAY" | "ARRIVE_AT_VPN_TUNNEL" | "ARRIVE_AT_VPC_CONNECTOR" | "NAT" | "PROXY_CONNECTION" | "DELIVER" | "DROP" | "FORWARD" | "ABORT" | "VIEWER_PERMISSION_MISSING";
  /**
   * Display information of a VPC connector.
   */
  vpcConnector?: VpcConnectorInfo;
  /**
   * Display information of a Compute Engine VPN gateway.
   */
  vpnGateway?: VpnGatewayInfo;
  /**
   * Display information of a Compute Engine VPN tunnel.
   */
  vpnTunnel?: VpnTunnelInfo;
}

function serializeStep(data: any): Step {
  return {
    ...data,
    cloudFunction: data["cloudFunction"] !== undefined ? serializeCloudFunctionInfo(data["cloudFunction"]) : undefined,
  };
}

function deserializeStep(data: any): Step {
  return {
    ...data,
    cloudFunction: data["cloudFunction"] !== undefined ? deserializeCloudFunctionInfo(data["cloudFunction"]) : undefined,
  };
}

/**
 * Request message for `TestIamPermissions` method.
 */
export interface TestIamPermissionsRequest {
  /**
   * The set of permissions to check for the `resource`. Permissions with
   * wildcards (such as `*` or `storage.*`) are not allowed. For more
   * information see [IAM
   * Overview](https://cloud.google.com/iam/docs/overview#permissions).
   */
  permissions?: string[];
}

/**
 * Response message for `TestIamPermissions` method.
 */
export interface TestIamPermissionsResponse {
  /**
   * A subset of `TestPermissionsRequest.permissions` that the caller is
   * allowed.
   */
  permissions?: string[];
}

/**
 * Trace represents one simulated packet forwarding path. * Each trace contains
 * multiple ordered steps. * Each step is in a particular state with associated
 * configuration. * State is categorized as final or non-final states. * Each
 * final state has a reason associated. * Each trace must end with a final state
 * (the last step). ``` |---------------------Trace----------------------|
 * Step1(State) Step2(State) --- StepN(State(final)) ```
 */
export interface Trace {
  /**
   * Derived from the source and destination endpoints definition specified by
   * user request, and validated by the data plane model. If there are multiple
   * traces starting from different source locations, then the endpoint_info may
   * be different between traces.
   */
  endpointInfo?: EndpointInfo;
  /**
   * A trace of a test contains multiple steps from the initial state to the
   * final state (delivered, dropped, forwarded, or aborted). The steps are
   * ordered by the processing sequence within the simulated network state
   * machine. It is critical to preserve the order of the steps and avoid
   * reordering or sorting them.
   */
  steps?: Step[];
}

function serializeTrace(data: any): Trace {
  return {
    ...data,
    steps: data["steps"] !== undefined ? data["steps"].map((item: any) => (serializeStep(item))) : undefined,
  };
}

function deserializeTrace(data: any): Trace {
  return {
    ...data,
    steps: data["steps"] !== undefined ? data["steps"].map((item: any) => (deserializeStep(item))) : undefined,
  };
}

/**
 * For display only. Metadata associated with a VPC connector.
 */
export interface VpcConnectorInfo {
  /**
   * Name of a VPC connector.
   */
  displayName?: string;
  /**
   * Location in which the VPC connector is deployed.
   */
  location?: string;
  /**
   * URI of a VPC connector.
   */
  uri?: string;
}

/**
 * For display only. Metadata associated with a Compute Engine VPN gateway.
 */
export interface VpnGatewayInfo {
  /**
   * Name of a VPN gateway.
   */
  displayName?: string;
  /**
   * IP address of the VPN gateway.
   */
  ipAddress?: string;
  /**
   * URI of a Compute Engine network where the VPN gateway is configured.
   */
  networkUri?: string;
  /**
   * Name of a Google Cloud region where this VPN gateway is configured.
   */
  region?: string;
  /**
   * URI of a VPN gateway.
   */
  uri?: string;
  /**
   * A VPN tunnel that is associated with this VPN gateway. There may be
   * multiple VPN tunnels configured on a VPN gateway, and only the one relevant
   * to the test is displayed.
   */
  vpnTunnelUri?: string;
}

/**
 * For display only. Metadata associated with a Compute Engine VPN tunnel.
 */
export interface VpnTunnelInfo {
  /**
   * Name of a VPN tunnel.
   */
  displayName?: string;
  /**
   * URI of a Compute Engine network where the VPN tunnel is configured.
   */
  networkUri?: string;
  /**
   * Name of a Google Cloud region where this VPN tunnel is configured.
   */
  region?: string;
  /**
   * URI of a VPN gateway at remote end of the tunnel.
   */
  remoteGateway?: string;
  /**
   * Remote VPN gateway's IP address.
   */
  remoteGatewayIp?: string;
  /**
   * Type of the routing policy.
   */
  routingType?:  | "ROUTING_TYPE_UNSPECIFIED" | "ROUTE_BASED" | "POLICY_BASED" | "DYNAMIC";
  /**
   * URI of the VPN gateway at local end of the tunnel.
   */
  sourceGateway?: string;
  /**
   * Local VPN gateway's IP address.
   */
  sourceGatewayIp?: string;
  /**
   * URI of a VPN tunnel.
   */
  uri?: string;
}

function decodeBase64(b64: string): Uint8Array {
  const binString = atob(b64);
  const size = binString.length;
  const bytes = new Uint8Array(size);
  for (let i = 0; i < size; i++) {
    bytes[i] = binString.charCodeAt(i);
  }
  return bytes;
}

const base64abc = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9","+","/"];
/**
 * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
 * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
 * @param data
 */
function encodeBase64(uint8: Uint8Array): string {
  let result = "", i;
  const l = uint8.length;
  for (i = 2; i < l; i += 3) {
    result += base64abc[uint8[i - 2] >> 2];
    result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
    result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
    result += base64abc[uint8[i] & 0x3f];
  }
  if (i === l + 1) {
    // 1 octet yet to write
    result += base64abc[uint8[i - 2] >> 2];
    result += base64abc[(uint8[i - 2] & 0x03) << 4];
    result += "==";
  }
  if (i === l) {
    // 2 octets yet to write
    result += base64abc[uint8[i - 2] >> 2];
    result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
    result += base64abc[(uint8[i - 1] & 0x0f) << 2];
    result += "=";
  }
  return result;
}