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

import { acceptWorkspaceInvitation } from "../funcs/acceptWorkspaceInvitation.js";
import { cancelDeploymentCredentialRotation } from "../funcs/cancelDeploymentCredentialRotation.js";
import { continueAwsVirtualKey } from "../funcs/continueAwsVirtualKey.js";
import { createAwsVirtualKey } from "../funcs/createAwsVirtualKey.js";
import { createWorkspaceInvitation } from "../funcs/createWorkspaceInvitation.js";
import { createWorkspaceInviteLink } from "../funcs/createWorkspaceInviteLink.js";
import { decommissionAwsVirtualKey } from "../funcs/decommissionAwsVirtualKey.js";
import { finalizeAwsVirtualKeyDeletion } from "../funcs/finalizeAwsVirtualKeyDeletion.js";
import { getAwsVirtualKey } from "../funcs/getAwsVirtualKey.js";
import { getDeploymentCredentialRotation } from "../funcs/getDeploymentCredentialRotation.js";
import { getDeploymentCredentialRotationValues } from "../funcs/getDeploymentCredentialRotationValues.js";
import { getWorkspaceInvitationPreview } from "../funcs/getWorkspaceInvitationPreview.js";
import { getWorkspaceInviteLink } from "../funcs/getWorkspaceInviteLink.js";
import { listAwsVirtualKeys } from "../funcs/listAwsVirtualKeys.js";
import { listWorkspaceInvitations } from "../funcs/listWorkspaceInvitations.js";
import { prepareDeploymentCredentialRotation } from "../funcs/prepareDeploymentCredentialRotation.js";
import { resendWorkspaceInvitation } from "../funcs/resendWorkspaceInvitation.js";
import { restoreAwsVirtualKey } from "../funcs/restoreAwsVirtualKey.js";
import { revokeWorkspaceInvitation } from "../funcs/revokeWorkspaceInvitation.js";
import { revokeWorkspaceInviteLink } from "../funcs/revokeWorkspaceInviteLink.js";
import { rotateAwsVirtualKeyCredential } from "../funcs/rotateAwsVirtualKeyCredential.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";
import { AgentSessions } from "./agentsessions.js";
import { ApiKeys } from "./apikeys.js";
import { Auth } from "./auth.js";
import { Billing } from "./billing.js";
import { CloudRegions } from "./cloudregions.js";
import { Commands } from "./commands.js";
import { ContainerRegistry } from "./containerregistry.js";
import { DebugSessions } from "./debugsessions.js";
import { Deployment } from "./deployment.js";
import { DeploymentGroups } from "./deploymentgroups.js";
import { Deployments } from "./deployments.js";
import { Domains } from "./domains.js";
import { Events } from "./events.js";
import { Gateways } from "./gateways.js";
import { Machines } from "./machines.js";
import { Managers } from "./managers.js";
import { Operations } from "./operations.js";
import { OperatorManifests } from "./operatormanifests.js";
import { Packages } from "./packages.js";
import { Projects } from "./projects.js";
import { ReleaseChannels } from "./releasechannels.js";
import { Releases } from "./releases.js";
import { RemoteBindings } from "./remotebindings.js";
import { Resolve } from "./resolve.js";
import { Resources } from "./resources.js";
import { SetupLinks } from "./setuplinks.js";
import { SlackIntegration } from "./slackintegration.js";
import { Sync } from "./sync.js";
import { User } from "./user.js";
import { Workspaces } from "./workspaces.js";

export class Alien extends ClientSDK {
  private _user?: User;
  get user(): User {
    return (this._user ??= new User(this._options));
  }

  private _auth?: Auth;
  get auth(): Auth {
    return (this._auth ??= new Auth(this._options));
  }

  private _workspaces?: Workspaces;
  get workspaces(): Workspaces {
    return (this._workspaces ??= new Workspaces(this._options));
  }

  private _projects?: Projects;
  get projects(): Projects {
    return (this._projects ??= new Projects(this._options));
  }

  private _remoteBindings?: RemoteBindings;
  get remoteBindings(): RemoteBindings {
    return (this._remoteBindings ??= new RemoteBindings(this._options));
  }

  private _deploymentGroups?: DeploymentGroups;
  get deploymentGroups(): DeploymentGroups {
    return (this._deploymentGroups ??= new DeploymentGroups(this._options));
  }

  private _setupLinks?: SetupLinks;
  get setupLinks(): SetupLinks {
    return (this._setupLinks ??= new SetupLinks(this._options));
  }

  private _containerRegistry?: ContainerRegistry;
  get containerRegistry(): ContainerRegistry {
    return (this._containerRegistry ??= new ContainerRegistry(this._options));
  }

  private _packages?: Packages;
  get packages(): Packages {
    return (this._packages ??= new Packages(this._options));
  }

  private _releases?: Releases;
  get releases(): Releases {
    return (this._releases ??= new Releases(this._options));
  }

  private _releaseChannels?: ReleaseChannels;
  get releaseChannels(): ReleaseChannels {
    return (this._releaseChannels ??= new ReleaseChannels(this._options));
  }

  private _deployments?: Deployments;
  get deployments(): Deployments {
    return (this._deployments ??= new Deployments(this._options));
  }

  private _managers?: Managers;
  get managers(): Managers {
    return (this._managers ??= new Managers(this._options));
  }

  private _operatorManifests?: OperatorManifests;
  get operatorManifests(): OperatorManifests {
    return (this._operatorManifests ??= new OperatorManifests(this._options));
  }

  private _apiKeys?: ApiKeys;
  get apiKeys(): ApiKeys {
    return (this._apiKeys ??= new ApiKeys(this._options));
  }

  private _domains?: Domains;
  get domains(): Domains {
    return (this._domains ??= new Domains(this._options));
  }

  private _events?: Events;
  get events(): Events {
    return (this._events ??= new Events(this._options));
  }

  private _machines?: Machines;
  get machines(): Machines {
    return (this._machines ??= new Machines(this._options));
  }

  private _commands?: Commands;
  get commands(): Commands {
    return (this._commands ??= new Commands(this._options));
  }

  private _debugSessions?: DebugSessions;
  get debugSessions(): DebugSessions {
    return (this._debugSessions ??= new DebugSessions(this._options));
  }

  private _deployment?: Deployment;
  get deployment(): Deployment {
    return (this._deployment ??= new Deployment(this._options));
  }

  private _slackIntegration?: SlackIntegration;
  get slackIntegration(): SlackIntegration {
    return (this._slackIntegration ??= new SlackIntegration(this._options));
  }

  private _agentSessions?: AgentSessions;
  get agentSessions(): AgentSessions {
    return (this._agentSessions ??= new AgentSessions(this._options));
  }

  private _operations?: Operations;
  get operations(): Operations {
    return (this._operations ??= new Operations(this._options));
  }

  private _sync?: Sync;
  get sync(): Sync {
    return (this._sync ??= new Sync(this._options));
  }

  private _resources?: Resources;
  get resources(): Resources {
    return (this._resources ??= new Resources(this._options));
  }

  private _resolve?: Resolve;
  get resolve(): Resolve {
    return (this._resolve ??= new Resolve(this._options));
  }

  private _cloudRegions?: CloudRegions;
  get cloudRegions(): CloudRegions {
    return (this._cloudRegions ??= new CloudRegions(this._options));
  }

  private _billing?: Billing;
  get billing(): Billing {
    return (this._billing ??= new Billing(this._options));
  }

  private _gateways?: Gateways;
  get gateways(): Gateways {
    return (this._gateways ??= new Gateways(this._options));
  }

  async getWorkspaceInvitationPreview(
    request: operations.GetWorkspaceInvitationPreviewRequest,
    options?: RequestOptions,
  ): Promise<models.WorkspaceInvitationPreview> {
    return unwrapAsync(getWorkspaceInvitationPreview(
      this,
      request,
      options,
    ));
  }

  async acceptWorkspaceInvitation(
    request: operations.AcceptWorkspaceInvitationRequest,
    options?: RequestOptions,
  ): Promise<models.AcceptWorkspaceInvitationResponse> {
    return unwrapAsync(acceptWorkspaceInvitation(
      this,
      request,
      options,
    ));
  }

  async listWorkspaceInvitations(
    request: operations.ListWorkspaceInvitationsRequest,
    options?: RequestOptions,
  ): Promise<operations.ListWorkspaceInvitationsResponse> {
    return unwrapAsync(listWorkspaceInvitations(
      this,
      request,
      options,
    ));
  }

  async createWorkspaceInvitation(
    request: operations.CreateWorkspaceInvitationRequest,
    options?: RequestOptions,
  ): Promise<models.WorkspaceInvitation> {
    return unwrapAsync(createWorkspaceInvitation(
      this,
      request,
      options,
    ));
  }

  async resendWorkspaceInvitation(
    request: operations.ResendWorkspaceInvitationRequest,
    options?: RequestOptions,
  ): Promise<models.WorkspaceInvitation> {
    return unwrapAsync(resendWorkspaceInvitation(
      this,
      request,
      options,
    ));
  }

  async revokeWorkspaceInvitation(
    request: operations.RevokeWorkspaceInvitationRequest,
    options?: RequestOptions,
  ): Promise<void> {
    return unwrapAsync(revokeWorkspaceInvitation(
      this,
      request,
      options,
    ));
  }

  async getWorkspaceInviteLink(
    request: operations.GetWorkspaceInviteLinkRequest,
    options?: RequestOptions,
  ): Promise<models.WorkspaceInviteLink> {
    return unwrapAsync(getWorkspaceInviteLink(
      this,
      request,
      options,
    ));
  }

  async createWorkspaceInviteLink(
    request: operations.CreateWorkspaceInviteLinkRequest,
    options?: RequestOptions,
  ): Promise<models.WorkspaceInviteLink> {
    return unwrapAsync(createWorkspaceInviteLink(
      this,
      request,
      options,
    ));
  }

  async revokeWorkspaceInviteLink(
    request: operations.RevokeWorkspaceInviteLinkRequest,
    options?: RequestOptions,
  ): Promise<void> {
    return unwrapAsync(revokeWorkspaceInviteLink(
      this,
      request,
      options,
    ));
  }

  async getDeploymentCredentialRotation(
    request: operations.GetDeploymentCredentialRotationRequest,
    options?: RequestOptions,
  ): Promise<models.DeploymentCredentialRotationStatus> {
    return unwrapAsync(getDeploymentCredentialRotation(
      this,
      request,
      options,
    ));
  }

  async prepareDeploymentCredentialRotation(
    request: operations.PrepareDeploymentCredentialRotationRequest,
    options?: RequestOptions,
  ): Promise<models.DeploymentCredentialRotation> {
    return unwrapAsync(prepareDeploymentCredentialRotation(
      this,
      request,
      options,
    ));
  }

  async cancelDeploymentCredentialRotation(
    request: operations.CancelDeploymentCredentialRotationRequest,
    options?: RequestOptions,
  ): Promise<models.DeploymentCredentialRotation> {
    return unwrapAsync(cancelDeploymentCredentialRotation(
      this,
      request,
      options,
    ));
  }

  async getDeploymentCredentialRotationValues(
    request: operations.GetDeploymentCredentialRotationValuesRequest,
    options?: RequestOptions,
  ): Promise<models.DeploymentCredentialRotationValues> {
    return unwrapAsync(getDeploymentCredentialRotationValues(
      this,
      request,
      options,
    ));
  }

  async listAwsVirtualKeys(
    request: operations.ListAwsVirtualKeysRequest,
    options?: RequestOptions,
  ): Promise<operations.ListAwsVirtualKeysResponse> {
    return unwrapAsync(listAwsVirtualKeys(
      this,
      request,
      options,
    ));
  }

  async createAwsVirtualKey(
    request?: operations.CreateAwsVirtualKeyRequest | undefined,
    options?: RequestOptions,
  ): Promise<operations.CreateAwsVirtualKeyResponse> {
    return unwrapAsync(createAwsVirtualKey(
      this,
      request,
      options,
    ));
  }

  async rotateAwsVirtualKeyCredential(
    request: operations.RotateAwsVirtualKeyCredentialRequest,
    options?: RequestOptions,
  ): Promise<operations.RotateAwsVirtualKeyCredentialResponse> {
    return unwrapAsync(rotateAwsVirtualKeyCredential(
      this,
      request,
      options,
    ));
  }

  async restoreAwsVirtualKey(
    request: operations.RestoreAwsVirtualKeyRequest,
    options?: RequestOptions,
  ): Promise<operations.RestoreAwsVirtualKeyResponse> {
    return unwrapAsync(restoreAwsVirtualKey(
      this,
      request,
      options,
    ));
  }

  async finalizeAwsVirtualKeyDeletion(
    request: operations.FinalizeAwsVirtualKeyDeletionRequest,
    options?: RequestOptions,
  ): Promise<operations.FinalizeAwsVirtualKeyDeletionResponse> {
    return unwrapAsync(finalizeAwsVirtualKeyDeletion(
      this,
      request,
      options,
    ));
  }

  async decommissionAwsVirtualKey(
    request: operations.DecommissionAwsVirtualKeyRequest,
    options?: RequestOptions,
  ): Promise<operations.DecommissionAwsVirtualKeyResponse> {
    return unwrapAsync(decommissionAwsVirtualKey(
      this,
      request,
      options,
    ));
  }

  async getAwsVirtualKey(
    request: operations.GetAwsVirtualKeyRequest,
    options?: RequestOptions,
  ): Promise<operations.GetAwsVirtualKeyResponse> {
    return unwrapAsync(getAwsVirtualKey(
      this,
      request,
      options,
    ));
  }

  async continueAwsVirtualKey(
    request: operations.ContinueAwsVirtualKeyRequest,
    options?: RequestOptions,
  ): Promise<operations.ContinueAwsVirtualKeyResponse> {
    return unwrapAsync(continueAwsVirtualKey(
      this,
      request,
      options,
    ));
  }
}