/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 * @generated-id: 4c4c88e592be
 */

import { deploymentsCreate } from "../funcs/deploymentsCreate.js";
import { deploymentsCreateSetupRegistrationOperation } from "../funcs/deploymentsCreateSetupRegistrationOperation.js";
import { deploymentsCreateToken } from "../funcs/deploymentsCreateToken.js";
import { deploymentsDelete } from "../funcs/deploymentsDelete.js";
import { deploymentsGet } from "../funcs/deploymentsGet.js";
import { deploymentsGetInfo } from "../funcs/deploymentsGetInfo.js";
import { deploymentsGetInputs } from "../funcs/deploymentsGetInputs.js";
import { deploymentsGetSetupRegistrationOperation } from "../funcs/deploymentsGetSetupRegistrationOperation.js";
import { deploymentsGetStats } from "../funcs/deploymentsGetStats.js";
import { deploymentsImport } from "../funcs/deploymentsImport.js";
import { deploymentsList } from "../funcs/deploymentsList.js";
import { deploymentsListFilterDeploymentGroups } from "../funcs/deploymentsListFilterDeploymentGroups.js";
import { deploymentsListFilterEnvironments } from "../funcs/deploymentsListFilterEnvironments.js";
import { deploymentsListMachines } from "../funcs/deploymentsListMachines.js";
import { deploymentsPinRelease } from "../funcs/deploymentsPinRelease.js";
import { deploymentsRedeploy } from "../funcs/deploymentsRedeploy.js";
import { deploymentsRetry } from "../funcs/deploymentsRetry.js";
import { deploymentsSetFirstPartyDeploymentInputs } from "../funcs/deploymentsSetFirstPartyDeploymentInputs.js";
import { deploymentsSetReleaseChannel } from "../funcs/deploymentsSetReleaseChannel.js";
import { deploymentsUpdateCompute } from "../funcs/deploymentsUpdateCompute.js";
import { deploymentsUpdateEnvironmentVariables } from "../funcs/deploymentsUpdateEnvironmentVariables.js";
import { deploymentsUpdateInputs } from "../funcs/deploymentsUpdateInputs.js";
import { ClientSDK, RequestOptions } from "../lib/sdks.js";
import * as models from "../models/index.js";
import * as operations from "../models/operations/index.js";
import { unwrapAsync } from "../types/fp.js";

export class Deployments extends ClientSDK {
  /**
   * Retrieve all deployments.
   */
  async list(
    request?: operations.ListDeploymentsRequest | undefined,
    options?: RequestOptions,
  ): Promise<operations.ListDeploymentsResponse> {
    return unwrapAsync(deploymentsList(
      this,
      request,
      options,
    ));
  }

  /**
   * Create a new deployment. Deployment group tokens automatically use their group. Workspace/project tokens must provide deploymentGroupId.
   */
  async create(
    request?: models.NewDeploymentRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.CreateDeploymentResponse> {
    return unwrapAsync(deploymentsCreate(
      this,
      request,
      options,
    ));
  }

  /**
   * Get aggregated deployment statistics. Returns total count and breakdown by status.
   */
  async getStats(
    request?: operations.GetDeploymentStatsRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.DeploymentStats> {
    return unwrapAsync(deploymentsGetStats(
      this,
      request,
      options,
    ));
  }

  /**
   * List distinct effective environments used by deployments. Used for filter dropdowns.
   */
  async listFilterEnvironments(
    request?: operations.ListDeploymentFilterEnvironmentsRequest | undefined,
    options?: RequestOptions,
  ): Promise<operations.ListDeploymentFilterEnvironmentsResponse> {
    return unwrapAsync(deploymentsListFilterEnvironments(
      this,
      request,
      options,
    ));
  }

  /**
   * List deployment groups with deployment counts. Used for filter dropdowns.
   */
  async listFilterDeploymentGroups(
    request?:
      | operations.ListDeploymentFilterDeploymentGroupsRequest
      | undefined,
    options?: RequestOptions,
  ): Promise<operations.ListDeploymentFilterDeploymentGroupsResponse> {
    return unwrapAsync(deploymentsListFilterDeploymentGroups(
      this,
      request,
      options,
    ));
  }

  /**
   * Retrieve a deployment by ID.
   */
  async get(
    request: operations.GetDeploymentRequest,
    options?: RequestOptions,
  ): Promise<models.DeploymentDetailResponse> {
    return unwrapAsync(deploymentsGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Get deployment connection information including command endpoint and resource URLs.
   */
  async getInfo(
    request: operations.GetDeploymentConnectionInfoRequest,
    options?: RequestOptions,
  ): Promise<models.DeploymentConnectionInfo> {
    return unwrapAsync(deploymentsGetInfo(
      this,
      request,
      options,
    ));
  }

  /**
   * Import a deployment from resolved setup infrastructure such as CloudFormation, Terraform, or Helm.
   */
  async import(
    request?: models.ImportDeploymentRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.Deployment> {
    return unwrapAsync(deploymentsImport(
      this,
      request,
      options,
    ));
  }

  /**
   * Store operator-provided input values on a first-party deployment session token so CLI/local deploys apply them.
   */
  async setFirstPartyDeploymentInputs(
    request?: models.SetFirstPartyDeploymentInputsRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.SetFirstPartyDeploymentInputsResponse> {
    return unwrapAsync(deploymentsSetFirstPartyDeploymentInputs(
      this,
      request,
      options,
    ));
  }

  /**
   * Start a durable setup registration operation for CloudFormation, Terraform, or Helm.
   */
  async createSetupRegistrationOperation(
    request?: models.CreateSetupRegistrationOperationRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.SetupRegistrationOperationResponse> {
    return unwrapAsync(deploymentsCreateSetupRegistrationOperation(
      this,
      request,
      options,
    ));
  }

  /**
   * Get setup registration operation status.
   */
  async getSetupRegistrationOperation(
    request: operations.GetSetupRegistrationOperationRequest,
    options?: RequestOptions,
  ): Promise<models.SetupRegistrationOperationResponse> {
    return unwrapAsync(deploymentsGetSetupRegistrationOperation(
      this,
      request,
      options,
    ));
  }

  /**
   * Delete, detach, or forget a deployment by ID.
   */
  async delete(
    request: operations.DeleteDeploymentRequest,
    options?: RequestOptions,
  ): Promise<models.DeleteDeploymentResponse> {
    return unwrapAsync(deploymentsDelete(
      this,
      request,
      options,
    ));
  }

  /**
   * Redeploy a running deployment with the same release and fresh environment variables. Sets status to update-pending.
   */
  async redeploy(
    request: operations.RedeployDeploymentRequest,
    options?: RequestOptions,
  ): Promise<operations.RedeployDeploymentResponse> {
    return unwrapAsync(deploymentsRedeploy(
      this,
      request,
      options,
    ));
  }

  /**
   * Pin or unpin a running or runtime-failed deployment. Running deployments start an update; failed deployments retry toward the selected release.
   */
  async pinRelease(
    request: operations.PinDeploymentReleaseRequest,
    options?: RequestOptions,
  ): Promise<operations.PinDeploymentReleaseResponse> {
    return unwrapAsync(deploymentsPinRelease(
      this,
      request,
      options,
    ));
  }

  async setReleaseChannel(
    request: operations.SetDeploymentReleaseChannelRequest,
    options?: RequestOptions,
  ): Promise<models.Deployment> {
    return unwrapAsync(deploymentsSetReleaseChannel(
      this,
      request,
      options,
    ));
  }

  /**
   * Retry a failed deployment operation. Uses alien-infra's retry mechanisms to resume from exact failure point.
   */
  async retry(
    request: operations.RetryDeploymentRequest,
    options?: RequestOptions,
  ): Promise<operations.RetryDeploymentResponse> {
    return unwrapAsync(deploymentsRetry(
      this,
      request,
      options,
    ));
  }

  /**
   * Get the active input definitions and current non-secret values for a deployment.
   */
  async getInputs(
    request: operations.GetDeploymentInputsRequest,
    options?: RequestOptions,
  ): Promise<models.DeploymentInputsResponse> {
    return unwrapAsync(deploymentsGetInputs(
      this,
      request,
      options,
    ));
  }

  /**
   * Update runtime stack inputs, rebuild their environment-variable mappings, and request a deployment update when runtime configuration changes.
   */
  async updateInputs(
    request: operations.UpdateDeploymentInputsRequest,
    options?: RequestOptions,
  ): Promise<models.UpdateDeploymentInputsResponse> {
    return unwrapAsync(deploymentsUpdateInputs(
      this,
      request,
      options,
    ));
  }

  /**
   * Update deployment-time compute pool selections and request reconciliation by the hosted manager.
   */
  async updateCompute(
    request: operations.UpdateDeploymentComputeRequest,
    options?: RequestOptions,
  ): Promise<operations.UpdateDeploymentComputeResponse> {
    return unwrapAsync(deploymentsUpdateCompute(
      this,
      request,
      options,
    ));
  }

  /**
   * Replace a deployment's advanced environment variables. Stack-input-backed variables are write-only through the input endpoint. If the deployment is running and not locked, the status will be changed to update-pending to trigger a deployment.
   */
  async updateEnvironmentVariables(
    request: operations.UpdateDeploymentEnvironmentVariablesRequest,
    options?: RequestOptions,
  ): Promise<operations.UpdateDeploymentEnvironmentVariablesResponse> {
    return unwrapAsync(deploymentsUpdateEnvironmentVariables(
      this,
      request,
      options,
    ));
  }

  /**
   * Create a deployment token (deployment-scoped API key). The deployment must exist before creating a token.
   */
  async createToken(
    request: operations.CreateDeploymentTokenRequest,
    options?: RequestOptions,
  ): Promise<models.CreateDeploymentTokenResponse> {
    return unwrapAsync(deploymentsCreateToken(
      this,
      request,
      options,
    ));
  }

  async listMachines(
    request: operations.ListDeploymentMachinesRequest,
    options?: RequestOptions,
  ): Promise<models.ListDeploymentMachinesResponse> {
    return unwrapAsync(deploymentsListMachines(
      this,
      request,
      options,
    ));
  }
}