// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Cloud Deploy API Client for Deno
 * ================================
 * 
 * 
 * 
 * Docs: https://cloud.google.com/deploy/
 * Source: https://googleapis.deno.dev/v1/clouddeploy:v1.ts
 */

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

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

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

  /**
   * Creates a new CustomTargetType in a given project and location.
   *
   * @param parent Required. The parent collection in which the `CustomTargetType` must be created. The format is `projects/{project_id}/locations/{location_name}`.
   */
  async projectsLocationsCustomTargetTypesCreate(parent: string, req: CustomTargetType, opts: ProjectsLocationsCustomTargetTypesCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/customTargetTypes`);
    if (opts.customTargetTypeId !== undefined) {
      url.searchParams.append("customTargetTypeId", String(opts.customTargetTypeId));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a single CustomTargetType.
   *
   * @param name Required. The name of the `CustomTargetType` to delete. Format must be `projects/{project_id}/locations/{location_name}/customTargetTypes/{custom_target_type}`.
   */
  async projectsLocationsCustomTargetTypesDelete(name: string, opts: ProjectsLocationsCustomTargetTypesDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets details of a single CustomTargetType.
   *
   * @param name Required. Name of the `CustomTargetType`. Format must be `projects/{project_id}/locations/{location_name}/customTargetTypes/{custom_target_type}`.
   */
  async projectsLocationsCustomTargetTypesGet(name: string): Promise<CustomTargetType> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as CustomTargetType;
  }

  /**
   * 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 projectsLocationsCustomTargetTypesGetIamPolicy(resource: string, opts: ProjectsLocationsCustomTargetTypesGetIamPolicyOptions = {}): 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 CustomTargetTypes in a given project and location.
   *
   * @param parent Required. The parent that owns this collection of custom target types. Format must be `projects/{project_id}/locations/{location_name}`.
   */
  async projectsLocationsCustomTargetTypesList(parent: string, opts: ProjectsLocationsCustomTargetTypesListOptions = {}): Promise<ListCustomTargetTypesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/customTargetTypes`);
    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 ListCustomTargetTypesResponse;
  }

  /**
   * Updates a single CustomTargetType.
   *
   * @param name Optional. Name of the `CustomTargetType`. Format is `projects/{project}/locations/{location}/customTargetTypes/{customTargetType}`. The `customTargetType` component must match `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  async projectsLocationsCustomTargetTypesPatch(name: string, req: CustomTargetType, opts: ProjectsLocationsCustomTargetTypesPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsCustomTargetTypesPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    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 projectsLocationsCustomTargetTypesSetIamPolicy(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);
  }

  /**
   * Cancels an AutomationRun. The `state` of the `AutomationRun` after
   * cancelling is `CANCELLED`. `CancelAutomationRun` can be called on
   * AutomationRun in the state `IN_PROGRESS` and `PENDING`; AutomationRun in a
   * different state returns an `FAILED_PRECONDITION` error.
   *
   * @param name Required. Name of the `AutomationRun`. Format is `projects/{project}/locations/{location}/deliveryPipelines/{delivery_pipeline}/automationRuns/{automation_run}`.
   */
  async projectsLocationsDeliveryPipelinesAutomationRunsCancel(name: string, req: CancelAutomationRunRequest): Promise<CancelAutomationRunResponse> {
    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 CancelAutomationRunResponse;
  }

  /**
   * Gets details of a single AutomationRun.
   *
   * @param name Required. Name of the `AutomationRun`. Format must be `projects/{project}/locations/{location}/deliveryPipelines/{delivery_pipeline}/automationRuns/{automation_run}`.
   */
  async projectsLocationsDeliveryPipelinesAutomationRunsGet(name: string): Promise<AutomationRun> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as AutomationRun;
  }

  /**
   * Lists AutomationRuns in a given project and location.
   *
   * @param parent Required. The parent `Delivery Pipeline`, which owns this collection of automationRuns. Format must be `projects/{project}/locations/{location}/deliveryPipelines/{delivery_pipeline}`.
   */
  async projectsLocationsDeliveryPipelinesAutomationRunsList(parent: string, opts: ProjectsLocationsDeliveryPipelinesAutomationRunsListOptions = {}): Promise<ListAutomationRunsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/automationRuns`);
    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 ListAutomationRunsResponse;
  }

  /**
   * Creates a new Automation in a given project and location.
   *
   * @param parent Required. The parent collection in which the `Automation` must be created. The format is `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}`.
   */
  async projectsLocationsDeliveryPipelinesAutomationsCreate(parent: string, req: Automation, opts: ProjectsLocationsDeliveryPipelinesAutomationsCreateOptions = {}): Promise<Operation> {
    req = serializeAutomation(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/automations`);
    if (opts.automationId !== undefined) {
      url.searchParams.append("automationId", String(opts.automationId));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a single Automation resource.
   *
   * @param name Required. The name of the `Automation` to delete. The format is `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}/automations/{automation_name}`.
   */
  async projectsLocationsDeliveryPipelinesAutomationsDelete(name: string, opts: ProjectsLocationsDeliveryPipelinesAutomationsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets details of a single Automation.
   *
   * @param name Required. Name of the `Automation`. Format must be `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}/automations/{automation_name}`.
   */
  async projectsLocationsDeliveryPipelinesAutomationsGet(name: string): Promise<Automation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeAutomation(data);
  }

  /**
   * Lists Automations in a given project and location.
   *
   * @param parent Required. The parent `Delivery Pipeline`, which owns this collection of automations. Format must be `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}`.
   */
  async projectsLocationsDeliveryPipelinesAutomationsList(parent: string, opts: ProjectsLocationsDeliveryPipelinesAutomationsListOptions = {}): Promise<ListAutomationsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/automations`);
    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 deserializeListAutomationsResponse(data);
  }

  /**
   * Updates the parameters of a single Automation resource.
   *
   * @param name Output only. Name of the `Automation`. Format is `projects/{project}/locations/{location}/deliveryPipelines/{delivery_pipeline}/automations/{automation}`.
   */
  async projectsLocationsDeliveryPipelinesAutomationsPatch(name: string, req: Automation, opts: ProjectsLocationsDeliveryPipelinesAutomationsPatchOptions = {}): Promise<Operation> {
    req = serializeAutomation(req);
    opts = serializeProjectsLocationsDeliveryPipelinesAutomationsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

  /**
   * Creates a new DeliveryPipeline in a given project and location.
   *
   * @param parent Required. The parent collection in which the `DeliveryPipeline` must be created. The format is `projects/{project_id}/locations/{location_name}`.
   */
  async projectsLocationsDeliveryPipelinesCreate(parent: string, req: DeliveryPipeline, opts: ProjectsLocationsDeliveryPipelinesCreateOptions = {}): Promise<Operation> {
    req = serializeDeliveryPipeline(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/deliveryPipelines`);
    if (opts.deliveryPipelineId !== undefined) {
      url.searchParams.append("deliveryPipelineId", String(opts.deliveryPipelineId));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a single DeliveryPipeline.
   *
   * @param name Required. The name of the `DeliveryPipeline` to delete. The format is `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}`.
   */
  async projectsLocationsDeliveryPipelinesDelete(name: string, opts: ProjectsLocationsDeliveryPipelinesDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    if (opts.force !== undefined) {
      url.searchParams.append("force", String(opts.force));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets details of a single DeliveryPipeline.
   *
   * @param name Required. Name of the `DeliveryPipeline`. Format must be `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}`.
   */
  async projectsLocationsDeliveryPipelinesGet(name: string): Promise<DeliveryPipeline> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeDeliveryPipeline(data);
  }

  /**
   * Gets the access control policy for a resource. Returns an empty policy if
   * the resource exists and does not have a policy set.
   *
   * @param resource REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
   */
  async projectsLocationsDeliveryPipelinesGetIamPolicy(resource: string, opts: ProjectsLocationsDeliveryPipelinesGetIamPolicyOptions = {}): 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 DeliveryPipelines in a given project and location.
   *
   * @param parent Required. The parent, which owns this collection of pipelines. Format must be `projects/{project_id}/locations/{location_name}`.
   */
  async projectsLocationsDeliveryPipelinesList(parent: string, opts: ProjectsLocationsDeliveryPipelinesListOptions = {}): Promise<ListDeliveryPipelinesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/deliveryPipelines`);
    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 deserializeListDeliveryPipelinesResponse(data);
  }

  /**
   * Updates the parameters of a single DeliveryPipeline.
   *
   * @param name Optional. Name of the `DeliveryPipeline`. Format is `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}`. The `deliveryPipeline` component must match `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  async projectsLocationsDeliveryPipelinesPatch(name: string, req: DeliveryPipeline, opts: ProjectsLocationsDeliveryPipelinesPatchOptions = {}): Promise<Operation> {
    req = serializeDeliveryPipeline(req);
    opts = serializeProjectsLocationsDeliveryPipelinesPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

  /**
   * Abandons a Release in the Delivery Pipeline.
   *
   * @param name Required. Name of the Release. Format is `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesAbandon(name: string, req: AbandonReleaseRequest): Promise<AbandonReleaseResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:abandon`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as AbandonReleaseResponse;
  }

  /**
   * Creates a new Release in a given project and location.
   *
   * @param parent Required. The parent collection in which the `Release` is created. The format is `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesCreate(parent: string, req: Release, opts: ProjectsLocationsDeliveryPipelinesReleasesCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/releases`);
    if (opts.overrideDeployPolicy !== undefined) {
      url.searchParams.append("overrideDeployPolicy", String(opts.overrideDeployPolicy));
    }
    if (opts.releaseId !== undefined) {
      url.searchParams.append("releaseId", String(opts.releaseId));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Gets details of a single Release.
   *
   * @param name Required. Name of the `Release`. Format must be `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}/releases/{release_name}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesGet(name: string): Promise<Release> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Release;
  }

  /**
   * Lists Releases in a given project and location.
   *
   * @param parent Required. The `DeliveryPipeline` which owns this collection of `Release` objects.
   */
  async projectsLocationsDeliveryPipelinesReleasesList(parent: string, opts: ProjectsLocationsDeliveryPipelinesReleasesListOptions = {}): Promise<ListReleasesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/releases`);
    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 ListReleasesResponse;
  }

  /**
   * Advances a Rollout in a given project and location.
   *
   * @param name Required. Name of the Rollout. Format is `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsAdvance(name: string, req: AdvanceRolloutRequest): Promise<AdvanceRolloutResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:advance`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as AdvanceRolloutResponse;
  }

  /**
   * Approves a Rollout.
   *
   * @param name Required. Name of the Rollout. Format is `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsApprove(name: string, req: ApproveRolloutRequest): Promise<ApproveRolloutResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:approve`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as ApproveRolloutResponse;
  }

  /**
   * Cancels a Rollout in a given project and location.
   *
   * @param name Required. Name of the Rollout. Format is `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsCancel(name: string, req: CancelRolloutRequest): Promise<CancelRolloutResponse> {
    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 CancelRolloutResponse;
  }

  /**
   * Creates a new Rollout in a given project and location.
   *
   * @param parent Required. The parent collection in which the `Rollout` must be created. The format is `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}/releases/{release_name}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsCreate(parent: string, req: Rollout, opts: ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/rollouts`);
    if (opts.overrideDeployPolicy !== undefined) {
      url.searchParams.append("overrideDeployPolicy", String(opts.overrideDeployPolicy));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.rolloutId !== undefined) {
      url.searchParams.append("rolloutId", String(opts.rolloutId));
    }
    if (opts.startingPhaseId !== undefined) {
      url.searchParams.append("startingPhaseId", String(opts.startingPhaseId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Gets details of a single Rollout.
   *
   * @param name Required. Name of the `Rollout`. Format must be `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}/releases/{release_name}/rollouts/{rollout_name}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsGet(name: string): Promise<Rollout> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Rollout;
  }

  /**
   * Ignores the specified Job in a Rollout.
   *
   * @param rollout Required. Name of the Rollout. Format is `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJob(rollout: string, req: IgnoreJobRequest): Promise<IgnoreJobResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ rollout }:ignoreJob`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as IgnoreJobResponse;
  }

  /**
   * Gets details of a single JobRun.
   *
   * @param name Required. Name of the `JobRun`. Format must be `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}/releases/{release_name}/rollouts/{rollout_name}/jobRuns/{job_run_name}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGet(name: string): Promise<JobRun> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as JobRun;
  }

  /**
   * Lists JobRuns in a given project and location.
   *
   * @param parent Required. The `Rollout` which owns this collection of `JobRun` objects.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsList(parent: string, opts: ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListOptions = {}): Promise<ListJobRunsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/jobRuns`);
    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 ListJobRunsResponse;
  }

  /**
   * Terminates a Job Run in a given project and location.
   *
   * @param name Required. Name of the `JobRun`. Format must be `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}/jobRuns/{jobRun}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminate(name: string, req: TerminateJobRunRequest): Promise<TerminateJobRunResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:terminate`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as TerminateJobRunResponse;
  }

  /**
   * Lists Rollouts in a given project and location.
   *
   * @param parent Required. The `Release` which owns this collection of `Rollout` objects.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsList(parent: string, opts: ProjectsLocationsDeliveryPipelinesReleasesRolloutsListOptions = {}): Promise<ListRolloutsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/rollouts`);
    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 ListRolloutsResponse;
  }

  /**
   * Retries the specified Job in a Rollout.
   *
   * @param rollout Required. Name of the Rollout. Format is `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   */
  async projectsLocationsDeliveryPipelinesReleasesRolloutsRetryJob(rollout: string, req: RetryJobRequest): Promise<RetryJobResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ rollout }:retryJob`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as RetryJobResponse;
  }

  /**
   * Creates a `Rollout` to roll back the specified target.
   *
   * @param name Required. The `DeliveryPipeline` for which the rollback `Rollout` must be created. The format is `projects/{project_id}/locations/{location_name}/deliveryPipelines/{pipeline_name}`.
   */
  async projectsLocationsDeliveryPipelinesRollbackTarget(name: string, req: RollbackTargetRequest): Promise<RollbackTargetResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:rollbackTarget`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as RollbackTargetResponse;
  }

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

  /**
   * Creates a new DeployPolicy in a given project and location.
   *
   * @param parent Required. The parent collection in which the `DeployPolicy` must be created. The format is `projects/{project_id}/locations/{location_name}`.
   */
  async projectsLocationsDeployPoliciesCreate(parent: string, req: DeployPolicy, opts: ProjectsLocationsDeployPoliciesCreateOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/deployPolicies`);
    if (opts.deployPolicyId !== undefined) {
      url.searchParams.append("deployPolicyId", String(opts.deployPolicyId));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a single DeployPolicy.
   *
   * @param name Required. The name of the `DeployPolicy` to delete. The format is `projects/{project_id}/locations/{location_name}/deployPolicies/{deploy_policy_name}`.
   */
  async projectsLocationsDeployPoliciesDelete(name: string, opts: ProjectsLocationsDeployPoliciesDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets details of a single DeployPolicy.
   *
   * @param name Required. Name of the `DeployPolicy`. Format must be `projects/{project_id}/locations/{location_name}/deployPolicies/{deploy_policy_name}`.
   */
  async projectsLocationsDeployPoliciesGet(name: string): Promise<DeployPolicy> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as DeployPolicy;
  }

  /**
   * Lists DeployPolicies in a given project and location.
   *
   * @param parent Required. The parent, which owns this collection of deploy policies. Format must be `projects/{project_id}/locations/{location_name}`.
   */
  async projectsLocationsDeployPoliciesList(parent: string, opts: ProjectsLocationsDeployPoliciesListOptions = {}): Promise<ListDeployPoliciesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/deployPolicies`);
    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 ListDeployPoliciesResponse;
  }

  /**
   * Updates the parameters of a single DeployPolicy.
   *
   * @param name Output only. Name of the `DeployPolicy`. Format is `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`. The `deployPolicy` component must match `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  async projectsLocationsDeployPoliciesPatch(name: string, req: DeployPolicy, opts: ProjectsLocationsDeployPoliciesPatchOptions = {}): Promise<Operation> {
    opts = serializeProjectsLocationsDeployPoliciesPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Operation;
  }

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

  /**
   * Gets the configuration for a location.
   *
   * @param name Required. Name of requested configuration.
   */
  async projectsLocationsGetConfig(name: string): Promise<Config> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeConfig(data);
  }

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

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

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

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

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

  /**
   * Creates a new Target in a given project and location.
   *
   * @param parent Required. The parent collection in which the `Target` must be created. The format is `projects/{project_id}/locations/{location_name}`.
   */
  async projectsLocationsTargetsCreate(parent: string, req: Target, opts: ProjectsLocationsTargetsCreateOptions = {}): Promise<Operation> {
    req = serializeTarget(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/targets`);
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.targetId !== undefined) {
      url.searchParams.append("targetId", String(opts.targetId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Operation;
  }

  /**
   * Deletes a single Target.
   *
   * @param name Required. The name of the `Target` to delete. The format is `projects/{project_id}/locations/{location_name}/targets/{target_name}`.
   */
  async projectsLocationsTargetsDelete(name: string, opts: ProjectsLocationsTargetsDeleteOptions = {}): Promise<Operation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.etag !== undefined) {
      url.searchParams.append("etag", String(opts.etag));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as Operation;
  }

  /**
   * Gets details of a single Target.
   *
   * @param name Required. Name of the `Target`. Format must be `projects/{project_id}/locations/{location_name}/targets/{target_name}`.
   */
  async projectsLocationsTargetsGet(name: string): Promise<Target> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeTarget(data);
  }

  /**
   * Gets the access control policy for a resource. Returns an empty policy if
   * the resource exists and does not have a policy set.
   *
   * @param resource REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
   */
  async projectsLocationsTargetsGetIamPolicy(resource: string, opts: ProjectsLocationsTargetsGetIamPolicyOptions = {}): 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 Targets in a given project and location.
   *
   * @param parent Required. The parent, which owns this collection of targets. Format must be `projects/{project_id}/locations/{location_name}`.
   */
  async projectsLocationsTargetsList(parent: string, opts: ProjectsLocationsTargetsListOptions = {}): Promise<ListTargetsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/targets`);
    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 deserializeListTargetsResponse(data);
  }

  /**
   * Updates the parameters of a single Target.
   *
   * @param name Optional. Name of the `Target`. Format is `projects/{project}/locations/{location}/targets/{target}`. The `target` component must match `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  async projectsLocationsTargetsPatch(name: string, req: Target, opts: ProjectsLocationsTargetsPatchOptions = {}): Promise<Operation> {
    req = serializeTarget(req);
    opts = serializeProjectsLocationsTargetsPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.allowMissing !== undefined) {
      url.searchParams.append("allowMissing", String(opts.allowMissing));
    }
    if (opts.requestId !== undefined) {
      url.searchParams.append("requestId", String(opts.requestId));
    }
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    if (opts.validateOnly !== undefined) {
      url.searchParams.append("validateOnly", String(opts.validateOnly));
    }
    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 projectsLocationsTargetsSetIamPolicy(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 projectsLocationsTargetsTestIamPermissions(resource: string, req: TestIamPermissionsRequest): Promise<TestIamPermissionsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ resource }:testIamPermissions`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as TestIamPermissionsResponse;
  }
}

/**
 * The request object used by `AbandonRelease`.
 */
export interface AbandonReleaseRequest {
}

/**
 * The response object for `AbandonRelease`.
 */
export interface AbandonReleaseResponse {
}

/**
 * An advanceChildRollout Job.
 */
export interface AdvanceChildRolloutJob {
}

/**
 * AdvanceChildRolloutJobRun contains information specific to a
 * advanceChildRollout `JobRun`.
 */
export interface AdvanceChildRolloutJobRun {
  /**
   * Output only. Name of the `ChildRollout`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   */
  readonly rollout?: string;
  /**
   * Output only. the ID of the ChildRollout's Phase.
   */
  readonly rolloutPhaseId?: string;
}

/**
 * Contains the information of an automated advance-rollout operation.
 */
export interface AdvanceRolloutOperation {
  /**
   * Output only. The phase the rollout will be advanced to.
   */
  readonly destinationPhase?: string;
  /**
   * Output only. The name of the rollout that initiates the `AutomationRun`.
   */
  readonly rollout?: string;
  /**
   * Output only. The phase of a deployment that initiated the operation.
   */
  readonly sourcePhase?: string;
  /**
   * Output only. How long the operation will be paused.
   */
  readonly wait?: number /* Duration */;
}

/**
 * The request object used by `AdvanceRollout`.
 */
export interface AdvanceRolloutRequest {
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   */
  overrideDeployPolicy?: string[];
  /**
   * Required. The phase ID to advance the `Rollout` to.
   */
  phaseId?: string;
}

/**
 * The response object from `AdvanceRollout`.
 */
export interface AdvanceRolloutResponse {
}

/**
 * The `AdvanceRollout` automation rule will automatically advance a successful
 * Rollout to the next phase.
 */
export interface AdvanceRolloutRule {
  /**
   * Output only. Information around the state of the Automation rule.
   */
  readonly condition?: AutomationRuleCondition;
  /**
   * Required. ID of the rule. This id must be unique in the `Automation`
   * resource to which this rule belongs. The format is
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  id?: string;
  /**
   * Optional. Proceeds only after phase name matched any one in the list. This
   * value must consist of lower-case letters, numbers, and hyphens, start with
   * a letter and end with a letter or a number, and have a max length of 63
   * characters. In other words, it must match the following regex:
   * `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`.
   */
  sourcePhases?: string[];
  /**
   * Optional. How long to wait after a rollout is finished.
   */
  wait?: number /* Duration */;
}

function serializeAdvanceRolloutRule(data: any): AdvanceRolloutRule {
  return {
    ...data,
    wait: data["wait"] !== undefined ? data["wait"] : undefined,
  };
}

function deserializeAdvanceRolloutRule(data: any): AdvanceRolloutRule {
  return {
    ...data,
    condition: data["condition"] !== undefined ? deserializeAutomationRuleCondition(data["condition"]) : undefined,
    wait: data["wait"] !== undefined ? data["wait"] : undefined,
  };
}

/**
 * Information specifying an Anthos Cluster.
 */
export interface AnthosCluster {
  /**
   * Optional. Membership of the GKE Hub-registered cluster to which to apply
   * the Skaffold configuration. Format is
   * `projects/{project}/locations/{location}/memberships/{membership_name}`.
   */
  membership?: string;
}

/**
 * The request object used by `ApproveRollout`.
 */
export interface ApproveRolloutRequest {
  /**
   * Required. True = approve; false = reject
   */
  approved?: boolean;
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   */
  overrideDeployPolicy?: string[];
}

/**
 * The response object from `ApproveRollout`.
 */
export interface ApproveRolloutResponse {
}

/**
 * Information about entities associated with a `Target`.
 */
export interface AssociatedEntities {
  /**
   * Optional. Information specifying Anthos clusters as associated entities.
   */
  anthosClusters?: AnthosCluster[];
  /**
   * Optional. Information specifying GKE clusters as associated entities.
   */
  gkeClusters?: GkeCluster[];
}

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

/**
 * An `Automation` resource in the Cloud Deploy API. An `Automation` enables
 * the automation of manually driven actions for a Delivery Pipeline, which
 * includes Release promotion among Targets, Rollout repair and Rollout
 * deployment strategy advancement. The intention of Automation is to reduce
 * manual intervention in the continuous delivery process.
 */
export interface Automation {
  /**
   * Optional. User annotations. These attributes can only be set and used by
   * the user, and not by Cloud Deploy. Annotations must meet the following
   * constraints: * Annotations are key/value pairs. * Valid annotation keys
   * have two segments: an optional prefix and name, separated by a slash (`/`).
   * * The name segment is required and must be 63 characters or less, beginning
   * and ending with an alphanumeric character (`[a-z0-9A-Z]`) with dashes
   * (`-`), underscores (`_`), dots (`.`), and alphanumerics between. * The
   * prefix is optional. If specified, the prefix must be a DNS subdomain: a
   * series of DNS labels separated by dots(`.`), not longer than 253 characters
   * in total, followed by a slash (`/`). See
   * https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/#syntax-and-character-set
   * for more details.
   */
  annotations?: {
    [key: string]: string
  };
  /**
   * Output only. Time at which the automation was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. Description of the `Automation`. Max length is 255 characters.
   */
  description?: string;
  /**
   * Optional. The weak etag of the `Automation` resource. This checksum is
   * computed by the server based on the value of other fields, and may be sent
   * on update and delete requests to ensure the client has an up-to-date value
   * before proceeding.
   */
  etag?: string;
  /**
   * Optional. Labels are attributes that can be set and used by both the user
   * and by Cloud Deploy. Labels must meet the following constraints: * Keys and
   * values can contain only lowercase letters, numeric characters, underscores,
   * and dashes. * All characters must use UTF-8 encoding, and international
   * characters are allowed. * Keys must start with a lowercase letter or
   * international character. * Each resource is limited to a maximum of 64
   * labels. Both keys and values are additionally constrained to be <= 63
   * characters.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. Name of the `Automation`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{delivery_pipeline}/automations/{automation}`.
   */
  readonly name?: string;
  /**
   * Required. List of Automation rules associated with the Automation
   * resource. Must have at least one rule and limited to 250 rules per Delivery
   * Pipeline. Note: the order of the rules here is not the same as the order of
   * execution.
   */
  rules?: AutomationRule[];
  /**
   * Required. Selected resources to which the automation will be applied.
   */
  selector?: AutomationResourceSelector;
  /**
   * Required. Email address of the user-managed IAM service account that
   * creates Cloud Deploy release and rollout resources.
   */
  serviceAccount?: string;
  /**
   * Optional. When Suspended, automation is deactivated from execution.
   */
  suspended?: boolean;
  /**
   * Output only. Unique identifier of the `Automation`.
   */
  readonly uid?: string;
  /**
   * Output only. Time at which the automation was updated.
   */
  readonly updateTime?: Date;
}

function serializeAutomation(data: any): Automation {
  return {
    ...data,
    rules: data["rules"] !== undefined ? data["rules"].map((item: any) => (serializeAutomationRule(item))) : undefined,
  };
}

function deserializeAutomation(data: any): Automation {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    rules: data["rules"] !== undefined ? data["rules"].map((item: any) => (deserializeAutomationRule(item))) : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
  };
}

/**
 * Payload proto for "clouddeploy.googleapis.com/automation" Platform Log event
 * that describes the Automation related events.
 */
export interface AutomationEvent {
  /**
   * The name of the `AutomationRun`.
   */
  automation?: string;
  /**
   * Debug message for when there is an update on the AutomationRun. Provides
   * further details about the resource creation or state change.
   */
  message?: string;
  /**
   * Unique identifier of the `DeliveryPipeline`.
   */
  pipelineUid?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * AutomationResourceSelector contains the information to select the resources
 * to which an Automation is going to be applied.
 */
export interface AutomationResourceSelector {
  /**
   * Contains attributes about a target.
   */
  targets?: TargetAttribute[];
}

/**
 * AutomationRolloutMetadata contains Automation-related actions that were
 * performed on a rollout.
 */
export interface AutomationRolloutMetadata {
  /**
   * Output only. The names of the AutomationRuns initiated by an advance
   * rollout rule.
   */
  readonly advanceAutomationRuns?: string[];
  /**
   * Output only. The name of the AutomationRun initiated by a promote release
   * rule.
   */
  readonly promoteAutomationRun?: string;
  /**
   * Output only. The names of the AutomationRuns initiated by a repair rollout
   * rule.
   */
  readonly repairAutomationRuns?: string[];
}

/**
 * `AutomationRule` defines the automation activities.
 */
export interface AutomationRule {
  /**
   * Optional. The `AdvanceRolloutRule` will automatically advance a successful
   * Rollout.
   */
  advanceRolloutRule?: AdvanceRolloutRule;
  /**
   * Optional. `PromoteReleaseRule` will automatically promote a release from
   * the current target to a specified target.
   */
  promoteReleaseRule?: PromoteReleaseRule;
  /**
   * Optional. The `RepairRolloutRule` will automatically repair a failed
   * rollout.
   */
  repairRolloutRule?: RepairRolloutRule;
  /**
   * Optional. The `TimedPromoteReleaseRule` will automatically promote a
   * release from the current target(s) to the specified target(s) on a
   * configured schedule.
   */
  timedPromoteReleaseRule?: TimedPromoteReleaseRule;
}

function serializeAutomationRule(data: any): AutomationRule {
  return {
    ...data,
    advanceRolloutRule: data["advanceRolloutRule"] !== undefined ? serializeAdvanceRolloutRule(data["advanceRolloutRule"]) : undefined,
    promoteReleaseRule: data["promoteReleaseRule"] !== undefined ? serializePromoteReleaseRule(data["promoteReleaseRule"]) : undefined,
    repairRolloutRule: data["repairRolloutRule"] !== undefined ? serializeRepairRolloutRule(data["repairRolloutRule"]) : undefined,
  };
}

function deserializeAutomationRule(data: any): AutomationRule {
  return {
    ...data,
    advanceRolloutRule: data["advanceRolloutRule"] !== undefined ? deserializeAdvanceRolloutRule(data["advanceRolloutRule"]) : undefined,
    promoteReleaseRule: data["promoteReleaseRule"] !== undefined ? deserializePromoteReleaseRule(data["promoteReleaseRule"]) : undefined,
    repairRolloutRule: data["repairRolloutRule"] !== undefined ? deserializeRepairRolloutRule(data["repairRolloutRule"]) : undefined,
  };
}

/**
 * `AutomationRuleCondition` contains conditions relevant to an `Automation`
 * rule.
 */
export interface AutomationRuleCondition {
  /**
   * Optional. Details around targets enumerated in the rule.
   */
  targetsPresentCondition?: TargetsPresentCondition;
  /**
   * Optional. TimedPromoteReleaseCondition contains rule conditions specific
   * to a an Automation with a timed promote release rule defined.
   */
  timedPromoteReleaseCondition?: TimedPromoteReleaseCondition;
}

function serializeAutomationRuleCondition(data: any): AutomationRuleCondition {
  return {
    ...data,
    targetsPresentCondition: data["targetsPresentCondition"] !== undefined ? serializeTargetsPresentCondition(data["targetsPresentCondition"]) : undefined,
  };
}

function deserializeAutomationRuleCondition(data: any): AutomationRuleCondition {
  return {
    ...data,
    targetsPresentCondition: data["targetsPresentCondition"] !== undefined ? deserializeTargetsPresentCondition(data["targetsPresentCondition"]) : undefined,
  };
}

/**
 * An `AutomationRun` resource in the Cloud Deploy API. An `AutomationRun`
 * represents an execution instance of an automation rule.
 */
export interface AutomationRun {
  /**
   * Output only. Advances a rollout to the next phase.
   */
  readonly advanceRolloutOperation?: AdvanceRolloutOperation;
  /**
   * Output only. The ID of the automation that initiated the operation.
   */
  readonly automationId?: string;
  /**
   * Output only. Snapshot of the Automation taken at AutomationRun creation
   * time.
   */
  readonly automationSnapshot?: Automation;
  /**
   * Output only. Time at which the `AutomationRun` was created.
   */
  readonly createTime?: Date;
  /**
   * Output only. The weak etag of the `AutomationRun` resource. This checksum
   * is computed by the server based on the value of other fields, and may be
   * sent on update and delete requests to ensure the client has an up-to-date
   * value before proceeding.
   */
  readonly etag?: string;
  /**
   * Output only. Time the `AutomationRun` expires. An `AutomationRun` expires
   * after 14 days from its creation date.
   */
  readonly expireTime?: Date;
  /**
   * Output only. Name of the `AutomationRun`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{delivery_pipeline}/automationRuns/{automation_run}`.
   */
  readonly name?: string;
  /**
   * Output only. Contains information about what policies prevented the
   * `AutomationRun` from proceeding.
   */
  readonly policyViolation?: PolicyViolation;
  /**
   * Output only. Promotes a release to a specified 'Target'.
   */
  readonly promoteReleaseOperation?: PromoteReleaseOperation;
  /**
   * Output only. Repairs a failed 'Rollout'.
   */
  readonly repairRolloutOperation?: RepairRolloutOperation;
  /**
   * Output only. The ID of the automation rule that initiated the operation.
   */
  readonly ruleId?: string;
  /**
   * Output only. Email address of the user-managed IAM service account that
   * performs the operations against Cloud Deploy resources.
   */
  readonly serviceAccount?: string;
  /**
   * Output only. Current state of the `AutomationRun`.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "SUCCEEDED" | "CANCELLED" | "FAILED" | "IN_PROGRESS" | "PENDING" | "ABORTED";
  /**
   * Output only. Explains the current state of the `AutomationRun`. Present
   * only when an explanation is needed.
   */
  readonly stateDescription?: string;
  /**
   * Output only. The ID of the source target that initiates the
   * `AutomationRun`. The value of this field is the last segment of a target
   * name.
   */
  readonly targetId?: string;
  /**
   * Output only. Promotes a release to a specified 'Target' as defined in a
   * Timed Promote Release rule.
   */
  readonly timedPromoteReleaseOperation?: TimedPromoteReleaseOperation;
  /**
   * Output only. Time at which the automationRun was updated.
   */
  readonly updateTime?: Date;
  /**
   * Output only. Earliest time the `AutomationRun` will attempt to resume.
   * Wait-time is configured by `wait` in automation rule.
   */
  readonly waitUntilTime?: Date;
}

/**
 * Payload proto for "clouddeploy.googleapis.com/automation_run" Platform Log
 * event that describes the AutomationRun related events.
 */
export interface AutomationRunEvent {
  /**
   * Identifier of the `Automation`.
   */
  automationId?: string;
  /**
   * The name of the `AutomationRun`.
   */
  automationRun?: string;
  /**
   * ID of the `Target` to which the `AutomationRun` is created.
   */
  destinationTargetId?: string;
  /**
   * Debug message for when there is an update on the AutomationRun. Provides
   * further details about the resource creation or state change.
   */
  message?: string;
  /**
   * Unique identifier of the `DeliveryPipeline`.
   */
  pipelineUid?: string;
  /**
   * Identifier of the `Automation` rule.
   */
  ruleId?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

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

/**
 * Description of an a image to use during Skaffold rendering.
 */
export interface BuildArtifact {
  /**
   * Image name in Skaffold configuration.
   */
  image?: string;
  /**
   * Image tag to use. This will generally be the full path to an image, such
   * as "gcr.io/my-project/busybox:1.2.3" or
   * "gcr.io/my-project/busybox@sha256:abc123".
   */
  tag?: string;
}

/**
 * Canary represents the canary deployment strategy.
 */
export interface Canary {
  /**
   * Configures the progressive based deployment for a Target.
   */
  canaryDeployment?: CanaryDeployment;
  /**
   * Configures the progressive based deployment for a Target, but allows
   * customizing at the phase level where a phase represents each of the
   * percentage deployments.
   */
  customCanaryDeployment?: CustomCanaryDeployment;
  /**
   * Optional. Runtime specific configurations for the deployment strategy. The
   * runtime configuration is used to determine how Cloud Deploy will split
   * traffic to enable a progressive deployment.
   */
  runtimeConfig?: RuntimeConfig;
}

function serializeCanary(data: any): Canary {
  return {
    ...data,
    runtimeConfig: data["runtimeConfig"] !== undefined ? serializeRuntimeConfig(data["runtimeConfig"]) : undefined,
  };
}

function deserializeCanary(data: any): Canary {
  return {
    ...data,
    runtimeConfig: data["runtimeConfig"] !== undefined ? deserializeRuntimeConfig(data["runtimeConfig"]) : undefined,
  };
}

/**
 * CanaryDeployment represents the canary deployment configuration
 */
export interface CanaryDeployment {
  /**
   * Required. The percentage based deployments that will occur as a part of a
   * `Rollout`. List is expected in ascending order and each integer n is 0 <= n
   * < 100. If the GatewayServiceMesh is configured for Kubernetes, then the
   * range for n is 0 <= n <= 100.
   */
  percentages?: number[];
  /**
   * Optional. Configuration for the postdeploy job of the last phase. If this
   * is not configured, there will be no postdeploy job for this phase.
   */
  postdeploy?: Postdeploy;
  /**
   * Optional. Configuration for the predeploy job of the first phase. If this
   * is not configured, there will be no predeploy job for this phase.
   */
  predeploy?: Predeploy;
  /**
   * Whether to run verify tests after each percentage deployment.
   */
  verify?: boolean;
}

/**
 * The request object used by `CancelAutomationRun`.
 */
export interface CancelAutomationRunRequest {
}

/**
 * The response object from `CancelAutomationRun`.
 */
export interface CancelAutomationRunResponse {
}

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

/**
 * The request object used by `CancelRollout`.
 */
export interface CancelRolloutRequest {
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   */
  overrideDeployPolicy?: string[];
}

/**
 * The response object from `CancelRollout`.
 */
export interface CancelRolloutResponse {
}

/**
 * ChildRollouts job composition
 */
export interface ChildRolloutJobs {
  /**
   * Output only. List of AdvanceChildRolloutJobs
   */
  readonly advanceRolloutJobs?: Job[];
  /**
   * Output only. List of CreateChildRolloutJobs
   */
  readonly createRolloutJobs?: Job[];
}

/**
 * CloudRunConfig contains the Cloud Run runtime configuration.
 */
export interface CloudRunConfig {
  /**
   * Whether Cloud Deploy should update the traffic stanza in a Cloud Run
   * Service on the user's behalf to facilitate traffic splitting. This is
   * required to be true for CanaryDeployments, but optional for
   * CustomCanaryDeployments.
   */
  automaticTrafficControl?: boolean;
  /**
   * Optional. A list of tags that are added to the canary revision while the
   * canary phase is in progress.
   */
  canaryRevisionTags?: string[];
  /**
   * Optional. A list of tags that are added to the prior revision while the
   * canary phase is in progress.
   */
  priorRevisionTags?: string[];
  /**
   * Optional. A list of tags that are added to the final stable revision when
   * the stable phase is applied.
   */
  stableRevisionTags?: string[];
}

/**
 * Information specifying where to deploy a Cloud Run Service.
 */
export interface CloudRunLocation {
  /**
   * Required. The location for the Cloud Run Service. Format must be
   * `projects/{project}/locations/{location}`.
   */
  location?: string;
}

/**
 * CloudRunMetadata contains information from a Cloud Run deployment.
 */
export interface CloudRunMetadata {
  /**
   * Output only. The name of the Cloud Run job that is associated with a
   * `Rollout`. Format is
   * `projects/{project}/locations/{location}/jobs/{job_name}`.
   */
  readonly job?: string;
  /**
   * Output only. The Cloud Run Revision id associated with a `Rollout`.
   */
  readonly revision?: string;
  /**
   * Output only. The name of the Cloud Run Service that is associated with a
   * `Rollout`. Format is
   * `projects/{project}/locations/{location}/services/{service}`.
   */
  readonly service?: string;
  /**
   * Output only. The Cloud Run Service urls that are associated with a
   * `Rollout`.
   */
  readonly serviceUrls?: string[];
}

/**
 * CloudRunRenderMetadata contains Cloud Run information associated with a
 * `Release` render.
 */
export interface CloudRunRenderMetadata {
  /**
   * Output only. The name of the Cloud Run Service in the rendered manifest.
   * Format is `projects/{project}/locations/{location}/services/{service}`.
   */
  readonly service?: string;
}

/**
 * Service-wide configuration.
 */
export interface Config {
  /**
   * Default Skaffold version that is assigned when a Release is created
   * without specifying a Skaffold version.
   */
  defaultSkaffoldVersion?: string;
  /**
   * Name of the configuration.
   */
  name?: string;
  /**
   * All supported versions of Skaffold.
   */
  supportedVersions?: SkaffoldVersion[];
}

function serializeConfig(data: any): Config {
  return {
    ...data,
    supportedVersions: data["supportedVersions"] !== undefined ? data["supportedVersions"].map((item: any) => (serializeSkaffoldVersion(item))) : undefined,
  };
}

function deserializeConfig(data: any): Config {
  return {
    ...data,
    supportedVersions: data["supportedVersions"] !== undefined ? data["supportedVersions"].map((item: any) => (deserializeSkaffoldVersion(item))) : undefined,
  };
}

/**
 * A createChildRollout Job.
 */
export interface CreateChildRolloutJob {
}

/**
 * CreateChildRolloutJobRun contains information specific to a
 * createChildRollout `JobRun`.
 */
export interface CreateChildRolloutJobRun {
  /**
   * Output only. Name of the `ChildRollout`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   */
  readonly rollout?: string;
  /**
   * Output only. The ID of the childRollout Phase initiated by this JobRun.
   */
  readonly rolloutPhaseId?: string;
}

/**
 * CustomCanaryDeployment represents the custom canary deployment
 * configuration.
 */
export interface CustomCanaryDeployment {
  /**
   * Required. Configuration for each phase in the canary deployment in the
   * order executed.
   */
  phaseConfigs?: PhaseConfig[];
}

/**
 * CustomMetadata contains information from a user-defined operation.
 */
export interface CustomMetadata {
  /**
   * Output only. Key-value pairs provided by the user-defined operation.
   */
  readonly values?: {
    [key: string]: string
  };
}

/**
 * Information specifying a Custom Target.
 */
export interface CustomTarget {
  /**
   * Required. The name of the CustomTargetType. Format must be
   * `projects/{project}/locations/{location}/customTargetTypes/{custom_target_type}`.
   */
  customTargetType?: string;
}

/**
 * CustomTargetDeployMetadata contains information from a Custom Target deploy
 * operation.
 */
export interface CustomTargetDeployMetadata {
  /**
   * Output only. Skip message provided in the results of a custom deploy
   * operation.
   */
  readonly skipMessage?: string;
}

/**
 * CustomTargetSkaffoldActions represents the `CustomTargetType` configuration
 * using Skaffold custom actions.
 */
export interface CustomTargetSkaffoldActions {
  /**
   * Required. The Skaffold custom action responsible for deploy operations.
   */
  deployAction?: string;
  /**
   * Optional. List of Skaffold modules Cloud Deploy will include in the
   * Skaffold Config as required before performing diagnose.
   */
  includeSkaffoldModules?: SkaffoldModules[];
  /**
   * Optional. The Skaffold custom action responsible for render operations. If
   * not provided then Cloud Deploy will perform the render operations via
   * `skaffold render`.
   */
  renderAction?: string;
}

/**
 * A `CustomTargetType` resource in the Cloud Deploy API. A `CustomTargetType`
 * defines a type of custom target that can be referenced in a `Target` in order
 * to facilitate deploying to other systems besides the supported runtimes.
 */
export interface CustomTargetType {
  /**
   * Optional. User annotations. These attributes can only be set and used by
   * the user, and not by Cloud Deploy. See
   * https://google.aip.dev/128#annotations for more details such as format and
   * size limitations.
   */
  annotations?: {
    [key: string]: string
  };
  /**
   * Output only. Time at which the `CustomTargetType` was created.
   */
  readonly createTime?: Date;
  /**
   * Configures render and deploy for the `CustomTargetType` using Skaffold
   * custom actions.
   */
  customActions?: CustomTargetSkaffoldActions;
  /**
   * Output only. Resource id of the `CustomTargetType`.
   */
  readonly customTargetTypeId?: string;
  /**
   * Optional. Description of the `CustomTargetType`. Max length is 255
   * characters.
   */
  description?: string;
  /**
   * Optional. This checksum is computed by the server based on the value of
   * other fields, and may be sent on update and delete requests to ensure the
   * client has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Optional. Labels are attributes that can be set and used by both the user
   * and by Cloud Deploy. Labels must meet the following constraints: * Keys and
   * values can contain only lowercase letters, numeric characters, underscores,
   * and dashes. * All characters must use UTF-8 encoding, and international
   * characters are allowed. * Keys must start with a lowercase letter or
   * international character. * Each resource is limited to a maximum of 64
   * labels. Both keys and values are additionally constrained to be <= 128
   * bytes.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. Name of the `CustomTargetType`. Format is
   * `projects/{project}/locations/{location}/customTargetTypes/{customTargetType}`.
   * The `customTargetType` component must match
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  name?: string;
  /**
   * Output only. Unique identifier of the `CustomTargetType`.
   */
  readonly uid?: string;
  /**
   * Output only. Most recent time at which the `CustomTargetType` was updated.
   */
  readonly updateTime?: Date;
}

/**
 * Payload proto for "clouddeploy.googleapis.com/customtargettype_notification"
 * Platform Log event that describes the failure to send a custom target type
 * status change Pub/Sub notification.
 */
export interface CustomTargetTypeNotificationEvent {
  /**
   * The name of the `CustomTargetType`.
   */
  customTargetType?: string;
  /**
   * Unique identifier of the `CustomTargetType`.
   */
  customTargetTypeUid?: string;
  /**
   * Debug message for when a notification fails to send.
   */
  message?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * Represents a whole or partial calendar date, such as a birthday. The time of
 * day and time zone are either specified elsewhere or are insignificant. The
 * date is relative to the Gregorian Calendar. This can represent one of the
 * following: * A full date, with non-zero year, month, and day values. * A
 * month and day, with a zero year (for example, an anniversary). * A year on
 * its own, with a zero month and a zero day. * A year and month, with a zero
 * day (for example, a credit card expiration date). Related types: *
 * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp
 */
export interface Date {
  /**
   * Day of a month. Must be from 1 to 31 and valid for the year and month, or
   * 0 to specify a year by itself or a year and month where the day isn't
   * significant.
   */
  day?: number;
  /**
   * Month of a year. Must be from 1 to 12, or 0 to specify a year without a
   * month and day.
   */
  month?: number;
  /**
   * Year of the date. Must be from 1 to 9999, or 0 to specify a date without a
   * year.
   */
  year?: number;
}

/**
 * Execution using the default Cloud Build pool.
 */
export interface DefaultPool {
  /**
   * Optional. Cloud Storage location where execution outputs should be stored.
   * This can either be a bucket ("gs://my-bucket") or a path within a bucket
   * ("gs://my-bucket/my-dir"). If unspecified, a default bucket located in the
   * same region will be used.
   */
  artifactStorage?: string;
  /**
   * Optional. Google service account to use for execution. If unspecified, the
   * project execution service account (-compute@developer.gserviceaccount.com)
   * will be used.
   */
  serviceAccount?: string;
}

/**
 * A `DeliveryPipeline` resource in the Cloud Deploy API. A `DeliveryPipeline`
 * defines a pipeline through which a Skaffold configuration can progress.
 */
export interface DeliveryPipeline {
  /**
   * User annotations. These attributes can only be set and used by the user,
   * and not by Cloud Deploy.
   */
  annotations?: {
    [key: string]: string
  };
  /**
   * Output only. Information around the state of the Delivery Pipeline.
   */
  readonly condition?: PipelineCondition;
  /**
   * Output only. Time at which the pipeline was created.
   */
  readonly createTime?: Date;
  /**
   * Description of the `DeliveryPipeline`. Max length is 255 characters.
   */
  description?: string;
  /**
   * This checksum is computed by the server based on the value of other
   * fields, and may be sent on update and delete requests to ensure the client
   * has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Labels are attributes that can be set and used by both the user and by
   * Cloud Deploy. Labels must meet the following constraints: * Keys and values
   * can contain only lowercase letters, numeric characters, underscores, and
   * dashes. * All characters must use UTF-8 encoding, and international
   * characters are allowed. * Keys must start with a lowercase letter or
   * international character. * Each resource is limited to a maximum of 64
   * labels. Both keys and values are additionally constrained to be <= 128
   * bytes.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. Name of the `DeliveryPipeline`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}`.
   * The `deliveryPipeline` component must match
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  name?: string;
  /**
   * SerialPipeline defines a sequential set of stages for a
   * `DeliveryPipeline`.
   */
  serialPipeline?: SerialPipeline;
  /**
   * When suspended, no new releases or rollouts can be created, but
   * in-progress ones will complete.
   */
  suspended?: boolean;
  /**
   * Output only. Unique identifier of the `DeliveryPipeline`.
   */
  readonly uid?: string;
  /**
   * Output only. Most recent time at which the pipeline was updated.
   */
  readonly updateTime?: Date;
}

function serializeDeliveryPipeline(data: any): DeliveryPipeline {
  return {
    ...data,
    serialPipeline: data["serialPipeline"] !== undefined ? serializeSerialPipeline(data["serialPipeline"]) : undefined,
  };
}

function deserializeDeliveryPipeline(data: any): DeliveryPipeline {
  return {
    ...data,
    condition: data["condition"] !== undefined ? deserializePipelineCondition(data["condition"]) : undefined,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    serialPipeline: data["serialPipeline"] !== undefined ? deserializeSerialPipeline(data["serialPipeline"]) : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
  };
}

/**
 * Contains criteria for selecting DeliveryPipelines.
 */
export interface DeliveryPipelineAttribute {
  /**
   * ID of the `DeliveryPipeline`. The value of this field could be one of the
   * following: * The last segment of a pipeline name * "*", all delivery
   * pipelines in a location
   */
  id?: string;
  /**
   * DeliveryPipeline labels.
   */
  labels?: {
    [key: string]: string
  };
}

/**
 * Payload proto for "clouddeploy.googleapis.com/deliverypipeline_notification"
 * Platform Log event that describes the failure to send delivery pipeline
 * status change Pub/Sub notification.
 */
export interface DeliveryPipelineNotificationEvent {
  /**
   * The name of the `Delivery Pipeline`.
   */
  deliveryPipeline?: string;
  /**
   * Debug message for when a notification fails to send.
   */
  message?: string;
  /**
   * Unique identifier of the `DeliveryPipeline`.
   */
  pipelineUid?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * The artifacts produced by a deploy operation.
 */
export interface DeployArtifact {
  /**
   * Output only. URI of a directory containing the artifacts. All paths are
   * relative to this location.
   */
  readonly artifactUri?: string;
  /**
   * Output only. File paths of the manifests applied during the deploy
   * operation relative to the URI.
   */
  readonly manifestPaths?: string[];
}

/**
 * A deploy Job.
 */
export interface DeployJob {
}

/**
 * DeployJobRun contains information specific to a deploy `JobRun`.
 */
export interface DeployJobRun {
  /**
   * Output only. The artifact of a deploy job run, if available.
   */
  readonly artifact?: DeployArtifact;
  /**
   * Output only. The resource name of the Cloud Build `Build` object that is
   * used to deploy. Format is
   * `projects/{project}/locations/{location}/builds/{build}`.
   */
  readonly build?: string;
  /**
   * Output only. The reason the deploy failed. This will always be unspecified
   * while the deploy is in progress or if it succeeded.
   */
  readonly failureCause?:  | "FAILURE_CAUSE_UNSPECIFIED" | "CLOUD_BUILD_UNAVAILABLE" | "EXECUTION_FAILED" | "DEADLINE_EXCEEDED" | "MISSING_RESOURCES_FOR_CANARY" | "CLOUD_BUILD_REQUEST_FAILED" | "DEPLOY_FEATURE_NOT_SUPPORTED";
  /**
   * Output only. Additional information about the deploy failure, if
   * available.
   */
  readonly failureMessage?: string;
  /**
   * Output only. Metadata containing information about the deploy job run.
   */
  readonly metadata?: DeployJobRunMetadata;
}

/**
 * DeployJobRunMetadata surfaces information associated with a `DeployJobRun`
 * to the user.
 */
export interface DeployJobRunMetadata {
  /**
   * Output only. The name of the Cloud Run Service that is associated with a
   * `DeployJobRun`.
   */
  readonly cloudRun?: CloudRunMetadata;
  /**
   * Output only. Custom metadata provided by user-defined deploy operation.
   */
  readonly custom?: CustomMetadata;
  /**
   * Output only. Custom Target metadata associated with a `DeployJobRun`.
   */
  readonly customTarget?: CustomTargetDeployMetadata;
}

/**
 * Deployment job composition.
 */
export interface DeploymentJobs {
  /**
   * Output only. The deploy Job. This is the deploy job in the phase.
   */
  readonly deployJob?: Job;
  /**
   * Output only. The postdeploy Job, which is the last job on the phase.
   */
  readonly postdeployJob?: Job;
  /**
   * Output only. The predeploy Job, which is the first job on the phase.
   */
  readonly predeployJob?: Job;
  /**
   * Output only. The verify Job. Runs after a deploy if the deploy succeeds.
   */
  readonly verifyJob?: Job;
}

/**
 * DeployParameters contains deploy parameters information.
 */
export interface DeployParameters {
  /**
   * Optional. Deploy parameters are applied to targets with match labels. If
   * unspecified, deploy parameters are applied to all targets (including child
   * targets of a multi-target).
   */
  matchTargetLabels?: {
    [key: string]: string
  };
  /**
   * Required. Values are deploy parameters in key-value pairs.
   */
  values?: {
    [key: string]: string
  };
}

/**
 * A `DeployPolicy` resource in the Cloud Deploy API. A `DeployPolicy` inhibits
 * manual or automation-driven actions within a Delivery Pipeline or Target.
 */
export interface DeployPolicy {
  /**
   * User annotations. These attributes can only be set and used by the user,
   * and not by Cloud Deploy. Annotations must meet the following constraints: *
   * Annotations are key/value pairs. * Valid annotation keys have two segments:
   * an optional prefix and name, separated by a slash (`/`). * The name segment
   * is required and must be 63 characters or less, beginning and ending with an
   * alphanumeric character (`[a-z0-9A-Z]`) with dashes (`-`), underscores
   * (`_`), dots (`.`), and alphanumerics between. * The prefix is optional. If
   * specified, the prefix must be a DNS subdomain: a series of DNS labels
   * separated by dots(`.`), not longer than 253 characters in total, followed
   * by a slash (`/`). See
   * https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/#syntax-and-character-set
   * for more details.
   */
  annotations?: {
    [key: string]: string
  };
  /**
   * Output only. Time at which the deploy policy was created.
   */
  readonly createTime?: Date;
  /**
   * Description of the `DeployPolicy`. Max length is 255 characters.
   */
  description?: string;
  /**
   * The weak etag of the `Automation` resource. This checksum is computed by
   * the server based on the value of other fields, and may be sent on update
   * and delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: string;
  /**
   * Labels are attributes that can be set and used by both the user and by
   * Cloud Deploy. Labels must meet the following constraints: * Keys and values
   * can contain only lowercase letters, numeric characters, underscores, and
   * dashes. * All characters must use UTF-8 encoding, and international
   * characters are allowed. * Keys must start with a lowercase letter or
   * international character. * Each resource is limited to a maximum of 64
   * labels. Both keys and values are additionally constrained to be <= 128
   * bytes.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. Name of the `DeployPolicy`. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   * The `deployPolicy` component must match `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  readonly name?: string;
  /**
   * Required. Rules to apply. At least one rule must be present.
   */
  rules?: PolicyRule[];
  /**
   * Required. Selected resources to which the policy will be applied. At least
   * one selector is required. If one selector matches the resource the policy
   * applies. For example, if there are two selectors and the action being
   * attempted matches one of them, the policy will apply to that action.
   */
  selectors?: DeployPolicyResourceSelector[];
  /**
   * When suspended, the policy will not prevent actions from occurring, even
   * if the action violates the policy.
   */
  suspended?: boolean;
  /**
   * Output only. Unique identifier of the `DeployPolicy`.
   */
  readonly uid?: string;
  /**
   * Output only. Most recent time at which the deploy policy was updated.
   */
  readonly updateTime?: Date;
}

/**
 * Payload proto for "clouddeploy.googleapis.com/deploypolicy_evaluation"
 * Platform Log event that describes the deploy policy evaluation event.
 */
export interface DeployPolicyEvaluationEvent {
  /**
   * Whether the request is allowed. Allowed is set as true if: (1) the request
   * complies with the policy; or (2) the request doesn't comply with the policy
   * but the policy was overridden; or (3) the request doesn't comply with the
   * policy but the policy was suspended
   */
  allowed?: boolean;
  /**
   * The name of the `Delivery Pipeline`.
   */
  deliveryPipeline?: string;
  /**
   * The name of the `DeployPolicy`.
   */
  deployPolicy?: string;
  /**
   * Unique identifier of the `DeployPolicy`.
   */
  deployPolicyUid?: string;
  /**
   * What invoked the action (e.g. a user or automation).
   */
  invoker?:  | "INVOKER_UNSPECIFIED" | "USER" | "DEPLOY_AUTOMATION";
  /**
   * Debug message for when a deploy policy event occurs.
   */
  message?: string;
  /**
   * Things that could have overridden the policy verdict. Overrides together
   * with verdict decide whether the request is allowed.
   */
  overrides?:  | "POLICY_VERDICT_OVERRIDE_UNSPECIFIED" | "POLICY_OVERRIDDEN" | "POLICY_SUSPENDED"[];
  /**
   * Unique identifier of the `Delivery Pipeline`.
   */
  pipelineUid?: string;
  /**
   * Rule id.
   */
  rule?: string;
  /**
   * Rule type (e.g. Restrict Rollouts).
   */
  ruleType?: string;
  /**
   * The name of the `Target`. This is an optional field, as a `Target` may not
   * always be applicable to a policy.
   */
  target?: string;
  /**
   * Unique identifier of the `Target`. This is an optional field, as a
   * `Target` may not always be applicable to a policy.
   */
  targetUid?: string;
  /**
   * The policy verdict of the request.
   */
  verdict?:  | "POLICY_VERDICT_UNSPECIFIED" | "ALLOWED_BY_POLICY" | "DENIED_BY_POLICY";
}

/**
 * Payload proto for "clouddeploy.googleapis.com/deploypolicy_notification".
 * Platform Log event that describes the failure to send a pub/sub notification
 * when there is a DeployPolicy status change.
 */
export interface DeployPolicyNotificationEvent {
  /**
   * The name of the `DeployPolicy`.
   */
  deployPolicy?: string;
  /**
   * Unique identifier of the deploy policy.
   */
  deployPolicyUid?: string;
  /**
   * Debug message for when a deploy policy fails to send a pub/sub
   * notification.
   */
  message?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * Contains information on the resources to select for a deploy policy.
 * Attributes provided must all match the resource in order for policy
 * restrictions to apply. For example, if delivery pipelines attributes given
 * are an id "prod" and labels "foo: bar", a delivery pipeline resource must
 * match both that id and have that label in order to be subject to the policy.
 */
export interface DeployPolicyResourceSelector {
  /**
   * Optional. Contains attributes about a delivery pipeline.
   */
  deliveryPipeline?: DeliveryPipelineAttribute;
  /**
   * Optional. Contains attributes about a target.
   */
  target?: TargetAttribute;
}

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

/**
 * Configuration of the environment to use when calling Skaffold.
 */
export interface ExecutionConfig {
  /**
   * Optional. Cloud Storage location in which to store execution outputs. This
   * can either be a bucket ("gs://my-bucket") or a path within a bucket
   * ("gs://my-bucket/my-dir"). If unspecified, a default bucket located in the
   * same region will be used.
   */
  artifactStorage?: string;
  /**
   * Optional. Use default Cloud Build pool.
   */
  defaultPool?: DefaultPool;
  /**
   * Optional. Execution timeout for a Cloud Build Execution. This must be
   * between 10m and 24h in seconds format. If unspecified, a default timeout of
   * 1h is used.
   */
  executionTimeout?: number /* Duration */;
  /**
   * Optional. Use private Cloud Build pool.
   */
  privatePool?: PrivatePool;
  /**
   * Optional. Google service account to use for execution. If unspecified, the
   * project execution service account (-compute@developer.gserviceaccount.com)
   * is used.
   */
  serviceAccount?: string;
  /**
   * Required. Usages when this configuration should be applied.
   */
  usages?:  | "EXECUTION_ENVIRONMENT_USAGE_UNSPECIFIED" | "RENDER" | "DEPLOY" | "VERIFY" | "PREDEPLOY" | "POSTDEPLOY"[];
  /**
   * Optional. If true, additional logging will be enabled when running builds
   * in this execution environment.
   */
  verbose?: boolean;
  /**
   * Optional. The resource name of the `WorkerPool`, with the format
   * `projects/{project}/locations/{location}/workerPools/{worker_pool}`. If
   * this optional field is unspecified, the default Cloud Build pool will be
   * used.
   */
  workerPool?: string;
}

function serializeExecutionConfig(data: any): ExecutionConfig {
  return {
    ...data,
    executionTimeout: data["executionTimeout"] !== undefined ? data["executionTimeout"] : undefined,
  };
}

function deserializeExecutionConfig(data: any): ExecutionConfig {
  return {
    ...data,
    executionTimeout: data["executionTimeout"] !== undefined ? data["executionTimeout"] : undefined,
  };
}

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

/**
 * Information about the Kubernetes Gateway API service mesh configuration.
 */
export interface GatewayServiceMesh {
  /**
   * Required. Name of the Kubernetes Deployment whose traffic is managed by
   * the specified HTTPRoute and Service.
   */
  deployment?: string;
  /**
   * Required. Name of the Gateway API HTTPRoute.
   */
  httpRoute?: string;
  /**
   * Optional. The label to use when selecting Pods for the Deployment and
   * Service resources. This label must already be present in both resources.
   */
  podSelectorLabel?: string;
  /**
   * Optional. Route destinations allow configuring the Gateway API HTTPRoute
   * to be deployed to additional clusters. This option is available for
   * multi-cluster service mesh set ups that require the route to exist in the
   * clusters that call the service. If unspecified, the HTTPRoute will only be
   * deployed to the Target cluster.
   */
  routeDestinations?: RouteDestinations;
  /**
   * Optional. The time to wait for route updates to propagate. The maximum
   * configurable time is 3 hours, in seconds format. If unspecified, there is
   * no wait time.
   */
  routeUpdateWaitTime?: number /* Duration */;
  /**
   * Required. Name of the Kubernetes Service.
   */
  service?: string;
  /**
   * Optional. The amount of time to migrate traffic back from the canary
   * Service to the original Service during the stable phase deployment. If
   * specified, must be between 15s and 3600s. If unspecified, there is no
   * cutback time.
   */
  stableCutbackDuration?: number /* Duration */;
}

function serializeGatewayServiceMesh(data: any): GatewayServiceMesh {
  return {
    ...data,
    routeUpdateWaitTime: data["routeUpdateWaitTime"] !== undefined ? data["routeUpdateWaitTime"] : undefined,
    stableCutbackDuration: data["stableCutbackDuration"] !== undefined ? data["stableCutbackDuration"] : undefined,
  };
}

function deserializeGatewayServiceMesh(data: any): GatewayServiceMesh {
  return {
    ...data,
    routeUpdateWaitTime: data["routeUpdateWaitTime"] !== undefined ? data["routeUpdateWaitTime"] : undefined,
    stableCutbackDuration: data["stableCutbackDuration"] !== undefined ? data["stableCutbackDuration"] : undefined,
  };
}

/**
 * Information specifying a GKE Cluster.
 */
export interface GkeCluster {
  /**
   * Optional. Information specifying a GKE Cluster. Format is
   * `projects/{project_id}/locations/{location_id}/clusters/{cluster_id}`.
   */
  cluster?: string;
  /**
   * Optional. If true, `cluster` is accessed using the private IP address of
   * the control plane endpoint. Otherwise, the default IP address of the
   * control plane endpoint is used. The default IP address is the private IP
   * address for clusters with private control-plane endpoints and the public IP
   * address otherwise. Only specify this option when `cluster` is a [private
   * GKE
   * cluster](https://cloud.google.com/kubernetes-engine/docs/concepts/private-cluster-concept).
   */
  internalIp?: boolean;
  /**
   * Optional. If set, used to configure a
   * [proxy](https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#proxy)
   * to the Kubernetes server.
   */
  proxyUrl?: string;
}

/**
 * The request object used by `IgnoreJob`.
 */
export interface IgnoreJobRequest {
  /**
   * Required. The job ID for the Job to ignore.
   */
  jobId?: string;
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   */
  overrideDeployPolicy?: string[];
  /**
   * Required. The phase ID the Job to ignore belongs to.
   */
  phaseId?: string;
}

/**
 * The response object from `IgnoreJob`.
 */
export interface IgnoreJobResponse {
}

/**
 * Job represents an operation for a `Rollout`.
 */
export interface Job {
  /**
   * Output only. An advanceChildRollout Job.
   */
  readonly advanceChildRolloutJob?: AdvanceChildRolloutJob;
  /**
   * Output only. A createChildRollout Job.
   */
  readonly createChildRolloutJob?: CreateChildRolloutJob;
  /**
   * Output only. A deploy Job.
   */
  readonly deployJob?: DeployJob;
  /**
   * Output only. The ID of the Job.
   */
  readonly id?: string;
  /**
   * Output only. The name of the `JobRun` responsible for the most recent
   * invocation of this Job.
   */
  readonly jobRun?: string;
  /**
   * Output only. A postdeploy Job.
   */
  readonly postdeployJob?: PostdeployJob;
  /**
   * Output only. A predeploy Job.
   */
  readonly predeployJob?: PredeployJob;
  /**
   * Output only. Additional information on why the Job was skipped, if
   * available.
   */
  readonly skipMessage?: string;
  /**
   * Output only. The current state of the Job.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "PENDING" | "DISABLED" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "ABORTED" | "SKIPPED" | "IGNORED";
  /**
   * Output only. A verify Job.
   */
  readonly verifyJob?: VerifyJob;
}

/**
 * A `JobRun` resource in the Cloud Deploy API. A `JobRun` contains information
 * of a single `Rollout` job evaluation.
 */
export interface JobRun {
  /**
   * Output only. Information specific to an advanceChildRollout `JobRun`
   */
  readonly advanceChildRolloutJobRun?: AdvanceChildRolloutJobRun;
  /**
   * Output only. Information specific to a createChildRollout `JobRun`.
   */
  readonly createChildRolloutJobRun?: CreateChildRolloutJobRun;
  /**
   * Output only. Time at which the `JobRun` was created.
   */
  readonly createTime?: Date;
  /**
   * Output only. Information specific to a deploy `JobRun`.
   */
  readonly deployJobRun?: DeployJobRun;
  /**
   * Output only. Time at which the `JobRun` ended.
   */
  readonly endTime?: Date;
  /**
   * Output only. This checksum is computed by the server based on the value of
   * other fields, and may be sent on update and delete requests to ensure the
   * client has an up-to-date value before proceeding.
   */
  readonly etag?: string;
  /**
   * Output only. ID of the `Rollout` job this `JobRun` corresponds to.
   */
  readonly jobId?: string;
  /**
   * Optional. Name of the `JobRun`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{releases}/rollouts/{rollouts}/jobRuns/{uuid}`.
   */
  name?: string;
  /**
   * Output only. ID of the `Rollout` phase this `JobRun` belongs in.
   */
  readonly phaseId?: string;
  /**
   * Output only. Information specific to a postdeploy `JobRun`.
   */
  readonly postdeployJobRun?: PostdeployJobRun;
  /**
   * Output only. Information specific to a predeploy `JobRun`.
   */
  readonly predeployJobRun?: PredeployJobRun;
  /**
   * Output only. Time at which the `JobRun` was started.
   */
  readonly startTime?: Date;
  /**
   * Output only. The current state of the `JobRun`.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "TERMINATING" | "TERMINATED";
  /**
   * Output only. Unique identifier of the `JobRun`.
   */
  readonly uid?: string;
  /**
   * Output only. Information specific to a verify `JobRun`.
   */
  readonly verifyJobRun?: VerifyJobRun;
}

/**
 * Payload proto for "clouddeploy.googleapis.com/jobrun_notification" Platform
 * Log event that describes the failure to send JobRun resource update Pub/Sub
 * notification.
 */
export interface JobRunNotificationEvent {
  /**
   * The name of the `JobRun`.
   */
  jobRun?: string;
  /**
   * Debug message for when a notification fails to send.
   */
  message?: string;
  /**
   * Unique identifier of the `DeliveryPipeline`.
   */
  pipelineUid?: string;
  /**
   * The name of the `Release`.
   */
  release?: string;
  /**
   * Unique identifier of the `Release`.
   */
  releaseUid?: string;
  /**
   * The name of the `Rollout`.
   */
  rollout?: string;
  /**
   * Unique identifier of the `Rollout`.
   */
  rolloutUid?: string;
  /**
   * ID of the `Target`.
   */
  targetId?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * KubernetesConfig contains the Kubernetes runtime configuration.
 */
export interface KubernetesConfig {
  /**
   * Kubernetes Gateway API service mesh configuration.
   */
  gatewayServiceMesh?: GatewayServiceMesh;
  /**
   * Kubernetes Service networking configuration.
   */
  serviceNetworking?: ServiceNetworking;
}

function serializeKubernetesConfig(data: any): KubernetesConfig {
  return {
    ...data,
    gatewayServiceMesh: data["gatewayServiceMesh"] !== undefined ? serializeGatewayServiceMesh(data["gatewayServiceMesh"]) : undefined,
  };
}

function deserializeKubernetesConfig(data: any): KubernetesConfig {
  return {
    ...data,
    gatewayServiceMesh: data["gatewayServiceMesh"] !== undefined ? deserializeGatewayServiceMesh(data["gatewayServiceMesh"]) : undefined,
  };
}

/**
 * The response object from `ListAutomationRuns`.
 */
export interface ListAutomationRunsResponse {
  /**
   * The `AutomationRuns` objects.
   */
  automationRuns?: AutomationRun[];
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * The response object from `ListAutomations`.
 */
export interface ListAutomationsResponse {
  /**
   * The `Automation` objects.
   */
  automations?: Automation[];
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

function serializeListAutomationsResponse(data: any): ListAutomationsResponse {
  return {
    ...data,
    automations: data["automations"] !== undefined ? data["automations"].map((item: any) => (serializeAutomation(item))) : undefined,
  };
}

function deserializeListAutomationsResponse(data: any): ListAutomationsResponse {
  return {
    ...data,
    automations: data["automations"] !== undefined ? data["automations"].map((item: any) => (deserializeAutomation(item))) : undefined,
  };
}

/**
 * The response object from `ListCustomTargetTypes.`
 */
export interface ListCustomTargetTypesResponse {
  /**
   * The `CustomTargetType` objects.
   */
  customTargetTypes?: CustomTargetType[];
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * The response object from `ListDeliveryPipelines`.
 */
export interface ListDeliveryPipelinesResponse {
  /**
   * The `DeliveryPipeline` objects.
   */
  deliveryPipelines?: DeliveryPipeline[];
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

function serializeListDeliveryPipelinesResponse(data: any): ListDeliveryPipelinesResponse {
  return {
    ...data,
    deliveryPipelines: data["deliveryPipelines"] !== undefined ? data["deliveryPipelines"].map((item: any) => (serializeDeliveryPipeline(item))) : undefined,
  };
}

function deserializeListDeliveryPipelinesResponse(data: any): ListDeliveryPipelinesResponse {
  return {
    ...data,
    deliveryPipelines: data["deliveryPipelines"] !== undefined ? data["deliveryPipelines"].map((item: any) => (deserializeDeliveryPipeline(item))) : undefined,
  };
}

/**
 * The response object from `ListDeployPolicies`.
 */
export interface ListDeployPoliciesResponse {
  /**
   * The `DeployPolicy` objects.
   */
  deployPolicies?: DeployPolicy[];
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * ListJobRunsResponse is the response object returned by `ListJobRuns`.
 */
export interface ListJobRunsResponse {
  /**
   * The `JobRun` objects.
   */
  jobRuns?: JobRun[];
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * Locations that could not be reached
   */
  unreachable?: string[];
}

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

/**
 * The response object from `ListReleases`.
 */
export interface ListReleasesResponse {
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * The `Release` objects.
   */
  releases?: Release[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * ListRolloutsResponse is the response object reutrned by `ListRollouts`.
 */
export interface ListRolloutsResponse {
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * The `Rollout` objects.
   */
  rollouts?: Rollout[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

/**
 * The response object from `ListTargets`.
 */
export interface ListTargetsResponse {
  /**
   * A token, which can be sent as `page_token` to retrieve the next page. If
   * this field is omitted, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * The `Target` objects.
   */
  targets?: Target[];
  /**
   * Locations that could not be reached.
   */
  unreachable?: string[];
}

function serializeListTargetsResponse(data: any): ListTargetsResponse {
  return {
    ...data,
    targets: data["targets"] !== undefined ? data["targets"].map((item: any) => (serializeTarget(item))) : undefined,
  };
}

function deserializeListTargetsResponse(data: any): ListTargetsResponse {
  return {
    ...data,
    targets: data["targets"] !== undefined ? data["targets"].map((item: any) => (deserializeTarget(item))) : undefined,
  };
}

/**
 * A resource that represents a Google Cloud location.
 */
export interface Location {
  /**
   * The friendly name for this location, typically a nearby city name. For
   * example, "Tokyo".
   */
  displayName?: string;
  /**
   * Cross-service attributes for the location. For example
   * {"cloud.googleapis.com/region": "us-east1"}
   */
  labels?: {
    [key: string]: string
  };
  /**
   * The canonical id for this location. For example: `"us-east1"`.
   */
  locationId?: string;
  /**
   * Service-specific metadata. For example the available capacity at the given
   * location.
   */
  metadata?: {
    [key: string]: any
  };
  /**
   * Resource name for the location, which may vary between implementations.
   * For example: `"projects/example-project/locations/us-east1"`
   */
  name?: string;
}

/**
 * Metadata includes information associated with a `Rollout`.
 */
export interface Metadata {
  /**
   * Output only. AutomationRolloutMetadata contains the information about the
   * interactions between Automation service and this rollout.
   */
  readonly automation?: AutomationRolloutMetadata;
  /**
   * Output only. The name of the Cloud Run Service that is associated with a
   * `Rollout`.
   */
  readonly cloudRun?: CloudRunMetadata;
  /**
   * Output only. Custom metadata provided by user-defined `Rollout`
   * operations.
   */
  readonly custom?: CustomMetadata;
}

/**
 * Information specifying a multiTarget.
 */
export interface MultiTarget {
  /**
   * Required. The target_ids of this multiTarget.
   */
  targetIds?: string[];
}

/**
 * One-time window within which actions are restricted. For example, blocking
 * actions over New Year's Eve from December 31st at 5pm to January 1st at 9am.
 */
export interface OneTimeWindow {
  /**
   * Required. End date.
   */
  endDate?: Date;
  /**
   * Required. End time (exclusive). You may use 24:00 for the end of the day.
   */
  endTime?: TimeOfDay;
  /**
   * Required. Start date.
   */
  startDate?: Date;
  /**
   * Required. Start time (inclusive). Use 00:00 for the beginning of the day.
   */
  startTime?: TimeOfDay;
}

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

/**
 * Phase represents a collection of jobs that are logically grouped together
 * for a `Rollout`.
 */
export interface Phase {
  /**
   * Output only. ChildRollout job composition.
   */
  readonly childRolloutJobs?: ChildRolloutJobs;
  /**
   * Output only. Deployment job composition.
   */
  readonly deploymentJobs?: DeploymentJobs;
  /**
   * Output only. The ID of the Phase.
   */
  readonly id?: string;
  /**
   * Output only. Additional information on why the Phase was skipped, if
   * available.
   */
  readonly skipMessage?: string;
  /**
   * Output only. Current state of the Phase.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "PENDING" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "ABORTED" | "SKIPPED";
}

/**
 * Contains the paths to the artifacts, relative to the URI, for a phase.
 */
export interface PhaseArtifact {
  /**
   * Output only. File path of the directory of rendered job manifests relative
   * to the URI. This is only set if it is applicable.
   */
  readonly jobManifestsPath?: string;
  /**
   * Output only. File path of the rendered manifest relative to the URI.
   */
  readonly manifestPath?: string;
  /**
   * Output only. File path of the resolved Skaffold configuration relative to
   * the URI.
   */
  readonly skaffoldConfigPath?: string;
}

/**
 * PhaseConfig represents the configuration for a phase in the custom canary
 * deployment.
 */
export interface PhaseConfig {
  /**
   * Required. Percentage deployment for the phase.
   */
  percentage?: number;
  /**
   * Required. The ID to assign to the `Rollout` phase. This value must consist
   * of lower-case letters, numbers, and hyphens, start with a letter and end
   * with a letter or a number, and have a max length of 63 characters. In other
   * words, it must match the following regex:
   * `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`.
   */
  phaseId?: string;
  /**
   * Optional. Configuration for the postdeploy job of this phase. If this is
   * not configured, there will be no postdeploy job for this phase.
   */
  postdeploy?: Postdeploy;
  /**
   * Optional. Configuration for the predeploy job of this phase. If this is
   * not configured, there will be no predeploy job for this phase.
   */
  predeploy?: Predeploy;
  /**
   * Skaffold profiles to use when rendering the manifest for this phase. These
   * are in addition to the profiles list specified in the `DeliveryPipeline`
   * stage.
   */
  profiles?: string[];
  /**
   * Whether to run verify tests after the deployment.
   */
  verify?: boolean;
}

/**
 * PipelineCondition contains all conditions relevant to a Delivery Pipeline.
 */
export interface PipelineCondition {
  /**
   * Details around the Pipeline's overall status.
   */
  pipelineReadyCondition?: PipelineReadyCondition;
  /**
   * Details around targets enumerated in the pipeline.
   */
  targetsPresentCondition?: TargetsPresentCondition;
  /**
   * Details on the whether the targets enumerated in the pipeline are of the
   * same type.
   */
  targetsTypeCondition?: TargetsTypeCondition;
}

function serializePipelineCondition(data: any): PipelineCondition {
  return {
    ...data,
    pipelineReadyCondition: data["pipelineReadyCondition"] !== undefined ? serializePipelineReadyCondition(data["pipelineReadyCondition"]) : undefined,
    targetsPresentCondition: data["targetsPresentCondition"] !== undefined ? serializeTargetsPresentCondition(data["targetsPresentCondition"]) : undefined,
  };
}

function deserializePipelineCondition(data: any): PipelineCondition {
  return {
    ...data,
    pipelineReadyCondition: data["pipelineReadyCondition"] !== undefined ? deserializePipelineReadyCondition(data["pipelineReadyCondition"]) : undefined,
    targetsPresentCondition: data["targetsPresentCondition"] !== undefined ? deserializeTargetsPresentCondition(data["targetsPresentCondition"]) : undefined,
  };
}

/**
 * PipelineReadyCondition contains information around the status of the
 * Pipeline.
 */
export interface PipelineReadyCondition {
  /**
   * True if the Pipeline is in a valid state. Otherwise at least one condition
   * in `PipelineCondition` is in an invalid state. Iterate over those
   * conditions and see which condition(s) has status = false to find out what
   * is wrong with the Pipeline.
   */
  status?: boolean;
  /**
   * Last time the condition was updated.
   */
  updateTime?: Date;
}

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

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

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

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

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

/**
 * Deploy Policy rule.
 */
export interface PolicyRule {
  /**
   * Rollout restrictions.
   */
  rolloutRestriction?: RolloutRestriction;
}

/**
 * Returned from an action if one or more policies were violated, and therefore
 * the action was prevented. Contains information about what policies were
 * violated and why.
 */
export interface PolicyViolation {
  /**
   * Policy violation details.
   */
  policyViolationDetails?: PolicyViolationDetails[];
}

/**
 * Policy violation details.
 */
export interface PolicyViolationDetails {
  /**
   * User readable message about why the request violated a policy. This is not
   * intended for machine parsing.
   */
  failureMessage?: string;
  /**
   * Name of the policy that was violated. Policy resource will be in the
   * format of `projects/{project}/locations/{location}/policies/{policy}`.
   */
  policy?: string;
  /**
   * Id of the rule that triggered the policy violation.
   */
  ruleId?: string;
}

/**
 * Postdeploy contains the postdeploy job configuration information.
 */
export interface Postdeploy {
  /**
   * Optional. A sequence of Skaffold custom actions to invoke during execution
   * of the postdeploy job.
   */
  actions?: string[];
}

/**
 * A postdeploy Job.
 */
export interface PostdeployJob {
  /**
   * Output only. The custom actions that the postdeploy Job executes.
   */
  readonly actions?: string[];
}

/**
 * PostdeployJobRun contains information specific to a postdeploy `JobRun`.
 */
export interface PostdeployJobRun {
  /**
   * Output only. The resource name of the Cloud Build `Build` object that is
   * used to execute the custom actions associated with the postdeploy Job.
   * Format is `projects/{project}/locations/{location}/builds/{build}`.
   */
  readonly build?: string;
  /**
   * Output only. The reason the postdeploy failed. This will always be
   * unspecified while the postdeploy is in progress or if it succeeded.
   */
  readonly failureCause?:  | "FAILURE_CAUSE_UNSPECIFIED" | "CLOUD_BUILD_UNAVAILABLE" | "EXECUTION_FAILED" | "DEADLINE_EXCEEDED" | "CLOUD_BUILD_REQUEST_FAILED";
  /**
   * Output only. Additional information about the postdeploy failure, if
   * available.
   */
  readonly failureMessage?: string;
}

/**
 * Predeploy contains the predeploy job configuration information.
 */
export interface Predeploy {
  /**
   * Optional. A sequence of Skaffold custom actions to invoke during execution
   * of the predeploy job.
   */
  actions?: string[];
}

/**
 * A predeploy Job.
 */
export interface PredeployJob {
  /**
   * Output only. The custom actions that the predeploy Job executes.
   */
  readonly actions?: string[];
}

/**
 * PredeployJobRun contains information specific to a predeploy `JobRun`.
 */
export interface PredeployJobRun {
  /**
   * Output only. The resource name of the Cloud Build `Build` object that is
   * used to execute the custom actions associated with the predeploy Job.
   * Format is `projects/{project}/locations/{location}/builds/{build}`.
   */
  readonly build?: string;
  /**
   * Output only. The reason the predeploy failed. This will always be
   * unspecified while the predeploy is in progress or if it succeeded.
   */
  readonly failureCause?:  | "FAILURE_CAUSE_UNSPECIFIED" | "CLOUD_BUILD_UNAVAILABLE" | "EXECUTION_FAILED" | "DEADLINE_EXCEEDED" | "CLOUD_BUILD_REQUEST_FAILED";
  /**
   * Output only. Additional information about the predeploy failure, if
   * available.
   */
  readonly failureMessage?: string;
}

/**
 * Execution using a private Cloud Build pool.
 */
export interface PrivatePool {
  /**
   * Optional. Cloud Storage location where execution outputs should be stored.
   * This can either be a bucket ("gs://my-bucket") or a path within a bucket
   * ("gs://my-bucket/my-dir"). If unspecified, a default bucket located in the
   * same region will be used.
   */
  artifactStorage?: string;
  /**
   * Optional. Google service account to use for execution. If unspecified, the
   * project execution service account (-compute@developer.gserviceaccount.com)
   * will be used.
   */
  serviceAccount?: string;
  /**
   * Required. Resource name of the Cloud Build worker pool to use. The format
   * is `projects/{project}/locations/{location}/workerPools/{pool}`.
   */
  workerPool?: string;
}

/**
 * Additional options for CloudDeploy#projectsLocationsCustomTargetTypesCreate.
 */
export interface ProjectsLocationsCustomTargetTypesCreateOptions {
  /**
   * Required. ID of the `CustomTargetType`.
   */
  customTargetTypeId?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for CloudDeploy#projectsLocationsCustomTargetTypesDelete.
 */
export interface ProjectsLocationsCustomTargetTypesDeleteOptions {
  /**
   * Optional. If set to true, then deleting an already deleted or non-existing
   * `CustomTargetType` will succeed.
   */
  allowMissing?: boolean;
  /**
   * Optional. This checksum is computed by the server based on the value of
   * other fields, and may be sent on update and delete requests to ensure the
   * client has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set to true, the request is validated but no actual change is
   * made.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsCustomTargetTypesGetIamPolicy.
 */
export interface ProjectsLocationsCustomTargetTypesGetIamPolicyOptions {
  /**
   * 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 CloudDeploy#projectsLocationsCustomTargetTypesList.
 */
export interface ProjectsLocationsCustomTargetTypesListOptions {
  /**
   * Optional. Filter custom target types to be returned. See
   * https://google.aip.dev/160 for more details.
   */
  filter?: string;
  /**
   * Optional. Field to sort by. See https://google.aip.dev/132#ordering for
   * more details.
   */
  orderBy?: string;
  /**
   * Optional. The maximum number of `CustomTargetType` objects to return. The
   * service may return fewer than this value. If unspecified, at most 50
   * `CustomTargetType` objects will be returned. The maximum value is 1000;
   * values above 1000 will be set to 1000.
   */
  pageSize?: number;
  /**
   * Optional. A page token, received from a previous `ListCustomTargetTypes`
   * call. Provide this to retrieve the subsequent page. When paginating, all
   * other provided parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for CloudDeploy#projectsLocationsCustomTargetTypesPatch.
 */
export interface ProjectsLocationsCustomTargetTypesPatchOptions {
  /**
   * Optional. If set to true, updating a `CustomTargetType` that does not
   * exist will result in the creation of a new `CustomTargetType`.
   */
  allowMissing?: boolean;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Required. Field mask is used to specify the fields to be overwritten by
   * the update in the `CustomTargetType` resource. The fields specified in the
   * update_mask are relative to the resource, not the full request. A field
   * will be overwritten if it's in the mask. If the user doesn't provide a mask
   * then all fields are overwritten.
   */
  updateMask?: string /* FieldMask */;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

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

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

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesAutomationRunsList.
 */
export interface ProjectsLocationsDeliveryPipelinesAutomationRunsListOptions {
  /**
   * Filter automationRuns to be returned. All fields can be used in the
   * filter.
   */
  filter?: string;
  /**
   * Field to sort by.
   */
  orderBy?: string;
  /**
   * The maximum number of automationRuns to return. The service may return
   * fewer than this value. If unspecified, at most 50 automationRuns will be
   * returned. The maximum value is 1000; values above 1000 will be set to 1000.
   */
  pageSize?: number;
  /**
   * A page token, received from a previous `ListAutomationRuns` call. Provide
   * this to retrieve the subsequent page. When paginating, all other provided
   * parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesAutomationsCreate.
 */
export interface ProjectsLocationsDeliveryPipelinesAutomationsCreateOptions {
  /**
   * Required. ID of the `Automation`.
   */
  automationId?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesAutomationsDelete.
 */
export interface ProjectsLocationsDeliveryPipelinesAutomationsDeleteOptions {
  /**
   * Optional. If set to true, then deleting an already deleted or non-existing
   * `Automation` will succeed.
   */
  allowMissing?: boolean;
  /**
   * Optional. The weak etag of the request. This checksum is computed by the
   * server based on the value of other fields, and may be sent on update and
   * delete requests to ensure the client has an up-to-date value before
   * proceeding.
   */
  etag?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set, validate the request and verify whether the resource
   * exists, but do not actually post it.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesAutomationsList.
 */
export interface ProjectsLocationsDeliveryPipelinesAutomationsListOptions {
  /**
   * Filter automations to be returned. All fields can be used in the filter.
   */
  filter?: string;
  /**
   * Field to sort by.
   */
  orderBy?: string;
  /**
   * The maximum number of automations to return. The service may return fewer
   * than this value. If unspecified, at most 50 automations will be returned.
   * The maximum value is 1000; values above 1000 will be set to 1000.
   */
  pageSize?: number;
  /**
   * A page token, received from a previous `ListAutomations` call. Provide
   * this to retrieve the subsequent page. When paginating, all other provided
   * parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesAutomationsPatch.
 */
export interface ProjectsLocationsDeliveryPipelinesAutomationsPatchOptions {
  /**
   * Optional. If set to true, updating a `Automation` that does not exist will
   * result in the creation of a new `Automation`.
   */
  allowMissing?: boolean;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Required. Field mask is used to specify the fields to be overwritten by
   * the update in the `Automation` resource. The fields specified in the
   * update_mask are relative to the resource, not the full request. A field
   * will be overwritten if it's in the mask. If the user doesn't provide a mask
   * then all fields are overwritten.
   */
  updateMask?: string /* FieldMask */;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

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

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

/**
 * Additional options for CloudDeploy#projectsLocationsDeliveryPipelinesCreate.
 */
export interface ProjectsLocationsDeliveryPipelinesCreateOptions {
  /**
   * Required. ID of the `DeliveryPipeline`.
   */
  deliveryPipelineId?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for CloudDeploy#projectsLocationsDeliveryPipelinesDelete.
 */
export interface ProjectsLocationsDeliveryPipelinesDeleteOptions {
  /**
   * Optional. If set to true, then deleting an already deleted or non-existing
   * `DeliveryPipeline` will succeed.
   */
  allowMissing?: boolean;
  /**
   * Optional. This checksum is computed by the server based on the value of
   * other fields, and may be sent on update and delete requests to ensure the
   * client has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Optional. If set to true, all child resources under this pipeline will
   * also be deleted. Otherwise, the request will only work if the pipeline has
   * no child resources.
   */
  force?: boolean;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set, validate the request and preview the review, but do not
   * actually post it.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesGetIamPolicy.
 */
export interface ProjectsLocationsDeliveryPipelinesGetIamPolicyOptions {
  /**
   * 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 CloudDeploy#projectsLocationsDeliveryPipelinesList.
 */
export interface ProjectsLocationsDeliveryPipelinesListOptions {
  /**
   * Filter pipelines to be returned. See https://google.aip.dev/160 for more
   * details.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * The maximum number of pipelines to return. The service may return fewer
   * than this value. If unspecified, at most 50 pipelines will be returned. The
   * maximum value is 1000; values above 1000 will be set to 1000.
   */
  pageSize?: number;
  /**
   * A page token, received from a previous `ListDeliveryPipelines` call.
   * Provide this to retrieve the subsequent page. When paginating, all other
   * provided parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for CloudDeploy#projectsLocationsDeliveryPipelinesPatch.
 */
export interface ProjectsLocationsDeliveryPipelinesPatchOptions {
  /**
   * Optional. If set to true, updating a `DeliveryPipeline` that does not
   * exist will result in the creation of a new `DeliveryPipeline`.
   */
  allowMissing?: boolean;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Required. Field mask is used to specify the fields to be overwritten by
   * the update in the `DeliveryPipeline` resource. The fields specified in the
   * update_mask are relative to the resource, not the full request. A field
   * will be overwritten if it's in the mask. If the user doesn't provide a mask
   * then all fields are overwritten.
   */
  updateMask?: string /* FieldMask */;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

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

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

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesReleasesCreate.
 */
export interface ProjectsLocationsDeliveryPipelinesReleasesCreateOptions {
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   */
  overrideDeployPolicy?: string;
  /**
   * Required. ID of the `Release`.
   */
  releaseId?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesReleasesList.
 */
export interface ProjectsLocationsDeliveryPipelinesReleasesListOptions {
  /**
   * Optional. Filter releases to be returned. See https://google.aip.dev/160
   * for more details.
   */
  filter?: string;
  /**
   * Optional. Field to sort by. See https://google.aip.dev/132#ordering for
   * more details.
   */
  orderBy?: string;
  /**
   * Optional. The maximum number of `Release` objects to return. The service
   * may return fewer than this value. If unspecified, at most 50 `Release`
   * objects will be returned. The maximum value is 1000; values above 1000 will
   * be set to 1000.
   */
  pageSize?: number;
  /**
   * Optional. A page token, received from a previous `ListReleases` call.
   * Provide this to retrieve the subsequent page. When paginating, all other
   * provided parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesReleasesRolloutsCreate.
 */
export interface ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateOptions {
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   */
  overrideDeployPolicy?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Required. ID of the `Rollout`.
   */
  rolloutId?: string;
  /**
   * Optional. The starting phase ID for the `Rollout`. If empty the `Rollout`
   * will start at the first phase.
   */
  startingPhaseId?: string;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsList.
 */
export interface ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListOptions {
  /**
   * Optional. Filter results to be returned. See https://google.aip.dev/160
   * for more details.
   */
  filter?: string;
  /**
   * Optional. Field to sort by. See https://google.aip.dev/132#ordering for
   * more details.
   */
  orderBy?: string;
  /**
   * Optional. The maximum number of `JobRun` objects to return. The service
   * may return fewer than this value. If unspecified, at most 50 `JobRun`
   * objects will be returned. The maximum value is 1000; values above 1000 will
   * be set to 1000.
   */
  pageSize?: number;
  /**
   * Optional. A page token, received from a previous `ListJobRuns` call.
   * Provide this to retrieve the subsequent page. When paginating, all other
   * provided parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * CloudDeploy#projectsLocationsDeliveryPipelinesReleasesRolloutsList.
 */
export interface ProjectsLocationsDeliveryPipelinesReleasesRolloutsListOptions {
  /**
   * Optional. Filter rollouts to be returned. See https://google.aip.dev/160
   * for more details.
   */
  filter?: string;
  /**
   * Optional. Field to sort by. See https://google.aip.dev/132#ordering for
   * more details.
   */
  orderBy?: string;
  /**
   * Optional. The maximum number of `Rollout` objects to return. The service
   * may return fewer than this value. If unspecified, at most 50 `Rollout`
   * objects will be returned. The maximum value is 1000; values above 1000 will
   * be set to 1000.
   */
  pageSize?: number;
  /**
   * Optional. A page token, received from a previous `ListRollouts` call.
   * Provide this to retrieve the subsequent page. When paginating, all other
   * provided parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for CloudDeploy#projectsLocationsDeployPoliciesCreate.
 */
export interface ProjectsLocationsDeployPoliciesCreateOptions {
  /**
   * Required. ID of the `DeployPolicy`.
   */
  deployPolicyId?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for CloudDeploy#projectsLocationsDeployPoliciesDelete.
 */
export interface ProjectsLocationsDeployPoliciesDeleteOptions {
  /**
   * Optional. If set to true, then deleting an already deleted or non-existing
   * `DeployPolicy` will succeed.
   */
  allowMissing?: boolean;
  /**
   * Optional. This checksum is computed by the server based on the value of
   * other fields, and may be sent on update and delete requests to ensure the
   * client has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set, validate the request and preview the review, but do not
   * actually post it.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for CloudDeploy#projectsLocationsDeployPoliciesList.
 */
export interface ProjectsLocationsDeployPoliciesListOptions {
  /**
   * Filter deploy policies to be returned. See https://google.aip.dev/160 for
   * more details. All fields can be used in the filter.
   */
  filter?: string;
  /**
   * Field to sort by. See https://google.aip.dev/132#ordering for more
   * details.
   */
  orderBy?: string;
  /**
   * The maximum number of deploy policies to return. The service may return
   * fewer than this value. If unspecified, at most 50 deploy policies will be
   * returned. The maximum value is 1000; values above 1000 will be set to 1000.
   */
  pageSize?: number;
  /**
   * A page token, received from a previous `ListDeployPolicies` call. Provide
   * this to retrieve the subsequent page. When paginating, all other provided
   * parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for CloudDeploy#projectsLocationsDeployPoliciesPatch.
 */
export interface ProjectsLocationsDeployPoliciesPatchOptions {
  /**
   * Optional. If set to true, updating a `DeployPolicy` that does not exist
   * will result in the creation of a new `DeployPolicy`.
   */
  allowMissing?: boolean;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Required. Field mask is used to specify the fields to be overwritten by
   * the update in the `DeployPolicy` resource. The fields specified in the
   * update_mask are relative to the resource, not the full request. A field
   * will be overwritten if it's in the mask. If the user doesn't provide a mask
   * then all fields are overwritten.
   */
  updateMask?: string /* FieldMask */;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

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

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

/**
 * Additional options for CloudDeploy#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 CloudDeploy#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 CloudDeploy#projectsLocationsTargetsCreate.
 */
export interface ProjectsLocationsTargetsCreateOptions {
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Required. ID of the `Target`.
   */
  targetId?: string;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for CloudDeploy#projectsLocationsTargetsDelete.
 */
export interface ProjectsLocationsTargetsDeleteOptions {
  /**
   * Optional. If set to true, then deleting an already deleted or non-existing
   * `Target` will succeed.
   */
  allowMissing?: boolean;
  /**
   * Optional. This checksum is computed by the server based on the value of
   * other fields, and may be sent on update and delete requests to ensure the
   * client has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Optional. If set, validate the request and preview the review, but do not
   * actually post it.
   */
  validateOnly?: boolean;
}

/**
 * Additional options for CloudDeploy#projectsLocationsTargetsGetIamPolicy.
 */
export interface ProjectsLocationsTargetsGetIamPolicyOptions {
  /**
   * 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 CloudDeploy#projectsLocationsTargetsList.
 */
export interface ProjectsLocationsTargetsListOptions {
  /**
   * Optional. Filter targets to be returned. See https://google.aip.dev/160
   * for more details.
   */
  filter?: string;
  /**
   * Optional. Field to sort by. See https://google.aip.dev/132#ordering for
   * more details.
   */
  orderBy?: string;
  /**
   * Optional. The maximum number of `Target` objects to return. The service
   * may return fewer than this value. If unspecified, at most 50 `Target`
   * objects will be returned. The maximum value is 1000; values above 1000 will
   * be set to 1000.
   */
  pageSize?: number;
  /**
   * Optional. A page token, received from a previous `ListTargets` call.
   * Provide this to retrieve the subsequent page. When paginating, all other
   * provided parameters match the call that provided the page token.
   */
  pageToken?: string;
}

/**
 * Additional options for CloudDeploy#projectsLocationsTargetsPatch.
 */
export interface ProjectsLocationsTargetsPatchOptions {
  /**
   * Optional. If set to true, updating a `Target` that does not exist will
   * result in the creation of a new `Target`.
   */
  allowMissing?: boolean;
  /**
   * Optional. A request ID to identify requests. Specify a unique request ID
   * so that if you must retry your request, the server knows to ignore the
   * request if it has already been completed. The server guarantees that 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;
  /**
   * Required. Field mask is used to specify the fields to be overwritten by
   * the update in the `Target` resource. The fields specified in the
   * update_mask are relative to the resource, not the full request. A field
   * will be overwritten if it's in the mask. If the user doesn't provide a mask
   * then all fields are overwritten.
   */
  updateMask?: string /* FieldMask */;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with an expected result, but no actual change is made.
   */
  validateOnly?: boolean;
}

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

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

/**
 * Contains the information of an automated promote-release operation.
 */
export interface PromoteReleaseOperation {
  /**
   * Output only. The starting phase of the rollout created by this operation.
   */
  readonly phase?: string;
  /**
   * Output only. The name of the rollout that initiates the `AutomationRun`.
   */
  readonly rollout?: string;
  /**
   * Output only. The ID of the target that represents the promotion stage to
   * which the release will be promoted. The value of this field is the last
   * segment of a target name.
   */
  readonly targetId?: string;
  /**
   * Output only. How long the operation will be paused.
   */
  readonly wait?: number /* Duration */;
}

/**
 * The `PromoteRelease` rule will automatically promote a release from the
 * current target to a specified target.
 */
export interface PromoteReleaseRule {
  /**
   * Output only. Information around the state of the Automation rule.
   */
  readonly condition?: AutomationRuleCondition;
  /**
   * Optional. The starting phase of the rollout created by this operation.
   * Default to the first phase.
   */
  destinationPhase?: string;
  /**
   * Optional. The ID of the stage in the pipeline to which this `Release` is
   * deploying. If unspecified, default it to the next stage in the promotion
   * flow. The value of this field could be one of the following: * The last
   * segment of a target name * "@next", the next target in the promotion
   * sequence
   */
  destinationTargetId?: string;
  /**
   * Required. ID of the rule. This id must be unique in the `Automation`
   * resource to which this rule belongs. The format is
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  id?: string;
  /**
   * Optional. How long the release need to be paused until being promoted to
   * the next target.
   */
  wait?: number /* Duration */;
}

function serializePromoteReleaseRule(data: any): PromoteReleaseRule {
  return {
    ...data,
    wait: data["wait"] !== undefined ? data["wait"] : undefined,
  };
}

function deserializePromoteReleaseRule(data: any): PromoteReleaseRule {
  return {
    ...data,
    condition: data["condition"] !== undefined ? deserializeAutomationRuleCondition(data["condition"]) : undefined,
    wait: data["wait"] !== undefined ? data["wait"] : undefined,
  };
}

/**
 * A `Release` resource in the Cloud Deploy API. A `Release` defines a specific
 * Skaffold configuration instance that can be deployed.
 */
export interface Release {
  /**
   * Output only. Indicates whether this is an abandoned release.
   */
  readonly abandoned?: boolean;
  /**
   * User annotations. These attributes can only be set and used by the user,
   * and not by Cloud Deploy. See https://google.aip.dev/128#annotations for
   * more details such as format and size limitations.
   */
  annotations?: {
    [key: string]: string
  };
  /**
   * List of artifacts to pass through to Skaffold command.
   */
  buildArtifacts?: BuildArtifact[];
  /**
   * Output only. Information around the state of the Release.
   */
  readonly condition?: ReleaseCondition;
  /**
   * Output only. Time at which the `Release` was created.
   */
  readonly createTime?: Date;
  /**
   * Output only. Snapshot of the custom target types referenced by the targets
   * taken at release creation time.
   */
  readonly customTargetTypeSnapshots?: CustomTargetType[];
  /**
   * Output only. Snapshot of the parent pipeline taken at release creation
   * time.
   */
  readonly deliveryPipelineSnapshot?: DeliveryPipeline;
  /**
   * Optional. The deploy parameters to use for all targets in this release.
   */
  deployParameters?: {
    [key: string]: string
  };
  /**
   * Description of the `Release`. Max length is 255 characters.
   */
  description?: string;
  /**
   * This checksum is computed by the server based on the value of other
   * fields, and may be sent on update and delete requests to ensure the client
   * has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Labels are attributes that can be set and used by both the user and by
   * Cloud Deploy. Labels must meet the following constraints: * Keys and values
   * can contain only lowercase letters, numeric characters, underscores, and
   * dashes. * All characters must use UTF-8 encoding, and international
   * characters are allowed. * Keys must start with a lowercase letter or
   * international character. * Each resource is limited to a maximum of 64
   * labels. Both keys and values are additionally constrained to be <= 128
   * bytes.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. Name of the `Release`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}`.
   * The `release` component must match `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  name?: string;
  /**
   * Output only. Time at which the render completed.
   */
  readonly renderEndTime?: Date;
  /**
   * Output only. Time at which the render began.
   */
  readonly renderStartTime?: Date;
  /**
   * Output only. Current state of the render operation.
   */
  readonly renderState?:  | "RENDER_STATE_UNSPECIFIED" | "SUCCEEDED" | "FAILED" | "IN_PROGRESS";
  /**
   * Filepath of the Skaffold config inside of the config URI.
   */
  skaffoldConfigPath?: string;
  /**
   * Cloud Storage URI of tar.gz archive containing Skaffold configuration.
   */
  skaffoldConfigUri?: string;
  /**
   * The Skaffold version to use when operating on this release, such as
   * "1.20.0". Not all versions are valid; Cloud Deploy supports a specific set
   * of versions. If unset, the most recent supported Skaffold version will be
   * used.
   */
  skaffoldVersion?: string;
  /**
   * Output only. Map from target ID to the target artifacts created during the
   * render operation.
   */
  readonly targetArtifacts?: {
    [key: string]: TargetArtifact
  };
  /**
   * Output only. Map from target ID to details of the render operation for
   * that target.
   */
  readonly targetRenders?: {
    [key: string]: TargetRender
  };
  /**
   * Output only. Snapshot of the targets taken at release creation time.
   */
  readonly targetSnapshots?: Target[];
  /**
   * Output only. Unique identifier of the `Release`.
   */
  readonly uid?: string;
}

/**
 * ReleaseCondition contains all conditions relevant to a Release.
 */
export interface ReleaseCondition {
  /**
   * Details around the Releases's overall status.
   */
  releaseReadyCondition?: ReleaseReadyCondition;
  /**
   * Details around the support state of the release's Skaffold version.
   */
  skaffoldSupportedCondition?: SkaffoldSupportedCondition;
}

function serializeReleaseCondition(data: any): ReleaseCondition {
  return {
    ...data,
    skaffoldSupportedCondition: data["skaffoldSupportedCondition"] !== undefined ? serializeSkaffoldSupportedCondition(data["skaffoldSupportedCondition"]) : undefined,
  };
}

function deserializeReleaseCondition(data: any): ReleaseCondition {
  return {
    ...data,
    skaffoldSupportedCondition: data["skaffoldSupportedCondition"] !== undefined ? deserializeSkaffoldSupportedCondition(data["skaffoldSupportedCondition"]) : undefined,
  };
}

/**
 * Payload proto for "clouddeploy.googleapis.com/release_notification" Platform
 * Log event that describes the failure to send release status change Pub/Sub
 * notification.
 */
export interface ReleaseNotificationEvent {
  /**
   * Debug message for when a notification fails to send.
   */
  message?: string;
  /**
   * Unique identifier of the `DeliveryPipeline`.
   */
  pipelineUid?: string;
  /**
   * The name of the `Release`.
   */
  release?: string;
  /**
   * Unique identifier of the `Release`.
   */
  releaseUid?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * ReleaseReadyCondition contains information around the status of the Release.
 * If a release is not ready, you cannot create a rollout with the release.
 */
export interface ReleaseReadyCondition {
  /**
   * True if the Release is in a valid state. Otherwise at least one condition
   * in `ReleaseCondition` is in an invalid state. Iterate over those conditions
   * and see which condition(s) has status = false to find out what is wrong
   * with the Release.
   */
  status?: boolean;
}

/**
 * Payload proto for "clouddeploy.googleapis.com/release_render" Platform Log
 * event that describes the render status change.
 */
export interface ReleaseRenderEvent {
  /**
   * Debug message for when a render transition occurs. Provides further
   * details as rendering progresses through render states.
   */
  message?: string;
  /**
   * Unique identifier of the `DeliveryPipeline`.
   */
  pipelineUid?: string;
  /**
   * The name of the release. release_uid is not in this log message because we
   * write some of these log messages at release creation time, before we've
   * generated the uid.
   */
  release?: string;
  /**
   * The state of the release render.
   */
  releaseRenderState?:  | "RENDER_STATE_UNSPECIFIED" | "SUCCEEDED" | "FAILED" | "IN_PROGRESS";
  /**
   * Type of this notification, e.g. for a release render state change event.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * RenderMetadata includes information associated with a `Release` render.
 */
export interface RenderMetadata {
  /**
   * Output only. Metadata associated with rendering for Cloud Run.
   */
  readonly cloudRun?: CloudRunRenderMetadata;
  /**
   * Output only. Custom metadata provided by user-defined render operation.
   */
  readonly custom?: CustomMetadata;
}

/**
 * RepairPhase tracks the repair attempts that have been made for each
 * `RepairPhaseConfig` specified in the `Automation` resource.
 */
export interface RepairPhase {
  /**
   * Output only. Records of the retry attempts for retry repair mode.
   */
  readonly retry?: RetryPhase;
  /**
   * Output only. Rollback attempt for rollback repair mode .
   */
  readonly rollback?: RollbackAttempt;
}

/**
 * Configuration of the repair phase.
 */
export interface RepairPhaseConfig {
  /**
   * Optional. Retries a failed job.
   */
  retry?: Retry;
  /**
   * Optional. Rolls back a `Rollout`.
   */
  rollback?: Rollback;
}

function serializeRepairPhaseConfig(data: any): RepairPhaseConfig {
  return {
    ...data,
    retry: data["retry"] !== undefined ? serializeRetry(data["retry"]) : undefined,
  };
}

function deserializeRepairPhaseConfig(data: any): RepairPhaseConfig {
  return {
    ...data,
    retry: data["retry"] !== undefined ? deserializeRetry(data["retry"]) : undefined,
  };
}

/**
 * Contains the information for an automated `repair rollout` operation.
 */
export interface RepairRolloutOperation {
  /**
   * Output only. The index of the current repair action in the repair
   * sequence.
   */
  readonly currentRepairPhaseIndex?: bigint;
  /**
   * Output only. The job ID for the Job to repair.
   */
  readonly jobId?: string;
  /**
   * Output only. The phase ID of the phase that includes the job being
   * repaired.
   */
  readonly phaseId?: string;
  /**
   * Output only. Records of the repair attempts. Each repair phase may have
   * multiple retry attempts or single rollback attempt.
   */
  readonly repairPhases?: RepairPhase[];
  /**
   * Output only. The name of the rollout that initiates the `AutomationRun`.
   */
  readonly rollout?: string;
}

/**
 * The `RepairRolloutRule` automation rule will automatically repair a failed
 * `Rollout`.
 */
export interface RepairRolloutRule {
  /**
   * Output only. Information around the state of the 'Automation' rule.
   */
  readonly condition?: AutomationRuleCondition;
  /**
   * Required. ID of the rule. This id must be unique in the `Automation`
   * resource to which this rule belongs. The format is
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  id?: string;
  /**
   * Optional. Jobs to repair. Proceeds only after job name matched any one in
   * the list, or for all jobs if unspecified or empty. The phase that includes
   * the job must match the phase ID specified in `source_phase`. This value
   * must consist of lower-case letters, numbers, and hyphens, start with a
   * letter and end with a letter or a number, and have a max length of 63
   * characters. In other words, it must match the following regex:
   * `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`.
   */
  jobs?: string[];
  /**
   * Optional. Phases within which jobs are subject to automatic repair actions
   * on failure. Proceeds only after phase name matched any one in the list, or
   * for all phases if unspecified. This value must consist of lower-case
   * letters, numbers, and hyphens, start with a letter and end with a letter or
   * a number, and have a max length of 63 characters. In other words, it must
   * match the following regex: `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`.
   */
  phases?: string[];
  /**
   * Required. Defines the types of automatic repair phases for failed jobs.
   */
  repairPhases?: RepairPhaseConfig[];
}

function serializeRepairRolloutRule(data: any): RepairRolloutRule {
  return {
    ...data,
    repairPhases: data["repairPhases"] !== undefined ? data["repairPhases"].map((item: any) => (serializeRepairPhaseConfig(item))) : undefined,
  };
}

function deserializeRepairRolloutRule(data: any): RepairRolloutRule {
  return {
    ...data,
    condition: data["condition"] !== undefined ? deserializeAutomationRuleCondition(data["condition"]) : undefined,
    repairPhases: data["repairPhases"] !== undefined ? data["repairPhases"].map((item: any) => (deserializeRepairPhaseConfig(item))) : undefined,
  };
}

/**
 * Retries the failed job.
 */
export interface Retry {
  /**
   * Required. Total number of retries. Retry is skipped if set to 0; The
   * minimum value is 1, and the maximum value is 10.
   */
  attempts?: bigint;
  /**
   * Optional. The pattern of how wait time will be increased. Default is
   * linear. Backoff mode will be ignored if `wait` is 0.
   */
  backoffMode?:  | "BACKOFF_MODE_UNSPECIFIED" | "BACKOFF_MODE_LINEAR" | "BACKOFF_MODE_EXPONENTIAL";
  /**
   * Optional. How long to wait for the first retry. Default is 0, and the
   * maximum value is 14d.
   */
  wait?: number /* Duration */;
}

function serializeRetry(data: any): Retry {
  return {
    ...data,
    attempts: data["attempts"] !== undefined ? String(data["attempts"]) : undefined,
    wait: data["wait"] !== undefined ? data["wait"] : undefined,
  };
}

function deserializeRetry(data: any): Retry {
  return {
    ...data,
    attempts: data["attempts"] !== undefined ? BigInt(data["attempts"]) : undefined,
    wait: data["wait"] !== undefined ? data["wait"] : undefined,
  };
}

/**
 * RetryAttempt represents an action of retrying the failed Cloud Deploy job.
 */
export interface RetryAttempt {
  /**
   * Output only. The index of this retry attempt.
   */
  readonly attempt?: bigint;
  /**
   * Output only. Valid state of this retry action.
   */
  readonly state?:  | "REPAIR_STATE_UNSPECIFIED" | "REPAIR_STATE_SUCCEEDED" | "REPAIR_STATE_CANCELLED" | "REPAIR_STATE_FAILED" | "REPAIR_STATE_IN_PROGRESS" | "REPAIR_STATE_PENDING" | "REPAIR_STATE_ABORTED";
  /**
   * Output only. Description of the state of the Retry.
   */
  readonly stateDesc?: string;
  /**
   * Output only. How long the operation will be paused.
   */
  readonly wait?: number /* Duration */;
}

/**
 * RetryJobRequest is the request object used by `RetryJob`.
 */
export interface RetryJobRequest {
  /**
   * Required. The job ID for the Job to retry.
   */
  jobId?: string;
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   */
  overrideDeployPolicy?: string[];
  /**
   * Required. The phase ID the Job to retry belongs to.
   */
  phaseId?: string;
}

/**
 * The response object from 'RetryJob'.
 */
export interface RetryJobResponse {
}

/**
 * RetryPhase contains the retry attempts and the metadata for initiating a new
 * attempt.
 */
export interface RetryPhase {
  /**
   * Output only. Detail of a retry action.
   */
  readonly attempts?: RetryAttempt[];
  /**
   * Output only. The pattern of how the wait time of the retry attempt is
   * calculated.
   */
  readonly backoffMode?:  | "BACKOFF_MODE_UNSPECIFIED" | "BACKOFF_MODE_LINEAR" | "BACKOFF_MODE_EXPONENTIAL";
  /**
   * Output only. The number of attempts that have been made.
   */
  readonly totalAttempts?: bigint;
}

/**
 * Rolls back a `Rollout`.
 */
export interface Rollback {
  /**
   * Optional. The starting phase ID for the `Rollout`. If unspecified, the
   * `Rollout` will start in the stable phase.
   */
  destinationPhase?: string;
  /**
   * Optional. If pending rollout exists on the target, the rollback operation
   * will be aborted.
   */
  disableRollbackIfRolloutPending?: boolean;
}

/**
 * RollbackAttempt represents an action of rolling back a Cloud Deploy
 * 'Target'.
 */
export interface RollbackAttempt {
  /**
   * Output only. The phase to which the rollout will be rolled back to.
   */
  readonly destinationPhase?: string;
  /**
   * Output only. If active rollout exists on the target, abort this rollback.
   */
  readonly disableRollbackIfRolloutPending?: boolean;
  /**
   * Output only. ID of the rollback `Rollout` to create.
   */
  readonly rolloutId?: string;
  /**
   * Output only. Valid state of this rollback action.
   */
  readonly state?:  | "REPAIR_STATE_UNSPECIFIED" | "REPAIR_STATE_SUCCEEDED" | "REPAIR_STATE_CANCELLED" | "REPAIR_STATE_FAILED" | "REPAIR_STATE_IN_PROGRESS" | "REPAIR_STATE_PENDING" | "REPAIR_STATE_ABORTED";
  /**
   * Output only. Description of the state of the Rollback.
   */
  readonly stateDesc?: string;
}

/**
 * Configs for the Rollback rollout.
 */
export interface RollbackTargetConfig {
  /**
   * Optional. The rollback `Rollout` to create.
   */
  rollout?: Rollout;
  /**
   * Optional. The starting phase ID for the `Rollout`. If unspecified, the
   * `Rollout` will start in the stable phase.
   */
  startingPhaseId?: string;
}

/**
 * The request object for `RollbackTarget`.
 */
export interface RollbackTargetRequest {
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deploy_policy}`.
   */
  overrideDeployPolicy?: string[];
  /**
   * Optional. ID of the `Release` to roll back to. If this isn't specified,
   * the previous successful `Rollout` to the specified target will be used to
   * determine the `Release`.
   */
  releaseId?: string;
  /**
   * Optional. Configs for the rollback `Rollout`.
   */
  rollbackConfig?: RollbackTargetConfig;
  /**
   * Required. ID of the rollback `Rollout` to create.
   */
  rolloutId?: string;
  /**
   * Optional. If provided, this must be the latest `Rollout` that is on the
   * `Target`.
   */
  rolloutToRollBack?: string;
  /**
   * Required. ID of the `Target` that is being rolled back.
   */
  targetId?: string;
  /**
   * Optional. If set to true, the request is validated and the user is
   * provided with a `RollbackTargetResponse`.
   */
  validateOnly?: boolean;
}

/**
 * The response object from `RollbackTarget`.
 */
export interface RollbackTargetResponse {
  /**
   * The config of the rollback `Rollout` created or will be created.
   */
  rollbackConfig?: RollbackTargetConfig;
}

/**
 * A `Rollout` resource in the Cloud Deploy API. A `Rollout` contains
 * information around a specific deployment to a `Target`.
 */
export interface Rollout {
  /**
   * Output only. The AutomationRun actively repairing the rollout.
   */
  readonly activeRepairAutomationRun?: string;
  /**
   * User annotations. These attributes can only be set and used by the user,
   * and not by Cloud Deploy. See https://google.aip.dev/128#annotations for
   * more details such as format and size limitations.
   */
  annotations?: {
    [key: string]: string
  };
  /**
   * Output only. Approval state of the `Rollout`.
   */
  readonly approvalState?:  | "APPROVAL_STATE_UNSPECIFIED" | "NEEDS_APPROVAL" | "DOES_NOT_NEED_APPROVAL" | "APPROVED" | "REJECTED";
  /**
   * Output only. Time at which the `Rollout` was approved.
   */
  readonly approveTime?: Date;
  /**
   * Output only. Name of the `ControllerRollout`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   */
  readonly controllerRollout?: string;
  /**
   * Output only. Time at which the `Rollout` was created.
   */
  readonly createTime?: Date;
  /**
   * Output only. Time at which the `Rollout` finished deploying.
   */
  readonly deployEndTime?: Date;
  /**
   * Output only. The reason this rollout failed. This will always be
   * unspecified while the rollout is in progress.
   */
  readonly deployFailureCause?:  | "FAILURE_CAUSE_UNSPECIFIED" | "CLOUD_BUILD_UNAVAILABLE" | "EXECUTION_FAILED" | "DEADLINE_EXCEEDED" | "RELEASE_FAILED" | "RELEASE_ABANDONED" | "VERIFICATION_CONFIG_NOT_FOUND" | "CLOUD_BUILD_REQUEST_FAILED" | "OPERATION_FEATURE_NOT_SUPPORTED";
  /**
   * Output only. The resource name of the Cloud Build `Build` object that is
   * used to deploy the Rollout. Format is
   * `projects/{project}/locations/{location}/builds/{build}`.
   */
  readonly deployingBuild?: string;
  /**
   * Output only. Time at which the `Rollout` started deploying.
   */
  readonly deployStartTime?: Date;
  /**
   * Description of the `Rollout` for user purposes. Max length is 255
   * characters.
   */
  description?: string;
  /**
   * Output only. Time at which the `Rollout` was enqueued.
   */
  readonly enqueueTime?: Date;
  /**
   * This checksum is computed by the server based on the value of other
   * fields, and may be sent on update and delete requests to ensure the client
   * has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Output only. Additional information about the rollout failure, if
   * available.
   */
  readonly failureReason?: string;
  /**
   * Labels are attributes that can be set and used by both the user and by
   * Cloud Deploy. Labels must meet the following constraints: * Keys and values
   * can contain only lowercase letters, numeric characters, underscores, and
   * dashes. * All characters must use UTF-8 encoding, and international
   * characters are allowed. * Keys must start with a lowercase letter or
   * international character. * Each resource is limited to a maximum of 64
   * labels. Both keys and values are additionally constrained to be <= 128
   * bytes.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Output only. Metadata contains information about the rollout.
   */
  readonly metadata?: Metadata;
  /**
   * Optional. Name of the `Rollout`. Format is
   * `projects/{project}/locations/{location}/deliveryPipelines/{deliveryPipeline}/releases/{release}/rollouts/{rollout}`.
   * The `rollout` component must match `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  name?: string;
  /**
   * Output only. The phases that represent the workflows of this `Rollout`.
   */
  readonly phases?: Phase[];
  /**
   * Output only. Name of the `Rollout` that is rolled back by this `Rollout`.
   * Empty if this `Rollout` wasn't created as a rollback.
   */
  readonly rollbackOfRollout?: string;
  /**
   * Output only. Names of `Rollouts` that rolled back this `Rollout`.
   */
  readonly rolledBackByRollouts?: string[];
  /**
   * Output only. Current state of the `Rollout`.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "SUCCEEDED" | "FAILED" | "IN_PROGRESS" | "PENDING_APPROVAL" | "APPROVAL_REJECTED" | "PENDING" | "PENDING_RELEASE" | "CANCELLING" | "CANCELLED" | "HALTED";
  /**
   * Required. The ID of Target to which this `Rollout` is deploying.
   */
  targetId?: string;
  /**
   * Output only. Unique identifier of the `Rollout`.
   */
  readonly uid?: string;
}

/**
 * Payload proto for "clouddeploy.googleapis.com/rollout_notification" Platform
 * Log event that describes the failure to send rollout status change Pub/Sub
 * notification.
 */
export interface RolloutNotificationEvent {
  /**
   * Debug message for when a notification fails to send.
   */
  message?: string;
  /**
   * Unique identifier of the `DeliveryPipeline`.
   */
  pipelineUid?: string;
  /**
   * The name of the `Release`.
   */
  release?: string;
  /**
   * Unique identifier of the `Release`.
   */
  releaseUid?: string;
  /**
   * The name of the `Rollout`.
   */
  rollout?: string;
  /**
   * Unique identifier of the `Rollout`.
   */
  rolloutUid?: string;
  /**
   * ID of the `Target` that the rollout is deployed to.
   */
  targetId?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * Rollout restrictions.
 */
export interface RolloutRestriction {
  /**
   * Optional. Rollout actions to be restricted as part of the policy. If left
   * empty, all actions will be restricted.
   */
  actions?:  | "ROLLOUT_ACTIONS_UNSPECIFIED" | "ADVANCE" | "APPROVE" | "CANCEL" | "CREATE" | "IGNORE_JOB" | "RETRY_JOB" | "ROLLBACK" | "TERMINATE_JOBRUN"[];
  /**
   * Required. Restriction rule ID. Required and must be unique within a
   * DeployPolicy. The format is `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  id?: string;
  /**
   * Optional. What invoked the action. If left empty, all invoker types will
   * be restricted.
   */
  invokers?:  | "INVOKER_UNSPECIFIED" | "USER" | "DEPLOY_AUTOMATION"[];
  /**
   * Required. Time window within which actions are restricted.
   */
  timeWindows?: TimeWindows;
}

/**
 * Payload proto for "clouddeploy.googleapis.com/rollout_update" Platform Log
 * event that describes the rollout update event.
 */
export interface RolloutUpdateEvent {
  /**
   * Debug message for when a rollout update event occurs.
   */
  message?: string;
  /**
   * Unique identifier of the pipeline.
   */
  pipelineUid?: string;
  /**
   * The name of the `Release`.
   */
  release?: string;
  /**
   * Unique identifier of the release.
   */
  releaseUid?: string;
  /**
   * The name of the rollout. rollout_uid is not in this log message because we
   * write some of these log messages at rollout creation time, before we've
   * generated the uid.
   */
  rollout?: string;
  /**
   * The type of the rollout update.
   */
  rolloutUpdateType?:  | "ROLLOUT_UPDATE_TYPE_UNSPECIFIED" | "PENDING" | "PENDING_RELEASE" | "IN_PROGRESS" | "CANCELLING" | "CANCELLED" | "HALTED" | "SUCCEEDED" | "FAILED" | "APPROVAL_REQUIRED" | "APPROVED" | "REJECTED" | "ADVANCE_REQUIRED" | "ADVANCED";
  /**
   * ID of the target.
   */
  targetId?: string;
  /**
   * Type of this notification, e.g. for a rollout update event.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * Information about route destinations for the Gateway API service mesh.
 */
export interface RouteDestinations {
  /**
   * Required. The clusters where the Gateway API HTTPRoute resource will be
   * deployed to. Valid entries include the associated entities IDs configured
   * in the Target resource and "@self" to include the Target cluster.
   */
  destinationIds?: string[];
  /**
   * Optional. Whether to propagate the Kubernetes Service to the route
   * destination clusters. The Service will always be deployed to the Target
   * cluster even if the HTTPRoute is not. This option may be used to
   * facilitiate successful DNS lookup in the route destination clusters. Can
   * only be set to true if destinations are specified.
   */
  propagateService?: boolean;
}

/**
 * RuntimeConfig contains the runtime specific configurations for a deployment
 * strategy.
 */
export interface RuntimeConfig {
  /**
   * Cloud Run runtime configuration.
   */
  cloudRun?: CloudRunConfig;
  /**
   * Kubernetes runtime configuration.
   */
  kubernetes?: KubernetesConfig;
}

function serializeRuntimeConfig(data: any): RuntimeConfig {
  return {
    ...data,
    kubernetes: data["kubernetes"] !== undefined ? serializeKubernetesConfig(data["kubernetes"]) : undefined,
  };
}

function deserializeRuntimeConfig(data: any): RuntimeConfig {
  return {
    ...data,
    kubernetes: data["kubernetes"] !== undefined ? deserializeKubernetesConfig(data["kubernetes"]) : undefined,
  };
}

/**
 * SerialPipeline defines a sequential set of stages for a `DeliveryPipeline`.
 */
export interface SerialPipeline {
  /**
   * Each stage specifies configuration for a `Target`. The ordering of this
   * list defines the promotion flow.
   */
  stages?: Stage[];
}

function serializeSerialPipeline(data: any): SerialPipeline {
  return {
    ...data,
    stages: data["stages"] !== undefined ? data["stages"].map((item: any) => (serializeStage(item))) : undefined,
  };
}

function deserializeSerialPipeline(data: any): SerialPipeline {
  return {
    ...data,
    stages: data["stages"] !== undefined ? data["stages"].map((item: any) => (deserializeStage(item))) : undefined,
  };
}

/**
 * Information about the Kubernetes Service networking configuration.
 */
export interface ServiceNetworking {
  /**
   * Required. Name of the Kubernetes Deployment whose traffic is managed by
   * the specified Service.
   */
  deployment?: string;
  /**
   * Optional. Whether to disable Pod overprovisioning. If Pod overprovisioning
   * is disabled then Cloud Deploy will limit the number of total Pods used for
   * the deployment strategy to the number of Pods the Deployment has on the
   * cluster.
   */
  disablePodOverprovisioning?: boolean;
  /**
   * Optional. The label to use when selecting Pods for the Deployment
   * resource. This label must already be present in the Deployment.
   */
  podSelectorLabel?: string;
  /**
   * Required. Name of the Kubernetes Service.
   */
  service?: 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,
  };
}

/**
 * Cloud Build V2 Repository containing Skaffold Configs.
 */
export interface SkaffoldGCBRepoSource {
  /**
   * Optional. Relative path from the repository root to the Skaffold Config
   * file.
   */
  path?: string;
  /**
   * Optional. Branch or tag to use when cloning the repository.
   */
  ref?: string;
  /**
   * Required. Name of the Cloud Build V2 Repository. Format is
   * projects/{project}/locations/{location}/connections/{connection}/repositories/{repository}.
   */
  repository?: string;
}

/**
 * Cloud Storage bucket containing Skaffold Config modules.
 */
export interface SkaffoldGCSSource {
  /**
   * Optional. Relative path from the source to the Skaffold file.
   */
  path?: string;
  /**
   * Required. Cloud Storage source paths to copy recursively. For example,
   * providing "gs://my-bucket/dir/configs/*" will result in Skaffold copying
   * all files within the "dir/configs" directory in the bucket "my-bucket".
   */
  source?: string;
}

/**
 * Git repository containing Skaffold Config modules.
 */
export interface SkaffoldGitSource {
  /**
   * Optional. Relative path from the repository root to the Skaffold file.
   */
  path?: string;
  /**
   * Optional. Git branch or tag to use when cloning the repository.
   */
  ref?: string;
  /**
   * Required. Git repository the package should be cloned from.
   */
  repo?: string;
}

/**
 * Skaffold Config modules and their remote source.
 */
export interface SkaffoldModules {
  /**
   * Optional. The Skaffold Config modules to use from the specified source.
   */
  configs?: string[];
  /**
   * Remote git repository containing the Skaffold Config modules.
   */
  git?: SkaffoldGitSource;
  /**
   * Cloud Build V2 repository containing the Skaffold Config modules.
   */
  googleCloudBuildRepo?: SkaffoldGCBRepoSource;
  /**
   * Cloud Storage bucket containing the Skaffold Config modules.
   */
  googleCloudStorage?: SkaffoldGCSSource;
}

/**
 * SkaffoldSupportedCondition contains information about when support for the
 * release's version of Skaffold ends.
 */
export interface SkaffoldSupportedCondition {
  /**
   * The time at which this release's version of Skaffold will enter
   * maintenance mode.
   */
  maintenanceModeTime?: Date;
  /**
   * The Skaffold support state for this release's version of Skaffold.
   */
  skaffoldSupportState?:  | "SKAFFOLD_SUPPORT_STATE_UNSPECIFIED" | "SKAFFOLD_SUPPORT_STATE_SUPPORTED" | "SKAFFOLD_SUPPORT_STATE_MAINTENANCE_MODE" | "SKAFFOLD_SUPPORT_STATE_UNSUPPORTED";
  /**
   * True if the version of Skaffold used by this release is supported.
   */
  status?: boolean;
  /**
   * The time at which this release's version of Skaffold will no longer be
   * supported.
   */
  supportExpirationTime?: Date;
}

function serializeSkaffoldSupportedCondition(data: any): SkaffoldSupportedCondition {
  return {
    ...data,
    maintenanceModeTime: data["maintenanceModeTime"] !== undefined ? data["maintenanceModeTime"].toISOString() : undefined,
    supportExpirationTime: data["supportExpirationTime"] !== undefined ? data["supportExpirationTime"].toISOString() : undefined,
  };
}

function deserializeSkaffoldSupportedCondition(data: any): SkaffoldSupportedCondition {
  return {
    ...data,
    maintenanceModeTime: data["maintenanceModeTime"] !== undefined ? new Date(data["maintenanceModeTime"]) : undefined,
    supportExpirationTime: data["supportExpirationTime"] !== undefined ? new Date(data["supportExpirationTime"]) : undefined,
  };
}

/**
 * Details of a supported Skaffold version.
 */
export interface SkaffoldVersion {
  /**
   * The time at which this version of Skaffold will enter maintenance mode.
   */
  maintenanceModeTime?: Date;
  /**
   * Date when this version is expected to no longer be supported.
   */
  supportEndDate?: Date;
  /**
   * The time at which this version of Skaffold will no longer be supported.
   */
  supportExpirationTime?: Date;
  /**
   * Release version number. For example, "1.20.3".
   */
  version?: string;
}

function serializeSkaffoldVersion(data: any): SkaffoldVersion {
  return {
    ...data,
    maintenanceModeTime: data["maintenanceModeTime"] !== undefined ? data["maintenanceModeTime"].toISOString() : undefined,
    supportExpirationTime: data["supportExpirationTime"] !== undefined ? data["supportExpirationTime"].toISOString() : undefined,
  };
}

function deserializeSkaffoldVersion(data: any): SkaffoldVersion {
  return {
    ...data,
    maintenanceModeTime: data["maintenanceModeTime"] !== undefined ? new Date(data["maintenanceModeTime"]) : undefined,
    supportExpirationTime: data["supportExpirationTime"] !== undefined ? new Date(data["supportExpirationTime"]) : undefined,
  };
}

/**
 * Stage specifies a location to which to deploy.
 */
export interface Stage {
  /**
   * Optional. The deploy parameters to use for the target in this stage.
   */
  deployParameters?: DeployParameters[];
  /**
   * Skaffold profiles to use when rendering the manifest for this stage's
   * `Target`.
   */
  profiles?: string[];
  /**
   * Optional. The strategy to use for a `Rollout` to this stage.
   */
  strategy?: Strategy;
  /**
   * The target_id to which this stage points. This field refers exclusively to
   * the last segment of a target name. For example, this field would just be
   * `my-target` (rather than
   * `projects/project/locations/location/targets/my-target`). The location of
   * the `Target` is inferred to be the same as the location of the
   * `DeliveryPipeline` that contains this `Stage`.
   */
  targetId?: string;
}

function serializeStage(data: any): Stage {
  return {
    ...data,
    strategy: data["strategy"] !== undefined ? serializeStrategy(data["strategy"]) : undefined,
  };
}

function deserializeStage(data: any): Stage {
  return {
    ...data,
    strategy: data["strategy"] !== undefined ? deserializeStrategy(data["strategy"]) : undefined,
  };
}

/**
 * Standard represents the standard deployment strategy.
 */
export interface Standard {
  /**
   * Optional. Configuration for the postdeploy job. If this is not configured,
   * postdeploy job will not be present.
   */
  postdeploy?: Postdeploy;
  /**
   * Optional. Configuration for the predeploy job. If this is not configured,
   * predeploy job will not be present.
   */
  predeploy?: Predeploy;
  /**
   * Whether to verify a deployment.
   */
  verify?: boolean;
}

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

/**
 * Strategy contains deployment strategy information.
 */
export interface Strategy {
  /**
   * Canary deployment strategy provides progressive percentage based
   * deployments to a Target.
   */
  canary?: Canary;
  /**
   * Standard deployment strategy executes a single deploy and allows verifying
   * the deployment.
   */
  standard?: Standard;
}

function serializeStrategy(data: any): Strategy {
  return {
    ...data,
    canary: data["canary"] !== undefined ? serializeCanary(data["canary"]) : undefined,
  };
}

function deserializeStrategy(data: any): Strategy {
  return {
    ...data,
    canary: data["canary"] !== undefined ? deserializeCanary(data["canary"]) : undefined,
  };
}

/**
 * A `Target` resource in the Cloud Deploy API. A `Target` defines a location
 * to which a Skaffold configuration can be deployed.
 */
export interface Target {
  /**
   * Optional. User annotations. These attributes can only be set and used by
   * the user, and not by Cloud Deploy. See
   * https://google.aip.dev/128#annotations for more details such as format and
   * size limitations.
   */
  annotations?: {
    [key: string]: string
  };
  /**
   * Optional. Information specifying an Anthos Cluster.
   */
  anthosCluster?: AnthosCluster;
  /**
   * Optional. Map of entity IDs to their associated entities. Associated
   * entities allows specifying places other than the deployment target for
   * specific features. For example, the Gateway API canary can be configured to
   * deploy the HTTPRoute to a different cluster(s) than the deployment cluster
   * using associated entities. An entity ID must consist of lower-case letters,
   * numbers, and hyphens, start with a letter and end with a letter or a
   * number, and have a max length of 63 characters. In other words, it must
   * match the following regex: `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`.
   */
  associatedEntities?: {
    [key: string]: AssociatedEntities
  };
  /**
   * Output only. Time at which the `Target` was created.
   */
  readonly createTime?: Date;
  /**
   * Optional. Information specifying a Custom Target.
   */
  customTarget?: CustomTarget;
  /**
   * Optional. The deploy parameters to use for this target.
   */
  deployParameters?: {
    [key: string]: string
  };
  /**
   * Optional. Description of the `Target`. Max length is 255 characters.
   */
  description?: string;
  /**
   * Optional. This checksum is computed by the server based on the value of
   * other fields, and may be sent on update and delete requests to ensure the
   * client has an up-to-date value before proceeding.
   */
  etag?: string;
  /**
   * Configurations for all execution that relates to this `Target`. Each
   * `ExecutionEnvironmentUsage` value may only be used in a single
   * configuration; using the same value multiple times is an error. When one or
   * more configurations are specified, they must include the `RENDER` and
   * `DEPLOY` `ExecutionEnvironmentUsage` values. When no configurations are
   * specified, execution will use the default specified in `DefaultPool`.
   */
  executionConfigs?: ExecutionConfig[];
  /**
   * Optional. Information specifying a GKE Cluster.
   */
  gke?: GkeCluster;
  /**
   * Optional. Labels are attributes that can be set and used by both the user
   * and by Cloud Deploy. Labels must meet the following constraints: * Keys and
   * values can contain only lowercase letters, numeric characters, underscores,
   * and dashes. * All characters must use UTF-8 encoding, and international
   * characters are allowed. * Keys must start with a lowercase letter or
   * international character. * Each resource is limited to a maximum of 64
   * labels. Both keys and values are additionally constrained to be <= 128
   * bytes.
   */
  labels?: {
    [key: string]: string
  };
  /**
   * Optional. Information specifying a multiTarget.
   */
  multiTarget?: MultiTarget;
  /**
   * Optional. Name of the `Target`. Format is
   * `projects/{project}/locations/{location}/targets/{target}`. The `target`
   * component must match `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`
   */
  name?: string;
  /**
   * Optional. Whether or not the `Target` requires approval.
   */
  requireApproval?: boolean;
  /**
   * Optional. Information specifying a Cloud Run deployment target.
   */
  run?: CloudRunLocation;
  /**
   * Output only. Resource id of the `Target`.
   */
  readonly targetId?: string;
  /**
   * Output only. Unique identifier of the `Target`.
   */
  readonly uid?: string;
  /**
   * Output only. Most recent time at which the `Target` was updated.
   */
  readonly updateTime?: Date;
}

function serializeTarget(data: any): Target {
  return {
    ...data,
    executionConfigs: data["executionConfigs"] !== undefined ? data["executionConfigs"].map((item: any) => (serializeExecutionConfig(item))) : undefined,
  };
}

function deserializeTarget(data: any): Target {
  return {
    ...data,
    createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined,
    executionConfigs: data["executionConfigs"] !== undefined ? data["executionConfigs"].map((item: any) => (deserializeExecutionConfig(item))) : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
  };
}

/**
 * The artifacts produced by a target render operation.
 */
export interface TargetArtifact {
  /**
   * Output only. URI of a directory containing the artifacts. This contains
   * deployment configuration used by Skaffold during a rollout, and all paths
   * are relative to this location.
   */
  readonly artifactUri?: string;
  /**
   * Output only. File path of the rendered manifest relative to the URI.
   */
  readonly manifestPath?: string;
  /**
   * Output only. Map from the phase ID to the phase artifacts for the
   * `Target`.
   */
  readonly phaseArtifacts?: {
    [key: string]: PhaseArtifact
  };
  /**
   * Output only. File path of the resolved Skaffold configuration relative to
   * the URI.
   */
  readonly skaffoldConfigPath?: string;
}

/**
 * Contains criteria for selecting Targets. This could be used to select
 * targets for a Deploy Policy or for an Automation.
 */
export interface TargetAttribute {
  /**
   * ID of the `Target`. The value of this field could be one of the following:
   * * The last segment of a target name * "*", all targets in a location
   */
  id?: string;
  /**
   * Target labels.
   */
  labels?: {
    [key: string]: string
  };
}

/**
 * Payload proto for "clouddeploy.googleapis.com/target_notification" Platform
 * Log event that describes the failure to send target status change Pub/Sub
 * notification.
 */
export interface TargetNotificationEvent {
  /**
   * Debug message for when a notification fails to send.
   */
  message?: string;
  /**
   * The name of the `Target`.
   */
  target?: string;
  /**
   * Type of this notification, e.g. for a Pub/Sub failure.
   */
  type?:  | "TYPE_UNSPECIFIED" | "TYPE_PUBSUB_NOTIFICATION_FAILURE" | "TYPE_RESOURCE_STATE_CHANGE" | "TYPE_PROCESS_ABORTED" | "TYPE_RESTRICTION_VIOLATED" | "TYPE_RESOURCE_DELETED" | "TYPE_ROLLOUT_UPDATE" | "TYPE_DEPLOY_POLICY_EVALUATION" | "TYPE_RENDER_STATUES_CHANGE";
}

/**
 * Details of rendering for a single target.
 */
export interface TargetRender {
  /**
   * Output only. Reason this render failed. This will always be unspecified
   * while the render in progress.
   */
  readonly failureCause?:  | "FAILURE_CAUSE_UNSPECIFIED" | "CLOUD_BUILD_UNAVAILABLE" | "EXECUTION_FAILED" | "CLOUD_BUILD_REQUEST_FAILED" | "VERIFICATION_CONFIG_NOT_FOUND" | "CUSTOM_ACTION_NOT_FOUND" | "DEPLOYMENT_STRATEGY_NOT_SUPPORTED" | "RENDER_FEATURE_NOT_SUPPORTED";
  /**
   * Output only. Additional information about the render failure, if
   * available.
   */
  readonly failureMessage?: string;
  /**
   * Output only. Metadata related to the `Release` render for this Target.
   */
  readonly metadata?: RenderMetadata;
  /**
   * Output only. The resource name of the Cloud Build `Build` object that is
   * used to render the manifest for this target. Format is
   * `projects/{project}/locations/{location}/builds/{build}`.
   */
  readonly renderingBuild?: string;
  /**
   * Output only. Current state of the render operation for this Target.
   */
  readonly renderingState?:  | "TARGET_RENDER_STATE_UNSPECIFIED" | "SUCCEEDED" | "FAILED" | "IN_PROGRESS";
}

/**
 * The targets involved in a single timed promotion.
 */
export interface Targets {
  /**
   * Optional. The destination target ID.
   */
  destinationTargetId?: string;
  /**
   * Optional. The source target ID.
   */
  sourceTargetId?: string;
}

/**
 * `TargetsPresentCondition` contains information on any Targets referenced in
 * the Delivery Pipeline that do not actually exist.
 */
export interface TargetsPresentCondition {
  /**
   * The list of Target names that do not exist. For example,
   * `projects/{project_id}/locations/{location_name}/targets/{target_name}`.
   */
  missingTargets?: string[];
  /**
   * True if there aren't any missing Targets.
   */
  status?: boolean;
  /**
   * Last time the condition was updated.
   */
  updateTime?: Date;
}

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

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

/**
 * TargetsTypeCondition contains information on whether the Targets defined in
 * the Delivery Pipeline are of the same type.
 */
export interface TargetsTypeCondition {
  /**
   * Human readable error message.
   */
  errorDetails?: string;
  /**
   * True if the targets are all a comparable type. For example this is true if
   * all targets are GKE clusters. This is false if some targets are Cloud Run
   * targets and others are GKE clusters.
   */
  status?: boolean;
}

/**
 * The request object used by `TerminateJobRun`.
 */
export interface TerminateJobRunRequest {
  /**
   * Optional. Deploy policies to override. Format is
   * `projects/{project}/locations/{location}/deployPolicies/{deployPolicy}`.
   */
  overrideDeployPolicy?: string[];
}

/**
 * The response object from `TerminateJobRun`.
 */
export interface TerminateJobRunResponse {
}

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

/**
 * `TimedPromoteReleaseCondition` contains conditions specific to an Automation
 * with a Timed Promote Release rule defined.
 */
export interface TimedPromoteReleaseCondition {
  /**
   * Output only. When the next scheduled promotion(s) will occur.
   */
  readonly nextPromotionTime?: Date;
  /**
   * Output only. A list of targets involved in the upcoming timed
   * promotion(s).
   */
  readonly targetsList?: Targets[];
}

/**
 * Contains the information of an automated timed promote-release operation.
 */
export interface TimedPromoteReleaseOperation {
  /**
   * Output only. The starting phase of the rollout created by this operation.
   */
  readonly phase?: string;
  /**
   * Output only. The name of the release to be promoted.
   */
  readonly release?: string;
  /**
   * Output only. The ID of the target that represents the promotion stage to
   * which the release will be promoted. The value of this field is the last
   * segment of a target name.
   */
  readonly targetId?: string;
}

/**
 * The `TimedPromoteReleaseRule` will automatically promote a release from the
 * current target(s) to the specified target(s) on a configured schedule.
 */
export interface TimedPromoteReleaseRule {
  /**
   * Output only. Information around the state of the Automation rule.
   */
  readonly condition?: AutomationRuleCondition;
  /**
   * Optional. The starting phase of the rollout created by this rule. Default
   * to the first phase.
   */
  destinationPhase?: string;
  /**
   * Optional. The ID of the stage in the pipeline to which this `Release` is
   * deploying. If unspecified, default it to the next stage in the promotion
   * flow. The value of this field could be one of the following: * The last
   * segment of a target name * "@next", the next target in the promotion
   * sequence
   */
  destinationTargetId?: string;
  /**
   * Required. ID of the rule. This ID must be unique in the `Automation`
   * resource to which this rule belongs. The format is
   * `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`.
   */
  id?: string;
  /**
   * Required. Schedule in crontab format. e.g. "0 9 * * 1" for every Monday at
   * 9am.
   */
  schedule?: string;
  /**
   * Required. The time zone in IANA format [IANA Time Zone
   * Database](https://www.iana.org/time-zones) (e.g. America/New_York).
   */
  timeZone?: string;
}

/**
 * Represents a time of day. The date and time zone are either not significant
 * or are specified elsewhere. An API may choose to allow leap seconds. Related
 * types are google.type.Date and `google.protobuf.Timestamp`.
 */
export interface TimeOfDay {
  /**
   * Hours of a day in 24 hour format. Must be greater than or equal to 0 and
   * typically must be less than or equal to 23. An API may choose to allow the
   * value "24:00:00" for scenarios like business closing time.
   */
  hours?: number;
  /**
   * Minutes of an hour. Must be greater than or equal to 0 and less than or
   * equal to 59.
   */
  minutes?: number;
  /**
   * Fractions of seconds, in nanoseconds. Must be greater than or equal to 0
   * and less than or equal to 999,999,999.
   */
  nanos?: number;
  /**
   * Seconds of a minute. Must be greater than or equal to 0 and typically must
   * be less than or equal to 59. An API may allow the value 60 if it allows
   * leap-seconds.
   */
  seconds?: number;
}

/**
 * Time windows within which actions are restricted. See the
 * [documentation](https://cloud.google.com/deploy/docs/deploy-policy#dates_times)
 * for more information on how to configure dates/times.
 */
export interface TimeWindows {
  /**
   * Optional. One-time windows within which actions are restricted.
   */
  oneTimeWindows?: OneTimeWindow[];
  /**
   * Required. The time zone in IANA format [IANA Time Zone
   * Database](https://www.iana.org/time-zones) (e.g. America/New_York).
   */
  timeZone?: string;
  /**
   * Optional. Recurring weekly windows within which actions are restricted.
   */
  weeklyWindows?: WeeklyWindow[];
}

/**
 * A verify Job.
 */
export interface VerifyJob {
}

/**
 * VerifyJobRun contains information specific to a verify `JobRun`.
 */
export interface VerifyJobRun {
  /**
   * Output only. URI of a directory containing the verify artifacts. This
   * contains the Skaffold event log.
   */
  readonly artifactUri?: string;
  /**
   * Output only. The resource name of the Cloud Build `Build` object that is
   * used to verify. Format is
   * `projects/{project}/locations/{location}/builds/{build}`.
   */
  readonly build?: string;
  /**
   * Output only. File path of the Skaffold event log relative to the artifact
   * URI.
   */
  readonly eventLogPath?: string;
  /**
   * Output only. The reason the verify failed. This will always be unspecified
   * while the verify is in progress or if it succeeded.
   */
  readonly failureCause?:  | "FAILURE_CAUSE_UNSPECIFIED" | "CLOUD_BUILD_UNAVAILABLE" | "EXECUTION_FAILED" | "DEADLINE_EXCEEDED" | "VERIFICATION_CONFIG_NOT_FOUND" | "CLOUD_BUILD_REQUEST_FAILED";
  /**
   * Output only. Additional information about the verify failure, if
   * available.
   */
  readonly failureMessage?: string;
}

/**
 * Weekly windows. For example, blocking actions every Saturday and Sunday.
 * Another example would be blocking actions every weekday from 5pm to midnight.
 */
export interface WeeklyWindow {
  /**
   * Optional. Days of week. If left empty, all days of the week will be
   * included.
   */
  daysOfWeek?:  | "DAY_OF_WEEK_UNSPECIFIED" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY"[];
  /**
   * Optional. End time (exclusive). Use 24:00 to indicate midnight. If you
   * specify end_time you must also specify start_time. If left empty, this will
   * block for the entire day for the days specified in days_of_week.
   */
  endTime?: TimeOfDay;
  /**
   * Optional. Start time (inclusive). Use 00:00 for the beginning of the day.
   * If you specify start_time you must also specify end_time. If left empty,
   * this will block for the entire day for the days specified in days_of_week.
   */
  startTime?: TimeOfDay;
}

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