freestyle-sandboxes 0.0.96 → 0.1.0

package/index.cjs

@@ -0,0 +1,4362 @@
+'use strict';
+
+function errorFromJSON(body) {
+  const ErrorClass = FREESTYLE_ERROR_CODE_MAP[body.code];
+  if (ErrorClass) {
+    return new ErrorClass(body);
+  } else {
+    return new Error(`Unknown error code: ${body.code} - ${body.description}`);
+  }
+}
+class VmNotFoundInFsError extends Error {
+  constructor(body) {
+    super(
+      `VM_NOT_FOUND_IN_FS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmNotFoundInFsError";
+  }
+  static code = "VM_NOT_FOUND_IN_FS";
+  static statusCode = 406;
+  static description = `Vm Not found in filesystem`;
+}
+class VmNotRunningError extends Error {
+  constructor(body) {
+    super(
+      `VM_NOT_RUNNING: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmNotRunningError";
+  }
+  static code = "VM_NOT_RUNNING";
+  static statusCode = 400;
+  static description = `VmNotRunning`;
+}
+class VmNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `VM_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmNotFoundError";
+  }
+  static code = "VM_NOT_FOUND";
+  static statusCode = 404;
+  static description = `VmNotFound`;
+}
+class InternalForkVmNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `INTERNAL_FORK_VM_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InternalForkVmNotFoundError";
+  }
+  static code = "INTERNAL_FORK_VM_NOT_FOUND";
+  static statusCode = 404;
+  static description = `The VM you're trying to fork from was not found: {fork_vm_id}`;
+}
+class BadRequestError extends Error {
+  constructor(body) {
+    super(
+      `BAD_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "BadRequestError";
+  }
+  static code = "BAD_REQUEST";
+  static statusCode = 400;
+  static description = `Bad request: {message}`;
+}
+class InternalVmNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `INTERNAL_VM_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InternalVmNotFoundError";
+  }
+  static code = "INTERNAL_VM_NOT_FOUND";
+  static statusCode = 404;
+  static description = `VM not found: {vm_id}`;
+}
+class VmMustBeStoppedError extends Error {
+  constructor(body) {
+    super(
+      `VM_MUST_BE_STOPPED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmMustBeStoppedError";
+  }
+  static code = "VM_MUST_BE_STOPPED";
+  static statusCode = 400;
+  static description = `VM must be stopped before converting to base`;
+}
+class AlreadyHasBaseError extends Error {
+  constructor(body) {
+    super(
+      `ALREADY_HAS_BASE: ${body.message}`
+    );
+    this.body = body;
+    this.name = "AlreadyHasBaseError";
+  }
+  static code = "ALREADY_HAS_BASE";
+  static statusCode = 400;
+  static description = `VM already has a base rootfs`;
+}
+class NotFoundError extends Error {
+  constructor(body) {
+    super(
+      `NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "NotFoundError";
+  }
+  static code = "NOT_FOUND";
+  static statusCode = 404;
+  static description = `VM not found`;
+}
+class InternalErrorError extends Error {
+  constructor(body) {
+    super(
+      `INTERNAL_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InternalErrorError";
+  }
+  static code = "INTERNAL_ERROR";
+  static statusCode = 500;
+  static description = `Internal error: {message}`;
+}
+class DockerImportBadRequestError extends Error {
+  constructor(body) {
+    super(
+      `DOCKER_IMPORT_BAD_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DockerImportBadRequestError";
+  }
+  static code = "DOCKER_IMPORT_BAD_REQUEST";
+  static statusCode = 400;
+  static description = `Bad request: {message}`;
+}
+class ForkVmNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `FORK_VM_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ForkVmNotFoundError";
+  }
+  static code = "FORK_VM_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Fork VM not found: {fork_vm_id}`;
+}
+class CreateSnapshotBadRequestError extends Error {
+  constructor(body) {
+    super(
+      `CREATE_SNAPSHOT_BAD_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CreateSnapshotBadRequestError";
+  }
+  static code = "CREATE_SNAPSHOT_BAD_REQUEST";
+  static statusCode = 400;
+  static description = `Bad request: {message}`;
+}
+class SnapshotVmBadRequestError extends Error {
+  constructor(body) {
+    super(
+      `SNAPSHOT_VM_BAD_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "SnapshotVmBadRequestError";
+  }
+  static code = "SNAPSHOT_VM_BAD_REQUEST";
+  static statusCode = 400;
+  static description = `Bad request: {message}`;
+}
+class FileNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `FILE_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FileNotFoundError";
+  }
+  static code = "FILE_NOT_FOUND";
+  static statusCode = 404;
+  static description = `File not found: {path}`;
+}
+class FilesBadRequestError extends Error {
+  constructor(body) {
+    super(
+      `FILES_BAD_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FilesBadRequestError";
+  }
+  static code = "FILES_BAD_REQUEST";
+  static statusCode = 400;
+  static description = `Bad request: {message}`;
+}
+class VmDeletedError extends Error {
+  constructor(body) {
+    super(
+      `VM_DELETED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmDeletedError";
+  }
+  static code = "VM_DELETED";
+  static statusCode = 410;
+  static description = `Cannot start VM: VM files have been deleted. This VM was ephemeral and its files were removed.`;
+}
+class ReqwestError extends Error {
+  constructor(body) {
+    super(
+      `REQWEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ReqwestError";
+  }
+  static code = "REQWEST";
+  static statusCode = 500;
+  static description = `Reqwest error`;
+}
+class FirecrackerPidNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `FIRECRACKER_PID_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FirecrackerPidNotFoundError";
+  }
+  static code = "FIRECRACKER_PID_NOT_FOUND";
+  static statusCode = 500;
+  static description = `Firecracker PID not found`;
+}
+class FirecrackerApiSocketNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `FIRECRACKER_API_SOCKET_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FirecrackerApiSocketNotFoundError";
+  }
+  static code = "FIRECRACKER_API_SOCKET_NOT_FOUND";
+  static statusCode = 500;
+  static description = `Firecracker API socket not found`;
+}
+class VmStartTimeoutError extends Error {
+  constructor(body) {
+    super(
+      `VM_START_TIMEOUT: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmStartTimeoutError";
+  }
+  static code = "VM_START_TIMEOUT";
+  static statusCode = 504;
+  static description = `VM did not become ready within the specified timeout`;
+}
+class VmExitDuringStartError extends Error {
+  constructor(body) {
+    super(
+      `VM_EXIT_DURING_START: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmExitDuringStartError";
+  }
+  static code = "VM_EXIT_DURING_START";
+  static statusCode = 500;
+  static description = `VM process exited unexpectedly during start`;
+}
+class StdIoError extends Error {
+  constructor(body) {
+    super(
+      `STD_IO: ${body.message}`
+    );
+    this.body = body;
+    this.name = "StdIoError";
+  }
+  static code = "STD_IO";
+  static statusCode = 500;
+  static description = `Standard IO error`;
+}
+class VmCreateTmuxSessionError extends Error {
+  constructor(body) {
+    super(
+      `VM_CREATE_TMUX_SESSION: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmCreateTmuxSessionError";
+  }
+  static code = "VM_CREATE_TMUX_SESSION";
+  static statusCode = 500;
+  static description = `Failed to create tmux session for VM`;
+}
+class VmSubnetNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `VM_SUBNET_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmSubnetNotFoundError";
+  }
+  static code = "VM_SUBNET_NOT_FOUND";
+  static statusCode = 500;
+  static description = `Subnet for VM not found`;
+}
+class VmOperationDeniedDuringTransactionError extends Error {
+  constructor(body) {
+    super(
+      `VM_OPERATION_DENIED_DURING_TRANSACTION: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmOperationDeniedDuringTransactionError";
+  }
+  static code = "VM_OPERATION_DENIED_DURING_TRANSACTION";
+  static statusCode = 409;
+  static description = `VM operation denied during active transaction for VM {vm_id} in transaction {transaction_id}`;
+}
+class VmTransactionIdMismatchError extends Error {
+  constructor(body) {
+    super(
+      `VM_TRANSACTION_ID_MISMATCH: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmTransactionIdMismatchError";
+  }
+  static code = "VM_TRANSACTION_ID_MISMATCH";
+  static statusCode = 400;
+  static description = `Transaction ID {provided_transaction_id} does not match the current VM transaction {expected_transaction_id} for VM {vm_id}`;
+}
+class VmNotInTransactionError extends Error {
+  constructor(body) {
+    super(
+      `VM_NOT_IN_TRANSACTION: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmNotInTransactionError";
+  }
+  static code = "VM_NOT_IN_TRANSACTION";
+  static statusCode = 404;
+  static description = `VM not in a transaction: {vm_id}`;
+}
+class CreateVmBadRequestError extends Error {
+  constructor(body) {
+    super(
+      `CREATE_VM_BAD_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CreateVmBadRequestError";
+  }
+  static code = "CREATE_VM_BAD_REQUEST";
+  static statusCode = 400;
+  static description = `Bad request: {message}`;
+}
+class UserNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `USER_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UserNotFoundError";
+  }
+  static code = "USER_NOT_FOUND";
+  static statusCode = 404;
+  static description = `User not found: {user_name}`;
+}
+class UserAlreadyExistsError extends Error {
+  constructor(body) {
+    super(
+      `USER_ALREADY_EXISTS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UserAlreadyExistsError";
+  }
+  static code = "USER_ALREADY_EXISTS";
+  static statusCode = 409;
+  static description = `Conflict: User '{user_name}' already exists`;
+}
+class ValidationErrorError extends Error {
+  constructor(body) {
+    super(
+      `VALIDATION_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ValidationErrorError";
+  }
+  static code = "VALIDATION_ERROR";
+  static statusCode = 400;
+  static description = `Validation error: {message}`;
+}
+class GroupNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `GROUP_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GroupNotFoundError";
+  }
+  static code = "GROUP_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Group not found: {group_name}`;
+}
+class GroupAlreadyExistsError extends Error {
+  constructor(body) {
+    super(
+      `GROUP_ALREADY_EXISTS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GroupAlreadyExistsError";
+  }
+  static code = "GROUP_ALREADY_EXISTS";
+  static statusCode = 409;
+  static description = `Conflict: Group '{group_name}' already exists`;
+}
+class DuplicateUserNameError extends Error {
+  constructor(body) {
+    super(
+      `DUPLICATE_USER_NAME: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DuplicateUserNameError";
+  }
+  static code = "DUPLICATE_USER_NAME";
+  static statusCode = 400;
+  static description = `Duplicate user name '{name}' found`;
+}
+class UserGroupEmptyError extends Error {
+  constructor(body) {
+    super(
+      `USER_GROUP_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UserGroupEmptyError";
+  }
+  static code = "USER_GROUP_EMPTY";
+  static statusCode = 400;
+  static description = `User '{user}' has empty string in groups`;
+}
+class UserSystemFlagMismatchError extends Error {
+  constructor(body) {
+    super(
+      `USER_SYSTEM_FLAG_MISMATCH: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UserSystemFlagMismatchError";
+  }
+  static code = "USER_SYSTEM_FLAG_MISMATCH";
+  static statusCode = 400;
+  static description = `User '{user}' has system=true but UID {uid} is > 999 (system range)`;
+}
+class UserUidOutOfRangeError extends Error {
+  constructor(body) {
+    super(
+      `USER_UID_OUT_OF_RANGE: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UserUidOutOfRangeError";
+  }
+  static code = "USER_UID_OUT_OF_RANGE";
+  static statusCode = 400;
+  static description = `User '{user}' has invalid UID {uid} (must be 0-65535)`;
+}
+class UserHomeInvalidError extends Error {
+  constructor(body) {
+    super(
+      `USER_HOME_INVALID: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UserHomeInvalidError";
+  }
+  static code = "USER_HOME_INVALID";
+  static statusCode = 400;
+  static description = `User '{user}' has invalid home path '{home}' (must be absolute path starting with /)`;
+}
+class UserShellInvalidError extends Error {
+  constructor(body) {
+    super(
+      `USER_SHELL_INVALID: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UserShellInvalidError";
+  }
+  static code = "USER_SHELL_INVALID";
+  static statusCode = 400;
+  static description = `User '{user}' has invalid shell path '{shell}' (must be absolute path starting with /)`;
+}
+class DuplicateGroupNameError extends Error {
+  constructor(body) {
+    super(
+      `DUPLICATE_GROUP_NAME: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DuplicateGroupNameError";
+  }
+  static code = "DUPLICATE_GROUP_NAME";
+  static statusCode = 400;
+  static description = `Duplicate group name '{name}' found`;
+}
+class GroupNameReservedError extends Error {
+  constructor(body) {
+    super(
+      `GROUP_NAME_RESERVED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GroupNameReservedError";
+  }
+  static code = "GROUP_NAME_RESERVED";
+  static statusCode = 400;
+  static description = `Group name '{name}' is reserved and cannot be used`;
+}
+class GroupNameInvalidCharsError extends Error {
+  constructor(body) {
+    super(
+      `GROUP_NAME_INVALID_CHARS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GroupNameInvalidCharsError";
+  }
+  static code = "GROUP_NAME_INVALID_CHARS";
+  static statusCode = 400;
+  static description = `Group name '{name}' contains invalid characters (must match [a-z_][a-z0-9_-]*)`;
+}
+class GroupNameTooLongError extends Error {
+  constructor(body) {
+    super(
+      `GROUP_NAME_TOO_LONG: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GroupNameTooLongError";
+  }
+  static code = "GROUP_NAME_TOO_LONG";
+  static statusCode = 400;
+  static description = `Group name '{name}' is too long (max {max_length} characters)`;
+}
+class GroupNameEmptyError extends Error {
+  constructor(body) {
+    super(
+      `GROUP_NAME_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GroupNameEmptyError";
+  }
+  static code = "GROUP_NAME_EMPTY";
+  static statusCode = 400;
+  static description = `Group name cannot be empty`;
+}
+class WantedByEmptyError extends Error {
+  constructor(body) {
+    super(
+      `WANTED_BY_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "WantedByEmptyError";
+  }
+  static code = "WANTED_BY_EMPTY";
+  static statusCode = 400;
+  static description = `wanted_by cannot be empty if provided`;
+}
+class WorkdirEmptyError extends Error {
+  constructor(body) {
+    super(
+      `WORKDIR_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "WorkdirEmptyError";
+  }
+  static code = "WORKDIR_EMPTY";
+  static statusCode = 400;
+  static description = `Working directory cannot be empty if provided`;
+}
+class GroupEmptyError extends Error {
+  constructor(body) {
+    super(
+      `GROUP_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GroupEmptyError";
+  }
+  static code = "GROUP_EMPTY";
+  static statusCode = 400;
+  static description = `Group cannot be empty if provided`;
+}
+class UserEmptyError extends Error {
+  constructor(body) {
+    super(
+      `USER_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UserEmptyError";
+  }
+  static code = "USER_EMPTY";
+  static statusCode = 400;
+  static description = `User cannot be empty if provided`;
+}
+class OnFailureArrayContainsEmptyError extends Error {
+  constructor(body) {
+    super(
+      `ON_FAILURE_ARRAY_CONTAINS_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "OnFailureArrayContainsEmptyError";
+  }
+  static code = "ON_FAILURE_ARRAY_CONTAINS_EMPTY";
+  static statusCode = 400;
+  static description = `'onFailure' array cannot contain empty strings`;
+}
+class RequiresArrayContainsEmptyError extends Error {
+  constructor(body) {
+    super(
+      `REQUIRES_ARRAY_CONTAINS_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RequiresArrayContainsEmptyError";
+  }
+  static code = "REQUIRES_ARRAY_CONTAINS_EMPTY";
+  static statusCode = 400;
+  static description = `'requires' array cannot contain empty strings`;
+}
+class AfterArrayContainsEmptyError extends Error {
+  constructor(body) {
+    super(
+      `AFTER_ARRAY_CONTAINS_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "AfterArrayContainsEmptyError";
+  }
+  static code = "AFTER_ARRAY_CONTAINS_EMPTY";
+  static statusCode = 400;
+  static description = `'after' array cannot contain empty strings`;
+}
+class EnvKeyContainsEqualsError extends Error {
+  constructor(body) {
+    super(
+      `ENV_KEY_CONTAINS_EQUALS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "EnvKeyContainsEqualsError";
+  }
+  static code = "ENV_KEY_CONTAINS_EQUALS";
+  static statusCode = 400;
+  static description = `Environment variable key '{key}' cannot contain '='`;
+}
+class EnvKeyEmptyError extends Error {
+  constructor(body) {
+    super(
+      `ENV_KEY_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "EnvKeyEmptyError";
+  }
+  static code = "ENV_KEY_EMPTY";
+  static statusCode = 400;
+  static description = `Environment variable key cannot be empty`;
+}
+class ExecEmptyError extends Error {
+  constructor(body) {
+    super(
+      `EXEC_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ExecEmptyError";
+  }
+  static code = "EXEC_EMPTY";
+  static statusCode = 400;
+  static description = `Executable path (exec) cannot be empty`;
+}
+class ServiceNameTooLongError extends Error {
+  constructor(body) {
+    super(
+      `SERVICE_NAME_TOO_LONG: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ServiceNameTooLongError";
+  }
+  static code = "SERVICE_NAME_TOO_LONG";
+  static statusCode = 400;
+  static description = `Service name '{name}' is too long (max {max_length} characters)`;
+}
+class ServiceNameInvalidPrefixError extends Error {
+  constructor(body) {
+    super(
+      `SERVICE_NAME_INVALID_PREFIX: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ServiceNameInvalidPrefixError";
+  }
+  static code = "SERVICE_NAME_INVALID_PREFIX";
+  static statusCode = 400;
+  static description = `Service name '{name}' cannot start with '.' or '-'`;
+}
+class ServiceNameInvalidCharsError extends Error {
+  constructor(body) {
+    super(
+      `SERVICE_NAME_INVALID_CHARS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ServiceNameInvalidCharsError";
+  }
+  static code = "SERVICE_NAME_INVALID_CHARS";
+  static statusCode = 400;
+  static description = `Service name '{name}' contains invalid characters (/ or null)`;
+}
+class ServiceNameEmptyError extends Error {
+  constructor(body) {
+    super(
+      `SERVICE_NAME_EMPTY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ServiceNameEmptyError";
+  }
+  static code = "SERVICE_NAME_EMPTY";
+  static statusCode = 400;
+  static description = `Service name cannot be empty`;
+}
+class ServiceAlreadyExistsError extends Error {
+  constructor(body) {
+    super(
+      `SERVICE_ALREADY_EXISTS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ServiceAlreadyExistsError";
+  }
+  static code = "SERVICE_ALREADY_EXISTS";
+  static statusCode = 409;
+  static description = `Service '{service_name}' already exists`;
+}
+class ServiceNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `SERVICE_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ServiceNotFoundError";
+  }
+  static code = "SERVICE_NOT_FOUND";
+  static statusCode = 404;
+  static description = `null`;
+}
+class InternalError extends Error {
+  constructor(body) {
+    super(
+      `INTERNAL: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InternalError";
+  }
+  static code = "INTERNAL";
+  static statusCode = 500;
+  static description = `Internal error: {0}`;
+}
+class SigningError extends Error {
+  constructor(body) {
+    super(
+      `SIGNING: ${body.message}`
+    );
+    this.body = body;
+    this.name = "SigningError";
+  }
+  static code = "SIGNING";
+  static statusCode = 500;
+  static description = `Signing error`;
+}
+class InvalidSignatureError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_SIGNATURE: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidSignatureError";
+  }
+  static code = "INVALID_SIGNATURE";
+  static statusCode = 403;
+  static description = `Invalid signature`;
+}
+class InvalidParametersError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_PARAMETERS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidParametersError";
+  }
+  static code = "INVALID_PARAMETERS";
+  static statusCode = 400;
+  static description = `Invalid parameters`;
+}
+class MaxUsesExceededError extends Error {
+  constructor(body) {
+    super(
+      `MAX_USES_EXCEEDED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "MaxUsesExceededError";
+  }
+  static code = "MAX_USES_EXCEEDED";
+  static statusCode = 403;
+  static description = `Session maximum uses exceeded`;
+}
+class ExpiredError extends Error {
+  constructor(body) {
+    super(
+      `EXPIRED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ExpiredError";
+  }
+  static code = "EXPIRED";
+  static statusCode = 403;
+  static description = `Session has expired`;
+}
+class ConflictError extends Error {
+  constructor(body) {
+    super(
+      `CONFLICT: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ConflictError";
+  }
+  static code = "CONFLICT";
+  static statusCode = 409;
+  static description = `Sync conflict: {message}`;
+}
+class RepoNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `REPO_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RepoNotFoundError";
+  }
+  static code = "REPO_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Repository not found`;
+}
+class ForbiddenError extends Error {
+  constructor(body) {
+    super(
+      `FORBIDDEN: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ForbiddenError";
+  }
+  static code = "FORBIDDEN";
+  static statusCode = 403;
+  static description = `Forbidden: {message}`;
+}
+class UnsupportedTransferError extends Error {
+  constructor(body) {
+    super(
+      `UNSUPPORTED_TRANSFER: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UnsupportedTransferError";
+  }
+  static code = "UNSUPPORTED_TRANSFER";
+  static statusCode = 400;
+  static description = `Unsupported LFS transfer protocol(s)`;
+}
+class BranchNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `BRANCH_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "BranchNotFoundError";
+  }
+  static code = "BRANCH_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Branch not found: {branch}`;
+}
+class InvalidObjectIdError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_OBJECT_ID: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidObjectIdError";
+  }
+  static code = "INVALID_OBJECT_ID";
+  static statusCode = 400;
+  static description = `Invalid object ID`;
+}
+class BlobNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `BLOB_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "BlobNotFoundError";
+  }
+  static code = "BLOB_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Blob not found: {hash}`;
+}
+class ReferenceNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `REFERENCE_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ReferenceNotFoundError";
+  }
+  static code = "REFERENCE_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Reference not found: {reference}`;
+}
+class TagNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `TAG_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "TagNotFoundError";
+  }
+  static code = "TAG_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Tag not found: {tag}`;
+}
+class CommitNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `COMMIT_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CommitNotFoundError";
+  }
+  static code = "COMMIT_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Commit not found: {hash}`;
+}
+class InvalidRequestError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidRequestError";
+  }
+  static code = "INVALID_REQUEST";
+  static statusCode = 400;
+  static description = `Invalid request: {message}`;
+}
+class PathNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `PATH_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "PathNotFoundError";
+  }
+  static code = "PATH_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Path not found: {path}`;
+}
+class InvalidRevisionError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_REVISION: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidRevisionError";
+  }
+  static code = "INVALID_REVISION";
+  static statusCode = 400;
+  static description = `null`;
+}
+class UnauthorizedError extends Error {
+  constructor(body) {
+    super(
+      `UNAUTHORIZED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UnauthorizedError";
+  }
+  static code = "UNAUTHORIZED";
+  static statusCode = 401;
+  static description = `Unauthorized`;
+}
+class TreeNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `TREE_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "TreeNotFoundError";
+  }
+  static code = "TREE_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Tree not found: {hash}`;
+}
+class BuildFailedError extends Error {
+  constructor(body) {
+    super(
+      `BUILD_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "BuildFailedError";
+  }
+  static code = "BUILD_FAILED";
+  static statusCode = 500;
+  static description = `Build failed on VM {vm_id}`;
+}
+class NoEntrypointFoundError extends Error {
+  constructor(body) {
+    super(
+      `NO_ENTRYPOINT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "NoEntrypointFoundError";
+  }
+  static code = "NO_ENTRYPOINT_FOUND";
+  static statusCode = 400;
+  static description = `No entrypoint found in deployment`;
+}
+class EntrypointNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `ENTRYPOINT_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "EntrypointNotFoundError";
+  }
+  static code = "ENTRYPOINT_NOT_FOUND";
+  static statusCode = 400;
+  static description = `Entrypoint not found: {entrypoint}`;
+}
+class NoDomainOwnershipError extends Error {
+  constructor(body) {
+    super(
+      `NO_DOMAIN_OWNERSHIP: ${body.message}`
+    );
+    this.body = body;
+    this.name = "NoDomainOwnershipError";
+  }
+  static code = "NO_DOMAIN_OWNERSHIP";
+  static statusCode = 403;
+  static description = `No domain ownership for: {domain}`;
+}
+class InvalidDomainsError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_DOMAINS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidDomainsError";
+  }
+  static code = "INVALID_DOMAINS";
+  static statusCode = 400;
+  static description = `Invalid domains provided`;
+}
+class WebDeploymentBadRequestError extends Error {
+  constructor(body) {
+    super(
+      `WEB_DEPLOYMENT_BAD_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "WebDeploymentBadRequestError";
+  }
+  static code = "WEB_DEPLOYMENT_BAD_REQUEST";
+  static statusCode = 400;
+  static description = `Bad request: {message}`;
+}
+class DeploymentNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `DEPLOYMENT_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DeploymentNotFoundError";
+  }
+  static code = "DEPLOYMENT_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Deployment not found`;
+}
+class DatabaseErrorError extends Error {
+  constructor(body) {
+    super(
+      `DATABASE_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DatabaseErrorError";
+  }
+  static code = "DATABASE_ERROR";
+  static statusCode = 500;
+  static description = `Database operation failed: {message}`;
+}
+class TriggerErrorError extends Error {
+  constructor(body) {
+    super(
+      `TRIGGER_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "TriggerErrorError";
+  }
+  static code = "TRIGGER_ERROR";
+  static statusCode = 500;
+  static description = `Failed to manage triggers: {message}`;
+}
+class TokenErrorError extends Error {
+  constructor(body) {
+    super(
+      `TOKEN_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "TokenErrorError";
+  }
+  static code = "TOKEN_ERROR";
+  static statusCode = 500;
+  static description = `Failed to manage tokens: {message}`;
+}
+class PermissionErrorError extends Error {
+  constructor(body) {
+    super(
+      `PERMISSION_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "PermissionErrorError";
+  }
+  static code = "PERMISSION_ERROR";
+  static statusCode = 500;
+  static description = `Failed to manage permissions: {message}`;
+}
+class IdentityErrorError extends Error {
+  constructor(body) {
+    super(
+      `IDENTITY_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "IdentityErrorError";
+  }
+  static code = "IDENTITY_ERROR";
+  static statusCode = 500;
+  static description = `Failed to manage identity: {message}`;
+}
+class GetContentFailedError extends Error {
+  constructor(body) {
+    super(
+      `GET_CONTENT_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GetContentFailedError";
+  }
+  static code = "GET_CONTENT_FAILED";
+  static statusCode = 500;
+  static description = `Failed to get content: {message}`;
+}
+class ContentNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `CONTENT_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ContentNotFoundError";
+  }
+  static code = "CONTENT_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Content not found: {path}`;
+}
+class DownloadFailedError extends Error {
+  constructor(body) {
+    super(
+      `DOWNLOAD_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DownloadFailedError";
+  }
+  static code = "DOWNLOAD_FAILED";
+  static statusCode = 500;
+  static description = `Failed to download repository: {message}`;
+}
+class GitServerErrorError extends Error {
+  constructor(body) {
+    super(
+      `GIT_SERVER_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GitServerErrorError";
+  }
+  static code = "GIT_SERVER_ERROR";
+  static statusCode = 500;
+  static description = `Git server error: {message}`;
+}
+class ParseResponseErrorError extends Error {
+  constructor(body) {
+    super(
+      `PARSE_RESPONSE_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ParseResponseErrorError";
+  }
+  static code = "PARSE_RESPONSE_ERROR";
+  static statusCode = 500;
+  static description = `Failed to parse response from Git server: {message}`;
+}
+class RepositoryAccessDeniedError extends Error {
+  constructor(body) {
+    super(
+      `REPOSITORY_ACCESS_DENIED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RepositoryAccessDeniedError";
+  }
+  static code = "REPOSITORY_ACCESS_DENIED";
+  static statusCode = 403;
+  static description = `Repository does not belong to account`;
+}
+class GitHubSyncFailedError extends Error {
+  constructor(body) {
+    super(
+      `GIT_HUB_SYNC_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GitHubSyncFailedError";
+  }
+  static code = "GIT_HUB_SYNC_FAILED";
+  static statusCode = 500;
+  static description = `Failed to configure GitHub sync: {message}`;
+}
+class UpdateDefaultBranchFailedError extends Error {
+  constructor(body) {
+    super(
+      `UPDATE_DEFAULT_BRANCH_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UpdateDefaultBranchFailedError";
+  }
+  static code = "UPDATE_DEFAULT_BRANCH_FAILED";
+  static statusCode = 500;
+  static description = `Failed to update default branch: {message}`;
+}
+class GetRepositoryInfoFailedError extends Error {
+  constructor(body) {
+    super(
+      `GET_REPOSITORY_INFO_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GetRepositoryInfoFailedError";
+  }
+  static code = "GET_REPOSITORY_INFO_FAILED";
+  static statusCode = 500;
+  static description = `Failed to get repository info: {message}`;
+}
+class ListRepositoriesFailedError extends Error {
+  constructor(body) {
+    super(
+      `LIST_REPOSITORIES_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ListRepositoriesFailedError";
+  }
+  static code = "LIST_REPOSITORIES_FAILED";
+  static statusCode = 500;
+  static description = `Failed to list repositories: {message}`;
+}
+class DeleteRepositoryFailedError extends Error {
+  constructor(body) {
+    super(
+      `DELETE_REPOSITORY_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DeleteRepositoryFailedError";
+  }
+  static code = "DELETE_REPOSITORY_FAILED";
+  static statusCode = 500;
+  static description = `Failed to delete repository: {message}`;
+}
+class CreateRepositoryFailedError extends Error {
+  constructor(body) {
+    super(
+      `CREATE_REPOSITORY_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CreateRepositoryFailedError";
+  }
+  static code = "CREATE_REPOSITORY_FAILED";
+  static statusCode = 500;
+  static description = `Failed to create repository: {message}`;
+}
+class SerializationErrorError extends Error {
+  constructor(body) {
+    super(
+      `SERIALIZATION_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "SerializationErrorError";
+  }
+  static code = "SERIALIZATION_ERROR";
+  static statusCode = 400;
+  static description = `Failed to serialize request: {message}`;
+}
+class GitInvalidRequestError extends Error {
+  constructor(body) {
+    super(
+      `GIT_INVALID_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GitInvalidRequestError";
+  }
+  static code = "GIT_INVALID_REQUEST";
+  static statusCode = 400;
+  static description = `Invalid request: {message}`;
+}
+class RepositoryNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `REPOSITORY_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RepositoryNotFoundError";
+  }
+  static code = "REPOSITORY_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Repository not found: {repo_id}`;
+}
+class FailedToProvisionCertificateError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_PROVISION_CERTIFICATE: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToProvisionCertificateError";
+  }
+  static code = "FAILED_TO_PROVISION_CERTIFICATE";
+  static statusCode = 422;
+  static description = `Failed to provision certificate: {message}`;
+}
+class FailedToInsertDomainMappingError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_INSERT_DOMAIN_MAPPING: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToInsertDomainMappingError";
+  }
+  static code = "FAILED_TO_INSERT_DOMAIN_MAPPING";
+  static statusCode = 500;
+  static description = `Failed to insert domain mapping: {message}`;
+}
+class PermissionDeniedError extends Error {
+  constructor(body) {
+    super(
+      `PERMISSION_DENIED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "PermissionDeniedError";
+  }
+  static code = "PERMISSION_DENIED";
+  static statusCode = 401;
+  static description = `Permission denied: {message}`;
+}
+class FailedToCheckPermissionsError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_CHECK_PERMISSIONS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToCheckPermissionsError";
+  }
+  static code = "FAILED_TO_CHECK_PERMISSIONS";
+  static statusCode = 502;
+  static description = `Failed to check permissions: {message}`;
+}
+class FailedToListDomainsError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_LIST_DOMAINS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToListDomainsError";
+  }
+  static code = "FAILED_TO_LIST_DOMAINS";
+  static statusCode = 500;
+  static description = `Failed to list domains: {message}`;
+}
+class FailedToListVerificationsError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_LIST_VERIFICATIONS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToListVerificationsError";
+  }
+  static code = "FAILED_TO_LIST_VERIFICATIONS";
+  static statusCode = 500;
+  static description = `Failed to list verifications: {message}`;
+}
+class FailedToVerifyDomainError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_VERIFY_DOMAIN: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToVerifyDomainError";
+  }
+  static code = "FAILED_TO_VERIFY_DOMAIN";
+  static statusCode = 500;
+  static description = `Failed to verify domain: {message}`;
+}
+class VerificationFailedError extends Error {
+  constructor(body) {
+    super(
+      `VERIFICATION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VerificationFailedError";
+  }
+  static code = "VERIFICATION_FAILED";
+  static statusCode = 400;
+  static description = `Domain verification failed: {message}`;
+}
+class FailedToDeleteVerificationError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_DELETE_VERIFICATION: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToDeleteVerificationError";
+  }
+  static code = "FAILED_TO_DELETE_VERIFICATION";
+  static statusCode = 400;
+  static description = `Failed to delete verification: {message}`;
+}
+class VerificationNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `VERIFICATION_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VerificationNotFoundError";
+  }
+  static code = "VERIFICATION_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Verification request not found for domain: {domain}`;
+}
+class FailedToCreateVerificationCodeError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_CREATE_VERIFICATION_CODE: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToCreateVerificationCodeError";
+  }
+  static code = "FAILED_TO_CREATE_VERIFICATION_CODE";
+  static statusCode = 400;
+  static description = `Failed to create verification code: {message}`;
+}
+class InvalidDomainError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_DOMAIN: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidDomainError";
+  }
+  static code = "INVALID_DOMAIN";
+  static statusCode = 400;
+  static description = `Invalid domain: {domain}`;
+}
+class DomainAlreadyExistsError extends Error {
+  constructor(body) {
+    super(
+      `DOMAIN_ALREADY_EXISTS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DomainAlreadyExistsError";
+  }
+  static code = "DOMAIN_ALREADY_EXISTS";
+  static statusCode = 400;
+  static description = `Domain already exists: {domain}`;
+}
+class FailedToInsertOwnershipError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_INSERT_OWNERSHIP: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToInsertOwnershipError";
+  }
+  static code = "FAILED_TO_INSERT_OWNERSHIP";
+  static statusCode = 500;
+  static description = `Failed to insert domain ownership: {message}`;
+}
+class FailedRemoveDomainMappingError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_REMOVE_DOMAIN_MAPPING: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedRemoveDomainMappingError";
+  }
+  static code = "FAILED_REMOVE_DOMAIN_MAPPING";
+  static statusCode = 500;
+  static description = `Failed to remove domain mapping: {message}`;
+}
+class FailedPermissionsCheckError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_PERMISSIONS_CHECK: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedPermissionsCheckError";
+  }
+  static code = "FAILED_PERMISSIONS_CHECK";
+  static statusCode = 401;
+  static description = `You do not have permission to delete the domain mapping for: {domain}`;
+}
+class FailedToCheckDomainMappingPermissionsError extends Error {
+  constructor(body) {
+    super(
+      `FAILED_TO_CHECK_DOMAIN_MAPPING_PERMISSIONS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "FailedToCheckDomainMappingPermissionsError";
+  }
+  static code = "FAILED_TO_CHECK_DOMAIN_MAPPING_PERMISSIONS";
+  static statusCode = 502;
+  static description = `Failed to check permissions: {message}`;
+}
+class AnyhowError extends Error {
+  constructor(body) {
+    super(
+      `ANYHOW: ${body.message}`
+    );
+    this.body = body;
+    this.name = "AnyhowError";
+  }
+  static code = "ANYHOW";
+  static statusCode = 500;
+  static description = `null`;
+}
+class ObservabilityDatabaseErrorError extends Error {
+  constructor(body) {
+    super(
+      `OBSERVABILITY_DATABASE_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ObservabilityDatabaseErrorError";
+  }
+  static code = "OBSERVABILITY_DATABASE_ERROR";
+  static statusCode = 500;
+  static description = `Database operation failed: {message}`;
+}
+class ObservabilityAccessDeniedError extends Error {
+  constructor(body) {
+    super(
+      `OBSERVABILITY_ACCESS_DENIED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ObservabilityAccessDeniedError";
+  }
+  static code = "OBSERVABILITY_ACCESS_DENIED";
+  static statusCode = 403;
+  static description = `Access denied to logs for deployment: {deployment_id}`;
+}
+class ParseLogsFailedError extends Error {
+  constructor(body) {
+    super(
+      `PARSE_LOGS_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ParseLogsFailedError";
+  }
+  static code = "PARSE_LOGS_FAILED";
+  static statusCode = 500;
+  static description = `Failed to parse logs: {message}`;
+}
+class RetrieveLogsFailedError extends Error {
+  constructor(body) {
+    super(
+      `RETRIEVE_LOGS_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RetrieveLogsFailedError";
+  }
+  static code = "RETRIEVE_LOGS_FAILED";
+  static statusCode = 500;
+  static description = `Failed to retrieve logs: {message}`;
+}
+class InvalidQueryError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_QUERY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidQueryError";
+  }
+  static code = "INVALID_QUERY";
+  static statusCode = 400;
+  static description = `Invalid log query: {message}`;
+}
+class LogsNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `LOGS_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "LogsNotFoundError";
+  }
+  static code = "LOGS_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Logs not found for deployment: {deployment_id}`;
+}
+class PermissionAlreadyExistsError extends Error {
+  constructor(body) {
+    super(
+      `PERMISSION_ALREADY_EXISTS: ${body.message}`
+    );
+    this.body = body;
+    this.name = "PermissionAlreadyExistsError";
+  }
+  static code = "PERMISSION_ALREADY_EXISTS";
+  static statusCode = 409;
+  static description = `Permission already exists`;
+}
+class ListTokensFailedError extends Error {
+  constructor(body) {
+    super(
+      `LIST_TOKENS_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ListTokensFailedError";
+  }
+  static code = "LIST_TOKENS_FAILED";
+  static statusCode = 500;
+  static description = `Failed to list tokens: {message}`;
+}
+class RevokeTokenFailedError extends Error {
+  constructor(body) {
+    super(
+      `REVOKE_TOKEN_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RevokeTokenFailedError";
+  }
+  static code = "REVOKE_TOKEN_FAILED";
+  static statusCode = 500;
+  static description = `Failed to revoke token: {message}`;
+}
+class CreateTokenFailedError extends Error {
+  constructor(body) {
+    super(
+      `CREATE_TOKEN_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CreateTokenFailedError";
+  }
+  static code = "CREATE_TOKEN_FAILED";
+  static statusCode = 500;
+  static description = `Failed to create token: {message}`;
+}
+class ListPermissionsFailedError extends Error {
+  constructor(body) {
+    super(
+      `LIST_PERMISSIONS_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ListPermissionsFailedError";
+  }
+  static code = "LIST_PERMISSIONS_FAILED";
+  static statusCode = 500;
+  static description = `Failed to list permissions: {message}`;
+}
+class GetPermissionFailedError extends Error {
+  constructor(body) {
+    super(
+      `GET_PERMISSION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GetPermissionFailedError";
+  }
+  static code = "GET_PERMISSION_FAILED";
+  static statusCode = 500;
+  static description = `Failed to get permission: {message}`;
+}
+class UpdatePermissionFailedError extends Error {
+  constructor(body) {
+    super(
+      `UPDATE_PERMISSION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "UpdatePermissionFailedError";
+  }
+  static code = "UPDATE_PERMISSION_FAILED";
+  static statusCode = 500;
+  static description = `Failed to update permission: {message}`;
+}
+class RevokePermissionFailedError extends Error {
+  constructor(body) {
+    super(
+      `REVOKE_PERMISSION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RevokePermissionFailedError";
+  }
+  static code = "REVOKE_PERMISSION_FAILED";
+  static statusCode = 500;
+  static description = `Failed to revoke permission: {message}`;
+}
+class GrantPermissionFailedError extends Error {
+  constructor(body) {
+    super(
+      `GRANT_PERMISSION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GrantPermissionFailedError";
+  }
+  static code = "GRANT_PERMISSION_FAILED";
+  static statusCode = 500;
+  static description = `Failed to grant permission: {message}`;
+}
+class ListIdentitiesFailedError extends Error {
+  constructor(body) {
+    super(
+      `LIST_IDENTITIES_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ListIdentitiesFailedError";
+  }
+  static code = "LIST_IDENTITIES_FAILED";
+  static statusCode = 500;
+  static description = `Failed to list identities: {message}`;
+}
+class DeleteIdentityFailedError extends Error {
+  constructor(body) {
+    super(
+      `DELETE_IDENTITY_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DeleteIdentityFailedError";
+  }
+  static code = "DELETE_IDENTITY_FAILED";
+  static statusCode = 500;
+  static description = `Failed to delete identity: {message}`;
+}
+class CreateIdentityFailedError extends Error {
+  constructor(body) {
+    super(
+      `CREATE_IDENTITY_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CreateIdentityFailedError";
+  }
+  static code = "CREATE_IDENTITY_FAILED";
+  static statusCode = 500;
+  static description = `Failed to create identity: {message}`;
+}
+class VmPermissionNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `VM_PERMISSION_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmPermissionNotFoundError";
+  }
+  static code = "VM_PERMISSION_NOT_FOUND";
+  static statusCode = 404;
+  static description = `VM permission not found`;
+}
+class PermissionNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `PERMISSION_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "PermissionNotFoundError";
+  }
+  static code = "PERMISSION_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Permission not found`;
+}
+class VmAccessDeniedError extends Error {
+  constructor(body) {
+    super(
+      `VM_ACCESS_DENIED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "VmAccessDeniedError";
+  }
+  static code = "VM_ACCESS_DENIED";
+  static statusCode = 403;
+  static description = `You are not allowed to access this VM`;
+}
+class GitRepositoryAccessDeniedError extends Error {
+  constructor(body) {
+    super(
+      `GIT_REPOSITORY_ACCESS_DENIED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GitRepositoryAccessDeniedError";
+  }
+  static code = "GIT_REPOSITORY_ACCESS_DENIED";
+  static statusCode = 403;
+  static description = `You are not allowed to access this repository`;
+}
+class GitRepositoryNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `GIT_REPOSITORY_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "GitRepositoryNotFoundError";
+  }
+  static code = "GIT_REPOSITORY_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Repository not found`;
+}
+class CannotDeleteManagedIdentityError extends Error {
+  constructor(body) {
+    super(
+      `CANNOT_DELETE_MANAGED_IDENTITY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CannotDeleteManagedIdentityError";
+  }
+  static code = "CANNOT_DELETE_MANAGED_IDENTITY";
+  static statusCode = 403;
+  static description = `Cannot delete managed identities`;
+}
+class CannotModifyManagedIdentityError extends Error {
+  constructor(body) {
+    super(
+      `CANNOT_MODIFY_MANAGED_IDENTITY: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CannotModifyManagedIdentityError";
+  }
+  static code = "CANNOT_MODIFY_MANAGED_IDENTITY";
+  static statusCode = 403;
+  static description = `Cannot modify managed identities`;
+}
+class IdentityAccessDeniedError extends Error {
+  constructor(body) {
+    super(
+      `IDENTITY_ACCESS_DENIED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "IdentityAccessDeniedError";
+  }
+  static code = "IDENTITY_ACCESS_DENIED";
+  static statusCode = 403;
+  static description = `You are not allowed to access this identity`;
+}
+class IdentityNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `IDENTITY_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "IdentityNotFoundError";
+  }
+  static code = "IDENTITY_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Identity not found`;
+}
+class ExecuteInternalErrorError extends Error {
+  constructor(body) {
+    super(
+      `EXECUTE_INTERNAL_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ExecuteInternalErrorError";
+  }
+  static code = "EXECUTE_INTERNAL_ERROR";
+  static statusCode = 500;
+  static description = `Internal error: {message}`;
+}
+class ExecuteAccessDeniedError extends Error {
+  constructor(body) {
+    super(
+      `EXECUTE_ACCESS_DENIED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ExecuteAccessDeniedError";
+  }
+  static code = "EXECUTE_ACCESS_DENIED";
+  static statusCode = 403;
+  static description = `Access denied to execute run`;
+}
+class ListRunsFailedError extends Error {
+  constructor(body) {
+    super(
+      `LIST_RUNS_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ListRunsFailedError";
+  }
+  static code = "LIST_RUNS_FAILED";
+  static statusCode = 500;
+  static description = `Failed to list execute runs: {message}`;
+}
+class ExecutionErrorError extends Error {
+  constructor(body) {
+    super(
+      `EXECUTION_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ExecutionErrorError";
+  }
+  static code = "EXECUTION_ERROR";
+  static statusCode = 500;
+  static description = `Script execution error: {message}`;
+}
+class ConnectionFailedError extends Error {
+  constructor(body) {
+    super(
+      `CONNECTION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ConnectionFailedError";
+  }
+  static code = "CONNECTION_FAILED";
+  static statusCode = 500;
+  static description = `Failed to connect to execute server: {message}`;
+}
+class MetadataWriteFailedError extends Error {
+  constructor(body) {
+    super(
+      `METADATA_WRITE_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "MetadataWriteFailedError";
+  }
+  static code = "METADATA_WRITE_FAILED";
+  static statusCode = 500;
+  static description = `Failed to write metadata file: {message}`;
+}
+class NodeModulesInstallFailedError extends Error {
+  constructor(body) {
+    super(
+      `NODE_MODULES_INSTALL_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "NodeModulesInstallFailedError";
+  }
+  static code = "NODE_MODULES_INSTALL_FAILED";
+  static statusCode = 500;
+  static description = `Failed to install node modules: {message}`;
+}
+class NodeModulesDownloadFailedError extends Error {
+  constructor(body) {
+    super(
+      `NODE_MODULES_DOWNLOAD_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "NodeModulesDownloadFailedError";
+  }
+  static code = "NODE_MODULES_DOWNLOAD_FAILED";
+  static statusCode = 500;
+  static description = `Failed to download node modules: {message}`;
+}
+class LockGenerationFailedError extends Error {
+  constructor(body) {
+    super(
+      `LOCK_GENERATION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "LockGenerationFailedError";
+  }
+  static code = "LOCK_GENERATION_FAILED";
+  static statusCode = 500;
+  static description = `Failed to generate lock file: {message}`;
+}
+class WriteScriptFailedError extends Error {
+  constructor(body) {
+    super(
+      `WRITE_SCRIPT_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "WriteScriptFailedError";
+  }
+  static code = "WRITE_SCRIPT_FAILED";
+  static statusCode = 500;
+  static description = `Failed to write script file: {message}`;
+}
+class DirectoryCreationFailedError extends Error {
+  constructor(body) {
+    super(
+      `DIRECTORY_CREATION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DirectoryCreationFailedError";
+  }
+  static code = "DIRECTORY_CREATION_FAILED";
+  static statusCode = 500;
+  static description = `Failed to create script directory: {message}`;
+}
+class NetworkPermissionsFailedError extends Error {
+  constructor(body) {
+    super(
+      `NETWORK_PERMISSIONS_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "NetworkPermissionsFailedError";
+  }
+  static code = "NETWORK_PERMISSIONS_FAILED";
+  static statusCode = 500;
+  static description = `Failed to insert network permissions: {message}`;
+}
+class LoggingFailedError extends Error {
+  constructor(body) {
+    super(
+      `LOGGING_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "LoggingFailedError";
+  }
+  static code = "LOGGING_FAILED";
+  static statusCode = 500;
+  static description = `Failed to log execute run: {message}`;
+}
+class RunNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `RUN_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RunNotFoundError";
+  }
+  static code = "RUN_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Execute run not found: {run_id}`;
+}
+class CloudstateInternalErrorError extends Error {
+  constructor(body) {
+    super(
+      `CLOUDSTATE_INTERNAL_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CloudstateInternalErrorError";
+  }
+  static code = "CLOUDSTATE_INTERNAL_ERROR";
+  static statusCode = 500;
+  static description = `Internal error: {message}`;
+}
+class CloudstateDatabaseErrorError extends Error {
+  constructor(body) {
+    super(
+      `CLOUDSTATE_DATABASE_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CloudstateDatabaseErrorError";
+  }
+  static code = "CLOUDSTATE_DATABASE_ERROR";
+  static statusCode = 500;
+  static description = `Database operation failed: {message}`;
+}
+class CloudstateAccessDeniedError extends Error {
+  constructor(body) {
+    super(
+      `CLOUDSTATE_ACCESS_DENIED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CloudstateAccessDeniedError";
+  }
+  static code = "CLOUDSTATE_ACCESS_DENIED";
+  static statusCode = 403;
+  static description = `Access denied to project: {project_id}`;
+}
+class RestoreFailedError extends Error {
+  constructor(body) {
+    super(
+      `RESTORE_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RestoreFailedError";
+  }
+  static code = "RESTORE_FAILED";
+  static statusCode = 500;
+  static description = `Failed to restore from backup: {message}`;
+}
+class CreateBackupFailedError extends Error {
+  constructor(body) {
+    super(
+      `CREATE_BACKUP_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CreateBackupFailedError";
+  }
+  static code = "CREATE_BACKUP_FAILED";
+  static statusCode = 500;
+  static description = `Failed to create backup: {message}`;
+}
+class BackupFailedError extends Error {
+  constructor(body) {
+    super(
+      `BACKUP_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "BackupFailedError";
+  }
+  static code = "BACKUP_FAILED";
+  static statusCode = 500;
+  static description = `Backup failed: {message}`;
+}
+class DeploymentFailedError extends Error {
+  constructor(body) {
+    super(
+      `DEPLOYMENT_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DeploymentFailedError";
+  }
+  static code = "DEPLOYMENT_FAILED";
+  static statusCode = 500;
+  static description = `Deployment failed: {message}`;
+}
+class InvalidDeploymentRequestError extends Error {
+  constructor(body) {
+    super(
+      `INVALID_DEPLOYMENT_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InvalidDeploymentRequestError";
+  }
+  static code = "INVALID_DEPLOYMENT_REQUEST";
+  static statusCode = 400;
+  static description = `Invalid deployment request: {message}`;
+}
+class ProjectNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `PROJECT_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ProjectNotFoundError";
+  }
+  static code = "PROJECT_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Project not found: {project_id}`;
+}
+class ResizeFailedError extends Error {
+  constructor(body) {
+    super(
+      `RESIZE_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ResizeFailedError";
+  }
+  static code = "RESIZE_FAILED";
+  static statusCode = 500;
+  static description = `Failed to resize VM: {message}`;
+}
+class InternalResizeVmNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `INTERNAL_RESIZE_VM_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "InternalResizeVmNotFoundError";
+  }
+  static code = "INTERNAL_RESIZE_VM_NOT_FOUND";
+  static statusCode = 404;
+  static description = `VM not found`;
+}
+class DomainOwnershipVerificationFailedError extends Error {
+  constructor(body) {
+    super(
+      `DOMAIN_OWNERSHIP_VERIFICATION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DomainOwnershipVerificationFailedError";
+  }
+  static code = "DOMAIN_OWNERSHIP_VERIFICATION_FAILED";
+  static statusCode = 403;
+  static description = `Domain ownership verification failed`;
+}
+class ErrorDeletingRecordError extends Error {
+  constructor(body) {
+    super(
+      `ERROR_DELETING_RECORD: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ErrorDeletingRecordError";
+  }
+  static code = "ERROR_DELETING_RECORD";
+  static statusCode = 500;
+  static description = `Error deleting DNS record for {domain}/{name}: {message}`;
+}
+class RecordOwnershipErrorError extends Error {
+  constructor(body) {
+    super(
+      `RECORD_OWNERSHIP_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RecordOwnershipErrorError";
+  }
+  static code = "RECORD_OWNERSHIP_ERROR";
+  static statusCode = 403;
+  static description = `Account {account_id} does not own record {record_id}`;
+}
+class ErrorCreatingRecordError extends Error {
+  constructor(body) {
+    super(
+      `ERROR_CREATING_RECORD: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ErrorCreatingRecordError";
+  }
+  static code = "ERROR_CREATING_RECORD";
+  static statusCode = 500;
+  static description = `Error creating DNS record: {message}`;
+}
+class DomainOwnershipErrorError extends Error {
+  constructor(body) {
+    super(
+      `DOMAIN_OWNERSHIP_ERROR: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DomainOwnershipErrorError";
+  }
+  static code = "DOMAIN_OWNERSHIP_ERROR";
+  static statusCode = 403;
+  static description = `Account {account_id} does not own domain {domain}`;
+}
+class BrowserOperationFailedError extends Error {
+  constructor(body) {
+    super(
+      `BROWSER_OPERATION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "BrowserOperationFailedError";
+  }
+  static code = "BROWSER_OPERATION_FAILED";
+  static statusCode = 500;
+  static description = `Browser operation failed: {message}`;
+}
+class WatchFilesFailedError extends Error {
+  constructor(body) {
+    super(
+      `WATCH_FILES_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "WatchFilesFailedError";
+  }
+  static code = "WATCH_FILES_FAILED";
+  static statusCode = 500;
+  static description = `Failed to watch files: {message}`;
+}
+class LogsFailedError extends Error {
+  constructor(body) {
+    super(
+      `LOGS_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "LogsFailedError";
+  }
+  static code = "LOGS_FAILED";
+  static statusCode = 500;
+  static description = `Failed to get logs: {message}`;
+}
+class StatusFailedError extends Error {
+  constructor(body) {
+    super(
+      `STATUS_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "StatusFailedError";
+  }
+  static code = "STATUS_FAILED";
+  static statusCode = 500;
+  static description = `Failed to get dev server status: {message}`;
+}
+class RestartFailedError extends Error {
+  constructor(body) {
+    super(
+      `RESTART_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RestartFailedError";
+  }
+  static code = "RESTART_FAILED";
+  static statusCode = 500;
+  static description = `Failed to restart dev server: {message}`;
+}
+class ShutdownFailedError extends Error {
+  constructor(body) {
+    super(
+      `SHUTDOWN_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ShutdownFailedError";
+  }
+  static code = "SHUTDOWN_FAILED";
+  static statusCode = 500;
+  static description = `Failed to shutdown dev server: {message}`;
+}
+class CommitFailedError extends Error {
+  constructor(body) {
+    super(
+      `COMMIT_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "CommitFailedError";
+  }
+  static code = "COMMIT_FAILED";
+  static statusCode = 500;
+  static description = `Failed to commit changes: {message}`;
+}
+class WriteFileFailedError extends Error {
+  constructor(body) {
+    super(
+      `WRITE_FILE_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "WriteFileFailedError";
+  }
+  static code = "WRITE_FILE_FAILED";
+  static statusCode = 500;
+  static description = `Failed to write file: {message}`;
+}
+class ReadFileFailedError extends Error {
+  constructor(body) {
+    super(
+      `READ_FILE_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ReadFileFailedError";
+  }
+  static code = "READ_FILE_FAILED";
+  static statusCode = 500;
+  static description = `Failed to read file: {message}`;
+}
+class ExecutionFailedError extends Error {
+  constructor(body) {
+    super(
+      `EXECUTION_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "ExecutionFailedError";
+  }
+  static code = "EXECUTION_FAILED";
+  static statusCode = 500;
+  static description = `Failed to execute command: {message}`;
+}
+class RequestFailedError extends Error {
+  constructor(body) {
+    super(
+      `REQUEST_FAILED: ${body.message}`
+    );
+    this.body = body;
+    this.name = "RequestFailedError";
+  }
+  static code = "REQUEST_FAILED";
+  static statusCode = 500;
+  static description = `Failed to request dev server: {message}`;
+}
+class DevServerFileNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `DEV_SERVER_FILE_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DevServerFileNotFoundError";
+  }
+  static code = "DEV_SERVER_FILE_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Dev server file not found: {path}`;
+}
+class DevServerInvalidRequestError extends Error {
+  constructor(body) {
+    super(
+      `DEV_SERVER_INVALID_REQUEST: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DevServerInvalidRequestError";
+  }
+  static code = "DEV_SERVER_INVALID_REQUEST";
+  static statusCode = 400;
+  static description = `Invalid dev server request: {message}`;
+}
+class DevServerNotFoundError extends Error {
+  constructor(body) {
+    super(
+      `DEV_SERVER_NOT_FOUND: ${body.message}`
+    );
+    this.body = body;
+    this.name = "DevServerNotFoundError";
+  }
+  static code = "DEV_SERVER_NOT_FOUND";
+  static statusCode = 404;
+  static description = `Dev server not found: {server_id}`;
+}
+const FREESTYLE_ERROR_CODE_MAP = {
+  "VM_NOT_FOUND_IN_FS": VmNotFoundInFsError,
+  "VM_NOT_RUNNING": VmNotRunningError,
+  "VM_NOT_FOUND": VmNotFoundError,
+  "INTERNAL_FORK_VM_NOT_FOUND": InternalForkVmNotFoundError,
+  "BAD_REQUEST": BadRequestError,
+  "INTERNAL_VM_NOT_FOUND": InternalVmNotFoundError,
+  "VM_MUST_BE_STOPPED": VmMustBeStoppedError,
+  "ALREADY_HAS_BASE": AlreadyHasBaseError,
+  "NOT_FOUND": NotFoundError,
+  "INTERNAL_ERROR": InternalErrorError,
+  "DOCKER_IMPORT_BAD_REQUEST": DockerImportBadRequestError,
+  "FORK_VM_NOT_FOUND": ForkVmNotFoundError,
+  "CREATE_SNAPSHOT_BAD_REQUEST": CreateSnapshotBadRequestError,
+  "SNAPSHOT_VM_BAD_REQUEST": SnapshotVmBadRequestError,
+  "FILE_NOT_FOUND": FileNotFoundError,
+  "FILES_BAD_REQUEST": FilesBadRequestError,
+  "VM_DELETED": VmDeletedError,
+  "REQWEST": ReqwestError,
+  "FIRECRACKER_PID_NOT_FOUND": FirecrackerPidNotFoundError,
+  "FIRECRACKER_API_SOCKET_NOT_FOUND": FirecrackerApiSocketNotFoundError,
+  "VM_START_TIMEOUT": VmStartTimeoutError,
+  "VM_EXIT_DURING_START": VmExitDuringStartError,
+  "STD_IO": StdIoError,
+  "VM_CREATE_TMUX_SESSION": VmCreateTmuxSessionError,
+  "VM_SUBNET_NOT_FOUND": VmSubnetNotFoundError,
+  "VM_OPERATION_DENIED_DURING_TRANSACTION": VmOperationDeniedDuringTransactionError,
+  "VM_TRANSACTION_ID_MISMATCH": VmTransactionIdMismatchError,
+  "VM_NOT_IN_TRANSACTION": VmNotInTransactionError,
+  "CREATE_VM_BAD_REQUEST": CreateVmBadRequestError,
+  "USER_NOT_FOUND": UserNotFoundError,
+  "USER_ALREADY_EXISTS": UserAlreadyExistsError,
+  "VALIDATION_ERROR": ValidationErrorError,
+  "GROUP_NOT_FOUND": GroupNotFoundError,
+  "GROUP_ALREADY_EXISTS": GroupAlreadyExistsError,
+  "DUPLICATE_USER_NAME": DuplicateUserNameError,
+  "USER_GROUP_EMPTY": UserGroupEmptyError,
+  "USER_SYSTEM_FLAG_MISMATCH": UserSystemFlagMismatchError,
+  "USER_UID_OUT_OF_RANGE": UserUidOutOfRangeError,
+  "USER_HOME_INVALID": UserHomeInvalidError,
+  "USER_SHELL_INVALID": UserShellInvalidError,
+  "DUPLICATE_GROUP_NAME": DuplicateGroupNameError,
+  "GROUP_NAME_RESERVED": GroupNameReservedError,
+  "GROUP_NAME_INVALID_CHARS": GroupNameInvalidCharsError,
+  "GROUP_NAME_TOO_LONG": GroupNameTooLongError,
+  "GROUP_NAME_EMPTY": GroupNameEmptyError,
+  "WANTED_BY_EMPTY": WantedByEmptyError,
+  "WORKDIR_EMPTY": WorkdirEmptyError,
+  "GROUP_EMPTY": GroupEmptyError,
+  "USER_EMPTY": UserEmptyError,
+  "ON_FAILURE_ARRAY_CONTAINS_EMPTY": OnFailureArrayContainsEmptyError,
+  "REQUIRES_ARRAY_CONTAINS_EMPTY": RequiresArrayContainsEmptyError,
+  "AFTER_ARRAY_CONTAINS_EMPTY": AfterArrayContainsEmptyError,
+  "ENV_KEY_CONTAINS_EQUALS": EnvKeyContainsEqualsError,
+  "ENV_KEY_EMPTY": EnvKeyEmptyError,
+  "EXEC_EMPTY": ExecEmptyError,
+  "SERVICE_NAME_TOO_LONG": ServiceNameTooLongError,
+  "SERVICE_NAME_INVALID_PREFIX": ServiceNameInvalidPrefixError,
+  "SERVICE_NAME_INVALID_CHARS": ServiceNameInvalidCharsError,
+  "SERVICE_NAME_EMPTY": ServiceNameEmptyError,
+  "SERVICE_ALREADY_EXISTS": ServiceAlreadyExistsError,
+  "SERVICE_NOT_FOUND": ServiceNotFoundError,
+  "INTERNAL": InternalError,
+  "SIGNING": SigningError,
+  "INVALID_SIGNATURE": InvalidSignatureError,
+  "INVALID_PARAMETERS": InvalidParametersError,
+  "MAX_USES_EXCEEDED": MaxUsesExceededError,
+  "EXPIRED": ExpiredError,
+  "CONFLICT": ConflictError,
+  "REPO_NOT_FOUND": RepoNotFoundError,
+  "FORBIDDEN": ForbiddenError,
+  "UNSUPPORTED_TRANSFER": UnsupportedTransferError,
+  "BRANCH_NOT_FOUND": BranchNotFoundError,
+  "INVALID_OBJECT_ID": InvalidObjectIdError,
+  "BLOB_NOT_FOUND": BlobNotFoundError,
+  "REFERENCE_NOT_FOUND": ReferenceNotFoundError,
+  "TAG_NOT_FOUND": TagNotFoundError,
+  "COMMIT_NOT_FOUND": CommitNotFoundError,
+  "INVALID_REQUEST": InvalidRequestError,
+  "PATH_NOT_FOUND": PathNotFoundError,
+  "INVALID_REVISION": InvalidRevisionError,
+  "UNAUTHORIZED": UnauthorizedError,
+  "TREE_NOT_FOUND": TreeNotFoundError,
+  "BUILD_FAILED": BuildFailedError,
+  "NO_ENTRYPOINT_FOUND": NoEntrypointFoundError,
+  "ENTRYPOINT_NOT_FOUND": EntrypointNotFoundError,
+  "NO_DOMAIN_OWNERSHIP": NoDomainOwnershipError,
+  "INVALID_DOMAINS": InvalidDomainsError,
+  "WEB_DEPLOYMENT_BAD_REQUEST": WebDeploymentBadRequestError,
+  "DEPLOYMENT_NOT_FOUND": DeploymentNotFoundError,
+  "DATABASE_ERROR": DatabaseErrorError,
+  "TRIGGER_ERROR": TriggerErrorError,
+  "TOKEN_ERROR": TokenErrorError,
+  "PERMISSION_ERROR": PermissionErrorError,
+  "IDENTITY_ERROR": IdentityErrorError,
+  "GET_CONTENT_FAILED": GetContentFailedError,
+  "CONTENT_NOT_FOUND": ContentNotFoundError,
+  "DOWNLOAD_FAILED": DownloadFailedError,
+  "GIT_SERVER_ERROR": GitServerErrorError,
+  "PARSE_RESPONSE_ERROR": ParseResponseErrorError,
+  "REPOSITORY_ACCESS_DENIED": RepositoryAccessDeniedError,
+  "GIT_HUB_SYNC_FAILED": GitHubSyncFailedError,
+  "UPDATE_DEFAULT_BRANCH_FAILED": UpdateDefaultBranchFailedError,
+  "GET_REPOSITORY_INFO_FAILED": GetRepositoryInfoFailedError,
+  "LIST_REPOSITORIES_FAILED": ListRepositoriesFailedError,
+  "DELETE_REPOSITORY_FAILED": DeleteRepositoryFailedError,
+  "CREATE_REPOSITORY_FAILED": CreateRepositoryFailedError,
+  "SERIALIZATION_ERROR": SerializationErrorError,
+  "GIT_INVALID_REQUEST": GitInvalidRequestError,
+  "REPOSITORY_NOT_FOUND": RepositoryNotFoundError,
+  "FAILED_TO_PROVISION_CERTIFICATE": FailedToProvisionCertificateError,
+  "FAILED_TO_INSERT_DOMAIN_MAPPING": FailedToInsertDomainMappingError,
+  "PERMISSION_DENIED": PermissionDeniedError,
+  "FAILED_TO_CHECK_PERMISSIONS": FailedToCheckPermissionsError,
+  "FAILED_TO_LIST_DOMAINS": FailedToListDomainsError,
+  "FAILED_TO_LIST_VERIFICATIONS": FailedToListVerificationsError,
+  "FAILED_TO_VERIFY_DOMAIN": FailedToVerifyDomainError,
+  "VERIFICATION_FAILED": VerificationFailedError,
+  "FAILED_TO_DELETE_VERIFICATION": FailedToDeleteVerificationError,
+  "VERIFICATION_NOT_FOUND": VerificationNotFoundError,
+  "FAILED_TO_CREATE_VERIFICATION_CODE": FailedToCreateVerificationCodeError,
+  "INVALID_DOMAIN": InvalidDomainError,
+  "DOMAIN_ALREADY_EXISTS": DomainAlreadyExistsError,
+  "FAILED_TO_INSERT_OWNERSHIP": FailedToInsertOwnershipError,
+  "FAILED_REMOVE_DOMAIN_MAPPING": FailedRemoveDomainMappingError,
+  "FAILED_PERMISSIONS_CHECK": FailedPermissionsCheckError,
+  "FAILED_TO_CHECK_DOMAIN_MAPPING_PERMISSIONS": FailedToCheckDomainMappingPermissionsError,
+  "ANYHOW": AnyhowError,
+  "OBSERVABILITY_DATABASE_ERROR": ObservabilityDatabaseErrorError,
+  "OBSERVABILITY_ACCESS_DENIED": ObservabilityAccessDeniedError,
+  "PARSE_LOGS_FAILED": ParseLogsFailedError,
+  "RETRIEVE_LOGS_FAILED": RetrieveLogsFailedError,
+  "INVALID_QUERY": InvalidQueryError,
+  "LOGS_NOT_FOUND": LogsNotFoundError,
+  "PERMISSION_ALREADY_EXISTS": PermissionAlreadyExistsError,
+  "LIST_TOKENS_FAILED": ListTokensFailedError,
+  "REVOKE_TOKEN_FAILED": RevokeTokenFailedError,
+  "CREATE_TOKEN_FAILED": CreateTokenFailedError,
+  "LIST_PERMISSIONS_FAILED": ListPermissionsFailedError,
+  "GET_PERMISSION_FAILED": GetPermissionFailedError,
+  "UPDATE_PERMISSION_FAILED": UpdatePermissionFailedError,
+  "REVOKE_PERMISSION_FAILED": RevokePermissionFailedError,
+  "GRANT_PERMISSION_FAILED": GrantPermissionFailedError,
+  "LIST_IDENTITIES_FAILED": ListIdentitiesFailedError,
+  "DELETE_IDENTITY_FAILED": DeleteIdentityFailedError,
+  "CREATE_IDENTITY_FAILED": CreateIdentityFailedError,
+  "VM_PERMISSION_NOT_FOUND": VmPermissionNotFoundError,
+  "PERMISSION_NOT_FOUND": PermissionNotFoundError,
+  "VM_ACCESS_DENIED": VmAccessDeniedError,
+  "GIT_REPOSITORY_ACCESS_DENIED": GitRepositoryAccessDeniedError,
+  "GIT_REPOSITORY_NOT_FOUND": GitRepositoryNotFoundError,
+  "CANNOT_DELETE_MANAGED_IDENTITY": CannotDeleteManagedIdentityError,
+  "CANNOT_MODIFY_MANAGED_IDENTITY": CannotModifyManagedIdentityError,
+  "IDENTITY_ACCESS_DENIED": IdentityAccessDeniedError,
+  "IDENTITY_NOT_FOUND": IdentityNotFoundError,
+  "EXECUTE_INTERNAL_ERROR": ExecuteInternalErrorError,
+  "EXECUTE_ACCESS_DENIED": ExecuteAccessDeniedError,
+  "LIST_RUNS_FAILED": ListRunsFailedError,
+  "EXECUTION_ERROR": ExecutionErrorError,
+  "CONNECTION_FAILED": ConnectionFailedError,
+  "METADATA_WRITE_FAILED": MetadataWriteFailedError,
+  "NODE_MODULES_INSTALL_FAILED": NodeModulesInstallFailedError,
+  "NODE_MODULES_DOWNLOAD_FAILED": NodeModulesDownloadFailedError,
+  "LOCK_GENERATION_FAILED": LockGenerationFailedError,
+  "WRITE_SCRIPT_FAILED": WriteScriptFailedError,
+  "DIRECTORY_CREATION_FAILED": DirectoryCreationFailedError,
+  "NETWORK_PERMISSIONS_FAILED": NetworkPermissionsFailedError,
+  "LOGGING_FAILED": LoggingFailedError,
+  "RUN_NOT_FOUND": RunNotFoundError,
+  "CLOUDSTATE_INTERNAL_ERROR": CloudstateInternalErrorError,
+  "CLOUDSTATE_DATABASE_ERROR": CloudstateDatabaseErrorError,
+  "CLOUDSTATE_ACCESS_DENIED": CloudstateAccessDeniedError,
+  "RESTORE_FAILED": RestoreFailedError,
+  "CREATE_BACKUP_FAILED": CreateBackupFailedError,
+  "BACKUP_FAILED": BackupFailedError,
+  "DEPLOYMENT_FAILED": DeploymentFailedError,
+  "INVALID_DEPLOYMENT_REQUEST": InvalidDeploymentRequestError,
+  "PROJECT_NOT_FOUND": ProjectNotFoundError,
+  "RESIZE_FAILED": ResizeFailedError,
+  "INTERNAL_RESIZE_VM_NOT_FOUND": InternalResizeVmNotFoundError,
+  "DOMAIN_OWNERSHIP_VERIFICATION_FAILED": DomainOwnershipVerificationFailedError,
+  "ERROR_DELETING_RECORD": ErrorDeletingRecordError,
+  "RECORD_OWNERSHIP_ERROR": RecordOwnershipErrorError,
+  "ERROR_CREATING_RECORD": ErrorCreatingRecordError,
+  "DOMAIN_OWNERSHIP_ERROR": DomainOwnershipErrorError,
+  "BROWSER_OPERATION_FAILED": BrowserOperationFailedError,
+  "WATCH_FILES_FAILED": WatchFilesFailedError,
+  "LOGS_FAILED": LogsFailedError,
+  "STATUS_FAILED": StatusFailedError,
+  "RESTART_FAILED": RestartFailedError,
+  "SHUTDOWN_FAILED": ShutdownFailedError,
+  "COMMIT_FAILED": CommitFailedError,
+  "WRITE_FILE_FAILED": WriteFileFailedError,
+  "READ_FILE_FAILED": ReadFileFailedError,
+  "EXECUTION_FAILED": ExecutionFailedError,
+  "REQUEST_FAILED": RequestFailedError,
+  "DEV_SERVER_FILE_NOT_FOUND": DevServerFileNotFoundError,
+  "DEV_SERVER_INVALID_REQUEST": DevServerInvalidRequestError,
+  "DEV_SERVER_NOT_FOUND": DevServerNotFoundError
+};
+
+var errors = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AfterArrayContainsEmptyError: AfterArrayContainsEmptyError,
+  AlreadyHasBaseError: AlreadyHasBaseError,
+  AnyhowError: AnyhowError,
+  BackupFailedError: BackupFailedError,
+  BadRequestError: BadRequestError,
+  BlobNotFoundError: BlobNotFoundError,
+  BranchNotFoundError: BranchNotFoundError,
+  BrowserOperationFailedError: BrowserOperationFailedError,
+  BuildFailedError: BuildFailedError,
+  CannotDeleteManagedIdentityError: CannotDeleteManagedIdentityError,
+  CannotModifyManagedIdentityError: CannotModifyManagedIdentityError,
+  CloudstateAccessDeniedError: CloudstateAccessDeniedError,
+  CloudstateDatabaseErrorError: CloudstateDatabaseErrorError,
+  CloudstateInternalErrorError: CloudstateInternalErrorError,
+  CommitFailedError: CommitFailedError,
+  CommitNotFoundError: CommitNotFoundError,
+  ConflictError: ConflictError,
+  ConnectionFailedError: ConnectionFailedError,
+  ContentNotFoundError: ContentNotFoundError,
+  CreateBackupFailedError: CreateBackupFailedError,
+  CreateIdentityFailedError: CreateIdentityFailedError,
+  CreateRepositoryFailedError: CreateRepositoryFailedError,
+  CreateSnapshotBadRequestError: CreateSnapshotBadRequestError,
+  CreateTokenFailedError: CreateTokenFailedError,
+  CreateVmBadRequestError: CreateVmBadRequestError,
+  DatabaseErrorError: DatabaseErrorError,
+  DeleteIdentityFailedError: DeleteIdentityFailedError,
+  DeleteRepositoryFailedError: DeleteRepositoryFailedError,
+  DeploymentFailedError: DeploymentFailedError,
+  DeploymentNotFoundError: DeploymentNotFoundError,
+  DevServerFileNotFoundError: DevServerFileNotFoundError,
+  DevServerInvalidRequestError: DevServerInvalidRequestError,
+  DevServerNotFoundError: DevServerNotFoundError,
+  DirectoryCreationFailedError: DirectoryCreationFailedError,
+  DockerImportBadRequestError: DockerImportBadRequestError,
+  DomainAlreadyExistsError: DomainAlreadyExistsError,
+  DomainOwnershipErrorError: DomainOwnershipErrorError,
+  DomainOwnershipVerificationFailedError: DomainOwnershipVerificationFailedError,
+  DownloadFailedError: DownloadFailedError,
+  DuplicateGroupNameError: DuplicateGroupNameError,
+  DuplicateUserNameError: DuplicateUserNameError,
+  EntrypointNotFoundError: EntrypointNotFoundError,
+  EnvKeyContainsEqualsError: EnvKeyContainsEqualsError,
+  EnvKeyEmptyError: EnvKeyEmptyError,
+  ErrorCreatingRecordError: ErrorCreatingRecordError,
+  ErrorDeletingRecordError: ErrorDeletingRecordError,
+  ExecEmptyError: ExecEmptyError,
+  ExecuteAccessDeniedError: ExecuteAccessDeniedError,
+  ExecuteInternalErrorError: ExecuteInternalErrorError,
+  ExecutionErrorError: ExecutionErrorError,
+  ExecutionFailedError: ExecutionFailedError,
+  ExpiredError: ExpiredError,
+  FREESTYLE_ERROR_CODE_MAP: FREESTYLE_ERROR_CODE_MAP,
+  FailedPermissionsCheckError: FailedPermissionsCheckError,
+  FailedRemoveDomainMappingError: FailedRemoveDomainMappingError,
+  FailedToCheckDomainMappingPermissionsError: FailedToCheckDomainMappingPermissionsError,
+  FailedToCheckPermissionsError: FailedToCheckPermissionsError,
+  FailedToCreateVerificationCodeError: FailedToCreateVerificationCodeError,
+  FailedToDeleteVerificationError: FailedToDeleteVerificationError,
+  FailedToInsertDomainMappingError: FailedToInsertDomainMappingError,
+  FailedToInsertOwnershipError: FailedToInsertOwnershipError,
+  FailedToListDomainsError: FailedToListDomainsError,
+  FailedToListVerificationsError: FailedToListVerificationsError,
+  FailedToProvisionCertificateError: FailedToProvisionCertificateError,
+  FailedToVerifyDomainError: FailedToVerifyDomainError,
+  FileNotFoundError: FileNotFoundError,
+  FilesBadRequestError: FilesBadRequestError,
+  FirecrackerApiSocketNotFoundError: FirecrackerApiSocketNotFoundError,
+  FirecrackerPidNotFoundError: FirecrackerPidNotFoundError,
+  ForbiddenError: ForbiddenError,
+  ForkVmNotFoundError: ForkVmNotFoundError,
+  GetContentFailedError: GetContentFailedError,
+  GetPermissionFailedError: GetPermissionFailedError,
+  GetRepositoryInfoFailedError: GetRepositoryInfoFailedError,
+  GitHubSyncFailedError: GitHubSyncFailedError,
+  GitInvalidRequestError: GitInvalidRequestError,
+  GitRepositoryAccessDeniedError: GitRepositoryAccessDeniedError,
+  GitRepositoryNotFoundError: GitRepositoryNotFoundError,
+  GitServerErrorError: GitServerErrorError,
+  GrantPermissionFailedError: GrantPermissionFailedError,
+  GroupAlreadyExistsError: GroupAlreadyExistsError,
+  GroupEmptyError: GroupEmptyError,
+  GroupNameEmptyError: GroupNameEmptyError,
+  GroupNameInvalidCharsError: GroupNameInvalidCharsError,
+  GroupNameReservedError: GroupNameReservedError,
+  GroupNameTooLongError: GroupNameTooLongError,
+  GroupNotFoundError: GroupNotFoundError,
+  IdentityAccessDeniedError: IdentityAccessDeniedError,
+  IdentityErrorError: IdentityErrorError,
+  IdentityNotFoundError: IdentityNotFoundError,
+  InternalError: InternalError,
+  InternalErrorError: InternalErrorError,
+  InternalForkVmNotFoundError: InternalForkVmNotFoundError,
+  InternalResizeVmNotFoundError: InternalResizeVmNotFoundError,
+  InternalVmNotFoundError: InternalVmNotFoundError,
+  InvalidDeploymentRequestError: InvalidDeploymentRequestError,
+  InvalidDomainError: InvalidDomainError,
+  InvalidDomainsError: InvalidDomainsError,
+  InvalidObjectIdError: InvalidObjectIdError,
+  InvalidParametersError: InvalidParametersError,
+  InvalidQueryError: InvalidQueryError,
+  InvalidRequestError: InvalidRequestError,
+  InvalidRevisionError: InvalidRevisionError,
+  InvalidSignatureError: InvalidSignatureError,
+  ListIdentitiesFailedError: ListIdentitiesFailedError,
+  ListPermissionsFailedError: ListPermissionsFailedError,
+  ListRepositoriesFailedError: ListRepositoriesFailedError,
+  ListRunsFailedError: ListRunsFailedError,
+  ListTokensFailedError: ListTokensFailedError,
+  LockGenerationFailedError: LockGenerationFailedError,
+  LoggingFailedError: LoggingFailedError,
+  LogsFailedError: LogsFailedError,
+  LogsNotFoundError: LogsNotFoundError,
+  MaxUsesExceededError: MaxUsesExceededError,
+  MetadataWriteFailedError: MetadataWriteFailedError,
+  NetworkPermissionsFailedError: NetworkPermissionsFailedError,
+  NoDomainOwnershipError: NoDomainOwnershipError,
+  NoEntrypointFoundError: NoEntrypointFoundError,
+  NodeModulesDownloadFailedError: NodeModulesDownloadFailedError,
+  NodeModulesInstallFailedError: NodeModulesInstallFailedError,
+  NotFoundError: NotFoundError,
+  ObservabilityAccessDeniedError: ObservabilityAccessDeniedError,
+  ObservabilityDatabaseErrorError: ObservabilityDatabaseErrorError,
+  OnFailureArrayContainsEmptyError: OnFailureArrayContainsEmptyError,
+  ParseLogsFailedError: ParseLogsFailedError,
+  ParseResponseErrorError: ParseResponseErrorError,
+  PathNotFoundError: PathNotFoundError,
+  PermissionAlreadyExistsError: PermissionAlreadyExistsError,
+  PermissionDeniedError: PermissionDeniedError,
+  PermissionErrorError: PermissionErrorError,
+  PermissionNotFoundError: PermissionNotFoundError,
+  ProjectNotFoundError: ProjectNotFoundError,
+  ReadFileFailedError: ReadFileFailedError,
+  RecordOwnershipErrorError: RecordOwnershipErrorError,
+  ReferenceNotFoundError: ReferenceNotFoundError,
+  RepoNotFoundError: RepoNotFoundError,
+  RepositoryAccessDeniedError: RepositoryAccessDeniedError,
+  RepositoryNotFoundError: RepositoryNotFoundError,
+  RequestFailedError: RequestFailedError,
+  RequiresArrayContainsEmptyError: RequiresArrayContainsEmptyError,
+  ReqwestError: ReqwestError,
+  ResizeFailedError: ResizeFailedError,
+  RestartFailedError: RestartFailedError,
+  RestoreFailedError: RestoreFailedError,
+  RetrieveLogsFailedError: RetrieveLogsFailedError,
+  RevokePermissionFailedError: RevokePermissionFailedError,
+  RevokeTokenFailedError: RevokeTokenFailedError,
+  RunNotFoundError: RunNotFoundError,
+  SerializationErrorError: SerializationErrorError,
+  ServiceAlreadyExistsError: ServiceAlreadyExistsError,
+  ServiceNameEmptyError: ServiceNameEmptyError,
+  ServiceNameInvalidCharsError: ServiceNameInvalidCharsError,
+  ServiceNameInvalidPrefixError: ServiceNameInvalidPrefixError,
+  ServiceNameTooLongError: ServiceNameTooLongError,
+  ServiceNotFoundError: ServiceNotFoundError,
+  ShutdownFailedError: ShutdownFailedError,
+  SigningError: SigningError,
+  SnapshotVmBadRequestError: SnapshotVmBadRequestError,
+  StatusFailedError: StatusFailedError,
+  StdIoError: StdIoError,
+  TagNotFoundError: TagNotFoundError,
+  TokenErrorError: TokenErrorError,
+  TreeNotFoundError: TreeNotFoundError,
+  TriggerErrorError: TriggerErrorError,
+  UnauthorizedError: UnauthorizedError,
+  UnsupportedTransferError: UnsupportedTransferError,
+  UpdateDefaultBranchFailedError: UpdateDefaultBranchFailedError,
+  UpdatePermissionFailedError: UpdatePermissionFailedError,
+  UserAlreadyExistsError: UserAlreadyExistsError,
+  UserEmptyError: UserEmptyError,
+  UserGroupEmptyError: UserGroupEmptyError,
+  UserHomeInvalidError: UserHomeInvalidError,
+  UserNotFoundError: UserNotFoundError,
+  UserShellInvalidError: UserShellInvalidError,
+  UserSystemFlagMismatchError: UserSystemFlagMismatchError,
+  UserUidOutOfRangeError: UserUidOutOfRangeError,
+  ValidationErrorError: ValidationErrorError,
+  VerificationFailedError: VerificationFailedError,
+  VerificationNotFoundError: VerificationNotFoundError,
+  VmAccessDeniedError: VmAccessDeniedError,
+  VmCreateTmuxSessionError: VmCreateTmuxSessionError,
+  VmDeletedError: VmDeletedError,
+  VmExitDuringStartError: VmExitDuringStartError,
+  VmMustBeStoppedError: VmMustBeStoppedError,
+  VmNotFoundError: VmNotFoundError,
+  VmNotFoundInFsError: VmNotFoundInFsError,
+  VmNotInTransactionError: VmNotInTransactionError,
+  VmNotRunningError: VmNotRunningError,
+  VmOperationDeniedDuringTransactionError: VmOperationDeniedDuringTransactionError,
+  VmPermissionNotFoundError: VmPermissionNotFoundError,
+  VmStartTimeoutError: VmStartTimeoutError,
+  VmSubnetNotFoundError: VmSubnetNotFoundError,
+  VmTransactionIdMismatchError: VmTransactionIdMismatchError,
+  WantedByEmptyError: WantedByEmptyError,
+  WatchFilesFailedError: WatchFilesFailedError,
+  WebDeploymentBadRequestError: WebDeploymentBadRequestError,
+  WorkdirEmptyError: WorkdirEmptyError,
+  WriteFileFailedError: WriteFileFailedError,
+  WriteScriptFailedError: WriteScriptFailedError,
+  errorFromJSON: errorFromJSON
+});
+
+const SDK_VERSION = "0.1.0";
+const SDK_NAME = "freestyle-sdk-ts";
+class ApiClient {
+  baseUrl;
+  apiKey;
+  accessToken;
+  fetchFn;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || "https://api.freestyle.sh";
+    this.apiKey = "apiKey" in config ? config.apiKey : void 0;
+    this.accessToken = "accessToken" in config ? config.accessToken : void 0;
+    this.fetchFn = config.fetch || fetch;
+  }
+  buildUrl(path, params, query) {
+    let url = path;
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url = url.replace(`{${key}}`, encodeURIComponent(value));
+      }
+    }
+    if (query) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0 && value !== null) {
+          searchParams.append(key, String(value));
+        }
+      }
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    return this.baseUrl + url;
+  }
+  getDefaultHeaders() {
+    const headers = {
+      "X-Freestyle-SDK": SDK_NAME,
+      "X-Freestyle-SDK-Version": SDK_VERSION,
+      "User-Agent": `${SDK_NAME}/${SDK_VERSION}`
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    } else if (this.accessToken) {
+      headers["X-Freestyle-Identity-Access-Token"] = this.accessToken;
+    }
+    return headers;
+  }
+  async request(method, url, body) {
+    const headers = this.getDefaultHeaders();
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await this.fetchFn(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw errorFromJSON(errorData);
+    }
+    return response.json();
+  }
+  async fetch(url, options) {
+    const headers = this.getDefaultHeaders();
+    const finalOptions = {
+      ...options,
+      headers: {
+        ...headers,
+        ...options?.headers || {}
+      }
+    };
+    return this.fetchFn(url, finalOptions);
+  }
+  get(path, ...args) {
+    const options = args[0];
+    const url = this.buildUrl(path, options?.params, options?.query);
+    return this.request("GET", url, options?.body);
+  }
+  post(path, ...args) {
+    const options = args[0];
+    const url = this.buildUrl(path, options?.params, options?.query);
+    return this.request("POST", url, options?.body);
+  }
+  put(path, ...args) {
+    const options = args[0];
+    const url = this.buildUrl(path, options?.params, options?.query);
+    return this.request("PUT", url, options?.body);
+  }
+  delete(path, ...args) {
+    const options = args[0];
+    const url = this.buildUrl(path, options?.params, options?.query);
+    return this.request("DELETE", url, options?.body);
+  }
+  patch(path, ...args) {
+    const options = args[0];
+    const url = this.buildUrl(path, options?.params, options?.query);
+    return this.request("PATCH", url, options?.body);
+  }
+}
+
+class DomainVerificationsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Create a domain verification request.
+   */
+  async create({ domain }) {
+    const response = await this.apiClient.post("/domains/v1/verifications", {
+      body: { domain }
+    });
+    return {
+      verificationId: response.id,
+      instructions: `Navigate to your domain's DNS settings and create a TXT record with the following details:
+
+      Name: _freestyle-verification.${domain}
+
+      Value: ${response.verificationCode}
+      
+      After adding the record, return here to complete the verification process. Note that DNS changes may take some time to propagate. If verification fails after waiting a few minutes, try setting the Name to just "_freestyle-verification". Some DNS providers automatically append the domain name to the record name.`,
+      record: {
+        type: "TXT",
+        name: `_freestyle-verification.${domain}`,
+        value: response.verificationCode
+      }
+    };
+  }
+  /**
+   * Complete a domain verification by domain or verification ID.
+   */
+  async complete(options) {
+    return this.apiClient.put("/domains/v1/verifications", {
+      body: "verificationId" in options ? { id: options.verificationId } : { domain: options.domain }
+    });
+  }
+  /**
+   * List domain verification requests.
+   */
+  async list() {
+    return this.apiClient.get("/domains/v1/verifications", void 0);
+  }
+  /**
+   * Cancel a domain verification request.
+   */
+  async cancel({
+    domain,
+    verificationCode
+  }) {
+    return this.apiClient.delete("/domains/v1/verifications", {
+      body: { domain, verificationCode }
+    });
+  }
+}
+class DomainCertificatesNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Provision a wildcard certificate for a domain.
+   */
+  async createWildcard({
+    domain
+  }) {
+    return this.apiClient.post("/domains/v1/certs/{domain}/wildcard", {
+      params: { domain }
+    });
+  }
+}
+class DomainMappingsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Create a domain mapping to a deployment.
+   */
+  async create({
+    domain,
+    deploymentId
+  }) {
+    return this.apiClient.post("/domains/v1/mappings/{domain}", {
+      params: { domain },
+      body: { deploymentId }
+    });
+  }
+  /**
+   * Delete a domain mapping.
+   */
+  async delete({
+    domain
+  }) {
+    return this.apiClient.delete("/domains/v1/mappings/{domain}", {
+      params: { domain }
+    });
+  }
+  /**
+   * List domain mappings.
+   */
+  async list({
+    domain,
+    domainOwnership,
+    limit = 10,
+    cursor
+  } = {}) {
+    const offset = cursor ? parseInt(cursor, 10) : 0;
+    const mappings = await this.apiClient.get("/domains/v1/mappings", {
+      query: { domain, domainOwnership, limit, offset }
+    });
+    return { mappings };
+  }
+}
+class DomainsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+    this.verifications = new DomainVerificationsNamespace(apiClient);
+    this.certificates = new DomainCertificatesNamespace(apiClient);
+    this.mappings = new DomainMappingsNamespace(apiClient);
+  }
+  verifications;
+  certificates;
+  mappings;
+  /**
+   * List verified domains.
+   */
+  async list({
+    limit,
+    cursor
+  } = {}) {
+    const offset = cursor ? parseInt(cursor, 10) : 0;
+    return this.apiClient.get("/domains/v1/domains", {
+      query: { limit, offset }
+    });
+  }
+}
+
+class GitRepo {
+  constructor(repoId, apiClient) {
+    this.apiClient = apiClient;
+    this.repoId = repoId;
+  }
+  repoId;
+  /**
+   * Set the default branch for this repository.
+   */
+  async setDefaultBranch({
+    defaultBranch
+  }) {
+    return this.apiClient.put("/git/v1/repo/{repo_id}/default-branch", {
+      params: { repo_id: this.repoId },
+      body: { defaultBranch }
+    });
+  }
+  /**
+   * Get the default branch for this repository.
+   */
+  async getDefaultBranch() {
+    return this.apiClient.get("/git/v1/repo/{repo_id}/default-branch", {
+      params: { repo_id: this.repoId }
+    });
+  }
+  /**
+   * Get the contents of this repository at the given path.
+   */
+  async getContents({
+    path = "",
+    ref
+  } = {}) {
+    return this.apiClient.get("/git/v1/repo/{repo}/contents/{path}", {
+      params: { repo: this.repoId, path },
+      query: { ref }
+    });
+  }
+  /**
+   * Get the GitHub sync configuration for this repository.
+   */
+  async getGitHubSyncConfig() {
+    try {
+      return await this.apiClient.get("/git/v1/repo/{repo_id}/github-sync", {
+        params: { repo_id: this.repoId }
+      });
+    } catch (error) {
+      if (error.message?.includes("404")) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * List git triggers for this repository.
+   */
+  async listTriggers() {
+    return this.apiClient.get("/git/v1/repo/{repo}/trigger", {
+      params: { repo: this.repoId }
+    });
+  }
+  /**
+   * Create a git trigger for this repository.
+   */
+  async createTrigger({
+    trigger,
+    action
+  }) {
+    const response = await this.apiClient.post("/git/v1/repo/{repo}/trigger", {
+      params: { repo: this.repoId },
+      body: { trigger, action }
+    });
+    return {
+      triggerId: response.triggerId
+    };
+  }
+  /**
+   * Delete a git trigger.
+   */
+  async deleteTrigger({
+    triggerId
+  }) {
+    return this.apiClient.delete("/git/v1/repo/{repo}/trigger/{trigger}", {
+      params: { repo: this.repoId, trigger: triggerId }
+    });
+  }
+}
+class GitReposNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Create a new git repository.
+   */
+  async create({ ...body }) {
+    const response = await this.apiClient.post("/git/v1/repo", { body });
+    const repoId = response.repoId;
+    return {
+      repoId,
+      repo: new GitRepo(repoId, this.apiClient)
+    };
+  }
+  /**
+   * List git repositories.
+   */
+  async list({
+    limit = 10,
+    cursor
+  } = {}) {
+    const offset = cursor ? parseInt(cursor, 10) : 0;
+    return this.apiClient.get("/git/v1/repo", {
+      query: { limit, offset }
+    });
+  }
+  /**
+   * Get a repository instance by ID.
+   */
+  instance({ repoId }) {
+    return new GitRepo(repoId, this.apiClient);
+  }
+  /**
+   * Delete a git repository.
+   */
+  async delete({
+    repoId
+  }) {
+    return this.apiClient.delete("/git/v1/repo/{repo}", {
+      params: { repo: repoId }
+    });
+  }
+}
+class GitNamespace {
+  constructor(apiClient, freestyle) {
+    this.apiClient = apiClient;
+    this.freestyle = freestyle;
+    this.repos = new GitReposNamespace(apiClient);
+  }
+  repos;
+}
+
+class Identity {
+  constructor(identityId, apiClient) {
+    this.apiClient = apiClient;
+    this.identityId = identityId;
+    this.permissions = new IdentityPermissions(identityId, apiClient);
+  }
+  identityId;
+  permissions;
+  /**
+   * Create a new access token for this identity.
+   */
+  async createToken() {
+    const response = await this.apiClient.post(
+      "/identity/v1/identities/{identity}/tokens",
+      {
+        params: { identity: this.identityId }
+      }
+    );
+    return {
+      tokenId: response.id,
+      token: response.token
+    };
+  }
+  /**
+   * Revoke an access token.
+   */
+  async revokeToken({
+    tokenId
+  }) {
+    return this.apiClient.delete(
+      "/identity/v1/identities/{identity}/tokens/{token}",
+      {
+        params: { identity: this.identityId, token: tokenId }
+      }
+    );
+  }
+  /**
+   * List access tokens for this identity.
+   */
+  async listTokens() {
+    return this.apiClient.get("/identity/v1/identities/{identity}/tokens", {
+      params: { identity: this.identityId }
+    });
+  }
+}
+class IdentityPermissions {
+  constructor(identityId, apiClient) {
+    this.identityId = identityId;
+    this.apiClient = apiClient;
+    this.git = new GitPermissions(identityId, apiClient);
+    this.vms = new VmPermissions(identityId, apiClient);
+  }
+  git;
+  vms;
+}
+class GitPermissions {
+  constructor(identityId, apiClient) {
+    this.identityId = identityId;
+    this.apiClient = apiClient;
+  }
+  /**
+   * List all git repository access permissions for this identity.
+   */
+  async list({
+    limit,
+    cursor
+  } = {}) {
+    const offset = cursor ? parseInt(cursor, 10) : 0;
+    return this.apiClient.get(
+      "/identity/v1/identities/{identity}/permissions/git",
+      {
+        params: { identity: this.identityId },
+        query: { limit, offset }
+      }
+    );
+  }
+  /**
+   * Get this identity's permission level for a specific repository.
+   */
+  async get({
+    repoId
+  }) {
+    return this.apiClient.get(
+      "/identity/v1/identities/{identity}/permissions/git/{repo}",
+      {
+        params: { identity: this.identityId, repo: repoId }
+      }
+    );
+  }
+  /**
+   * Update this identity's access to a repository.
+   */
+  async update({
+    repoId,
+    permission
+  }) {
+    return this.apiClient.put(
+      "/identity/v1/identities/{identity}/permissions/git/{repo}",
+      {
+        params: { identity: this.identityId, repo: repoId },
+        body: { permission }
+      }
+    );
+  }
+  /**
+   * Grant this identity access to a repository.
+   */
+  async create({
+    repoId,
+    permission
+  }) {
+    return this.apiClient.post(
+      "/identity/v1/identities/{identity}/permissions/git/{repo}",
+      {
+        params: { identity: this.identityId, repo: repoId },
+        body: { permission }
+      }
+    );
+  }
+  /**
+   * Revoke this identity's access to a repository.
+   */
+  async delete({
+    repoId
+  }) {
+    return this.apiClient.delete(
+      "/identity/v1/identities/{identity}/permissions/git/{repo}",
+      {
+        params: { identity: this.identityId, repo: repoId }
+      }
+    );
+  }
+}
+class VmPermissions {
+  constructor(identityId, apiClient) {
+    this.identityId = identityId;
+    this.apiClient = apiClient;
+  }
+  /**
+   * List all VM access permissions for this identity.
+   */
+  async list({
+    limit,
+    cursor
+  } = {}) {
+    const offset = cursor ? parseInt(cursor, 10) : 0;
+    return this.apiClient.get(
+      "/identity/v1/identities/{identity}/permissions/vm",
+      {
+        params: { identity: this.identityId },
+        query: { limit, offset }
+      }
+    );
+  }
+  /**
+   * Get this identity's permission level for a specific VM.
+   */
+  async get({
+    vmId
+  }) {
+    return this.apiClient.get(
+      "/identity/v1/identities/{identity}/permissions/vm/{vm_id}",
+      {
+        params: { identity: this.identityId, vm_id: vmId }
+      }
+    );
+  }
+  /**
+   * Update this identity's access to a VM.
+   */
+  async update({
+    vmId,
+    allowedUsers
+  }) {
+    return this.apiClient.put(
+      "/identity/v1/identities/{identity}/permissions/vm/{vm_id}",
+      {
+        params: { identity: this.identityId, vm_id: vmId },
+        body: { allowedUsers }
+      }
+    );
+  }
+  /**
+   * Grant this identity access to a VM.
+   */
+  async create({
+    vmId,
+    allowedUsers
+  }) {
+    return this.apiClient.post(
+      "/identity/v1/identities/{identity}/permissions/vm/{vm_id}",
+      {
+        params: { identity: this.identityId, vm_id: vmId },
+        body: { allowedUsers }
+      }
+    );
+  }
+  /**
+   * Revoke this identity's access to a VM.
+   */
+  async delete({
+    vmId
+  }) {
+    return this.apiClient.delete(
+      "/identity/v1/identities/{identity}/permissions/vm/{vm_id}",
+      {
+        params: { identity: this.identityId, vm_id: vmId }
+      }
+    );
+  }
+}
+class IdentitiesNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * List all identities.
+   */
+  async list({
+    limit,
+    cursor
+  } = {}) {
+    const offset = cursor ? parseInt(cursor, 10) : 0;
+    return this.apiClient.get("/identity/v1/identities", {
+      query: { limit, offset }
+    });
+  }
+  /**
+   * Create a new identity.
+   * Identities are global entities that can be granted permissions to access git repositories and VMs.
+   */
+  async create({} = {}) {
+    const response = await this.apiClient.post(
+      "/identity/v1/identities",
+      void 0
+    );
+    const identityId = response.id;
+    return {
+      identityId,
+      identity: new Identity(identityId, this.apiClient)
+    };
+  }
+  /**
+   * Create an identity instance by ID without making an api call.
+   */
+  ref({ identityId }) {
+    return new Identity(identityId, this.apiClient);
+  }
+  /**
+   * Delete an identity.
+   */
+  async delete({
+    identityId
+  }) {
+    return this.apiClient.delete("/identity/v1/identities/{identity}", {
+      params: { identity: identityId }
+    });
+  }
+}
+
+class DnsRecordsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Create DNS records.
+   */
+  async create({
+    ...body
+  }) {
+    return this.apiClient.post("/dns/v1/records", { body });
+  }
+  /**
+   * List DNS records.
+   */
+  async list({
+    ...query
+  } = {}) {
+    return this.apiClient.get("/dns/v1/records", { query });
+  }
+  /**
+   * Delete DNS records.
+   */
+  async delete({
+    ...query
+  } = {}) {
+    return this.apiClient.delete("/dns/v1/records", { query });
+  }
+}
+class DnsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+    this.records = new DnsRecordsNamespace(apiClient);
+  }
+  records;
+}
+
+class Deployment {
+  constructor(deploymentId, apiClient) {
+    this.apiClient = apiClient;
+    this.deploymentId = deploymentId;
+  }
+  deploymentId;
+  /**
+   * Get details of this deployment (execute type).
+   */
+  async getDetails() {
+    return this.apiClient.get("/execute/v1/deployments/{deployment}", {
+      params: { deployment: this.deploymentId }
+    });
+  }
+  /**
+   * Get logs for this deployment.
+   */
+  async getLogs() {
+    return this.apiClient.get("/observability/v1/logs", {
+      query: { deploymentId: this.deploymentId }
+    });
+  }
+}
+class DeploymentsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Create a web deployment on the edge.
+   */
+  async create({ ...body }) {
+    let source;
+    if ("repo" in body) {
+      source = {
+        kind: "git",
+        url: body.repo,
+        branch: body.branch,
+        dir: body.rootPath
+      };
+    } else if ("code" in body) {
+      source = {
+        kind: "files",
+        files: {
+          "index.js": {
+            content: body.code
+          }
+        }
+      };
+    } else if ("files" in body) {
+      source = {
+        kind: "files",
+        files: Object.fromEntries(
+          body.files.map((file) => [file.path, { content: file.content }])
+        )
+      };
+    } else if ("tarUrl" in body) {
+      source = {
+        kind: "tar",
+        url: body.tarUrl
+      };
+    } else {
+      throw new Error(
+        "Invalid deployment source. You must provide repo, code, files, or tarUrl."
+      );
+    }
+    const response = await this.apiClient.post("/web/v1/deployment", {
+      body: {
+        source,
+        config: {
+          await: body.waitForRollout,
+          build: body.build,
+          domains: body.domains,
+          networkPermissions: body.networkPermissions?.map((np) => ({
+            action: np.action,
+            query: np.domain,
+            behavior: np.behavior
+          })),
+          envVars: body.envVars,
+          nodeModules: body.nodeModules,
+          timeout: body.timeoutMs,
+          entrypoint: body.entrypointPath
+        }
+      }
+    });
+    return {
+      deploymentId: response.deploymentId,
+      deployment: new Deployment(response.deploymentId, this.apiClient),
+      domains: body.domains || []
+    };
+  }
+  /**
+   * List web deployments.
+   */
+  async list({
+    limit = 50,
+    cursor
+  } = {}) {
+    const offset = cursor ? parseInt(cursor, 10) : 0;
+    return this.apiClient.get("/web/v1/deployments", {
+      query: { limit, offset }
+    });
+  }
+  /**
+   * Get a deployment instance by ID.
+   */
+  ref({ deploymentId }) {
+    return new Deployment(deploymentId, this.apiClient);
+  }
+}
+class RunsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Create and execute a script run.
+   */
+  async create({
+    code,
+    ...config
+  }) {
+    const response = await this.apiClient.post("/execute/v1/script", {
+      body: {
+        script: code,
+        config: {
+          customHeaders: config.customHeaders,
+          networkPermissions: config.networkPermissions?.map((np) => ({
+            action: np.action,
+            query: np.domain,
+            behavior: np.behavior
+          })),
+          envVars: config.envVars,
+          nodeModules: config.nodeModules,
+          timeout: config.timeoutMs
+          // entrypoint: config.entrypointPath,
+        }
+      }
+    });
+    if (!response.result && !response.logs) {
+      throw new Error("Execution failed");
+    }
+    return {
+      result: response.result,
+      logs: response.logs || []
+    };
+  }
+  /**
+   * List execution runs.
+   */
+  async list({
+    limit = 50,
+    cursor
+  } = {}) {
+    const offset = cursor ? parseInt(cursor, 10) : 0;
+    const res = await this.apiClient.get("/execute/v1/deployments", {
+      query: { limit, offset }
+    });
+    return {
+      runs: res.entries.map((item) => ({
+        createdAt: item.provisionedAt,
+        startedAt: item.startedAt || void 0,
+        runId: item.deployment,
+        status: item.state
+      })),
+      nextCursor: res.offset < res.total ? res.offset.toString() : void 0,
+      totalCount: res.total
+    };
+  }
+}
+class EdgeNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+    this.deployments = new DeploymentsNamespace(apiClient);
+    this.runs = new RunsNamespace(apiClient);
+  }
+  deployments;
+  runs;
+}
+
+class FileSystem {
+  constructor(vmId, client) {
+    this.vmId = vmId;
+    this.client = client;
+  }
+  /**
+   * Read a file from the VM as a buffer.
+   * @param filepath The path to the file in the VM
+   * @returns Buffer containing the file content
+   */
+  async readFile(filepath) {
+    const response = await this.client.get("/v1/vms/{vm_id}/files/{filepath}", {
+      params: { vm_id: this.vmId, filepath }
+    });
+    if (response && typeof response === "object" && "content" in response) {
+      const content = response.content;
+      try {
+        return Buffer.from(content, "base64");
+      } catch {
+        return Buffer.from(content, "utf-8");
+      }
+    }
+    throw new Error("Unexpected response format from VM file read");
+  }
+  /**
+   * Write a file to the VM from a buffer.
+   * @param filepath The path to the file in the VM
+   * @param content Buffer containing the content to write
+   */
+  async writeFile(filepath, content) {
+    const base64Content = content.toString("base64");
+    await this.client.put("/v1/vms/{vm_id}/files/{filepath}", {
+      params: { vm_id: this.vmId, filepath },
+      body: { content: base64Content }
+    });
+  }
+  /**
+   * Read a text file from the VM.
+   * @param filepath The path to the file in the VM
+   * @param encoding The text encoding to use (default: utf-8)
+   * @returns The file content as a string
+   */
+  async readTextFile(filepath, encoding = "utf-8") {
+    const buffer = await this.readFile(filepath);
+    return buffer.toString(encoding);
+  }
+  /**
+   * Write a text file to the VM.
+   * @param filepath The path to the file in the VM
+   * @param content The text content to write
+   * @param encoding The text encoding to use (default: utf-8)
+   */
+  async writeTextFile(filepath, content, encoding = "utf-8") {
+    const buffer = Buffer.from(content, encoding);
+    await this.writeFile(filepath, buffer);
+  }
+  /**
+   * Read a directory from the VM.
+   * @param path The path to the directory in the VM
+   * @returns Array of file/directory names
+   */
+  async readDir(path) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Create a directory in the VM.
+   * @param path The path to create
+   */
+  async mkdir(path) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Remove a file or directory from the VM.
+   * @param path The path to remove
+   */
+  async remove(path) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Check if a file or directory exists in the VM.
+   * @param path The path to check
+   * @returns True if exists, false otherwise
+   */
+  async exists(path) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Get file/directory stats.
+   * @param path The path to stat
+   * @returns File/directory stats
+   */
+  async stat(path) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Watch for file changes in the VM.
+   * @returns An async generator that yields file change events
+   */
+  async *watchFiles() {
+    const response = await this.client.fetch(
+      `/v1/vms/${this.vmId}/watch-files`,
+      {
+        method: "POST"
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to watch files: ${response.status} ${response.statusText}`
+      );
+    }
+    if (!response.body) {
+      throw new Error("Failed to watch files: No response body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line) {
+          yield JSON.parse(line);
+        }
+      }
+    }
+    if (buffer.trim()) {
+      yield JSON.parse(buffer.trim());
+    }
+  }
+}
+
+class VmWithInstance {
+  vm;
+  _init(vm) {
+    this.vm = vm;
+    return this;
+  }
+}
+class VmWith {
+  instance;
+  /**
+   * Helper method to compose multiple configurations together.
+   * Uses the same merging strategy as the main compose function.
+   */
+  compose(...configs) {
+    return composeCreateVmOptions(configs);
+  }
+}
+const VmService = VmWith;
+const VmBuilder = VmWith;
+function composeCreateVmOptions(arr) {
+  const result = {};
+  for (const options of arr) {
+    if (options.idleTimeoutSeconds !== void 0)
+      result.idleTimeoutSeconds = options.idleTimeoutSeconds;
+    if (options.waitForReadySignal !== void 0)
+      result.waitForReadySignal = options.waitForReadySignal;
+    if (options.readySignalTimeoutSeconds !== void 0)
+      result.readySignalTimeoutSeconds = options.readySignalTimeoutSeconds;
+    if (options.workdir !== void 0) result.workdir = options.workdir;
+    if (options.snapshotId !== void 0)
+      result.snapshotId = options.snapshotId;
+    if (options.recreate !== void 0) result.recreate = options.recreate;
+    if (options.persistence !== void 0)
+      result.persistence = options.persistence;
+    if (options.ports !== void 0) {
+      if (!result.ports) {
+        result.ports = options.ports;
+      } else if (options.ports !== null) {
+        const existingPorts = result.ports || [];
+        const newPorts = options.ports;
+        const portMap = /* @__PURE__ */ new Map();
+        for (const port of existingPorts) {
+          portMap.set(port.port, port);
+        }
+        for (const port of newPorts) {
+          portMap.set(port.port, port);
+        }
+        result.ports = Array.from(portMap.values());
+      }
+    }
+    if (options.systemd !== void 0) {
+      if (!result.systemd) {
+        result.systemd = options.systemd;
+      } else if (options.systemd !== null) {
+        if (options.systemd.services !== void 0) {
+          const existingServices = result.systemd.services || [];
+          const newServices = options.systemd.services || [];
+          const serviceMap = /* @__PURE__ */ new Map();
+          for (const service of existingServices) {
+            serviceMap.set(service.name, service);
+          }
+          for (const service of newServices) {
+            serviceMap.set(service.name, service);
+          }
+          result.systemd.services = Array.from(serviceMap.values());
+        }
+        if (options.systemd.patchedServices !== void 0) {
+          const existingPatched = result.systemd.patchedServices || [];
+          const newPatched = options.systemd.patchedServices || [];
+          const patchedMap = /* @__PURE__ */ new Map();
+          for (const service of existingPatched) {
+            patchedMap.set(service.name, service);
+          }
+          for (const service of newPatched) {
+            patchedMap.set(service.name, service);
+          }
+          result.systemd.patchedServices = Array.from(patchedMap.values());
+        }
+      }
+    }
+    if (options.users !== void 0) {
+      if (!result.users) {
+        result.users = options.users;
+      } else if (options.users !== null) {
+        const existingUsers = result.users || [];
+        const newUsers = options.users;
+        const userMap = /* @__PURE__ */ new Map();
+        for (const user of existingUsers) {
+          userMap.set(user.name, user);
+        }
+        for (const user of newUsers) {
+          userMap.set(user.name, user);
+        }
+        result.users = Array.from(userMap.values());
+      }
+    }
+    if (options.groups !== void 0) {
+      if (!result.groups) {
+        result.groups = options.groups;
+      } else if (options.groups !== null) {
+        const existingGroups = result.groups || [];
+        const newGroups = options.groups;
+        const groupMap = /* @__PURE__ */ new Map();
+        for (const group of existingGroups) {
+          groupMap.set(group.name, group);
+        }
+        for (const group of newGroups) {
+          groupMap.set(group.name, group);
+        }
+        result.groups = Array.from(groupMap.values());
+      }
+    }
+    if (options.additionalFiles !== void 0) {
+      if (!result.additionalFiles) {
+        result.additionalFiles = options.additionalFiles;
+      } else if (options.additionalFiles !== null) {
+        result.additionalFiles = {
+          ...result.additionalFiles,
+          ...options.additionalFiles
+        };
+      }
+    }
+    if (options.gitRepos !== void 0) {
+      if (!result.gitRepos) {
+        result.gitRepos = options.gitRepos;
+      } else if (options.gitRepos !== null) {
+        const existingRepos = result.gitRepos || [];
+        const newRepos = options.gitRepos;
+        const repoMap = /* @__PURE__ */ new Map();
+        for (const repo of existingRepos) {
+          repoMap.set(repo.path, repo);
+        }
+        for (const repo of newRepos) {
+          repoMap.set(repo.path, repo);
+        }
+        result.gitRepos = Array.from(repoMap.values());
+      }
+    }
+    if (options.template !== void 0) {
+      if (!result.template) {
+        result.template = options.template;
+      } else if (options.template !== null) {
+        const baseTemplate = result.template instanceof VmTemplate ? result.template["template"] : result.template;
+        const newTemplate = options.template instanceof VmTemplate ? options.template["template"] : options.template;
+        result.template = {
+          // Simple overrides - start with base, override with new
+          snapshotId: newTemplate.snapshotId !== void 0 ? newTemplate.snapshotId : baseTemplate.snapshotId,
+          rootfsSizeMb: newTemplate.rootfsSizeMb !== void 0 ? newTemplate.rootfsSizeMb : baseTemplate.rootfsSizeMb,
+          workdir: newTemplate.workdir !== void 0 ? newTemplate.workdir : baseTemplate.workdir,
+          idleTimeoutSeconds: newTemplate.idleTimeoutSeconds !== void 0 ? newTemplate.idleTimeoutSeconds : baseTemplate.idleTimeoutSeconds,
+          waitForReadySignal: newTemplate.waitForReadySignal !== void 0 ? newTemplate.waitForReadySignal : baseTemplate.waitForReadySignal,
+          readySignalTimeoutSeconds: newTemplate.readySignalTimeoutSeconds !== void 0 ? newTemplate.readySignalTimeoutSeconds : baseTemplate.readySignalTimeoutSeconds,
+          persistence: newTemplate.persistence !== void 0 ? newTemplate.persistence : baseTemplate.persistence,
+          // Merge ports
+          ports: (() => {
+            if (newTemplate.ports === null) return null;
+            if (!baseTemplate.ports) return newTemplate.ports;
+            if (newTemplate.ports === void 0) return baseTemplate.ports;
+            const portMap = /* @__PURE__ */ new Map();
+            for (const port of baseTemplate.ports || []) {
+              portMap.set(port.port, port);
+            }
+            for (const port of newTemplate.ports || []) {
+              portMap.set(port.port, port);
+            }
+            return Array.from(portMap.values());
+          })(),
+          // Merge systemd
+          systemd: (() => {
+            if (newTemplate.systemd === null) return null;
+            if (!baseTemplate.systemd) return newTemplate.systemd;
+            if (newTemplate.systemd === void 0) return baseTemplate.systemd;
+            const mergedSystemd = {
+              ...baseTemplate.systemd,
+              ...newTemplate.systemd
+            };
+            const baseServices = baseTemplate.systemd?.services || [];
+            const newServices = newTemplate.systemd?.services || [];
+            if (baseServices.length > 0 || newServices.length > 0) {
+              const serviceMap = /* @__PURE__ */ new Map();
+              for (const svc of baseServices) {
+                serviceMap.set(svc.name, svc);
+              }
+              for (const svc of newServices) {
+                serviceMap.set(svc.name, svc);
+              }
+              mergedSystemd.services = Array.from(serviceMap.values());
+            }
+            const basePatchedServices = baseTemplate.systemd?.patchedServices || [];
+            const newPatchedServices = newTemplate.systemd?.patchedServices || [];
+            if (basePatchedServices.length > 0 || newPatchedServices.length > 0) {
+              const patchedMap = /* @__PURE__ */ new Map();
+              for (const svc of basePatchedServices) {
+                patchedMap.set(svc.name, svc);
+              }
+              for (const svc of newPatchedServices) {
+                patchedMap.set(svc.name, svc);
+              }
+              mergedSystemd.patchedServices = Array.from(patchedMap.values());
+            }
+            return mergedSystemd;
+          })(),
+          // Merge users
+          users: (() => {
+            if (newTemplate.users === null) return null;
+            if (!baseTemplate.users) return newTemplate.users;
+            if (newTemplate.users === void 0) return baseTemplate.users;
+            const userMap = /* @__PURE__ */ new Map();
+            for (const user of baseTemplate.users || []) {
+              userMap.set(user.name, user);
+            }
+            for (const user of newTemplate.users || []) {
+              userMap.set(user.name, user);
+            }
+            return Array.from(userMap.values());
+          })(),
+          // Merge groups
+          groups: (() => {
+            if (newTemplate.groups === null) return null;
+            if (!baseTemplate.groups) return newTemplate.groups;
+            if (newTemplate.groups === void 0) return baseTemplate.groups;
+            const groupMap = /* @__PURE__ */ new Map();
+            for (const group of baseTemplate.groups || []) {
+              groupMap.set(group.name, group);
+            }
+            for (const group of newTemplate.groups || []) {
+              groupMap.set(group.name, group);
+            }
+            return Array.from(groupMap.values());
+          })(),
+          // Merge additionalFiles
+          additionalFiles: (() => {
+            if (newTemplate.additionalFiles === null) return null;
+            if (!baseTemplate.additionalFiles)
+              return newTemplate.additionalFiles;
+            if (newTemplate.additionalFiles === void 0)
+              return baseTemplate.additionalFiles;
+            return {
+              ...baseTemplate.additionalFiles,
+              ...newTemplate.additionalFiles
+            };
+          })(),
+          // Merge gitRepos
+          gitRepos: (() => {
+            if (newTemplate.gitRepos === null) return null;
+            if (!baseTemplate.gitRepos) return newTemplate.gitRepos;
+            if (newTemplate.gitRepos === void 0)
+              return baseTemplate.gitRepos;
+            const repoMap = /* @__PURE__ */ new Map();
+            for (const repo of baseTemplate.gitRepos || []) {
+              repoMap.set(repo.path, repo);
+            }
+            for (const repo of newTemplate.gitRepos || []) {
+              repoMap.set(repo.path, repo);
+            }
+            return Array.from(repoMap.values());
+          })()
+        };
+      }
+    }
+  }
+  return result;
+}
+
+class VmTerminals {
+  constructor(vmId, client) {
+    this.vmId = vmId;
+    this.client = client;
+  }
+  /**
+   * List all terminals in the VM.
+   * @returns Array of terminal information
+   */
+  async list() {
+    return this.client.get("/v1/vms/{vm_id}/terminals", {
+      params: { vm_id: this.vmId }
+    });
+  }
+  /**
+   * Get logs from a specific terminal.
+   * @param terminalId The ID of the terminal
+   * @returns Terminal log entries
+   */
+  async getLogs({ terminalId }) {
+    return this.client.get("/v1/vms/{vm_id}/terminals/{terminal_id}/logs", {
+      params: { vm_id: this.vmId, terminal_id: terminalId }
+    });
+  }
+  /**
+   * Get xterm-256color output from a specific terminal.
+   * @param terminalId The ID of the terminal
+   * @returns Terminal output
+   */
+  async getOutput({ terminalId }) {
+    return this.client.get(
+      "/v1/vms/{vm_id}/terminals/{terminal_id}/xterm-256color",
+      {
+        params: { vm_id: this.vmId, terminal_id: terminalId }
+      }
+    );
+  }
+}
+class Vm {
+  constructor(vmId, apiClient) {
+    this.apiClient = apiClient;
+    this.vmId = vmId;
+    this.fs = new FileSystem(vmId, apiClient);
+    this.terminals = new VmTerminals(vmId, apiClient);
+  }
+  vmId;
+  fs;
+  terminals;
+  /**
+   * Get the current state and metadata of the VM.
+   * @returns VM state information
+   */
+  async getInfo() {
+    return this.apiClient.get("/v1/vms/{vm_id}", {
+      params: { vm_id: this.vmId }
+    });
+  }
+  /**
+   * Start the VM.
+   * @param options Optional startup configuration
+   * @returns Start response with VM information
+   */
+  async start({ ...options } = {}) {
+    return this.apiClient.post("/v1/vms/{vm_id}/start", {
+      params: { vm_id: this.vmId },
+      body: options
+    });
+  }
+  /**
+   * Stop the VM gracefully.
+   * @returns Stop response
+   */
+  async stop() {
+    return this.apiClient.post("/v1/vms/{vm_id}/stop", {
+      params: { vm_id: this.vmId }
+    });
+  }
+  /**
+   * Suspend the VM to disk.
+   * @returns Suspend response
+   */
+  async suspend() {
+    return this.apiClient.post("/v1/vms/{vm_id}/suspend", {
+      params: { vm_id: this.vmId }
+    });
+  }
+  /**
+   * Kill the VM immediately.
+   * @returns Kill response
+   */
+  async kill() {
+    return this.apiClient.post("/v1/vms/{vm_id}/kill", {
+      params: { vm_id: this.vmId }
+    });
+  }
+  /**
+   * Wait for the VM to exit.
+   * @returns Await response with exit information
+   */
+  async waitForExit() {
+    return this.apiClient.post("/v1/vms/{vm_id}/await", {
+      params: { vm_id: this.vmId }
+    });
+  }
+  /**
+   * Execute a command in the VM and wait for it to complete.
+   * @param command The command to execute
+   * @param terminal Optional terminal ID
+   * @param timeoutMs Optional timeout in milliseconds
+   * @returns Execution result with stdout/stderr
+   */
+  async exec(options) {
+    if (typeof options === "string") {
+      options = { command: options };
+    }
+    const { command, terminal, timeoutMs } = options;
+    return this.apiClient.post("/v1/vms/{vm_id}/exec-await", {
+      params: { vm_id: this.vmId },
+      body: {
+        command,
+        terminal: terminal ?? null,
+        timeoutMs: timeoutMs ?? null
+      }
+    });
+  }
+  /**
+   * Fork (clone) the VM.
+   * @param options Optional fork configuration
+   * @returns A new VM instance representing the forked VM
+   */
+  async fork({
+    ...options
+  } = {}) {
+    const response = await this.apiClient.post("/v1/vms/{vm_id}/fork", {
+      params: { vm_id: this.vmId },
+      body: options
+    });
+    const vmId = response.id;
+    return {
+      vmId,
+      vm: new Vm(vmId, this.apiClient)
+    };
+  }
+  /**
+   * Optimize the VM (compact memory/disk).
+   * @returns Optimization response
+   */
+  async optimize() {
+    return this.apiClient.post("/v1/vms/{vm_id}/optimize", {
+      params: { vm_id: this.vmId }
+    });
+  }
+  /**
+   * Resize the VM's disk.
+   * @param sizeMb New disk size in megabytes
+   * @returns Resize response
+   */
+  async resize({
+    sizeMb
+  }) {
+    return this.apiClient.post("/v1/vms/{id}/resize", {
+      params: { id: this.vmId },
+      body: { sizeMb }
+    });
+  }
+}
+class VmSnapshotsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  async ensure(options) {
+    return this.apiClient.post("/v1/vms/snapshots", {
+      body: {
+        ...options,
+        // @ts-ignore
+        template: options.template?.template
+      }
+    });
+  }
+}
+class VmsNamespace {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+    this.snapshots = new VmSnapshotsNamespace(apiClient);
+  }
+  snapshots;
+  /**
+   * Create a new VM.
+   * @param options Optional VM configuration
+   * @returns A VM instance representing the created VM
+   */
+  async create(options = {}) {
+    const builders = options.with || {};
+    const { with: _, ...baseConfig } = options;
+    let config = baseConfig;
+    const keys = Object.keys(builders);
+    for (const key of keys) {
+      const builder = builders[key];
+      if (builder) {
+        config = await builder.configure(config);
+      }
+    }
+    const response = await this.apiClient.post("/v1/vms", {
+      body: {
+        ...config,
+        template: config.template instanceof VmTemplate ? config.template["template"] : config.template
+      }
+    });
+    const vmId = response.id;
+    const vm = new Vm(vmId, this.apiClient);
+    for (const key in builders) {
+      const builder = builders[key];
+      if (builder) {
+        const instance = builder.createInstance();
+        builder.createInstance = () => {
+          throw new Error(
+            `Attempted to create multiple instances from the same VmWith ${key}: ${builder.constructor.name}`
+          );
+        };
+        builder.instance = instance;
+        instance._init(vm);
+        vm[key] = instance;
+      }
+    }
+    return {
+      ...response,
+      vmId,
+      vm,
+      domains: response.domains || []
+    };
+  }
+  /**
+   * List all VMs.
+   * @returns List of VMs with their states and metadata
+   */
+  async list() {
+    return this.apiClient.get("/v1/vms", void 0);
+  }
+  /**
+   * Create a VM instance by ID without making an api call.
+   */
+  ref({ vmId }) {
+    return new Vm(vmId, this.apiClient);
+  }
+}
+class VmTemplate {
+  template;
+  constructor(template) {
+    this.template = template;
+  }
+}
+
+class Freestyle {
+  apiClient;
+  // Organized namespaces
+  domains;
+  git;
+  identities;
+  dns;
+  edge;
+  vms;
+  constructor(options = {}) {
+    options.baseUrl ?? process.env.FREESTYLE_API_URL;
+    let apiKey;
+    if ("accessToken" in options && options.accessToken) {
+      options.accessToken;
+    } else {
+      apiKey = options.apiKey ?? process.env.FREESTYLE_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "API key is required. Please provide it in the constructor or set the FREESTYLE_API_KEY environment variable."
+        );
+      }
+    }
+    this.apiClient = new ApiClient(options);
+    this.domains = new DomainsNamespace(this.apiClient);
+    this.git = new GitNamespace(this.apiClient, this);
+    this.identities = new IdentitiesNamespace(this.apiClient);
+    this.dns = new DnsNamespace(this.apiClient);
+    this.edge = new EdgeNamespace(this.apiClient);
+    this.vms = new VmsNamespace(this.apiClient);
+  }
+  /**
+   * Helper method to make raw fetch requests to the API.
+   */
+  fetch(path, init) {
+    return this.apiClient.fetch(path, init);
+  }
+}
+function createLazyFreestyle(options = {}) {
+  let instance = null;
+  const getOrCreateInstance = () => {
+    if (!instance) {
+      instance = new Freestyle(options);
+    }
+    return instance;
+  };
+  return new Proxy({}, {
+    get(_target, prop) {
+      const inst = getOrCreateInstance();
+      const value = inst[prop];
+      if (typeof value === "function") {
+        return value.bind(inst);
+      }
+      return value;
+    }
+  });
+}
+const freestyle = createLazyFreestyle();
+
+exports.Deployment = Deployment;
+exports.Errors = errors;
+exports.FileSystem = FileSystem;
+exports.Freestyle = Freestyle;
+exports.GitRepo = GitRepo;
+exports.Identity = Identity;
+exports.Vm = Vm;
+exports.VmBuilder = VmBuilder;
+exports.VmService = VmService;
+exports.VmTemplate = VmTemplate;
+exports.VmWith = VmWith;
+exports.VmWithInstance = VmWithInstance;
+exports.freestyle = freestyle;