// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Network Connectivity API Client for Deno
 * ========================================
 * 
 * This API enables connectivity with and between Google Cloud resources.
 * 
 * Docs: https://cloud.google.com/network-connectivity/docs/reference/networkconnectivity/rest
 * Source: https://googleapis.deno.dev/v1/networkconnectivity:v1.ts
 */

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

/**
 * This API enables connectivity with and between Google Cloud resources.
 */
export class NetworkConnectivity {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

  constructor(client?: CredentialsClient, baseUrl: string = "https://networkconnectivity.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;
  }

  /**
   * Accepts a proposal to attach a Network Connectivity Center spoke to a hub.
   *
   * @param name Required. The name of the hub into which to accept the spoke.
   */
  async projectsLocationsGlobalHubsAcceptSpoke(name: string, req: AcceptHubSpokeRequest): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:acceptSpoke`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Accepts a proposal to update a Network Connectivity Center spoke in a hub.
   *
   * @param name Required. The name of the hub to accept spoke update.
   */
  async projectsLocationsGlobalHubsAcceptSpokeUpdate(name: string, req: AcceptSpokeUpdateRequest): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:acceptSpokeUpdate`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Creates a new Network Connectivity Center hub in the specified project.
   *
   * @param parent Required. The parent resource.
   */
  async projectsLocationsGlobalHubsCreate(parent: string, req: Hub, opts: ProjectsLocationsGlobalHubsCreateOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/hubs`);
    if (opts.hubId !== undefined) {
      url.searchParams.append("hubId", String(opts.hubId));
    }
    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 GoogleLongrunningOperation;
  }

  /**
   * Deletes a Network Connectivity Center hub.
   *
   * @param name Required. The name of the hub to delete.
   */
  async projectsLocationsGlobalHubsDelete(name: string, opts: ProjectsLocationsGlobalHubsDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    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 GoogleLongrunningOperation;
  }

  /**
   * Gets details about a Network Connectivity Center hub.
   *
   * @param name Required. The name of the hub resource to get.
   */
  async projectsLocationsGlobalHubsGet(name: string): Promise<Hub> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Hub;
  }

  /**
   * 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 projectsLocationsGlobalHubsGetIamPolicy(resource: string, opts: ProjectsLocationsGlobalHubsGetIamPolicyOptions = {}): 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);
  }

  /**
   * Gets details about a Network Connectivity Center group.
   *
   * @param name Required. The name of the route table resource.
   */
  async projectsLocationsGlobalHubsGroupsGet(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;
  }

  /**
   * 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 projectsLocationsGlobalHubsGroupsGetIamPolicy(resource: string, opts: ProjectsLocationsGlobalHubsGroupsGetIamPolicyOptions = {}): 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 groups in a given hub.
   *
   * @param parent Required. The parent resource's name.
   */
  async projectsLocationsGlobalHubsGroupsList(parent: string, opts: ProjectsLocationsGlobalHubsGroupsListOptions = {}): 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 Network Connectivity Center group.
   *
   * @param name Immutable. The name of the group. Group names must be unique. They use the following form: `projects/{project_number}/locations/global/hubs/{hub}/groups/{group_id}`
   */
  async projectsLocationsGlobalHubsGroupsPatch(name: string, req: Group, opts: ProjectsLocationsGlobalHubsGroupsPatchOptions = {}): Promise<GoogleLongrunningOperation> {
    opts = serializeProjectsLocationsGlobalHubsGroupsPatchOptions(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 GoogleLongrunningOperation;
  }

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

  /**
   * Lists the Network Connectivity Center hubs associated with a given
   * project.
   *
   * @param parent Required. The parent resource's name.
   */
  async projectsLocationsGlobalHubsList(parent: string, opts: ProjectsLocationsGlobalHubsListOptions = {}): Promise<ListHubsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/hubs`);
    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 ListHubsResponse;
  }

  /**
   * Lists the Network Connectivity Center spokes associated with a specified
   * hub and location. The list includes both spokes that are attached to the
   * hub and spokes that have been proposed but not yet accepted.
   *
   * @param name Required. The name of the hub.
   */
  async projectsLocationsGlobalHubsListSpokes(name: string, opts: ProjectsLocationsGlobalHubsListSpokesOptions = {}): Promise<ListHubSpokesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:listSpokes`);
    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.spokeLocations !== undefined) {
      url.searchParams.append("spokeLocations", String(opts.spokeLocations));
    }
    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 ListHubSpokesResponse;
  }

  /**
   * Updates the description and/or labels of a Network Connectivity Center
   * hub.
   *
   * @param name Immutable. The name of the hub. Hub names must be unique. They use the following form: `projects/{project_number}/locations/global/hubs/{hub_id}`
   */
  async projectsLocationsGlobalHubsPatch(name: string, req: Hub, opts: ProjectsLocationsGlobalHubsPatchOptions = {}): Promise<GoogleLongrunningOperation> {
    opts = serializeProjectsLocationsGlobalHubsPatchOptions(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 GoogleLongrunningOperation;
  }

  /**
   * Query the Private Service Connect propagation status of a Network
   * Connectivity Center hub.
   *
   * @param name Required. The name of the hub.
   */
  async projectsLocationsGlobalHubsQueryStatus(name: string, opts: ProjectsLocationsGlobalHubsQueryStatusOptions = {}): Promise<QueryHubStatusResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:queryStatus`);
    if (opts.filter !== undefined) {
      url.searchParams.append("filter", String(opts.filter));
    }
    if (opts.groupBy !== undefined) {
      url.searchParams.append("groupBy", String(opts.groupBy));
    }
    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 QueryHubStatusResponse;
  }

  /**
   * Rejects a Network Connectivity Center spoke from being attached to a hub.
   * If the spoke was previously in the `ACTIVE` state, it transitions to the
   * `INACTIVE` state and is no longer able to connect to other spokes that are
   * attached to the hub.
   *
   * @param name Required. The name of the hub from which to reject the spoke.
   */
  async projectsLocationsGlobalHubsRejectSpoke(name: string, req: RejectHubSpokeRequest): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:rejectSpoke`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Rejects a proposal to update a Network Connectivity Center spoke in a hub.
   *
   * @param name Required. The name of the hub to reject spoke update.
   */
  async projectsLocationsGlobalHubsRejectSpokeUpdate(name: string, req: RejectSpokeUpdateRequest): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:rejectSpokeUpdate`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Gets details about a Network Connectivity Center route table.
   *
   * @param name Required. The name of the route table resource.
   */
  async projectsLocationsGlobalHubsRouteTablesGet(name: string): Promise<RouteTable> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as RouteTable;
  }

  /**
   * Lists route tables in a given hub.
   *
   * @param parent Required. The parent resource's name.
   */
  async projectsLocationsGlobalHubsRouteTablesList(parent: string, opts: ProjectsLocationsGlobalHubsRouteTablesListOptions = {}): Promise<ListRouteTablesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/routeTables`);
    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 ListRouteTablesResponse;
  }

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

  /**
   * Lists routes in a given route table.
   *
   * @param parent Required. The parent resource's name.
   */
  async projectsLocationsGlobalHubsRouteTablesRoutesList(parent: string, opts: ProjectsLocationsGlobalHubsRouteTablesRoutesListOptions = {}): Promise<ListRoutesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/routes`);
    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 ListRoutesResponse;
  }

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

  /**
   * Creates a new policy-based route in a given project and location.
   *
   * @param parent Required. The parent resource's name of the PolicyBasedRoute.
   */
  async projectsLocationsGlobalPolicyBasedRoutesCreate(parent: string, req: PolicyBasedRoute, opts: ProjectsLocationsGlobalPolicyBasedRoutesCreateOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/policyBasedRoutes`);
    if (opts.policyBasedRouteId !== undefined) {
      url.searchParams.append("policyBasedRouteId", String(opts.policyBasedRouteId));
    }
    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 GoogleLongrunningOperation;
  }

  /**
   * Deletes a single policy-based route.
   *
   * @param name Required. Name of the policy-based route resource to delete.
   */
  async projectsLocationsGlobalPolicyBasedRoutesDelete(name: string, opts: ProjectsLocationsGlobalPolicyBasedRoutesDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    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 GoogleLongrunningOperation;
  }

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

  /**
   * 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 projectsLocationsGlobalPolicyBasedRoutesGetIamPolicy(resource: string, opts: ProjectsLocationsGlobalPolicyBasedRoutesGetIamPolicyOptions = {}): 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 policy-based routes in a given project and location.
   *
   * @param parent Required. The parent resource's name.
   */
  async projectsLocationsGlobalPolicyBasedRoutesList(parent: string, opts: ProjectsLocationsGlobalPolicyBasedRoutesListOptions = {}): Promise<ListPolicyBasedRoutesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/policyBasedRoutes`);
    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 ListPolicyBasedRoutesResponse;
  }

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

  /**
   * Creates a new internal range in a given project and location.
   *
   * @param parent Required. The parent resource's name of the internal range.
   */
  async projectsLocationsInternalRangesCreate(parent: string, req: InternalRange, opts: ProjectsLocationsInternalRangesCreateOptions = {}): Promise<GoogleLongrunningOperation> {
    req = serializeInternalRange(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/internalRanges`);
    if (opts.internalRangeId !== undefined) {
      url.searchParams.append("internalRangeId", String(opts.internalRangeId));
    }
    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 GoogleLongrunningOperation;
  }

  /**
   * Deletes a single internal range.
   *
   * @param name Required. The name of the internal range to delete.
   */
  async projectsLocationsInternalRangesDelete(name: string, opts: ProjectsLocationsInternalRangesDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    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 GoogleLongrunningOperation;
  }

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

  /**
   * 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 projectsLocationsInternalRangesGetIamPolicy(resource: string, opts: ProjectsLocationsInternalRangesGetIamPolicyOptions = {}): 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 internal ranges in a given project and location.
   *
   * @param parent Required. The parent resource's name.
   */
  async projectsLocationsInternalRangesList(parent: string, opts: ProjectsLocationsInternalRangesListOptions = {}): Promise<ListInternalRangesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/internalRanges`);
    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 deserializeListInternalRangesResponse(data);
  }

  /**
   * Updates the parameters of a single internal range.
   *
   * @param name Identifier. The name of an internal range. Format: projects/{project}/locations/{location}/internalRanges/{internal_range} See: https://google.aip.dev/122#fields-representing-resource-names
   */
  async projectsLocationsInternalRangesPatch(name: string, req: InternalRange, opts: ProjectsLocationsInternalRangesPatchOptions = {}): Promise<GoogleLongrunningOperation> {
    req = serializeInternalRange(req);
    opts = serializeProjectsLocationsInternalRangesPatchOptions(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 GoogleLongrunningOperation;
  }

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

  /**
   * 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.extraLocationTypes !== undefined) {
      url.searchParams.append("extraLocationTypes", String(opts.extraLocationTypes));
    }
    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: GoogleLongrunningCancelOperationRequest): 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<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as GoogleLongrunningOperation;
  }

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

  /**
   * Creates a new RegionalEndpoint in a given project and location.
   *
   * @param parent Required. The parent resource's name of the RegionalEndpoint.
   */
  async projectsLocationsRegionalEndpointsCreate(parent: string, req: RegionalEndpoint, opts: ProjectsLocationsRegionalEndpointsCreateOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/regionalEndpoints`);
    if (opts.regionalEndpointId !== undefined) {
      url.searchParams.append("regionalEndpointId", String(opts.regionalEndpointId));
    }
    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 GoogleLongrunningOperation;
  }

  /**
   * Deletes a single RegionalEndpoint.
   *
   * @param name Required. The name of the RegionalEndpoint to delete.
   */
  async projectsLocationsRegionalEndpointsDelete(name: string, opts: ProjectsLocationsRegionalEndpointsDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    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 GoogleLongrunningOperation;
  }

  /**
   * Gets details of a single RegionalEndpoint.
   *
   * @param name Required. Name of the RegionalEndpoint resource to get. Format: `projects/{project}/locations/{location}/regionalEndpoints/{regional_endpoint}`
   */
  async projectsLocationsRegionalEndpointsGet(name: string): Promise<RegionalEndpoint> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as RegionalEndpoint;
  }

  /**
   * Lists RegionalEndpoints in a given project and location.
   *
   * @param parent Required. The parent resource's name of the RegionalEndpoint.
   */
  async projectsLocationsRegionalEndpointsList(parent: string, opts: ProjectsLocationsRegionalEndpointsListOptions = {}): Promise<ListRegionalEndpointsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/regionalEndpoints`);
    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 ListRegionalEndpointsResponse;
  }

  /**
   * Deletes a single ServiceClass.
   *
   * @param name Required. The name of the ServiceClass to delete.
   */
  async projectsLocationsServiceClassesDelete(name: string, opts: ProjectsLocationsServiceClassesDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    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 GoogleLongrunningOperation;
  }

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

  /**
   * 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 projectsLocationsServiceClassesGetIamPolicy(resource: string, opts: ProjectsLocationsServiceClassesGetIamPolicyOptions = {}): 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 ServiceClasses in a given project and location.
   *
   * @param parent Required. The parent resource's name. ex. projects/123/locations/us-east1
   */
  async projectsLocationsServiceClassesList(parent: string, opts: ProjectsLocationsServiceClassesListOptions = {}): Promise<ListServiceClassesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceClasses`);
    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 ListServiceClassesResponse;
  }

  /**
   * Updates the parameters of a single ServiceClass.
   *
   * @param name Immutable. The name of a ServiceClass resource. Format: projects/{project}/locations/{location}/serviceClasses/{service_class} See: https://google.aip.dev/122#fields-representing-resource-names
   */
  async projectsLocationsServiceClassesPatch(name: string, req: ServiceClass, opts: ProjectsLocationsServiceClassesPatchOptions = {}): Promise<GoogleLongrunningOperation> {
    opts = serializeProjectsLocationsServiceClassesPatchOptions(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 GoogleLongrunningOperation;
  }

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

  /**
   * Creates a new ServiceConnectionMap in a given project and location.
   *
   * @param parent Required. The parent resource's name of the ServiceConnectionMap. ex. projects/123/locations/us-east1
   */
  async projectsLocationsServiceConnectionMapsCreate(parent: string, req: ServiceConnectionMap, opts: ProjectsLocationsServiceConnectionMapsCreateOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceConnectionMaps`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.serviceConnectionMapId !== undefined) {
      url.searchParams.append("serviceConnectionMapId", String(opts.serviceConnectionMapId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Deletes a single ServiceConnectionMap.
   *
   * @param name Required. The name of the ServiceConnectionMap to delete.
   */
  async projectsLocationsServiceConnectionMapsDelete(name: string, opts: ProjectsLocationsServiceConnectionMapsDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    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 GoogleLongrunningOperation;
  }

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

  /**
   * 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 projectsLocationsServiceConnectionMapsGetIamPolicy(resource: string, opts: ProjectsLocationsServiceConnectionMapsGetIamPolicyOptions = {}): 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 ServiceConnectionMaps in a given project and location.
   *
   * @param parent Required. The parent resource's name. ex. projects/123/locations/us-east1
   */
  async projectsLocationsServiceConnectionMapsList(parent: string, opts: ProjectsLocationsServiceConnectionMapsListOptions = {}): Promise<ListServiceConnectionMapsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceConnectionMaps`);
    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 ListServiceConnectionMapsResponse;
  }

  /**
   * Updates the parameters of a single ServiceConnectionMap.
   *
   * @param name Immutable. The name of a ServiceConnectionMap. Format: projects/{project}/locations/{location}/serviceConnectionMaps/{service_connection_map} See: https://google.aip.dev/122#fields-representing-resource-names
   */
  async projectsLocationsServiceConnectionMapsPatch(name: string, req: ServiceConnectionMap, opts: ProjectsLocationsServiceConnectionMapsPatchOptions = {}): Promise<GoogleLongrunningOperation> {
    opts = serializeProjectsLocationsServiceConnectionMapsPatchOptions(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 GoogleLongrunningOperation;
  }

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

  /**
   * Creates a new ServiceConnectionPolicy in a given project and location.
   *
   * @param parent Required. The parent resource's name of the ServiceConnectionPolicy. ex. projects/123/locations/us-east1
   */
  async projectsLocationsServiceConnectionPoliciesCreate(parent: string, req: ServiceConnectionPolicy, opts: ProjectsLocationsServiceConnectionPoliciesCreateOptions = {}): Promise<GoogleLongrunningOperation> {
    req = serializeServiceConnectionPolicy(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceConnectionPolicies`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.serviceConnectionPolicyId !== undefined) {
      url.searchParams.append("serviceConnectionPolicyId", String(opts.serviceConnectionPolicyId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Deletes a single ServiceConnectionPolicy.
   *
   * @param name Required. The name of the ServiceConnectionPolicy to delete.
   */
  async projectsLocationsServiceConnectionPoliciesDelete(name: string, opts: ProjectsLocationsServiceConnectionPoliciesDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    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 GoogleLongrunningOperation;
  }

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

  /**
   * 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 projectsLocationsServiceConnectionPoliciesGetIamPolicy(resource: string, opts: ProjectsLocationsServiceConnectionPoliciesGetIamPolicyOptions = {}): 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 ServiceConnectionPolicies in a given project and location.
   *
   * @param parent Required. The parent resource's name. ex. projects/123/locations/us-east1
   */
  async projectsLocationsServiceConnectionPoliciesList(parent: string, opts: ProjectsLocationsServiceConnectionPoliciesListOptions = {}): Promise<ListServiceConnectionPoliciesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceConnectionPolicies`);
    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 deserializeListServiceConnectionPoliciesResponse(data);
  }

  /**
   * Updates the parameters of a single ServiceConnectionPolicy.
   *
   * @param name Immutable. The name of a ServiceConnectionPolicy. Format: projects/{project}/locations/{location}/serviceConnectionPolicies/{service_connection_policy} See: https://google.aip.dev/122#fields-representing-resource-names
   */
  async projectsLocationsServiceConnectionPoliciesPatch(name: string, req: ServiceConnectionPolicy, opts: ProjectsLocationsServiceConnectionPoliciesPatchOptions = {}): Promise<GoogleLongrunningOperation> {
    req = serializeServiceConnectionPolicy(req);
    opts = serializeProjectsLocationsServiceConnectionPoliciesPatchOptions(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 GoogleLongrunningOperation;
  }

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

  /**
   * Creates a new ServiceConnectionToken in a given project and location.
   *
   * @param parent Required. The parent resource's name of the ServiceConnectionToken. ex. projects/123/locations/us-east1
   */
  async projectsLocationsServiceConnectionTokensCreate(parent: string, req: ServiceConnectionToken, opts: ProjectsLocationsServiceConnectionTokensCreateOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceConnectionTokens`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.serviceConnectionTokenId !== undefined) {
      url.searchParams.append("serviceConnectionTokenId", String(opts.serviceConnectionTokenId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Deletes a single ServiceConnectionToken.
   *
   * @param name Required. The name of the ServiceConnectionToken to delete.
   */
  async projectsLocationsServiceConnectionTokensDelete(name: string, opts: ProjectsLocationsServiceConnectionTokensDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    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 GoogleLongrunningOperation;
  }

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

  /**
   * Lists ServiceConnectionTokens in a given project and location.
   *
   * @param parent Required. The parent resource's name. ex. projects/123/locations/us-east1
   */
  async projectsLocationsServiceConnectionTokensList(parent: string, opts: ProjectsLocationsServiceConnectionTokensListOptions = {}): Promise<ListServiceConnectionTokensResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceConnectionTokens`);
    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 ListServiceConnectionTokensResponse;
  }

  /**
   * Creates a Network Connectivity Center spoke.
   *
   * @param parent Required. The parent resource.
   */
  async projectsLocationsSpokesCreate(parent: string, req: Spoke, opts: ProjectsLocationsSpokesCreateOptions = {}): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/spokes`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.spokeId !== undefined) {
      url.searchParams.append("spokeId", String(opts.spokeId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Deletes a Network Connectivity Center spoke.
   *
   * @param name Required. The name of the spoke to delete.
   */
  async projectsLocationsSpokesDelete(name: string, opts: ProjectsLocationsSpokesDeleteOptions = {}): Promise<GoogleLongrunningOperation> {
    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 GoogleLongrunningOperation;
  }

  /**
   * Gets details about a Network Connectivity Center spoke.
   *
   * @param name Required. The name of the spoke resource.
   */
  async projectsLocationsSpokesGet(name: string): Promise<Spoke> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Spoke;
  }

  /**
   * 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 projectsLocationsSpokesGetIamPolicy(resource: string, opts: ProjectsLocationsSpokesGetIamPolicyOptions = {}): 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 the Network Connectivity Center spokes in a specified project and
   * location.
   *
   * @param parent Required. The parent resource.
   */
  async projectsLocationsSpokesList(parent: string, opts: ProjectsLocationsSpokesListOptions = {}): Promise<ListSpokesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/spokes`);
    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 ListSpokesResponse;
  }

  /**
   * Updates the parameters of a Network Connectivity Center spoke.
   *
   * @param name Immutable. The name of the spoke. Spoke names must be unique. They use the following form: `projects/{project_number}/locations/{region}/spokes/{spoke_id}`
   */
  async projectsLocationsSpokesPatch(name: string, req: Spoke, opts: ProjectsLocationsSpokesPatchOptions = {}): Promise<GoogleLongrunningOperation> {
    opts = serializeProjectsLocationsSpokesPatchOptions(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 GoogleLongrunningOperation;
  }

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

/**
 * The request for HubService.AcceptHubSpoke.
 */
export interface AcceptHubSpokeRequest {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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. The URI of the spoke to accept into the hub.
   */
  spokeUri?: string;
}

/**
 * The response for HubService.AcceptHubSpoke.
 */
export interface AcceptHubSpokeResponse {
  /**
   * The spoke that was operated on.
   */
  spoke?: Spoke;
}

/**
 * The request for HubService.AcceptSpokeUpdate.
 */
export interface AcceptSpokeUpdateRequest {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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. The etag of the spoke to accept update.
   */
  spokeEtag?: string;
  /**
   * Required. The URI of the spoke to accept update.
   */
  spokeUri?: string;
}

/**
 * Range auto-allocation options, to be optionally used when CIDR block is not
 * explicitly set.
 */
export interface AllocationOptions {
  /**
   * Optional. Allocation strategy Not setting this field when the allocation
   * is requested means an implementation defined strategy is used.
   */
  allocationStrategy?:  | "ALLOCATION_STRATEGY_UNSPECIFIED" | "RANDOM" | "FIRST_AVAILABLE" | "RANDOM_FIRST_N_AVAILABLE" | "FIRST_SMALLEST_FITTING";
  /**
   * Optional. This field must be set only when allocation_strategy is set to
   * RANDOM_FIRST_N_AVAILABLE. The value should be the maximum expected
   * parallelism of range creation requests issued to the same space of peered
   * netwroks.
   */
  firstAvailableRangesLookupSize?: number;
}

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

/**
 * The auto-accept setting for a group controls whether proposed spokes are
 * automatically attached to the hub. If auto-accept is enabled, the spoke
 * immediately is attached to the hub and becomes part of the group. In this
 * case, the new spoke is in the ACTIVE state. If auto-accept is disabled, the
 * spoke goes to the INACTIVE state, and it must be reviewed and accepted by a
 * hub administrator.
 */
export interface AutoAccept {
  /**
   * Optional. A list of project ids or project numbers for which you want to
   * enable auto-accept. The auto-accept setting is applied to spokes being
   * created or updated in these projects.
   */
  autoAcceptProjects?: string[];
}

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

/**
 * Allow the producer to specify which consumers can connect to it.
 */
export interface ConsumerPscConfig {
  /**
   * Required. The project ID or project number of the consumer project. This
   * project is the one that the consumer uses to interact with the producer
   * instance. From the perspective of a consumer who's created a producer
   * instance, this is the project of the producer instance. Format: 'projects/'
   * Eg. 'projects/consumer-project' or 'projects/1234'
   */
  consumerInstanceProject?: string;
  /**
   * This is used in PSC consumer ForwardingRule to control whether the PSC
   * endpoint can be accessed from another region.
   */
  disableGlobalAccess?: boolean;
  /**
   * The requested IP version for the PSC connection.
   */
  ipVersion?:  | "IP_VERSION_UNSPECIFIED" | "IPV4" | "IPV6";
  /**
   * The resource path of the consumer network where PSC connections are
   * allowed to be created in. Note, this network does not need be in the
   * ConsumerPscConfig.project in the case of SharedVPC. Example:
   * projects/{projectNumOrId}/global/networks/{networkId}.
   */
  network?: string;
  /**
   * Immutable. Deprecated. Use producer_instance_metadata instead. An
   * immutable identifier for the producer instance.
   */
  producerInstanceId?: string;
  /**
   * Immutable. An immutable map for the producer instance metadata.
   */
  producerInstanceMetadata?: {
    [key: string]: string
  };
  /**
   * The consumer project where PSC connections are allowed to be created in.
   */
  project?: string;
  /**
   * Output only. A map to store mapping between customer vip and target
   * service attachment. Only service attachment with producer specified ip
   * addresses are stored here.
   */
  readonly serviceAttachmentIpAddressMap?: {
    [key: string]: string
  };
  /**
   * Output only. Overall state of PSC Connections management for this consumer
   * psc config.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "VALID" | "CONNECTION_POLICY_MISSING" | "POLICY_LIMIT_REACHED" | "CONSUMER_INSTANCE_PROJECT_NOT_ALLOWLISTED";
}

/**
 * PSC connection details on consumer side.
 */
export interface ConsumerPscConnection {
  /**
   * The most recent error during operating this connection.
   */
  error?: GoogleRpcStatus;
  /**
   * Output only. The error info for the latest error during operating this
   * connection.
   */
  readonly errorInfo?: GoogleRpcErrorInfo;
  /**
   * The error type indicates whether the error is consumer facing, producer
   * facing or system internal.
   */
  errorType?:  | "CONNECTION_ERROR_TYPE_UNSPECIFIED" | "ERROR_INTERNAL" | "ERROR_CONSUMER_SIDE" | "ERROR_PRODUCER_SIDE";
  /**
   * The URI of the consumer forwarding rule created. Example:
   * projects/{projectNumOrId}/regions/us-east1/networks/{resourceId}.
   */
  forwardingRule?: string;
  /**
   * The last Compute Engine operation to setup PSC connection.
   */
  gceOperation?: string;
  /**
   * The IP literal allocated on the consumer network for the PSC forwarding
   * rule that is created to connect to the producer service attachment in this
   * service connection map.
   */
  ip?: string;
  /**
   * The requested IP version for the PSC connection.
   */
  ipVersion?:  | "IP_VERSION_UNSPECIFIED" | "IPV4" | "IPV6";
  /**
   * The consumer network whose PSC forwarding rule is connected to the service
   * attachments in this service connection map. Note that the network could be
   * on a different project (shared VPC).
   */
  network?: string;
  /**
   * Immutable. Deprecated. Use producer_instance_metadata instead. An
   * immutable identifier for the producer instance.
   */
  producerInstanceId?: string;
  /**
   * Immutable. An immutable map for the producer instance metadata.
   */
  producerInstanceMetadata?: {
    [key: string]: string
  };
  /**
   * The consumer project whose PSC forwarding rule is connected to the service
   * attachments in this service connection map.
   */
  project?: string;
  /**
   * The PSC connection id of the PSC forwarding rule connected to the service
   * attachments in this service connection map.
   */
  pscConnectionId?: string;
  /**
   * Output only. The URI of the selected subnetwork selected to allocate IP
   * address for this connection.
   */
  readonly selectedSubnetwork?: string;
  /**
   * The URI of a service attachment which is the target of the PSC connection.
   */
  serviceAttachmentUri?: string;
  /**
   * The state of the PSC connection.
   */
  state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "FAILED" | "CREATING" | "DELETING" | "CREATE_REPAIRING" | "DELETE_REPAIRING";
}

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

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

/**
 * Filter matches L4 traffic.
 */
export interface Filter {
  /**
   * Optional. The destination IP range of outgoing packets that this
   * policy-based route applies to. Default is "0.0.0.0/0" if protocol version
   * is IPv4 and "::/0" if protocol version is IPv6.
   */
  destRange?: string;
  /**
   * Optional. The IP protocol that this policy-based route applies to. Valid
   * values are 'TCP', 'UDP', and 'ALL'. Default is 'ALL'.
   */
  ipProtocol?: string;
  /**
   * Required. Internet protocol versions this policy-based route applies to.
   * IPV4 and IPV6 is supported.
   */
  protocolVersion?:  | "PROTOCOL_VERSION_UNSPECIFIED" | "IPV4" | "IPV6";
  /**
   * Optional. The source IP range of outgoing packets that this policy-based
   * route applies to. Default is "0.0.0.0/0" if protocol version is IPv4 and
   * "::/0" if protocol version is IPv6.
   */
  srcRange?: string;
}

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

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

/**
 * This resource represents a long-running operation that is the result of a
 * network API call.
 */
export interface GoogleLongrunningOperation {
  /**
   * 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?: GoogleRpcStatus;
  /**
   * 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
  };
}

/**
 * Describes the cause of the error with structured details. Example of an
 * error when contacting the "pubsub.googleapis.com" API when it is not enabled:
 * { "reason": "API_DISABLED" "domain": "googleapis.com" "metadata": {
 * "resource": "projects/123", "service": "pubsub.googleapis.com" } } This
 * response indicates that the pubsub.googleapis.com API is not enabled. Example
 * of an error that is returned when attempting to create a Spanner instance in
 * a region that is out of stock: { "reason": "STOCKOUT" "domain":
 * "spanner.googleapis.com", "metadata": { "availableRegions":
 * "us-central1,us-east2" } }
 */
export interface GoogleRpcErrorInfo {
  /**
   * The logical grouping to which the "reason" belongs. The error domain is
   * typically the registered service name of the tool or product that generates
   * the error. Example: "pubsub.googleapis.com". If the error is generated by
   * some common infrastructure, the error domain must be a globally unique
   * value that identifies the infrastructure. For Google API infrastructure,
   * the error domain is "googleapis.com".
   */
  domain?: string;
  /**
   * Additional structured details about this error. Keys must match a regular
   * expression of `a-z+` but should ideally be lowerCamelCase. Also, they must
   * be limited to 64 characters in length. When identifying the current value
   * of an exceeded limit, the units should be contained in the key, not the
   * value. For example, rather than `{"instanceLimit": "100/request"}`, should
   * be returned as, `{"instanceLimitPerRequest": "100"}`, if the client exceeds
   * the number of instances that can be created in a single (batch) request.
   */
  metadata?: {
    [key: string]: string
  };
  /**
   * The reason of the error. This is a constant value that identifies the
   * proximate cause of the error. Error reasons are unique within a particular
   * domain of errors. This should be at most 63 characters and match a regular
   * expression of `A-Z+[A-Z0-9]`, which represents UPPER_SNAKE_CASE.
   */
  reason?: 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 GoogleRpcStatus {
  /**
   * 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 group represents a subset of spokes attached to a hub.
 */
export interface Group {
  /**
   * Optional. The auto-accept setting for this group.
   */
  autoAccept?: AutoAccept;
  /**
   * Output only. The time the group was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. The description of the group.
   */
  description?: string;
  /**
   * Optional. Labels in key-value pair format. For more information about
   * labels, see [Requirements for
   * labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Immutable. The name of the group. Group names must be unique. They use the
   * following form:
   * `projects/{project_number}/locations/global/hubs/{hub}/groups/{group_id}`
   */
  name?: string;
  /**
   * Output only. The name of the route table that corresponds to this group.
   * They use the following form:
   * `projects/{project_number}/locations/global/hubs/{hub_id}/routeTables/{route_table_id}`
   */
  readonly routeTable?: string;
  /**
   * Output only. The current lifecycle state of this group.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING" | "ACCEPTING" | "REJECTING" | "UPDATING" | "INACTIVE" | "OBSOLETE" | "FAILED";
  /**
   * Output only. The Google-generated UUID for the group. This value is unique
   * across all group resources. If a group is deleted and another with the same
   * name is created, the new route table is assigned a different unique_id.
   */
  readonly uid?: string;
  /**
   * Output only. The time the group was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * A Network Connectivity Center hub is a global management resource to which
 * you attach spokes. A single hub can contain spokes from multiple regions.
 * However, if any of a hub's spokes use the site-to-site data transfer feature,
 * the resources associated with those spokes must all be in the same VPC
 * network. Spokes that do not use site-to-site data transfer can be associated
 * with any VPC network in your project.
 */
export interface Hub {
  /**
   * Output only. The time the hub was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. An optional description of the hub.
   */
  description?: string;
  /**
   * Optional. Whether Private Service Connect connection propagation is
   * enabled for the hub. If true, Private Service Connect endpoints in VPC
   * spokes attached to the hub are made accessible to other VPC spokes attached
   * to the hub. The default value is false.
   */
  exportPsc?: boolean;
  /**
   * Optional labels in key-value pair format. For more information about
   * labels, see [Requirements for
   * labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Immutable. The name of the hub. Hub names must be unique. They use the
   * following form: `projects/{project_number}/locations/global/hubs/{hub_id}`
   */
  name?: string;
  /**
   * Optional. The policy mode of this hub. This field can be either PRESET or
   * CUSTOM. If unspecified, the policy_mode defaults to PRESET.
   */
  policyMode?:  | "POLICY_MODE_UNSPECIFIED" | "PRESET";
  /**
   * Optional. The topology implemented in this hub. Currently, this field is
   * only used when policy_mode = PRESET. The available preset topologies are
   * MESH and STAR. If preset_topology is unspecified and policy_mode = PRESET,
   * the preset_topology defaults to MESH. When policy_mode = CUSTOM, the
   * preset_topology is set to PRESET_TOPOLOGY_UNSPECIFIED.
   */
  presetTopology?:  | "PRESET_TOPOLOGY_UNSPECIFIED" | "MESH" | "STAR";
  /**
   * Output only. The route tables that belong to this hub. They use the
   * following form:
   * `projects/{project_number}/locations/global/hubs/{hub_id}/routeTables/{route_table_id}`
   * This field is read-only. Network Connectivity Center automatically
   * populates it based on the route tables nested under the hub.
   */
  readonly routeTables?: string[];
  /**
   * Output only. The VPC networks associated with this hub's spokes. This
   * field is read-only. Network Connectivity Center automatically populates it
   * based on the set of spokes attached to the hub.
   */
  readonly routingVpcs?: RoutingVPC[];
  /**
   * Output only. A summary of the spokes associated with a hub. The summary
   * includes a count of spokes according to type and according to state. If any
   * spokes are inactive, the summary also lists the reasons they are inactive,
   * including a count for each reason.
   */
  readonly spokeSummary?: SpokeSummary;
  /**
   * Output only. The current lifecycle state of this hub.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING" | "ACCEPTING" | "REJECTING" | "UPDATING" | "INACTIVE" | "OBSOLETE" | "FAILED";
  /**
   * Output only. The Google-generated UUID for the hub. This value is unique
   * across all hub resources. If a hub is deleted and another with the same
   * name is created, the new hub is assigned a different unique_id.
   */
  readonly uniqueId?: string;
  /**
   * Output only. The time the hub was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * A hub status entry represents the status of a set of propagated Private
 * Service Connect connections grouped by certain fields.
 */
export interface HubStatusEntry {
  /**
   * The number of propagated Private Service Connect connections with this
   * status. If the `group_by` field was not set in the request message, the
   * value of this field is 1.
   */
  count?: number;
  /**
   * The fields that this entry is grouped by. This has the same value as the
   * `group_by` field in the request message.
   */
  groupBy?: string;
  /**
   * The Private Service Connect propagation status.
   */
  pscPropagationStatus?: PscPropagationStatus;
}

/**
 * InterconnectAttachment that this route applies to.
 */
export interface InterconnectAttachment {
  /**
   * Optional. Cloud region to install this policy-based route on interconnect
   * attachment. Use `all` to install it on all interconnect attachments.
   */
  region?: string;
}

/**
 * The internal range resource for IPAM operations within a VPC network. Used
 * to represent a private address range along with behavioral characteristics of
 * that range (its usage and peering behavior). Networking resources can link to
 * this range if they are created as belonging to it.
 */
export interface InternalRange {
  /**
   * Optional. Range auto-allocation options, may be set only when
   * auto-allocation is selected by not setting ip_cidr_range (and setting
   * prefix_length).
   */
  allocationOptions?: AllocationOptions;
  /**
   * Time when the internal range was created.
   */
  createTime?: Date;
  /**
   * Optional. A description of this resource.
   */
  description?: string;
  /**
   * Optional. ExcludeCidrRanges flag. Specifies a set of CIDR blocks that
   * allows exclusion of particular CIDR ranges from the auto-allocation
   * process, without having to reserve these blocks
   */
  excludeCidrRanges?: string[];
  /**
   * Optional. Immutable ranges cannot have their fields modified, except for
   * labels and description.
   */
  immutable?: boolean;
  /**
   * Optional. The IP range that this internal range defines. NOTE: IPv6 ranges
   * are limited to usage=EXTERNAL_TO_VPC and peering=FOR_SELF. NOTE: For IPv6
   * Ranges this field is compulsory, i.e. the address range must be specified
   * explicitly.
   */
  ipCidrRange?: string;
  /**
   * User-defined labels.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. Must be present if usage is set to FOR_MIGRATION.
   */
  migration?: Migration;
  /**
   * Identifier. The name of an internal range. Format:
   * projects/{project}/locations/{location}/internalRanges/{internal_range}
   * See: https://google.aip.dev/122#fields-representing-resource-names
   */
  name?: string;
  /**
   * Immutable. The URL or resource ID of the network in which to reserve the
   * internal range. The network cannot be deleted if there are any reserved
   * internal ranges referring to it. Legacy networks are not supported. For
   * example:
   * https://www.googleapis.com/compute/v1/projects/{project}/locations/global/networks/{network}
   * projects/{project}/locations/global/networks/{network} {network}
   */
  network?: string;
  /**
   * Optional. Types of resources that are allowed to overlap with the current
   * internal range.
   */
  overlaps?:  | "OVERLAP_UNSPECIFIED" | "OVERLAP_ROUTE_RANGE" | "OVERLAP_EXISTING_SUBNET_RANGE"[];
  /**
   * Optional. The type of peering set for this internal range.
   */
  peering?:  | "PEERING_UNSPECIFIED" | "FOR_SELF" | "FOR_PEER" | "NOT_SHARED";
  /**
   * Optional. An alternate to ip_cidr_range. Can be set when trying to create
   * an IPv4 reservation that automatically finds a free range of the given
   * size. If both ip_cidr_range and prefix_length are set, there is an error if
   * the range sizes do not match. Can also be used during updates to change the
   * range size. NOTE: For IPv6 this field only works if ip_cidr_range is set as
   * well, and both fields must match. In other words, with IPv6 this field only
   * works as a redundant parameter.
   */
  prefixLength?: number;
  /**
   * Optional. Can be set to narrow down or pick a different address space
   * while searching for a free range. If not set, defaults to the "10.0.0.0/8"
   * address space. This can be used to search in other rfc-1918 address spaces
   * like "172.16.0.0/12" and "192.168.0.0/16" or non-rfc-1918 address spaces
   * used in the VPC.
   */
  targetCidrRange?: string[];
  /**
   * Time when the internal range was updated.
   */
  updateTime?: Date;
  /**
   * Optional. The type of usage set for this InternalRange.
   */
  usage?:  | "USAGE_UNSPECIFIED" | "FOR_VPC" | "EXTERNAL_TO_VPC" | "FOR_MIGRATION";
  /**
   * Output only. The list of resources that refer to this internal range.
   * Resources that use the internal range for their range allocation are
   * referred to as users of the range. Other resources mark themselves as users
   * while doing so by creating a reference to this internal range. Having a
   * user, based on this reference, prevents deletion of the internal range
   * referred to. Can be empty.
   */
  readonly users?: string[];
}

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

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

/**
 * A collection of VLAN attachment resources. These resources should be
 * redundant attachments that all advertise the same prefixes to Google Cloud.
 * Alternatively, in active/passive configurations, all attachments should be
 * capable of advertising the same prefixes.
 */
export interface LinkedInterconnectAttachments {
  /**
   * Optional. IP ranges allowed to be included during import from hub (does
   * not control transit connectivity). The only allowed value for now is
   * "ALL_IPV4_RANGES".
   */
  includeImportRanges?: string[];
  /**
   * A value that controls whether site-to-site data transfer is enabled for
   * these resources. Data transfer is available only in [supported
   * locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
   */
  siteToSiteDataTransfer?: boolean;
  /**
   * The URIs of linked interconnect attachment resources
   */
  uris?: string[];
  /**
   * Output only. The VPC network where these VLAN attachments are located.
   */
  readonly vpcNetwork?: string;
}

export interface LinkedProducerVpcNetwork {
  /**
   * Optional. IP ranges encompassing the subnets to be excluded from peering.
   */
  excludeExportRanges?: string[];
  /**
   * Optional. IP ranges allowed to be included from peering.
   */
  includeExportRanges?: string[];
  /**
   * Immutable. The URI of the Service Consumer VPC that the Producer VPC is
   * peered with.
   */
  network?: string;
  /**
   * Immutable. The name of the VPC peering between the Service Consumer VPC
   * and the Producer VPC (defined in the Tenant project) which is added to the
   * NCC hub. This peering must be in ACTIVE state.
   */
  peering?: string;
  /**
   * Output only. The URI of the Producer VPC.
   */
  readonly producerNetwork?: string;
  /**
   * Output only. The proposed exclude export IP ranges waiting for hub
   * administration's approval.
   */
  readonly proposedExcludeExportRanges?: string[];
  /**
   * Output only. The proposed include export IP ranges waiting for hub
   * administration's approval.
   */
  readonly proposedIncludeExportRanges?: string[];
  /**
   * Output only. The Service Consumer Network spoke.
   */
  readonly serviceConsumerVpcSpoke?: string;
}

/**
 * A collection of router appliance instances. If you configure multiple router
 * appliance instances to receive data from the same set of sites outside of
 * Google Cloud, we recommend that you associate those instances with the same
 * spoke.
 */
export interface LinkedRouterApplianceInstances {
  /**
   * Optional. IP ranges allowed to be included during import from hub (does
   * not control transit connectivity). The only allowed value for now is
   * "ALL_IPV4_RANGES".
   */
  includeImportRanges?: string[];
  /**
   * The list of router appliance instances.
   */
  instances?: RouterApplianceInstance[];
  /**
   * A value that controls whether site-to-site data transfer is enabled for
   * these resources. Data transfer is available only in [supported
   * locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
   */
  siteToSiteDataTransfer?: boolean;
  /**
   * Output only. The VPC network where these router appliance instances are
   * located.
   */
  readonly vpcNetwork?: string;
}

/**
 * An existing VPC network.
 */
export interface LinkedVpcNetwork {
  /**
   * Optional. IP ranges encompassing the subnets to be excluded from peering.
   */
  excludeExportRanges?: string[];
  /**
   * Optional. IP ranges allowed to be included from peering.
   */
  includeExportRanges?: string[];
  /**
   * Output only. The list of Producer VPC spokes that this VPC spoke is a
   * service consumer VPC spoke for. These producer VPCs are connected through
   * VPC peering to this spoke's backing VPC network. Because they are directly
   * connected through VPC peering, NCC export filters do not apply between the
   * service consumer VPC spoke and any of its producer VPC spokes. This VPC
   * spoke cannot be deleted as long as any of these producer VPC spokes are
   * connected to the NCC Hub.
   */
  readonly producerVpcSpokes?: string[];
  /**
   * Output only. The proposed exclude export IP ranges waiting for hub
   * administration's approval.
   */
  readonly proposedExcludeExportRanges?: string[];
  /**
   * Output only. The proposed include export IP ranges waiting for hub
   * administration's approval.
   */
  readonly proposedIncludeExportRanges?: string[];
  /**
   * Required. The URI of the VPC network resource.
   */
  uri?: string;
}

/**
 * A collection of Cloud VPN tunnel resources. These resources should be
 * redundant HA VPN tunnels that all advertise the same prefixes to Google
 * Cloud. Alternatively, in a passive/active configuration, all tunnels should
 * be capable of advertising the same prefixes.
 */
export interface LinkedVpnTunnels {
  /**
   * Optional. IP ranges allowed to be included during import from hub (does
   * not control transit connectivity). The only allowed value for now is
   * "ALL_IPV4_RANGES".
   */
  includeImportRanges?: string[];
  /**
   * A value that controls whether site-to-site data transfer is enabled for
   * these resources. Data transfer is available only in [supported
   * locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
   */
  siteToSiteDataTransfer?: boolean;
  /**
   * The URIs of linked VPN tunnel resources.
   */
  uris?: string[];
  /**
   * Output only. The VPC network where these VPN tunnels are located.
   */
  readonly vpcNetwork?: string;
}

/**
 * Response for HubService.ListGroups method.
 */
export interface ListGroupsResponse {
  /**
   * The requested groups.
   */
  groups?: Group[];
  /**
   * The token for the next page of the response. To see more results, use this
   * value as the page_token for your next request. If this value is empty,
   * there are no more results.
   */
  nextPageToken?: string;
  /**
   * Hubs that could not be reached.
   */
  unreachable?: string[];
}

/**
 * The response for HubService.ListHubSpokes.
 */
export interface ListHubSpokesResponse {
  /**
   * The token for the next page of the response. To see more results, use this
   * value as the page_token for your next request. If this value is empty,
   * there are no more results.
   */
  nextPageToken?: string;
  /**
   * The requested spokes. The spoke fields can be partially populated based on
   * the `view` field in the request message.
   */
  spokes?: Spoke[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for HubService.ListHubs method.
 */
export interface ListHubsResponse {
  /**
   * The requested hubs.
   */
  hubs?: Hub[];
  /**
   * The token for the next page of the response. To see more results, use this
   * value as the page_token for your next request. If this value is empty,
   * there are no more results.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for InternalRange.ListInternalRanges
 */
export interface ListInternalRangesResponse {
  /**
   * Internal ranges to be returned.
   */
  internalRanges?: InternalRange[];
  /**
   * The next pagination token in the List response. It should be used as
   * page_token for the following request. An empty value means no more result.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

function serializeListInternalRangesResponse(data: any): ListInternalRangesResponse {
  return {
    ...data,
    internalRanges: data["internalRanges"] !== undefined ? data["internalRanges"].map((item: any) => (serializeInternalRange(item))) : undefined,
  };
}

function deserializeListInternalRangesResponse(data: any): ListInternalRangesResponse {
  return {
    ...data,
    internalRanges: data["internalRanges"] !== undefined ? data["internalRanges"].map((item: any) => (deserializeInternalRange(item))) : undefined,
  };
}

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

/**
 * Response for PolicyBasedRoutingService.ListPolicyBasedRoutes method.
 */
export interface ListPolicyBasedRoutesResponse {
  /**
   * The next pagination token in the List response. It should be used as
   * page_token for the following request. An empty value means no more result.
   */
  nextPageToken?: string;
  /**
   * Policy-based routes to be returned.
   */
  policyBasedRoutes?: PolicyBasedRoute[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for ListRegionalEndpoints.
 */
export interface ListRegionalEndpointsResponse {
  /**
   * The next pagination token in the List response. It should be used as
   * page_token for the following request. An empty value means no more result.
   */
  nextPageToken?: string;
  /**
   * Regional endpoints to be returned.
   */
  regionalEndpoints?: RegionalEndpoint[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for HubService.ListRoutes method.
 */
export interface ListRoutesResponse {
  /**
   * The token for the next page of the response. To see more results, use this
   * value as the page_token for your next request. If this value is empty,
   * there are no more results.
   */
  nextPageToken?: string;
  /**
   * The requested routes.
   */
  routes?: Route[];
  /**
   * RouteTables that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for HubService.ListRouteTables method.
 */
export interface ListRouteTablesResponse {
  /**
   * The token for the next page of the response. To see more results, use this
   * value as the page_token for your next request. If this value is empty,
   * there are no more results.
   */
  nextPageToken?: string;
  /**
   * The requested route tables.
   */
  routeTables?: RouteTable[];
  /**
   * Hubs that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for ListServiceClasses.
 */
export interface ListServiceClassesResponse {
  /**
   * The next pagination token in the List response. It should be used as
   * page_token for the following request. An empty value means no more result.
   */
  nextPageToken?: string;
  /**
   * ServiceClasses to be returned.
   */
  serviceClasses?: ServiceClass[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for ListServiceConnectionMaps.
 */
export interface ListServiceConnectionMapsResponse {
  /**
   * The next pagination token in the List response. It should be used as
   * page_token for the following request. An empty value means no more result.
   */
  nextPageToken?: string;
  /**
   * ServiceConnectionMaps to be returned.
   */
  serviceConnectionMaps?: ServiceConnectionMap[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for ListServiceConnectionPolicies.
 */
export interface ListServiceConnectionPoliciesResponse {
  /**
   * The next pagination token in the List response. It should be used as
   * page_token for the following request. An empty value means no more result.
   */
  nextPageToken?: string;
  /**
   * ServiceConnectionPolicies to be returned.
   */
  serviceConnectionPolicies?: ServiceConnectionPolicy[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

function serializeListServiceConnectionPoliciesResponse(data: any): ListServiceConnectionPoliciesResponse {
  return {
    ...data,
    serviceConnectionPolicies: data["serviceConnectionPolicies"] !== undefined ? data["serviceConnectionPolicies"].map((item: any) => (serializeServiceConnectionPolicy(item))) : undefined,
  };
}

function deserializeListServiceConnectionPoliciesResponse(data: any): ListServiceConnectionPoliciesResponse {
  return {
    ...data,
    serviceConnectionPolicies: data["serviceConnectionPolicies"] !== undefined ? data["serviceConnectionPolicies"].map((item: any) => (deserializeServiceConnectionPolicy(item))) : undefined,
  };
}

/**
 * Response for ListServiceConnectionTokens.
 */
export interface ListServiceConnectionTokensResponse {
  /**
   * The next pagination token in the List response. It should be used as
   * page_token for the following request. An empty value means no more result.
   */
  nextPageToken?: string;
  /**
   * ServiceConnectionTokens to be returned.
   */
  serviceConnectionTokens?: ServiceConnectionToken[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * The response for HubService.ListSpokes.
 */
export interface ListSpokesResponse {
  /**
   * The token for the next page of the response. To see more results, use this
   * value as the page_token for your next request. If this value is empty,
   * there are no more results.
   */
  nextPageToken?: string;
  /**
   * The requested spokes.
   */
  spokes?: Spoke[];
  /**
   * 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;
}

/**
 * Metadata about locations
 */
export interface LocationMetadata {
  /**
   * List of supported features
   */
  locationFeatures?:  | "LOCATION_FEATURE_UNSPECIFIED" | "SITE_TO_CLOUD_SPOKES" | "SITE_TO_SITE_SPOKES" | "GATEWAY_SPOKES"[];
}

/**
 * Specification for migration with source and target resource names.
 */
export interface Migration {
  /**
   * Immutable. Resource path as an URI of the source resource, for example a
   * subnet. The project for the source resource should match the project for
   * the InternalRange. An example:
   * /projects/{project}/regions/{region}/subnetworks/{subnet}
   */
  source?: string;
  /**
   * Immutable. Resource path of the target resource. The target project can be
   * different, as in the cases when migrating to peer networks. For example:
   * /projects/{project}/regions/{region}/subnetworks/{subnet}
   */
  target?: string;
}

/**
 * A route next hop that leads to an interconnect attachment resource.
 */
export interface NextHopInterconnectAttachment {
  /**
   * Indicates whether site-to-site data transfer is allowed for this
   * interconnect attachment resource. Data transfer is available only in
   * [supported
   * locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
   */
  siteToSiteDataTransfer?: boolean;
  /**
   * The URI of the interconnect attachment resource.
   */
  uri?: string;
  /**
   * The VPC network where this interconnect attachment is located.
   */
  vpcNetwork?: string;
}

/**
 * A route next hop that leads to a Router appliance instance.
 */
export interface NextHopRouterApplianceInstance {
  /**
   * Indicates whether site-to-site data transfer is allowed for this Router
   * appliance instance resource. Data transfer is available only in [supported
   * locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
   */
  siteToSiteDataTransfer?: boolean;
  /**
   * The URI of the Router appliance instance.
   */
  uri?: string;
  /**
   * The VPC network where this VM is located.
   */
  vpcNetwork?: string;
}

/**
 * A route next hop that leads to a spoke resource.
 */
export interface NextHopSpoke {
  /**
   * Indicates whether site-to-site data transfer is allowed for this spoke
   * resource. Data transfer is available only in [supported
   * locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
   * Whether this route is accessible to other hybrid spokes with site-to-site
   * data transfer enabled. If this is false, the route is only accessible to
   * VPC spokes of the connected Hub.
   */
  siteToSiteDataTransfer?: boolean;
  /**
   * The URI of the spoke resource.
   */
  uri?: string;
}

export interface NextHopVpcNetwork {
  /**
   * The URI of the VPC network resource
   */
  uri?: string;
}

/**
 * A route next hop that leads to a VPN tunnel resource.
 */
export interface NextHopVPNTunnel {
  /**
   * Indicates whether site-to-site data transfer is allowed for this VPN
   * tunnel resource. Data transfer is available only in [supported
   * locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).
   */
  siteToSiteDataTransfer?: boolean;
  /**
   * The URI of the VPN tunnel resource.
   */
  uri?: string;
  /**
   * The VPC network where this VPN tunnel is located.
   */
  vpcNetwork?: string;
}

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

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

/**
 * Policy-based routes route L4 network traffic based on not just destination
 * IP address, but also source IP address, protocol, and more. If a policy-based
 * route conflicts with other types of routes, the policy-based route always
 * takes precedence.
 */
export interface PolicyBasedRoute {
  /**
   * Output only. Time when the policy-based route was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. An optional description of this resource. Provide this field
   * when you create the resource.
   */
  description?: string;
  /**
   * Required. The filter to match L4 traffic.
   */
  filter?: Filter;
  /**
   * Optional. The interconnect attachments that this policy-based route
   * applies to.
   */
  interconnectAttachment?: InterconnectAttachment;
  /**
   * Output only. Type of this resource. Always
   * networkconnectivity#policyBasedRoute for policy-based Route resources.
   */
  readonly kind?: string;
  /**
   * User-defined labels.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Immutable. A unique name of the resource in the form of
   * `projects/{project_number}/locations/global/PolicyBasedRoutes/{policy_based_route_id}`
   */
  name?: string;
  /**
   * Required. Fully-qualified URL of the network that this route applies to,
   * for example: projects/my-project/global/networks/my-network.
   */
  network?: string;
  /**
   * Optional. The IP address of a global-access-enabled L4 ILB that is the
   * next hop for matching packets. For this version, only nextHopIlbIp is
   * supported.
   */
  nextHopIlbIp?: string;
  /**
   * Optional. Other routes that will be referenced to determine the next hop
   * of the packet.
   */
  nextHopOtherRoutes?:  | "OTHER_ROUTES_UNSPECIFIED" | "DEFAULT_ROUTING";
  /**
   * Optional. The priority of this policy-based route. Priority is used to
   * break ties in cases where there are more than one matching policy-based
   * routes found. In cases where multiple policy-based routes are matched, the
   * one with the lowest-numbered priority value wins. The default value is
   * 1000. The priority value must be from 1 to 65535, inclusive.
   */
  priority?: number;
  /**
   * Output only. Server-defined fully-qualified URL for this resource.
   */
  readonly selfLink?: string;
  /**
   * Output only. Time when the policy-based route was updated.
   */
  readonly updateTime?: Date;
  /**
   * Optional. VM instances that this policy-based route applies to.
   */
  virtualMachine?: VirtualMachine;
  /**
   * Output only. If potential misconfigurations are detected for this route,
   * this field will be populated with warning messages.
   */
  readonly warnings?: Warnings[];
}

/**
 * The PSC configurations on producer side.
 */
export interface ProducerPscConfig {
  /**
   * The resource path of a service attachment. Example:
   * projects/{projectNumOrId}/regions/{region}/serviceAttachments/{resourceId}.
   */
  serviceAttachmentUri?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsGlobalHubsCreate.
 */
export interface ProjectsLocationsGlobalHubsCreateOptions {
  /**
   * Required. A unique identifier for the hub.
   */
  hubId?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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
 * NetworkConnectivity#projectsLocationsGlobalHubsDelete.
 */
export interface ProjectsLocationsGlobalHubsDeleteOptions {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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
 * NetworkConnectivity#projectsLocationsGlobalHubsGetIamPolicy.
 */
export interface ProjectsLocationsGlobalHubsGetIamPolicyOptions {
  /**
   * 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
 * NetworkConnectivity#projectsLocationsGlobalHubsGroupsGetIamPolicy.
 */
export interface ProjectsLocationsGlobalHubsGroupsGetIamPolicyOptions {
  /**
   * 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
 * NetworkConnectivity#projectsLocationsGlobalHubsGroupsList.
 */
export interface ProjectsLocationsGlobalHubsGroupsListOptions {
  /**
   * An expression that filters the list of results.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results to return per page.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsGlobalHubsGroupsPatch.
 */
export interface ProjectsLocationsGlobalHubsGroupsPatchOptions {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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;
  /**
   * Optional. In the case of an update to an existing group, field mask is
   * used to specify the fields to be overwritten. The fields specified in the
   * update_mask are relative to the resource, not the full request. A field is
   * overwritten if it is in the mask. If the user does not provide a mask, then
   * all fields are overwritten.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for NetworkConnectivity#projectsLocationsGlobalHubsList.
 */
export interface ProjectsLocationsGlobalHubsListOptions {
  /**
   * An expression that filters the list of results.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results per page to return.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsGlobalHubsListSpokes.
 */
export interface ProjectsLocationsGlobalHubsListSpokesOptions {
  /**
   * An expression that filters the list of results.
   */
  filter?: string;
  /**
   * Sort the results by name or create_time.
   */
  orderBy?: string;
  /**
   * The maximum number of results to return per page.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
  /**
   * A list of locations. Specify one of the following: `[global]`, a single
   * region (for example, `[us-central1]`), or a combination of values (for
   * example, `[global, us-central1, us-west1]`). If the spoke_locations field
   * is populated, the list of results includes only spokes in the specified
   * location. If the spoke_locations field is not populated, the list of
   * results includes spokes in all locations.
   */
  spokeLocations?: string;
  /**
   * The view of the spoke to return. The view that you use determines which
   * spoke fields are included in the response.
   */
  view?:  | "SPOKE_VIEW_UNSPECIFIED" | "BASIC" | "DETAILED";
}

/**
 * Additional options for NetworkConnectivity#projectsLocationsGlobalHubsPatch.
 */
export interface ProjectsLocationsGlobalHubsPatchOptions {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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;
  /**
   * Optional. In the case of an update to an existing hub, field mask is used
   * to specify the fields to be overwritten. The fields specified in the
   * update_mask are relative to the resource, not the full request. A field is
   * overwritten if it is in the mask. If the user does not provide a mask, then
   * all fields are overwritten.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsGlobalHubsQueryStatus.
 */
export interface ProjectsLocationsGlobalHubsQueryStatusOptions {
  /**
   * Optional. An expression that filters the list of results. The filter can
   * be used to filter the results by the following fields: *
   * `psc_propagation_status.source_spoke` *
   * `psc_propagation_status.source_group` *
   * `psc_propagation_status.source_forwarding_rule` *
   * `psc_propagation_status.target_spoke` *
   * `psc_propagation_status.target_group` * `psc_propagation_status.code` *
   * `psc_propagation_status.message`
   */
  filter?: string;
  /**
   * Optional. Aggregate the results by the specified fields. A comma-separated
   * list of any of these fields: * `psc_propagation_status.source_spoke` *
   * `psc_propagation_status.source_group` *
   * `psc_propagation_status.source_forwarding_rule` *
   * `psc_propagation_status.target_spoke` *
   * `psc_propagation_status.target_group` * `psc_propagation_status.code`
   */
  groupBy?: string;
  /**
   * Optional. Sort the results in ascending order by the specified fields. A
   * comma-separated list of any of these fields: *
   * `psc_propagation_status.source_spoke` *
   * `psc_propagation_status.source_group` *
   * `psc_propagation_status.source_forwarding_rule` *
   * `psc_propagation_status.target_spoke` *
   * `psc_propagation_status.target_group` * `psc_propagation_status.code` If
   * `group_by` is set, the value of the `order_by` field must be the same as or
   * a subset of the `group_by` field.
   */
  orderBy?: string;
  /**
   * Optional. The maximum number of results to return per page.
   */
  pageSize?: number;
  /**
   * Optional. The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsGlobalHubsRouteTablesList.
 */
export interface ProjectsLocationsGlobalHubsRouteTablesListOptions {
  /**
   * An expression that filters the list of results.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results to return per page.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsGlobalHubsRouteTablesRoutesList.
 */
export interface ProjectsLocationsGlobalHubsRouteTablesRoutesListOptions {
  /**
   * An expression that filters the list of results.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results to return per page.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsGlobalPolicyBasedRoutesCreate.
 */
export interface ProjectsLocationsGlobalPolicyBasedRoutesCreateOptions {
  /**
   * Required. Unique id for the policy-based route to create. Provided by the
   * client when the resource is created. The name must comply with
   * https://google.aip.dev/122#resource-id-segments. Specifically, the name
   * must be 1-63 characters long and match the regular expression
   * [a-z]([a-z0-9-]*[a-z0-9])?. The first character must be a lowercase letter,
   * and all following characters (except for the last character) must be a
   * dash, lowercase letter, or digit. The last character must be a lowercase
   * letter or digit.
   */
  policyBasedRouteId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server knows to
   * ignore the request if it has already been completed. The server guarantees
   * 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,
   * ignores 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
 * NetworkConnectivity#projectsLocationsGlobalPolicyBasedRoutesDelete.
 */
export interface ProjectsLocationsGlobalPolicyBasedRoutesDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server knows to
   * ignore the request if it has already been completed. The server guarantees
   * 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,
   * ignores 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
 * NetworkConnectivity#projectsLocationsGlobalPolicyBasedRoutesGetIamPolicy.
 */
export interface ProjectsLocationsGlobalPolicyBasedRoutesGetIamPolicyOptions {
  /**
   * 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
 * NetworkConnectivity#projectsLocationsGlobalPolicyBasedRoutesList.
 */
export interface ProjectsLocationsGlobalPolicyBasedRoutesListOptions {
  /**
   * A filter expression that filters the results listed in the response.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results per page that should be returned.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsInternalRangesCreate.
 */
export interface ProjectsLocationsInternalRangesCreateOptions {
  /**
   * Optional. Resource ID (i.e. 'foo' in
   * '[...]/projects/p/locations/l/internalRanges/foo') See
   * https://google.aip.dev/122#resource-id-segments Unique per location.
   */
  internalRangeId?: 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
 * NetworkConnectivity#projectsLocationsInternalRangesDelete.
 */
export interface ProjectsLocationsInternalRangesDeleteOptions {
  /**
   * 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
 * NetworkConnectivity#projectsLocationsInternalRangesGetIamPolicy.
 */
export interface ProjectsLocationsInternalRangesGetIamPolicyOptions {
  /**
   * 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
 * NetworkConnectivity#projectsLocationsInternalRangesList.
 */
export interface ProjectsLocationsInternalRangesListOptions {
  /**
   * A filter expression that filters the results listed in the response.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results per page that should be returned.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsInternalRangesPatch.
 */
export interface ProjectsLocationsInternalRangesPatchOptions {
  /**
   * 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;
  /**
   * Optional. Field mask is used to specify the fields to be overwritten in
   * the InternalRange resource by the update. The fields 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. If the user does not provide a
   * mask then all fields will be overwritten.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for NetworkConnectivity#projectsLocationsList.
 */
export interface ProjectsLocationsListOptions {
  /**
   * Optional. A list of extra location types that should be used as conditions
   * for controlling the visibility of the locations.
   */
  extraLocationTypes?: string;
  /**
   * 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 NetworkConnectivity#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
 * NetworkConnectivity#projectsLocationsRegionalEndpointsCreate.
 */
export interface ProjectsLocationsRegionalEndpointsCreateOptions {
  /**
   * Required. Unique id of the Regional Endpoint to be created. @pattern:
   * ^[-a-z0-9](?:[-a-z0-9]{0,44})[a-z0-9]$
   */
  regionalEndpointId?: string;
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server knows to
   * ignore the request if it has already been completed. The server guarantees
   * 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 the original operation with the same request ID was received, and if so,
   * ignores 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
 * NetworkConnectivity#projectsLocationsRegionalEndpointsDelete.
 */
export interface ProjectsLocationsRegionalEndpointsDeleteOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server knows to
   * ignore the request if it has already been completed. The server guarantees
   * 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 the original operation with the same request ID was received, and if so,
   * ignores 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
 * NetworkConnectivity#projectsLocationsRegionalEndpointsList.
 */
export interface ProjectsLocationsRegionalEndpointsListOptions {
  /**
   * A filter expression that filters the results listed in the response.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * Requested page size. Server may return fewer items than requested. If
   * unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * A page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceClassesDelete.
 */
export interface ProjectsLocationsServiceClassesDeleteOptions {
  /**
   * Optional. The etag is computed by the server, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: 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 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
 * NetworkConnectivity#projectsLocationsServiceClassesGetIamPolicy.
 */
export interface ProjectsLocationsServiceClassesGetIamPolicyOptions {
  /**
   * 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
 * NetworkConnectivity#projectsLocationsServiceClassesList.
 */
export interface ProjectsLocationsServiceClassesListOptions {
  /**
   * A filter expression that filters the results listed in the response.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results per page that should be returned.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceClassesPatch.
 */
export interface ProjectsLocationsServiceClassesPatchOptions {
  /**
   * 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;
  /**
   * Optional. Field mask is used to specify the fields to be overwritten in
   * the ServiceClass resource by the update. The fields 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. If the user does not provide a
   * mask then all fields will be overwritten.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceConnectionMapsCreate.
 */
export interface ProjectsLocationsServiceConnectionMapsCreateOptions {
  /**
   * 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;
  /**
   * Optional. Resource ID (i.e. 'foo' in
   * '[...]/projects/p/locations/l/serviceConnectionMaps/foo') See
   * https://google.aip.dev/122#resource-id-segments Unique per location. If one
   * is not provided, one will be generated.
   */
  serviceConnectionMapId?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceConnectionMapsDelete.
 */
export interface ProjectsLocationsServiceConnectionMapsDeleteOptions {
  /**
   * Optional. The etag is computed by the server, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: 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 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
 * NetworkConnectivity#projectsLocationsServiceConnectionMapsGetIamPolicy.
 */
export interface ProjectsLocationsServiceConnectionMapsGetIamPolicyOptions {
  /**
   * 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
 * NetworkConnectivity#projectsLocationsServiceConnectionMapsList.
 */
export interface ProjectsLocationsServiceConnectionMapsListOptions {
  /**
   * A filter expression that filters the results listed in the response.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results per page that should be returned.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceConnectionMapsPatch.
 */
export interface ProjectsLocationsServiceConnectionMapsPatchOptions {
  /**
   * 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;
  /**
   * Optional. Field mask is used to specify the fields to be overwritten in
   * the ServiceConnectionMap resource by the update. The fields 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. If the user does not provide a
   * mask then all fields will be overwritten.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceConnectionPoliciesCreate.
 */
export interface ProjectsLocationsServiceConnectionPoliciesCreateOptions {
  /**
   * 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;
  /**
   * Optional. Resource ID (i.e. 'foo' in
   * '[...]/projects/p/locations/l/serviceConnectionPolicies/foo') See
   * https://google.aip.dev/122#resource-id-segments Unique per location.
   */
  serviceConnectionPolicyId?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceConnectionPoliciesDelete.
 */
export interface ProjectsLocationsServiceConnectionPoliciesDeleteOptions {
  /**
   * Optional. The etag is computed by the server, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: 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 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
 * NetworkConnectivity#projectsLocationsServiceConnectionPoliciesGetIamPolicy.
 */
export interface ProjectsLocationsServiceConnectionPoliciesGetIamPolicyOptions {
  /**
   * 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
 * NetworkConnectivity#projectsLocationsServiceConnectionPoliciesList.
 */
export interface ProjectsLocationsServiceConnectionPoliciesListOptions {
  /**
   * A filter expression that filters the results listed in the response.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results per page that should be returned.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceConnectionPoliciesPatch.
 */
export interface ProjectsLocationsServiceConnectionPoliciesPatchOptions {
  /**
   * 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;
  /**
   * Optional. Field mask is used to specify the fields to be overwritten in
   * the ServiceConnectionPolicy resource by the update. The fields 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. If the user does not provide a
   * mask then all fields will be overwritten.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceConnectionTokensCreate.
 */
export interface ProjectsLocationsServiceConnectionTokensCreateOptions {
  /**
   * 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;
  /**
   * Optional. Resource ID (i.e. 'foo' in
   * '[...]/projects/p/locations/l/ServiceConnectionTokens/foo') See
   * https://google.aip.dev/122#resource-id-segments Unique per location. If one
   * is not provided, one will be generated.
   */
  serviceConnectionTokenId?: string;
}

/**
 * Additional options for
 * NetworkConnectivity#projectsLocationsServiceConnectionTokensDelete.
 */
export interface ProjectsLocationsServiceConnectionTokensDeleteOptions {
  /**
   * Optional. The etag is computed by the server, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: 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 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
 * NetworkConnectivity#projectsLocationsServiceConnectionTokensList.
 */
export interface ProjectsLocationsServiceConnectionTokensListOptions {
  /**
   * A filter expression that filters the results listed in the response.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results per page that should be returned.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for NetworkConnectivity#projectsLocationsSpokesCreate.
 */
export interface ProjectsLocationsSpokesCreateOptions {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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. Unique id for the spoke to create.
   */
  spokeId?: string;
}

/**
 * Additional options for NetworkConnectivity#projectsLocationsSpokesDelete.
 */
export interface ProjectsLocationsSpokesDeleteOptions {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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
 * NetworkConnectivity#projectsLocationsSpokesGetIamPolicy.
 */
export interface ProjectsLocationsSpokesGetIamPolicyOptions {
  /**
   * 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 NetworkConnectivity#projectsLocationsSpokesList.
 */
export interface ProjectsLocationsSpokesListOptions {
  /**
   * An expression that filters the list of results.
   */
  filter?: string;
  /**
   * Sort the results by a certain order.
   */
  orderBy?: string;
  /**
   * The maximum number of results to return per page.
   */
  pageSize?: number;
  /**
   * The page token.
   */
  pageToken?: string;
}

/**
 * Additional options for NetworkConnectivity#projectsLocationsSpokesPatch.
 */
export interface ProjectsLocationsSpokesPatchOptions {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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;
  /**
   * Optional. In the case of an update to an existing spoke, field mask is
   * used to specify the fields to be overwritten. The fields specified in the
   * update_mask are relative to the resource, not the full request. A field is
   * overwritten if it is in the mask. If the user does not provide a mask, then
   * all fields are overwritten.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Configuration used for Private Service Connect connections. Used when
 * Infrastructure is PSC.
 */
export interface PscConfig {
  /**
   * Optional. List of Projects, Folders, or Organizations from where the
   * Producer instance can be within. For example, a network administrator can
   * provide both 'organizations/foo' and 'projects/bar' as
   * allowed_google_producers_resource_hierarchy_levels. This allowlists this
   * network to connect with any Producer instance within the 'foo' organization
   * or the 'bar' project. By default,
   * allowed_google_producers_resource_hierarchy_level is empty. The format for
   * each allowed_google_producers_resource_hierarchy_level is / where is one of
   * 'projects', 'folders', or 'organizations' and is either the ID or the
   * number of the resource type. Format for each
   * allowed_google_producers_resource_hierarchy_level value: 'projects/' or
   * 'folders/' or 'organizations/' Eg. [projects/my-project-id, projects/567,
   * folders/891, organizations/123]
   */
  allowedGoogleProducersResourceHierarchyLevel?: string[];
  /**
   * Optional. Max number of PSC connections for this policy.
   */
  limit?: bigint;
  /**
   * Optional. ProducerInstanceLocation is used to specify which authorization
   * mechanism to use to determine which projects the Producer instance can be
   * within.
   */
  producerInstanceLocation?:  | "PRODUCER_INSTANCE_LOCATION_UNSPECIFIED" | "CUSTOM_RESOURCE_HIERARCHY_LEVELS";
  /**
   * The resource paths of subnetworks to use for IP address management.
   * Example:
   * projects/{projectNumOrId}/regions/{region}/subnetworks/{resourceId}.
   */
  subnetworks?: string[];
}

function serializePscConfig(data: any): PscConfig {
  return {
    ...data,
    limit: data["limit"] !== undefined ? String(data["limit"]) : undefined,
  };
}

function deserializePscConfig(data: any): PscConfig {
  return {
    ...data,
    limit: data["limit"] !== undefined ? BigInt(data["limit"]) : undefined,
  };
}

/**
 * Information about a specific Private Service Connect connection.
 */
export interface PscConnection {
  /**
   * The resource reference of the consumer address.
   */
  consumerAddress?: string;
  /**
   * The resource reference of the PSC Forwarding Rule within the consumer VPC.
   */
  consumerForwardingRule?: string;
  /**
   * The project where the PSC connection is created.
   */
  consumerTargetProject?: string;
  /**
   * The most recent error during operating this connection. Deprecated, please
   * use error_info instead.
   */
  error?: GoogleRpcStatus;
  /**
   * Output only. The error info for the latest error during operating this
   * connection.
   */
  readonly errorInfo?: GoogleRpcErrorInfo;
  /**
   * The error type indicates whether the error is consumer facing, producer
   * facing or system internal.
   */
  errorType?:  | "CONNECTION_ERROR_TYPE_UNSPECIFIED" | "ERROR_INTERNAL" | "ERROR_CONSUMER_SIDE" | "ERROR_PRODUCER_SIDE";
  /**
   * The last Compute Engine operation to setup PSC connection.
   */
  gceOperation?: string;
  /**
   * The requested IP version for the PSC connection.
   */
  ipVersion?:  | "IP_VERSION_UNSPECIFIED" | "IPV4" | "IPV6";
  /**
   * Immutable. Deprecated. Use producer_instance_metadata instead. An
   * immutable identifier for the producer instance.
   */
  producerInstanceId?: string;
  /**
   * Immutable. An immutable map for the producer instance metadata.
   */
  producerInstanceMetadata?: {
    [key: string]: string
  };
  /**
   * The PSC connection id of the PSC forwarding rule.
   */
  pscConnectionId?: string;
  /**
   * Output only. The URI of the subnetwork selected to allocate IP address for
   * this connection.
   */
  readonly selectedSubnetwork?: string;
  /**
   * Output only. [Output only] The service class associated with this PSC
   * Connection. The value is derived from the SCPolicy and matches the service
   * class name provided by the customer.
   */
  readonly serviceClass?: string;
  /**
   * State of the PSC Connection
   */
  state?:  | "STATE_UNSPECIFIED" | "ACTIVE" | "FAILED" | "CREATING" | "DELETING" | "CREATE_REPAIRING" | "DELETE_REPAIRING";
}

/**
 * The status of one or more propagated Private Service Connect connections in
 * a hub.
 */
export interface PscPropagationStatus {
  /**
   * The propagation status.
   */
  code?:  | "CODE_UNSPECIFIED" | "READY" | "PROPAGATING" | "ERROR_PRODUCER_PROPAGATED_CONNECTION_LIMIT_EXCEEDED" | "ERROR_PRODUCER_NAT_IP_SPACE_EXHAUSTED" | "ERROR_PRODUCER_QUOTA_EXCEEDED" | "ERROR_CONSUMER_QUOTA_EXCEEDED";
  /**
   * The human-readable summary of the Private Service Connect connection
   * propagation status.
   */
  message?: string;
  /**
   * The name of the forwarding rule exported to the hub.
   */
  sourceForwardingRule?: string;
  /**
   * The name of the group that the source spoke belongs to.
   */
  sourceGroup?: string;
  /**
   * The name of the spoke that the source forwarding rule belongs to.
   */
  sourceSpoke?: string;
  /**
   * The name of the group that the target spoke belongs to.
   */
  targetGroup?: string;
  /**
   * The name of the spoke that the source forwarding rule propagates to.
   */
  targetSpoke?: string;
}

/**
 * The response for HubService.QueryHubStatus.
 */
export interface QueryHubStatusResponse {
  /**
   * The list of hub status.
   */
  hubStatusEntries?: HubStatusEntry[];
  /**
   * The token for the next page of the response. To see more results, use this
   * value as the page_token for your next request. If this value is empty,
   * there are no more results.
   */
  nextPageToken?: string;
}

/**
 * The RegionalEndpoint resource.
 */
export interface RegionalEndpoint {
  /**
   * Required. The access type of this regional endpoint. This field is
   * reflected in the PSC Forwarding Rule configuration to enable global access.
   */
  accessType?:  | "ACCESS_TYPE_UNSPECIFIED" | "GLOBAL" | "REGIONAL";
  /**
   * Optional. The IP Address of the Regional Endpoint. When no address is
   * provided, an IP from the subnetwork is allocated. Use one of the following
   * formats: * IPv4 address as in `10.0.0.1` * Address resource URI as in
   * `projects/{project}/regions/{region}/addresses/{address_name}` for an IPv4
   * or IPv6 address.
   */
  address?: string;
  /**
   * Output only. Time when the RegionalEndpoint was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. A description of this resource.
   */
  description?: string;
  /**
   * Output only. The literal IP address of the PSC Forwarding Rule created on
   * behalf of the customer. This field is deprecated. Use address instead.
   */
  readonly ipAddress?: string;
  /**
   * User-defined labels.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. The name of a RegionalEndpoint. Pattern:
   * `projects/{project}/locations/{location}/regionalEndpoints/^[-a-z0-9](?:[-a-z0-9]{0,44})[a-z0-9]$`.
   */
  readonly name?: string;
  /**
   * The name of the VPC network for this private regional endpoint. Format:
   * `projects/{project}/global/networks/{network}`
   */
  network?: string;
  /**
   * Output only. The resource reference of the PSC Forwarding Rule created on
   * behalf of the customer. Format:
   * `//compute.googleapis.com/projects/{project}/regions/{region}/forwardingRules/{forwarding_rule_name}`
   */
  readonly pscForwardingRule?: string;
  /**
   * The name of the subnetwork from which the IP address will be allocated.
   * Format: `projects/{project}/regions/{region}/subnetworks/{subnetwork}`
   */
  subnetwork?: string;
  /**
   * Required. The service endpoint this private regional endpoint connects to.
   * Format: `{apiname}.{region}.p.rep.googleapis.com` Example:
   * "cloudkms.us-central1.p.rep.googleapis.com".
   */
  targetGoogleApi?: string;
  /**
   * Output only. Time when the RegionalEndpoint was updated.
   */
  readonly updateTime?: Date;
}

/**
 * The request for HubService.RejectHubSpoke.
 */
export interface RejectHubSpokeRequest {
  /**
   * Optional. Additional information provided by the hub administrator.
   */
  details?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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. The URI of the spoke to reject from the hub.
   */
  spokeUri?: string;
}

/**
 * The response for HubService.RejectHubSpoke.
 */
export interface RejectHubSpokeResponse {
  /**
   * The spoke that was operated on.
   */
  spoke?: Spoke;
}

/**
 * The request for HubService.RejectSpokeUpdate.
 */
export interface RejectSpokeUpdateRequest {
  /**
   * Optional. Additional information provided by the hub administrator.
   */
  details?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that a
   * request doesn't result in creation of duplicate commitments for at least 60
   * minutes. 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 to see whether the original operation
   * was received. If it was, the server ignores the second request. This
   * behavior prevents clients from mistakenly 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. The etag of the spoke to reject update.
   */
  spokeEtag?: string;
  /**
   * Required. The URI of the spoke to reject update.
   */
  spokeUri?: string;
}

/**
 * A route defines a path from VM instances within a spoke to a specific
 * destination resource. Only VPC spokes have routes.
 */
export interface Route {
  /**
   * Output only. The time the route was created.
   */
  readonly createTime?: Date;
  /**
   * An optional description of the route.
   */
  description?: string;
  /**
   * The destination IP address range.
   */
  ipCidrRange?: string;
  /**
   * Optional labels in key-value pair format. For more information about
   * labels, see [Requirements for
   * labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. The origin location of the route. Uses the following form:
   * "projects/{project}/locations/{location}" Example:
   * projects/1234/locations/us-central1
   */
  readonly location?: string;
  /**
   * Immutable. The name of the route. Route names must be unique. Route names
   * use the following form:
   * `projects/{project_number}/locations/global/hubs/{hub}/routeTables/{route_table_id}/routes/{route_id}`
   */
  name?: string;
  /**
   * Immutable. The next-hop VLAN attachment for packets on this route.
   */
  nextHopInterconnectAttachment?: NextHopInterconnectAttachment;
  /**
   * Immutable. The next-hop Router appliance instance for packets on this
   * route.
   */
  nextHopRouterApplianceInstance?: NextHopRouterApplianceInstance;
  /**
   * Immutable. The next-hop spoke for packets on this route.
   */
  nextHopSpoke?: NextHopSpoke;
  /**
   * Immutable. The destination VPC network for packets on this route.
   */
  nextHopVpcNetwork?: NextHopVpcNetwork;
  /**
   * Immutable. The next-hop VPN tunnel for packets on this route.
   */
  nextHopVpnTunnel?: NextHopVPNTunnel;
  /**
   * Output only. The priority of this route. Priority is used to break ties in
   * cases where a destination matches more than one route. In these cases the
   * route with the lowest-numbered priority value wins.
   */
  readonly priority?: bigint;
  /**
   * Immutable. The spoke that this route leads to. Example:
   * projects/12345/locations/global/spokes/SPOKE
   */
  spoke?: string;
  /**
   * Output only. The current lifecycle state of the route.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING" | "ACCEPTING" | "REJECTING" | "UPDATING" | "INACTIVE" | "OBSOLETE" | "FAILED";
  /**
   * Output only. The route's type. Its type is determined by the properties of
   * its IP address range.
   */
  readonly type?:  | "ROUTE_TYPE_UNSPECIFIED" | "VPC_PRIMARY_SUBNET" | "VPC_SECONDARY_SUBNET" | "DYNAMIC_ROUTE";
  /**
   * Output only. The Google-generated UUID for the route. This value is unique
   * across all Network Connectivity Center route resources. If a route is
   * deleted and another with the same name is created, the new route is
   * assigned a different `uid`.
   */
  readonly uid?: string;
  /**
   * Output only. The time the route was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * A router appliance instance is a Compute Engine virtual machine (VM)
 * instance that acts as a BGP speaker. A router appliance instance is specified
 * by the URI of the VM and the internal IP address of one of the VM's network
 * interfaces.
 */
export interface RouterApplianceInstance {
  /**
   * The IP address on the VM to use for peering.
   */
  ipAddress?: string;
  /**
   * The URI of the VM.
   */
  virtualMachine?: string;
}

export interface RouteTable {
  /**
   * Output only. The time the route table was created.
   */
  readonly createTime?: Date;
  /**
   * An optional description of the route table.
   */
  description?: string;
  /**
   * Optional labels in key-value pair format. For more information about
   * labels, see [Requirements for
   * labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Immutable. The name of the route table. Route table names must be unique.
   * They use the following form:
   * `projects/{project_number}/locations/global/hubs/{hub}/routeTables/{route_table_id}`
   */
  name?: string;
  /**
   * Output only. The current lifecycle state of this route table.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING" | "ACCEPTING" | "REJECTING" | "UPDATING" | "INACTIVE" | "OBSOLETE" | "FAILED";
  /**
   * Output only. The Google-generated UUID for the route table. This value is
   * unique across all route table resources. If a route table is deleted and
   * another with the same name is created, the new route table is assigned a
   * different `uid`.
   */
  readonly uid?: string;
  /**
   * Output only. The time the route table was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * RoutingVPC contains information about the VPC networks associated with the
 * spokes of a Network Connectivity Center hub.
 */
export interface RoutingVPC {
  /**
   * Output only. If true, indicates that this VPC network is currently
   * associated with spokes that use the data transfer feature (spokes where the
   * site_to_site_data_transfer field is set to true). If you create new spokes
   * that use data transfer, they must be associated with this VPC network. At
   * most, one VPC network will have this field set to true.
   */
  readonly requiredForNewSiteToSiteDataTransferSpokes?: boolean;
  /**
   * The URI of the VPC network.
   */
  uri?: string;
}

/**
 * The ServiceClass resource.
 */
export interface ServiceClass {
  /**
   * Output only. Time when the ServiceClass was created.
   */
  readonly createTime?: Date;
  /**
   * A description of this resource.
   */
  description?: string;
  /**
   * Optional. The etag is computed by the server, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: string;
  /**
   * User-defined labels.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Immutable. The name of a ServiceClass resource. Format:
   * projects/{project}/locations/{location}/serviceClasses/{service_class} See:
   * https://google.aip.dev/122#fields-representing-resource-names
   */
  name?: string;
  /**
   * Output only. The generated service class name. Use this name to refer to
   * the Service class in Service Connection Maps and Service Connection
   * Policies.
   */
  readonly serviceClass?: string;
  /**
   * Output only. Time when the ServiceClass was updated.
   */
  readonly updateTime?: Date;
}

/**
 * The ServiceConnectionMap resource.
 */
export interface ServiceConnectionMap {
  /**
   * The PSC configurations on consumer side.
   */
  consumerPscConfigs?: ConsumerPscConfig[];
  /**
   * Output only. PSC connection details on consumer side.
   */
  readonly consumerPscConnections?: ConsumerPscConnection[];
  /**
   * Output only. Time when the ServiceConnectionMap was created.
   */
  readonly createTime?: Date;
  /**
   * A description of this resource.
   */
  description?: string;
  /**
   * Optional. The etag is computed by the server, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: string;
  /**
   * Output only. The infrastructure used for connections between
   * consumers/producers.
   */
  readonly infrastructure?:  | "INFRASTRUCTURE_UNSPECIFIED" | "PSC";
  /**
   * User-defined labels.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Immutable. The name of a ServiceConnectionMap. Format:
   * projects/{project}/locations/{location}/serviceConnectionMaps/{service_connection_map}
   * See: https://google.aip.dev/122#fields-representing-resource-names
   */
  name?: string;
  /**
   * The PSC configurations on producer side.
   */
  producerPscConfigs?: ProducerPscConfig[];
  /**
   * The service class identifier this ServiceConnectionMap is for. The user of
   * ServiceConnectionMap create API needs to have
   * networkconnecitivty.serviceclasses.use iam permission for the service
   * class.
   */
  serviceClass?: string;
  /**
   * Output only. The service class uri this ServiceConnectionMap is for.
   */
  readonly serviceClassUri?: string;
  /**
   * The token provided by the consumer. This token authenticates that the
   * consumer can create a connection within the specified project and network.
   */
  token?: string;
  /**
   * Output only. Time when the ServiceConnectionMap was updated.
   */
  readonly updateTime?: Date;
}

/**
 * The ServiceConnectionPolicy resource.
 */
export interface ServiceConnectionPolicy {
  /**
   * Output only. Time when the ServiceConnectionPolicy was created.
   */
  readonly createTime?: Date;
  /**
   * A description of this resource.
   */
  description?: string;
  /**
   * Optional. The etag is computed by the server, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: string;
  /**
   * Output only. The type of underlying resources used to create the
   * connection.
   */
  readonly infrastructure?:  | "INFRASTRUCTURE_UNSPECIFIED" | "PSC";
  /**
   * User-defined labels.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Immutable. The name of a ServiceConnectionPolicy. Format:
   * projects/{project}/locations/{location}/serviceConnectionPolicies/{service_connection_policy}
   * See: https://google.aip.dev/122#fields-representing-resource-names
   */
  name?: string;
  /**
   * The resource path of the consumer network. Example: -
   * projects/{projectNumOrId}/global/networks/{resourceId}.
   */
  network?: string;
  /**
   * Configuration used for Private Service Connect connections. Used when
   * Infrastructure is PSC.
   */
  pscConfig?: PscConfig;
  /**
   * Output only. [Output only] Information about each Private Service Connect
   * connection.
   */
  readonly pscConnections?: PscConnection[];
  /**
   * The service class identifier for which this ServiceConnectionPolicy is
   * for. The service class identifier is a unique, symbolic representation of a
   * ServiceClass. It is provided by the Service Producer. Google services have
   * a prefix of gcp or google-cloud. For example, gcp-memorystore-redis or
   * google-cloud-sql. 3rd party services do not. For example,
   * test-service-a3dfcx.
   */
  serviceClass?: string;
  /**
   * Output only. Time when the ServiceConnectionPolicy was updated.
   */
  readonly updateTime?: Date;
}

function serializeServiceConnectionPolicy(data: any): ServiceConnectionPolicy {
  return {
    ...data,
    pscConfig: data["pscConfig"] !== undefined ? serializePscConfig(data["pscConfig"]) : undefined,
  };
}

function deserializeServiceConnectionPolicy(data: any): ServiceConnectionPolicy {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    pscConfig: data["pscConfig"] !== undefined ? deserializePscConfig(data["pscConfig"]) : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
  };
}

/**
 * The ServiceConnectionToken resource.
 */
export interface ServiceConnectionToken {
  /**
   * Output only. Time when the ServiceConnectionToken was created.
   */
  readonly createTime?: Date;
  /**
   * A description of this resource.
   */
  description?: string;
  /**
   * Optional. The etag is computed by the server, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: string;
  /**
   * Output only. The time to which this token is valid.
   */
  readonly expireTime?: Date;
  /**
   * User-defined labels.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Immutable. The name of a ServiceConnectionToken. Format:
   * projects/{project}/locations/{location}/ServiceConnectionTokens/{service_connection_token}
   * See: https://google.aip.dev/122#fields-representing-resource-names
   */
  name?: string;
  /**
   * The resource path of the network associated with this token. Example:
   * projects/{projectNumOrId}/global/networks/{resourceId}.
   */
  network?: string;
  /**
   * Output only. The token generated by Automation.
   */
  readonly token?: string;
  /**
   * Output only. Time when the ServiceConnectionToken was updated.
   */
  readonly updateTime?: Date;
}

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

/**
 * A Network Connectivity Center spoke represents one or more network
 * connectivity resources. When you create a spoke, you associate it with a hub.
 * You must also identify a value for exactly one of the following fields: *
 * linked_vpn_tunnels * linked_interconnect_attachments *
 * linked_router_appliance_instances * linked_vpc_network
 */
export interface Spoke {
  /**
   * Output only. The time the spoke was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. An optional description of the spoke.
   */
  description?: string;
  /**
   * Optional. This checksum is computed by the server based on the value of
   * other fields, and may be sent on update and delete requests to ensure the
   * client has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Optional. The list of fields waiting for hub administration's approval.
   */
  fieldPathsPendingUpdate?: string[];
  /**
   * Optional. The name of the group that this spoke is associated with.
   */
  group?: string;
  /**
   * Immutable. The name of the hub that this spoke is attached to.
   */
  hub?: string;
  /**
   * Optional labels in key-value pair format. For more information about
   * labels, see [Requirements for
   * labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. VLAN attachments that are associated with the spoke.
   */
  linkedInterconnectAttachments?: LinkedInterconnectAttachments;
  /**
   * Optional. The linked producer VPC that is associated with the spoke.
   */
  linkedProducerVpcNetwork?: LinkedProducerVpcNetwork;
  /**
   * Optional. Router appliance instances that are associated with the spoke.
   */
  linkedRouterApplianceInstances?: LinkedRouterApplianceInstances;
  /**
   * Optional. VPC network that is associated with the spoke.
   */
  linkedVpcNetwork?: LinkedVpcNetwork;
  /**
   * Optional. VPN tunnels that are associated with the spoke.
   */
  linkedVpnTunnels?: LinkedVpnTunnels;
  /**
   * Immutable. The name of the spoke. Spoke names must be unique. They use the
   * following form:
   * `projects/{project_number}/locations/{region}/spokes/{spoke_id}`
   */
  name?: string;
  /**
   * Output only. The reasons for current state of the spoke.
   */
  readonly reasons?: StateReason[];
  /**
   * Output only. The type of resource associated with the spoke.
   */
  readonly spokeType?:  | "SPOKE_TYPE_UNSPECIFIED" | "VPN_TUNNEL" | "INTERCONNECT_ATTACHMENT" | "ROUTER_APPLIANCE" | "VPC_NETWORK" | "PRODUCER_VPC_NETWORK";
  /**
   * Output only. The current lifecycle state of this spoke.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING" | "ACCEPTING" | "REJECTING" | "UPDATING" | "INACTIVE" | "OBSOLETE" | "FAILED";
  /**
   * Output only. The Google-generated UUID for the spoke. This value is unique
   * across all spoke resources. If a spoke is deleted and another with the same
   * name is created, the new spoke is assigned a different `unique_id`.
   */
  readonly uniqueId?: string;
  /**
   * Output only. The time the spoke was last updated.
   */
  readonly updateTime?: Date;
}

/**
 * The number of spokes that are in a particular state and associated with a
 * given hub.
 */
export interface SpokeStateCount {
  /**
   * Output only. The total number of spokes that are in this state and
   * associated with a given hub.
   */
  readonly count?: bigint;
  /**
   * Output only. The state of the spokes.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING" | "ACCEPTING" | "REJECTING" | "UPDATING" | "INACTIVE" | "OBSOLETE" | "FAILED";
}

/**
 * The number of spokes in the hub that are inactive for this reason.
 */
export interface SpokeStateReasonCount {
  /**
   * Output only. The total number of spokes that are inactive for a particular
   * reason and associated with a given hub.
   */
  readonly count?: bigint;
  /**
   * Output only. The reason that a spoke is inactive.
   */
  readonly stateReasonCode?:  | "CODE_UNSPECIFIED" | "PENDING_REVIEW" | "REJECTED" | "PAUSED" | "FAILED" | "UPDATE_PENDING_REVIEW" | "UPDATE_REJECTED" | "UPDATE_FAILED";
}

/**
 * Summarizes information about the spokes associated with a hub. The summary
 * includes a count of spokes according to type and according to state. If any
 * spokes are inactive, the summary also lists the reasons they are inactive,
 * including a count for each reason.
 */
export interface SpokeSummary {
  /**
   * Output only. Counts the number of spokes that are in each state and
   * associated with a given hub.
   */
  readonly spokeStateCounts?: SpokeStateCount[];
  /**
   * Output only. Counts the number of spokes that are inactive for each
   * possible reason and associated with a given hub.
   */
  readonly spokeStateReasonCounts?: SpokeStateReasonCount[];
  /**
   * Output only. Counts the number of spokes of each type that are associated
   * with a specific hub.
   */
  readonly spokeTypeCounts?: SpokeTypeCount[];
}

/**
 * The number of spokes of a given type that are associated with a specific
 * hub. The type indicates what kind of resource is associated with the spoke.
 */
export interface SpokeTypeCount {
  /**
   * Output only. The total number of spokes of this type that are associated
   * with the hub.
   */
  readonly count?: bigint;
  /**
   * Output only. The type of the spokes.
   */
  readonly spokeType?:  | "SPOKE_TYPE_UNSPECIFIED" | "VPN_TUNNEL" | "INTERCONNECT_ATTACHMENT" | "ROUTER_APPLIANCE" | "VPC_NETWORK" | "PRODUCER_VPC_NETWORK";
}

/**
 * The reason a spoke is inactive.
 */
export interface StateReason {
  /**
   * The code associated with this reason.
   */
  code?:  | "CODE_UNSPECIFIED" | "PENDING_REVIEW" | "REJECTED" | "PAUSED" | "FAILED" | "UPDATE_PENDING_REVIEW" | "UPDATE_REJECTED" | "UPDATE_FAILED";
  /**
   * Human-readable details about this reason.
   */
  message?: string;
  /**
   * Additional information provided by the user in the RejectSpoke call.
   */
  userDetails?: string;
}

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

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

/**
 * VM instances that this policy-based route applies to.
 */
export interface VirtualMachine {
  /**
   * Optional. A list of VM instance tags that this policy-based route applies
   * to. VM instances that have ANY of tags specified here installs this PBR.
   */
  tags?: string[];
}

/**
 * Informational warning message.
 */
export interface Warnings {
  /**
   * Output only. A warning code, if applicable.
   */
  readonly code?:  | "WARNING_UNSPECIFIED" | "RESOURCE_NOT_ACTIVE" | "RESOURCE_BEING_MODIFIED";
  /**
   * Output only. Metadata about this warning in key: value format. The key
   * should provides more detail on the warning being returned. For example, for
   * warnings where there are no results in a list request for a particular
   * zone, this key might be scope and the key value might be the zone name.
   * Other examples might be a key indicating a deprecated resource and a
   * suggested replacement.
   */
  readonly data?: {
    [key: string]: string
  };
  /**
   * Output only. A human-readable description of the warning code.
   */
  readonly warningMessage?: 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;
}