// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * App Hub API Client for Deno
 * ===========================
 * 
 * 
 * 
 * Docs: https://cloud.google.com/app-hub/docs/
 * Source: https://googleapis.deno.dev/v1/apphub:v1.ts
 */

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

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

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

  /**
   * Creates an Application in a host project and location.
   *
   * @param parent Required. Project and location to create Application in. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsApplicationsCreate(parent: string, req: Application, opts: ProjectsLocationsApplicationsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/applications`);
    if (opts.applicationId !== undefined) {
      url.searchParams.append("applicationId", String(opts.applicationId));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes an Application in a host project and location.
   *
   * @param name Required. Fully qualified name of the Application to delete. Expected format: `projects/{project}/locations/{location}/applications/{application}`.
   */
  async projectsLocationsApplicationsDelete(name: string, opts: ProjectsLocationsApplicationsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets an Application in a host project and location.
   *
   * @param name Required. Fully qualified name of the Application to fetch. Expected format: `projects/{project}/locations/{location}/applications/{application}`.
   */
  async projectsLocationsApplicationsGet(name: string): Promise<Application> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Application;
  }

  /**
   * 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 projectsLocationsApplicationsGetIamPolicy(resource: string, opts: ProjectsLocationsApplicationsGetIamPolicyOptions = {}): 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 Applications in a host project and location.
   *
   * @param parent Required. Project and location to list Applications on. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsApplicationsList(parent: string, opts: ProjectsLocationsApplicationsListOptions = {}): Promise<ListApplicationsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/applications`);
    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 ListApplicationsResponse;
  }

  /**
   * Updates an Application in a host project and location.
   *
   * @param name Identifier. The resource name of an Application. Format: `"projects/{host-project-id}/locations/{location}/applications/{application-id}"`
   */
  async projectsLocationsApplicationsPatch(name: string, req: Application, opts: ProjectsLocationsApplicationsPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsApplicationsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

  /**
   * Creates a Service in an Application.
   *
   * @param parent Required. Fully qualified name of the parent Application to create the Service in. Expected format: `projects/{project}/locations/{location}/applications/{application}`.
   */
  async projectsLocationsApplicationsServicesCreate(parent: string, req: Service, opts: ProjectsLocationsApplicationsServicesCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/services`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.serviceId !== undefined) {
      url.searchParams.append("serviceId", String(opts.serviceId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a Service from an Application.
   *
   * @param name Required. Fully qualified name of the Service to delete from an Application. Expected format: `projects/{project}/locations/{location}/applications/{application}/services/{service}`.
   */
  async projectsLocationsApplicationsServicesDelete(name: string, opts: ProjectsLocationsApplicationsServicesDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets a Service in an Application.
   *
   * @param name Required. Fully qualified name of the Service to fetch. Expected format: `projects/{project}/locations/{location}/applications/{application}/services/{service}`.
   */
  async projectsLocationsApplicationsServicesGet(name: string): Promise<Service> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Service;
  }

  /**
   * Lists Services in an Application.
   *
   * @param parent Required. Fully qualified name of the parent Application to list Services for. Expected format: `projects/{project}/locations/{location}/applications/{application}`.
   */
  async projectsLocationsApplicationsServicesList(parent: string, opts: ProjectsLocationsApplicationsServicesListOptions = {}): Promise<ListServicesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/services`);
    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 ListServicesResponse;
  }

  /**
   * Updates a Service in an Application.
   *
   * @param name Identifier. The resource name of a Service. Format: `"projects/{host-project-id}/locations/{location}/applications/{application-id}/services/{service-id}"`
   */
  async projectsLocationsApplicationsServicesPatch(name: string, req: Service, opts: ProjectsLocationsApplicationsServicesPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsApplicationsServicesPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

  /**
   * 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 projectsLocationsApplicationsSetIamPolicy(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 projectsLocationsApplicationsTestIamPermissions(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 Workload in an Application.
   *
   * @param parent Required. Fully qualified name of the Application to create Workload in. Expected format: `projects/{project}/locations/{location}/applications/{application}`.
   */
  async projectsLocationsApplicationsWorkloadsCreate(parent: string, req: Workload, opts: ProjectsLocationsApplicationsWorkloadsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/workloads`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.workloadId !== undefined) {
      url.searchParams.append("workloadId", String(opts.workloadId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a Workload from an Application.
   *
   * @param name Required. Fully qualified name of the Workload to delete from an Application. Expected format: `projects/{project}/locations/{location}/applications/{application}/workloads/{workload}`.
   */
  async projectsLocationsApplicationsWorkloadsDelete(name: string, opts: ProjectsLocationsApplicationsWorkloadsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets a Workload in an Application.
   *
   * @param name Required. Fully qualified name of the Workload to fetch. Expected format: `projects/{project}/locations/{location}/applications/{application}/workloads/{workload}`.
   */
  async projectsLocationsApplicationsWorkloadsGet(name: string): Promise<Workload> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Workload;
  }

  /**
   * Lists Workloads in an Application.
   *
   * @param parent Required. Fully qualified name of the parent Application to list Workloads for. Expected format: `projects/{project}/locations/{location}/applications/{application}`.
   */
  async projectsLocationsApplicationsWorkloadsList(parent: string, opts: ProjectsLocationsApplicationsWorkloadsListOptions = {}): Promise<ListWorkloadsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/workloads`);
    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 ListWorkloadsResponse;
  }

  /**
   * Updates a Workload in an Application.
   *
   * @param name Identifier. The resource name of the Workload. Format: `"projects/{host-project-id}/locations/{location}/applications/{application-id}/workloads/{workload-id}"`
   */
  async projectsLocationsApplicationsWorkloadsPatch(name: string, req: Workload, opts: ProjectsLocationsApplicationsWorkloadsPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsApplicationsWorkloadsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

  /**
   * Detaches a service project from a host project. You can call this API from
   * any service project without needing access to the host project that it is
   * attached to.
   *
   * @param name Required. Service project id and location to detach from a host project. Only global location is supported. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsDetachServiceProjectAttachment(name: string, req: DetachServiceProjectAttachmentRequest): Promise<DetachServiceProjectAttachmentResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:detachServiceProjectAttachment`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as DetachServiceProjectAttachmentResponse;
  }

  /**
   * Gets a Discovered Service in a host project and location.
   *
   * @param name Required. Fully qualified name of the Discovered Service to fetch. Expected format: `projects/{project}/locations/{location}/discoveredServices/{discoveredService}`.
   */
  async projectsLocationsDiscoveredServicesGet(name: string): Promise<DiscoveredService> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as DiscoveredService;
  }

  /**
   * Lists Discovered Services that can be added to an Application in a host
   * project and location.
   *
   * @param parent Required. Project and location to list Discovered Services on. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsDiscoveredServicesList(parent: string, opts: ProjectsLocationsDiscoveredServicesListOptions = {}): Promise<ListDiscoveredServicesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/discoveredServices`);
    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 ListDiscoveredServicesResponse;
  }

  /**
   * Lists a Discovered Service in a host project and location, with a given
   * resource URI.
   *
   * @param parent Required. Host project ID and location to lookup Discovered Service in. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsDiscoveredServicesLookup(parent: string, opts: ProjectsLocationsDiscoveredServicesLookupOptions = {}): Promise<LookupDiscoveredServiceResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/discoveredServices:lookup`);
    if (opts.uri !== undefined) {
      url.searchParams.append("uri", String(opts.uri));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as LookupDiscoveredServiceResponse;
  }

  /**
   * Gets a Discovered Workload in a host project and location.
   *
   * @param name Required. Fully qualified name of the Discovered Workload to fetch. Expected format: `projects/{project}/locations/{location}/discoveredWorkloads/{discoveredWorkload}`.
   */
  async projectsLocationsDiscoveredWorkloadsGet(name: string): Promise<DiscoveredWorkload> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as DiscoveredWorkload;
  }

  /**
   * Lists Discovered Workloads that can be added to an Application in a host
   * project and location.
   *
   * @param parent Required. Project and location to list Discovered Workloads on. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsDiscoveredWorkloadsList(parent: string, opts: ProjectsLocationsDiscoveredWorkloadsListOptions = {}): Promise<ListDiscoveredWorkloadsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/discoveredWorkloads`);
    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 ListDiscoveredWorkloadsResponse;
  }

  /**
   * Lists a Discovered Workload in a host project and location, with a given
   * resource URI.
   *
   * @param parent Required. Host project ID and location to lookup Discovered Workload in. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsDiscoveredWorkloadsLookup(parent: string, opts: ProjectsLocationsDiscoveredWorkloadsLookupOptions = {}): Promise<LookupDiscoveredWorkloadResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/discoveredWorkloads:lookup`);
    if (opts.uri !== undefined) {
      url.searchParams.append("uri", String(opts.uri));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as LookupDiscoveredWorkloadResponse;
  }

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

  /**
   * Lists information about the supported locations for this service.
   *
   * @param name The resource that owns the locations collection, if applicable.
   */
  async projectsLocationsList(name: string, opts: ProjectsLocationsListOptions = {}): Promise<ListLocationsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }/locations`);
    if (opts.filter !== undefined) {
      url.searchParams.append("filter", String(opts.filter));
    }
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListLocationsResponse;
  }

  /**
   * Lists a service project attachment for a given service project. You can
   * call this API from any project to find if it is attached to a host project.
   *
   * @param name Required. Service project ID and location to lookup service project attachment for. Only global location is supported. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsLookupServiceProjectAttachment(name: string): Promise<LookupServiceProjectAttachmentResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:lookupServiceProjectAttachment`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as LookupServiceProjectAttachmentResponse;
  }

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

  /**
   * Deletes a long-running operation. This method indicates that the client is
   * no longer interested in the operation result. It does not cancel the
   * operation. If the server doesn't support this method, it returns
   * `google.rpc.Code.UNIMPLEMENTED`.
   *
   * @param name The name of the operation resource to be deleted.
   */
  async projectsLocationsOperationsDelete(name: string): Promise<Empty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Empty;
  }

  /**
   * Gets the latest state of a long-running operation. Clients can use this
   * method to poll the operation result at intervals as recommended by the API
   * service.
   *
   * @param name The name of the operation resource.
   */
  async projectsLocationsOperationsGet(name: string): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Operation;
  }

  /**
   * Lists operations that match the specified filter in the request. If the
   * server doesn't support this method, it returns `UNIMPLEMENTED`.
   *
   * @param name The name of the operation's parent resource.
   */
  async projectsLocationsOperationsList(name: string, opts: ProjectsLocationsOperationsListOptions = {}): Promise<ListOperationsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }/operations`);
    if (opts.filter !== undefined) {
      url.searchParams.append("filter", String(opts.filter));
    }
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListOperationsResponse;
  }

  /**
   * Attaches a service project to the host project.
   *
   * @param parent Required. Host project ID and location to which service project is being attached. Only global location is supported. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsServiceProjectAttachmentsCreate(parent: string, req: ServiceProjectAttachment, opts: ProjectsLocationsServiceProjectAttachmentsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceProjectAttachments`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.serviceProjectAttachmentId !== undefined) {
      url.searchParams.append("serviceProjectAttachmentId", String(opts.serviceProjectAttachmentId));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a service project attachment.
   *
   * @param name Required. Fully qualified name of the service project attachment to delete. Expected format: `projects/{project}/locations/{location}/serviceProjectAttachments/{serviceProjectAttachment}`.
   */
  async projectsLocationsServiceProjectAttachmentsDelete(name: string, opts: ProjectsLocationsServiceProjectAttachmentsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets a service project attachment.
   *
   * @param name Required. Fully qualified name of the service project attachment to retrieve. Expected format: `projects/{project}/locations/{location}/serviceProjectAttachments/{serviceProjectAttachment}`.
   */
  async projectsLocationsServiceProjectAttachmentsGet(name: string): Promise<ServiceProjectAttachment> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ServiceProjectAttachment;
  }

  /**
   * Lists service projects attached to the host project.
   *
   * @param parent Required. Host project ID and location to list service project attachments. Only global location is supported. Expected format: `projects/{project}/locations/{location}`.
   */
  async projectsLocationsServiceProjectAttachmentsList(parent: string, opts: ProjectsLocationsServiceProjectAttachmentsListOptions = {}): Promise<ListServiceProjectAttachmentsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/serviceProjectAttachments`);
    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 ListServiceProjectAttachmentsResponse;
  }
}

/**
 * Application defines the governance boundary for App Hub entities that
 * perform a logical end-to-end business function. App Hub supports application
 * level IAM permission to align with governance requirements.
 */
export interface Application {
  /**
   * Optional. Consumer provided attributes.
   */
  attributes?: Attributes;
  /**
   * Output only. Create time.
   */
  readonly createTime?: Date;
  /**
   * Optional. User-defined description of an Application. Can have a maximum
   * length of 2048 characters.
   */
  description?: string;
  /**
   * Optional. User-defined name for the Application. Can have a maximum length
   * of 63 characters.
   */
  displayName?: string;
  /**
   * Identifier. The resource name of an Application. Format:
   * `"projects/{host-project-id}/locations/{location}/applications/{application-id}"`
   */
  name?: string;
  /**
   * Required. Immutable. Defines what data can be included into this
   * Application. Limits which Services and Workloads can be registered.
   */
  scope?: Scope;
  /**
   * Output only. Application state.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING";
  /**
   * Output only. A universally unique identifier (in UUID4 format) for the
   * `Application`.
   */
  readonly uid?: string;
  /**
   * Output only. Update time.
   */
  readonly updateTime?: Date;
}

/**
 * Provides the mapping of a cloud asset to a direct physical location or to a
 * proxy that defines the location on its behalf.
 */
export interface AssetLocation {
  /**
   * Spanner path of the CCFE RMS database. It is only applicable for CCFE
   * tenants that use CCFE RMS for storing resource metadata.
   */
  ccfeRmsPath?: string;
  /**
   * Defines the customer expectation around ZI/ZS for this asset and ZI/ZS
   * state of the region at the time of asset creation.
   */
  expected?: IsolationExpectations;
  /**
   * Defines extra parameters required for specific asset types.
   */
  extraParameters?: ExtraParameter[];
  /**
   * Contains all kinds of physical location definitions for this asset.
   */
  locationData?: LocationData[];
  /**
   * Defines parents assets if any in order to allow later generation of
   * child_asset_location data via child assets.
   */
  parentAsset?: CloudAsset[];
}

/**
 * Consumer provided attributes.
 */
export interface Attributes {
  /**
   * Optional. Business team that ensures user needs are met and value is
   * delivered
   */
  businessOwners?: ContactInfo[];
  /**
   * Optional. User-defined criticality information.
   */
  criticality?: Criticality;
  /**
   * Optional. Developer team that owns development and coding.
   */
  developerOwners?: ContactInfo[];
  /**
   * Optional. User-defined environment information.
   */
  environment?: Environment;
  /**
   * Optional. Operator team that ensures runtime and operations.
   */
  operatorOwners?: ContactInfo[];
}

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

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

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

/**
 * Policy ID that identified data placement in Blobstore as per
 * go/blobstore-user-guide#data-metadata-placement-and-failure-domains
 */
export interface BlobstoreLocation {
  policyId?: string[];
}

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

export interface CloudAsset {
  assetName?: string;
  assetType?: string;
}

export interface CloudAssetComposition {
  childAsset?: CloudAsset[];
}

/**
 * Contact information of stakeholders.
 */
export interface ContactInfo {
  /**
   * Optional. Contact's name. Can have a maximum length of 63 characters.
   */
  displayName?: string;
  /**
   * Required. Email address of the contacts.
   */
  email?: string;
}

/**
 * Criticality of the Application, Service, or Workload
 */
export interface Criticality {
  /**
   * Required. Criticality Type.
   */
  type?:  | "TYPE_UNSPECIFIED" | "MISSION_CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
}

/**
 * Request for DetachServiceProjectAttachment.
 */
export interface DetachServiceProjectAttachmentRequest {
}

/**
 * Response for DetachServiceProjectAttachment.
 */
export interface DetachServiceProjectAttachmentResponse {
}

export interface DirectLocationAssignment {
  location?: LocationAssignment[];
}

/**
 * DiscoveredService is a network or API interface that exposes some
 * functionality to clients for consumption over the network. A discovered
 * service can be registered to a App Hub service.
 */
export interface DiscoveredService {
  /**
   * Identifier. The resource name of the discovered service. Format:
   * `"projects/{host-project-id}/locations/{location}/discoveredServices/{uuid}"`
   */
  name?: string;
  /**
   * Output only. Properties of an underlying compute resource that can
   * comprise a Service. These are immutable.
   */
  readonly serviceProperties?: ServiceProperties;
  /**
   * Output only. Reference to an underlying networking resource that can
   * comprise a Service. These are immutable.
   */
  readonly serviceReference?: ServiceReference;
}

/**
 * DiscoveredWorkload is a binary deployment (such as managed instance groups
 * (MIGs) and GKE deployments) that performs the smallest logical subset of
 * business functionality. A discovered workload can be registered to an App Hub
 * Workload.
 */
export interface DiscoveredWorkload {
  /**
   * Identifier. The resource name of the discovered workload. Format:
   * `"projects/{host-project-id}/locations/{location}/discoveredWorkloads/{uuid}"`
   */
  name?: string;
  /**
   * Output only. Properties of an underlying compute resource represented by
   * the Workload. These are immutable.
   */
  readonly workloadProperties?: WorkloadProperties;
  /**
   * Output only. Reference of an underlying compute resource represented by
   * the Workload. These are immutable.
   */
  readonly workloadReference?: WorkloadReference;
}

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

/**
 * Environment of the Application, Service, or Workload
 */
export interface Environment {
  /**
   * Required. Environment Type.
   */
  type?:  | "TYPE_UNSPECIFIED" | "PRODUCTION" | "STAGING" | "TEST" | "DEVELOPMENT";
}

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

/**
 * Defines parameters that should only be used for specific asset types.
 */
export interface ExtraParameter {
  /**
   * Details about zones used by regional
   * compute.googleapis.com/InstanceGroupManager to create instances.
   */
  regionalMigDistributionPolicy?: RegionalMigDistributionPolicy;
}

export interface IsolationExpectations {
  /**
   * Explicit overrides for ZI and ZS requirements to be used for resources
   * that should be excluded from ZI/ZS verification logic.
   */
  requirementOverride?: RequirementOverride;
  ziOrgPolicy?:  | "ZI_UNSPECIFIED" | "ZI_UNKNOWN" | "ZI_NOT_REQUIRED" | "ZI_PREFERRED" | "ZI_REQUIRED";
  ziRegionPolicy?:  | "ZI_REGION_POLICY_UNSPECIFIED" | "ZI_REGION_POLICY_UNKNOWN" | "ZI_REGION_POLICY_NOT_SET" | "ZI_REGION_POLICY_FAIL_OPEN" | "ZI_REGION_POLICY_FAIL_CLOSED";
  ziRegionState?:  | "ZI_REGION_UNSPECIFIED" | "ZI_REGION_UNKNOWN" | "ZI_REGION_NOT_ENABLED" | "ZI_REGION_ENABLED";
  /**
   * Deprecated: use zi_org_policy, zi_region_policy and zi_region_state
   * instead for setting ZI expectations as per
   * go/zicy-publish-physical-location.
   */
  zoneIsolation?:  | "ZI_UNSPECIFIED" | "ZI_UNKNOWN" | "ZI_NOT_REQUIRED" | "ZI_PREFERRED" | "ZI_REQUIRED";
  /**
   * Deprecated: use zs_org_policy, and zs_region_stateinstead for setting Zs
   * expectations as per go/zicy-publish-physical-location.
   */
  zoneSeparation?:  | "ZS_UNSPECIFIED" | "ZS_UNKNOWN" | "ZS_NOT_REQUIRED" | "ZS_REQUIRED";
  zsOrgPolicy?:  | "ZS_UNSPECIFIED" | "ZS_UNKNOWN" | "ZS_NOT_REQUIRED" | "ZS_REQUIRED";
  zsRegionState?:  | "ZS_REGION_UNSPECIFIED" | "ZS_REGION_UNKNOWN" | "ZS_REGION_NOT_ENABLED" | "ZS_REGION_ENABLED";
}

/**
 * Response for ListApplications.
 */
export interface ListApplicationsResponse {
  /**
   * List of Applications.
   */
  applications?: Application[];
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for ListDiscoveredServices.
 */
export interface ListDiscoveredServicesResponse {
  /**
   * List of Discovered Services.
   */
  discoveredServices?: DiscoveredService[];
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for ListDiscoveredWorkloads.
 */
export interface ListDiscoveredWorkloadsResponse {
  /**
   * List of Discovered Workloads.
   */
  discoveredWorkloads?: DiscoveredWorkload[];
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

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

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

/**
 * Response for ListServiceProjectAttachments.
 */
export interface ListServiceProjectAttachmentsResponse {
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * List of service project attachments.
   */
  serviceProjectAttachments?: ServiceProjectAttachment[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for ListServices.
 */
export interface ListServicesResponse {
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * List of Services.
   */
  services?: Service[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * Response for ListWorkloads.
 */
export interface ListWorkloadsResponse {
  /**
   * A token identifying a page of results the server should return.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
  /**
   * List of Workloads.
   */
  workloads?: Workload[];
}

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

export interface LocationAssignment {
  location?: string;
  locationType?:  | "UNSPECIFIED" | "CLUSTER" | "POP" | "CLOUD_ZONE" | "CLOUD_REGION" | "MULTI_REGION_GEO" | "MULTI_REGION_JURISDICTION" | "GLOBAL" | "OTHER";
}

export interface LocationData {
  blobstoreLocation?: BlobstoreLocation;
  childAssetLocation?: CloudAssetComposition;
  directLocation?: DirectLocationAssignment;
  gcpProjectProxy?: TenantProjectProxy;
  placerLocation?: PlacerLocation;
  spannerLocation?: SpannerLocation;
}

/**
 * Response for LookupDiscoveredService.
 */
export interface LookupDiscoveredServiceResponse {
  /**
   * Discovered Service if exists, empty otherwise.
   */
  discoveredService?: DiscoveredService;
}

/**
 * Response for LookupDiscoveredWorkload.
 */
export interface LookupDiscoveredWorkloadResponse {
  /**
   * Discovered Workload if exists, empty otherwise.
   */
  discoveredWorkload?: DiscoveredWorkload;
}

/**
 * Response for LookupServiceProjectAttachment.
 */
export interface LookupServiceProjectAttachmentResponse {
  /**
   * Service project attachment for a project if exists, empty otherwise.
   */
  serviceProjectAttachment?: ServiceProjectAttachment;
}

/**
 * This resource represents a long-running operation that is the result of a
 * network API call.
 */
export interface Operation {
  /**
   * If the value is `false`, it means the operation is still in progress. If
   * `true`, the operation is completed, and either `error` or `response` is
   * available.
   */
  done?: boolean;
  /**
   * The error result of the operation in case of failure or cancellation.
   */
  error?: Status;
  /**
   * Service-specific metadata associated with the operation. It typically
   * contains progress information and common metadata such as create time. Some
   * services might not provide such metadata. Any method that returns a
   * long-running operation should document the metadata type, if any.
   */
  metadata?: {
    [key: string]: any
  };
  /**
   * The server-assigned name, which is only unique within the same service
   * that originally returns it. If you use the default HTTP mapping, the `name`
   * should be a resource name ending with `operations/{unique_id}`.
   */
  name?: string;
  /**
   * The normal, successful response of the operation. If the original method
   * returns no data on success, such as `Delete`, the response is
   * `google.protobuf.Empty`. If the original method is standard
   * `Get`/`Create`/`Update`, the response should be the resource. For other
   * methods, the response should have the type `XxxResponse`, where `Xxx` is
   * the original method name. For example, if the original method name is
   * `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
   */
  response?: {
    [key: string]: any
  };
}

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

/**
 * Message describing that the location of the customer resource is tied to
 * placer allocations
 */
export interface PlacerLocation {
  /**
   * Directory with a config related to it in placer (e.g.
   * "/placer/prod/home/my-root/my-dir")
   */
  placerConfig?: 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,
  };
}

/**
 * Additional options for AppHub#projectsLocationsApplicationsCreate.
 */
export interface ProjectsLocationsApplicationsCreateOptions {
  /**
   * Required. The Application identifier. Must contain only lowercase letters,
   * numbers or hyphens, with the first character a letter, the last a letter or
   * a number, and a 63 character maximum.
   */
  applicationId?: 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 AppHub#projectsLocationsApplicationsDelete.
 */
export interface ProjectsLocationsApplicationsDeleteOptions {
  /**
   * 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 AppHub#projectsLocationsApplicationsGetIamPolicy.
 */
export interface ProjectsLocationsApplicationsGetIamPolicyOptions {
  /**
   * 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 AppHub#projectsLocationsApplicationsList.
 */
export interface ProjectsLocationsApplicationsListOptions {
  /**
   * Optional. Filtering results.
   */
  filter?: string;
  /**
   * Optional. Hint for how to order the results.
   */
  orderBy?: string;
  /**
   * Optional. Requested page size. Server may return fewer items than
   * requested. If unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * Optional. A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for AppHub#projectsLocationsApplicationsPatch.
 */
export interface ProjectsLocationsApplicationsPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the Application resource by the update. The fields specified in the
   * update_mask are relative to the resource, not the full request. The API
   * changes the values of the fields as specified in the update_mask. The API
   * ignores the values of all fields not covered by the update_mask. You can
   * also unset a field by not specifying it in the updated message, but adding
   * the field to the mask. This clears whatever value the field previously had.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for AppHub#projectsLocationsApplicationsServicesCreate.
 */
export interface ProjectsLocationsApplicationsServicesCreateOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. The Service identifier. Must contain only lowercase letters,
   * numbers or hyphens, with the first character a letter, the last a letter or
   * a number, and a 63 character maximum.
   */
  serviceId?: string;
}

/**
 * Additional options for AppHub#projectsLocationsApplicationsServicesDelete.
 */
export interface ProjectsLocationsApplicationsServicesDeleteOptions {
  /**
   * 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 AppHub#projectsLocationsApplicationsServicesList.
 */
export interface ProjectsLocationsApplicationsServicesListOptions {
  /**
   * Optional. Filtering results
   */
  filter?: string;
  /**
   * Optional. Hint for how to order the results
   */
  orderBy?: string;
  /**
   * Optional. Requested page size. Server may return fewer items than
   * requested. If unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * Optional. A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for AppHub#projectsLocationsApplicationsServicesPatch.
 */
export interface ProjectsLocationsApplicationsServicesPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the Service resource by the update. The fields specified in the update_mask
   * are relative to the resource, not the full request. The API changes the
   * values of the fields as specified in the update_mask. The API ignores the
   * values of all fields not covered by the update_mask. You can also unset a
   * field by not specifying it in the updated message, but adding the field to
   * the mask. This clears whatever value the field previously had.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for AppHub#projectsLocationsApplicationsWorkloadsCreate.
 */
export interface ProjectsLocationsApplicationsWorkloadsCreateOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. The Workload identifier. Must contain only lowercase letters,
   * numbers or hyphens, with the first character a letter, the last a letter or
   * a number, and a 63 character maximum.
   */
  workloadId?: string;
}

/**
 * Additional options for AppHub#projectsLocationsApplicationsWorkloadsDelete.
 */
export interface ProjectsLocationsApplicationsWorkloadsDeleteOptions {
  /**
   * 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 AppHub#projectsLocationsApplicationsWorkloadsList.
 */
export interface ProjectsLocationsApplicationsWorkloadsListOptions {
  /**
   * Optional. Filtering results.
   */
  filter?: string;
  /**
   * Optional. Hint for how to order the results.
   */
  orderBy?: string;
  /**
   * Optional. Requested page size. Server may return fewer items than
   * requested. If unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * Optional. A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for AppHub#projectsLocationsApplicationsWorkloadsPatch.
 */
export interface ProjectsLocationsApplicationsWorkloadsPatchOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. Field mask is used to specify the fields to be overwritten in
   * the Workload resource by the update. The fields specified in the
   * update_mask are relative to the resource, not the full request. The API
   * changes the values of the fields as specified in the update_mask. The API
   * ignores the values of all fields not covered by the update_mask. You can
   * also unset a field by not specifying it in the updated message, but adding
   * the field to the mask. This clears whatever value the field previously had.
   */
  updateMask?: string /* FieldMask */;
}

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

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

/**
 * Additional options for AppHub#projectsLocationsDiscoveredServicesList.
 */
export interface ProjectsLocationsDiscoveredServicesListOptions {
  /**
   * Optional. Filtering results.
   */
  filter?: string;
  /**
   * Optional. Hint for how to order the results.
   */
  orderBy?: string;
  /**
   * Optional. Requested page size. Server may return fewer items than
   * requested. If unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * Optional. A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for AppHub#projectsLocationsDiscoveredServicesLookup.
 */
export interface ProjectsLocationsDiscoveredServicesLookupOptions {
  /**
   * Required. Resource URI to find DiscoveredService for. Accepts both project
   * number and project ID and does translation when needed.
   */
  uri?: string;
}

/**
 * Additional options for AppHub#projectsLocationsDiscoveredWorkloadsList.
 */
export interface ProjectsLocationsDiscoveredWorkloadsListOptions {
  /**
   * Optional. Filtering results.
   */
  filter?: string;
  /**
   * Optional. Hint for how to order the results.
   */
  orderBy?: string;
  /**
   * Optional. Requested page size. Server may return fewer items than
   * requested. If unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * Optional. A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Additional options for AppHub#projectsLocationsDiscoveredWorkloadsLookup.
 */
export interface ProjectsLocationsDiscoveredWorkloadsLookupOptions {
  /**
   * Required. Resource URI to find Discovered Workload for. Accepts both
   * project number and project ID and does translation when needed.
   */
  uri?: string;
}

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

/**
 * Additional options for AppHub#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
 * AppHub#projectsLocationsServiceProjectAttachmentsCreate.
 */
export interface ProjectsLocationsServiceProjectAttachmentsCreateOptions {
  /**
   * Optional. An optional request ID to identify requests. Specify a unique
   * request ID so that if you must retry your request, the server will know to
   * ignore the request if it has already been completed. The server will
   * guarantee that for at least 60 minutes since the first request. For
   * example, consider a situation where you make an initial request and the
   * request times out. If you make the request again with the same request ID,
   * the server can check if original operation with the same request ID was
   * received, and if so, will ignore the second request. This prevents clients
   * from accidentally creating duplicate commitments. The request ID must be a
   * valid UUID with the exception that zero UUID is not supported
   * (00000000-0000-0000-0000-000000000000).
   */
  requestId?: string;
  /**
   * Required. The service project attachment identifier must contain the
   * project id of the service project specified in the
   * service_project_attachment.service_project field.
   */
  serviceProjectAttachmentId?: string;
}

/**
 * Additional options for
 * AppHub#projectsLocationsServiceProjectAttachmentsDelete.
 */
export interface ProjectsLocationsServiceProjectAttachmentsDeleteOptions {
  /**
   * 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
 * AppHub#projectsLocationsServiceProjectAttachmentsList.
 */
export interface ProjectsLocationsServiceProjectAttachmentsListOptions {
  /**
   * Optional. Filtering results.
   */
  filter?: string;
  /**
   * Optional. Hint for how to order the results.
   */
  orderBy?: string;
  /**
   * Optional. Requested page size. Server may return fewer items than
   * requested. If unspecified, server will pick an appropriate default.
   */
  pageSize?: number;
  /**
   * Optional. A token identifying a page of results the server should return.
   */
  pageToken?: string;
}

/**
 * Operation metadata returned by the CLH during resource state reconciliation.
 */
export interface ReconciliationOperationMetadata {
  /**
   * DEPRECATED. Use exclusive_action instead.
   */
  deleteResource?: boolean;
  /**
   * Excluisive action returned by the CLH.
   */
  exclusiveAction?:  | "UNKNOWN_REPAIR_ACTION" | "DELETE" | "RETRY";
}

/**
 * To be used for specifying the intended distribution of regional
 * compute.googleapis.com/InstanceGroupManager instances
 */
export interface RegionalMigDistributionPolicy {
  /**
   * The shape in which the group converges around distribution of resources.
   * Instance of proto2 enum
   */
  targetShape?: number;
  /**
   * Cloud zones used by regional MIG to create instances.
   */
  zones?: ZoneConfiguration[];
}

export interface RequirementOverride {
  ziOverride?:  | "ZI_UNSPECIFIED" | "ZI_UNKNOWN" | "ZI_NOT_REQUIRED" | "ZI_PREFERRED" | "ZI_REQUIRED";
  zsOverride?:  | "ZS_UNSPECIFIED" | "ZS_UNKNOWN" | "ZS_NOT_REQUIRED" | "ZS_REQUIRED";
}

/**
 * Scope of an application.
 */
export interface Scope {
  /**
   * Required. Scope Type.
   */
  type?:  | "TYPE_UNSPECIFIED" | "REGIONAL" | "GLOBAL";
}

/**
 * Service is an App Hub data model that contains a discovered service, which
 * represents a network or API interface that exposes some functionality to
 * clients for consumption over the network.
 */
export interface Service {
  /**
   * Optional. Consumer provided attributes.
   */
  attributes?: Attributes;
  /**
   * Output only. Create time.
   */
  readonly createTime?: Date;
  /**
   * Optional. User-defined description of a Service. Can have a maximum length
   * of 2048 characters.
   */
  description?: string;
  /**
   * Required. Immutable. The resource name of the original discovered service.
   */
  discoveredService?: string;
  /**
   * Optional. User-defined name for the Service. Can have a maximum length of
   * 63 characters.
   */
  displayName?: string;
  /**
   * Identifier. The resource name of a Service. Format:
   * `"projects/{host-project-id}/locations/{location}/applications/{application-id}/services/{service-id}"`
   */
  name?: string;
  /**
   * Output only. Properties of an underlying compute resource that can
   * comprise a Service. These are immutable.
   */
  readonly serviceProperties?: ServiceProperties;
  /**
   * Output only. Reference to an underlying networking resource that can
   * comprise a Service. These are immutable.
   */
  readonly serviceReference?: ServiceReference;
  /**
   * Output only. Service state.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING" | "DETACHED";
  /**
   * Output only. A universally unique identifier (UUID) for the `Service` in
   * the UUID4 format.
   */
  readonly uid?: string;
  /**
   * Output only. Update time.
   */
  readonly updateTime?: Date;
}

/**
 * ServiceProjectAttachment represents an attachment from a service project to
 * a host project. Service projects contain the underlying cloud infrastructure
 * resources, and expose these resources to the host project through a
 * ServiceProjectAttachment. With the attachments, the host project can provide
 * an aggregated view of resources across all service projects.
 */
export interface ServiceProjectAttachment {
  /**
   * Output only. Create time.
   */
  readonly createTime?: Date;
  /**
   * Identifier. The resource name of a ServiceProjectAttachment. Format:
   * `"projects/{host-project-id}/locations/global/serviceProjectAttachments/{service-project-id}."`
   */
  name?: string;
  /**
   * Required. Immutable. Service project name in the format: `"projects/abc"`
   * or `"projects/123"`. As input, project name with either project id or
   * number are accepted. As output, this field will contain project number.
   */
  serviceProject?: string;
  /**
   * Output only. ServiceProjectAttachment state.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING";
  /**
   * Output only. A globally unique identifier (in UUID4 format) for the
   * `ServiceProjectAttachment`.
   */
  readonly uid?: string;
}

/**
 * Properties of an underlying cloud resource that can comprise a Service.
 */
export interface ServiceProperties {
  /**
   * Output only. The service project identifier that the underlying cloud
   * resource resides in.
   */
  readonly gcpProject?: string;
  /**
   * Output only. The location that the underlying resource resides in, for
   * example, us-west1.
   */
  readonly location?: string;
  /**
   * Output only. The location that the underlying resource resides in if it is
   * zonal, for example, us-west1-a).
   */
  readonly zone?: string;
}

/**
 * Reference to an underlying networking resource that can comprise a Service.
 */
export interface ServiceReference {
  /**
   * Output only. The underlying resource URI. For example, URI of Forwarding
   * Rule, URL Map, and Backend Service.
   */
  readonly uri?: string;
}

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

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

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

export interface SpannerLocation {
  /**
   * Set of backups used by the resource with name in the same format as what
   * is available at http://table/spanner_automon.backup_metadata
   */
  backupName?: string[];
  /**
   * Set of databases used by the resource in format /span//
   */
  dbName?: string[];
}

/**
 * The `Status` type defines a logical error model that is suitable for
 * different programming environments, including REST APIs and RPC APIs. It is
 * used by [gRPC](https://github.com/grpc). Each `Status` message contains three
 * pieces of data: error code, error message, and error details. You can find
 * out more about this error model and how to work with it in the [API Design
 * Guide](https://cloud.google.com/apis/design/errors).
 */
export interface Status {
  /**
   * The status code, which should be an enum value of google.rpc.Code.
   */
  code?: number;
  /**
   * A list of messages that carry the error details. There is a common set of
   * message types for APIs to use.
   */
  details?: {
    [key: string]: any
  }[];
  /**
   * A developer-facing error message, which should be in English. Any
   * user-facing error message should be localized and sent in the
   * google.rpc.Status.details field, or localized by the client.
   */
  message?: string;
}

export interface TenantProjectProxy {
  projectNumbers?: 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[];
}

/**
 * Workload is an App Hub data model that contains a discovered workload, which
 * represents a binary deployment (such as managed instance groups (MIGs) and
 * GKE deployments) that performs the smallest logical subset of business
 * functionality.
 */
export interface Workload {
  /**
   * Optional. Consumer provided attributes.
   */
  attributes?: Attributes;
  /**
   * Output only. Create time.
   */
  readonly createTime?: Date;
  /**
   * Optional. User-defined description of a Workload. Can have a maximum
   * length of 2048 characters.
   */
  description?: string;
  /**
   * Required. Immutable. The resource name of the original discovered
   * workload.
   */
  discoveredWorkload?: string;
  /**
   * Optional. User-defined name for the Workload. Can have a maximum length of
   * 63 characters.
   */
  displayName?: string;
  /**
   * Identifier. The resource name of the Workload. Format:
   * `"projects/{host-project-id}/locations/{location}/applications/{application-id}/workloads/{workload-id}"`
   */
  name?: string;
  /**
   * Output only. Workload state.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "DELETING" | "DETACHED";
  /**
   * Output only. A universally unique identifier (UUID) for the `Workload` in
   * the UUID4 format.
   */
  readonly uid?: string;
  /**
   * Output only. Update time.
   */
  readonly updateTime?: Date;
  /**
   * Output only. Properties of an underlying compute resource represented by
   * the Workload. These are immutable.
   */
  readonly workloadProperties?: WorkloadProperties;
  /**
   * Output only. Reference of an underlying compute resource represented by
   * the Workload. These are immutable.
   */
  readonly workloadReference?: WorkloadReference;
}

/**
 * Properties of an underlying compute resource represented by the Workload.
 */
export interface WorkloadProperties {
  /**
   * Output only. The service project identifier that the underlying cloud
   * resource resides in. Empty for non-cloud resources.
   */
  readonly gcpProject?: string;
  /**
   * Output only. The location that the underlying compute resource resides in
   * (for example, us-west1).
   */
  readonly location?: string;
  /**
   * Output only. The location that the underlying compute resource resides in
   * if it is zonal (for example, us-west1-a).
   */
  readonly zone?: string;
}

/**
 * Reference of an underlying compute resource represented by the Workload.
 */
export interface WorkloadReference {
  /**
   * Output only. The underlying compute resource uri.
   */
  readonly uri?: string;
}

export interface ZoneConfiguration {
  zone?: 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;
}