@3dverse/api 0.1.0 → 0.1.2

package/dist/index.js

@@ -0,0 +1,1095 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var library_exports = {};
+__export(library_exports, {
+  ApiError: () => ApiError,
+  UnexpectedServiceError: () => UnexpectedServiceError,
+  axiosInstance: () => axiosInstance,
+  createAsset: () => createAsset,
+  createFolder: () => createFolder,
+  createGroup: () => createGroup,
+  createSession: () => createSession,
+  createSubfolder: () => createSubfolder,
+  deleteAsset: () => deleteAsset,
+  deleteAssets: () => deleteAssets,
+  deleteEntity: () => deleteEntity,
+  deleteFolder: () => deleteFolder,
+  deleteGroup: () => deleteGroup,
+  deleteSourceFiles: () => deleteSourceFiles,
+  deleteUser: () => deleteUser,
+  downloadSourceFile: () => downloadSourceFile,
+  exportAsset: () => exportAsset,
+  generateGuestToken: () => generateGuestToken,
+  generateUserToken: () => generateUserToken,
+  getAssetCode: () => getAssetCode,
+  getAssetCustomTypes: () => getAssetCustomTypes,
+  getAssetDependencies: () => getAssetDependencies,
+  getAssetDescription: () => getAssetDescription,
+  getAssetDetails: () => getAssetDetails,
+  getAssetFolder: () => getAssetFolder,
+  getAssetHistory: () => getAssetHistory,
+  getAssetMeta: () => getAssetMeta,
+  getAssetPayload: () => getAssetPayload,
+  getAssetReferences: () => getAssetReferences,
+  getAssetSourceFile: () => getAssetSourceFile,
+  getAssetThumbnail: () => getAssetThumbnail,
+  getEntity: () => getEntity,
+  getFolderAssets: () => getFolderAssets,
+  getFolderInfo: () => getFolderInfo,
+  getGroup: () => getGroup,
+  getSceneAABB: () => getSceneAABB,
+  getSceneSessions: () => getSceneSessions,
+  getSession: () => getSession,
+  getSessionsInFolder: () => getSessionsInFolder,
+  getSourceFileAssets: () => getSourceFileAssets,
+  getSourceFileDetails: () => getSourceFileDetails,
+  getSourceFilesInFolder: () => getSourceFilesInFolder,
+  getUploadTask: () => getUploadTask,
+  getUploadTasksInFolder: () => getUploadTasksInFolder,
+  getUser: () => getUser,
+  getUserGroups: () => getUserGroups,
+  getUserUploadTasks: () => getUserUploadTasks,
+  grantMemberAccessToFolder: () => grantMemberAccessToFolder,
+  grantMemberAccessToGroup: () => grantMemberAccessToGroup,
+  joinSession: () => joinSession,
+  joinSessionAsGuest: () => joinSessionAsGuest,
+  kickClientFromSession: () => kickClientFromSession,
+  killSession: () => killSession,
+  listAssets: () => listAssets,
+  listFolderAccesses: () => listFolderAccesses,
+  listFolderSubFolders: () => listFolderSubFolders,
+  listFolders: () => listFolders,
+  listSourceFiles: () => listSourceFiles,
+  listUsers: () => listUsers,
+  moveAssets: () => moveAssets,
+  moveFolders: () => moveFolders,
+  moveSourceFiles: () => moveSourceFiles,
+  packageAsset: () => packageAsset,
+  registerUser: () => registerUser,
+  revokeMemberAccessToFolder: () => revokeMemberAccessToFolder,
+  revokeMemberAccessToGroup: () => revokeMemberAccessToGroup,
+  setApiKey: () => setApiKey,
+  setAssetThumbnail: () => setAssetThumbnail,
+  setBaseURL: () => setBaseURL,
+  setBaseUrl: () => setBaseUrl,
+  setUserToken: () => setUserToken,
+  updateAssetDescription: () => updateAssetDescription,
+  updateEntity: () => updateEntity,
+  updateFolder: () => updateFolder,
+  updateGroupDescription: () => updateGroupDescription,
+  updateSourceFileDetails: () => updateSourceFileDetails,
+  updateUser: () => updateUser,
+  uploadSourceFiles: () => uploadSourceFiles
+});
+module.exports = __toCommonJS(library_exports);
+
+// _prebuild/wrapper.ts
+var import_axios = __toESM(require("axios"));
+var axiosInstance = import_axios.default.create({
+  baseURL: "https://api.3dverse.com/app/v1",
+  operationId: "3dverse"
+});
+function setBaseURL(baseURL) {
+  axiosInstance.defaults.baseURL = baseURL;
+}
+function listUsers({
+  offset = 0,
+  limit = 10
+}) {
+  return axiosInstance({
+    operationId: "listUsers",
+    method: "get",
+    url: "/users",
+    params: {
+      offset,
+      limit
+    }
+  });
+}
+function registerUser({
+  username
+}) {
+  return axiosInstance({
+    operationId: "registerUser",
+    method: "post",
+    url: "/users",
+    data: {
+      username
+    }
+  });
+}
+function getUser({
+  user_id
+}) {
+  return axiosInstance({
+    operationId: "getUser",
+    method: "get",
+    url: "/users/" + user_id
+  });
+}
+function updateUser({
+  user_id,
+  username
+}) {
+  return axiosInstance({
+    operationId: "updateUser",
+    method: "patch",
+    url: "/users/" + user_id,
+    data: {
+      username
+    }
+  });
+}
+function deleteUser({
+  user_id
+}) {
+  return axiosInstance({
+    operationId: "deleteUser",
+    method: "delete",
+    url: "/users/" + user_id
+  });
+}
+function generateUserToken({
+  user_id,
+  scope,
+  ttl = "1h"
+}) {
+  return axiosInstance({
+    operationId: "generateUserToken",
+    method: "post",
+    url: "/users/" + user_id + "/tokens",
+    data: {
+      scope,
+      ttl
+    }
+  });
+}
+function getUserGroups({
+  user_id
+}) {
+  return axiosInstance({
+    operationId: "getUserGroups",
+    method: "get",
+    url: "/users/" + user_id + "/groups"
+  });
+}
+function getUserUploadTasks({
+  user_id,
+  offset = 0,
+  limit = 10
+}) {
+  return axiosInstance({
+    operationId: "getUserUploadTasks",
+    method: "get",
+    url: "/users/" + user_id + "/upload-tasks",
+    params: {
+      offset,
+      limit
+    }
+  });
+}
+function createGroup({
+  group_name,
+  group_description,
+  members
+}) {
+  return axiosInstance({
+    operationId: "createGroup",
+    method: "post",
+    url: "/groups",
+    data: {
+      group_name,
+      group_description,
+      members
+    }
+  });
+}
+function getGroup({
+  group_id
+}) {
+  return axiosInstance({
+    operationId: "getGroup",
+    method: "get",
+    url: "/groups/" + group_id
+  });
+}
+function updateGroupDescription({
+  group_id,
+  group_name,
+  group_description
+}) {
+  return axiosInstance({
+    operationId: "updateGroupDescription",
+    method: "patch",
+    url: "/groups/" + group_id,
+    data: {
+      group_name,
+      group_description
+    }
+  });
+}
+function deleteGroup({
+  group_id
+}) {
+  return axiosInstance({
+    operationId: "deleteGroup",
+    method: "delete",
+    url: "/groups/" + group_id
+  });
+}
+function grantMemberAccessToGroup({
+  group_id,
+  member_type,
+  member_id,
+  group_access,
+  folder_access
+}) {
+  return axiosInstance({
+    operationId: "grantMemberAccessToGroup",
+    method: "put",
+    url: "/groups/" + group_id + "/members/" + member_type + "/" + member_id,
+    data: {
+      group_access,
+      folder_access
+    }
+  });
+}
+function revokeMemberAccessToGroup({
+  group_id,
+  member_type,
+  member_id
+}) {
+  return axiosInstance({
+    operationId: "revokeMemberAccessToGroup",
+    method: "delete",
+    url: "/groups/" + group_id + "/members/" + member_type + "/" + member_id
+  });
+}
+function listFolders({
+  offset = 0,
+  limit = 10
+}) {
+  return axiosInstance({
+    operationId: "listFolders",
+    method: "get",
+    url: "/folders",
+    params: {
+      offset,
+      limit
+    }
+  });
+}
+function createFolder({
+  folder_name,
+  subfolders
+}) {
+  return axiosInstance({
+    operationId: "createFolder",
+    method: "post",
+    url: "/folders",
+    data: {
+      folder_name,
+      subfolders
+    }
+  });
+}
+function getFolderInfo({
+  folder_id
+}) {
+  return axiosInstance({
+    operationId: "getFolderInfo",
+    method: "get",
+    url: "/folders/" + folder_id
+  });
+}
+function moveFolders({
+  folder_id,
+  folderIds
+}) {
+  return axiosInstance({
+    operationId: "moveFolders",
+    method: "put",
+    url: "/folders/" + folder_id,
+    data: folderIds
+  });
+}
+function updateFolder({
+  folder_id,
+  folder_name
+}) {
+  return axiosInstance({
+    operationId: "updateFolder",
+    method: "patch",
+    url: "/folders/" + folder_id,
+    data: {
+      folder_name
+    }
+  });
+}
+function deleteFolder({
+  folder_id
+}) {
+  return axiosInstance({
+    operationId: "deleteFolder",
+    method: "delete",
+    url: "/folders/" + folder_id
+  });
+}
+function listFolderAccesses({
+  folder_id
+}) {
+  return axiosInstance({
+    operationId: "listFolderAccesses",
+    method: "get",
+    url: "/folders/" + folder_id + "/access"
+  });
+}
+function grantMemberAccessToFolder({
+  folder_id,
+  member_type,
+  member_id,
+  access
+}) {
+  return axiosInstance({
+    operationId: "grantMemberAccessToFolder",
+    method: "put",
+    url: "/folders/" + folder_id + "/access/" + member_type + "/" + member_id,
+    data: {
+      access
+    }
+  });
+}
+function revokeMemberAccessToFolder({
+  folder_id,
+  member_type,
+  member_id
+}) {
+  return axiosInstance({
+    operationId: "revokeMemberAccessToFolder",
+    method: "delete",
+    url: "/folders/" + folder_id + "/access/" + member_type + "/" + member_id
+  });
+}
+function createSubfolder({
+  folder_id,
+  folder_name,
+  subfolders
+}) {
+  return axiosInstance({
+    operationId: "createSubfolder",
+    method: "post",
+    url: "/folders/" + folder_id + "/folders",
+    data: {
+      folder_name,
+      subfolders
+    }
+  });
+}
+function listFolderSubFolders({
+  folder_id,
+  depth = 0
+}) {
+  return axiosInstance({
+    operationId: "listFolderSubFolders",
+    method: "get",
+    url: "/folders/" + folder_id + "/folders",
+    params: {
+      depth
+    }
+  });
+}
+function uploadSourceFiles({
+  folder_id,
+  body
+}) {
+  return axiosInstance({
+    operationId: "uploadSourceFiles",
+    method: "post",
+    url: "/folders/" + folder_id + "/source-files",
+    headers: {
+      "Content-Type": "multipart/form-data"
+    },
+    data: body
+  });
+}
+function getSourceFilesInFolder({
+  folder_id,
+  offset = 0,
+  limit = 10
+}) {
+  return axiosInstance({
+    operationId: "getSourceFilesInFolder",
+    method: "get",
+    url: "/folders/" + folder_id + "/source-files",
+    params: {
+      offset,
+      limit
+    }
+  });
+}
+function moveSourceFiles({
+  folder_id,
+  sourceFileIds
+}) {
+  return axiosInstance({
+    operationId: "moveSourceFiles",
+    method: "put",
+    url: "/folders/" + folder_id + "/source-files",
+    data: sourceFileIds
+  });
+}
+function getUploadTasksInFolder({
+  folder_id,
+  offset = 0,
+  limit = 10
+}) {
+  return axiosInstance({
+    operationId: "getUploadTasksInFolder",
+    method: "get",
+    url: "/folders/" + folder_id + "/upload-tasks",
+    params: {
+      offset,
+      limit
+    }
+  });
+}
+function getFolderAssets({
+  folder_id,
+  offset = 0,
+  limit = 10
+}) {
+  return axiosInstance({
+    operationId: "getFolderAssets",
+    method: "get",
+    url: "/folders/" + folder_id + "/assets",
+    params: {
+      offset,
+      limit
+    }
+  });
+}
+function moveAssets({
+  folder_id,
+  assetIds
+}) {
+  return axiosInstance({
+    operationId: "moveAssets",
+    method: "put",
+    url: "/folders/" + folder_id + "/assets",
+    data: assetIds
+  });
+}
+function createAsset({
+  folder_id,
+  asset_container_creatable,
+  assetCreationOptions
+}) {
+  return axiosInstance({
+    operationId: "createAsset",
+    method: "post",
+    url: "/folders/" + folder_id + "/assets/" + asset_container_creatable,
+    data: assetCreationOptions
+  });
+}
+function getSessionsInFolder({
+  folder_id
+}) {
+  return axiosInstance({
+    operationId: "getSessionsInFolder",
+    method: "get",
+    url: "/folders/" + folder_id + "/sessions"
+  });
+}
+function listSourceFiles({
+  offset = 0,
+  limit = 10
+}) {
+  return axiosInstance({
+    operationId: "listSourceFiles",
+    method: "get",
+    url: "/source-files",
+    params: {
+      offset,
+      limit
+    }
+  });
+}
+function deleteSourceFiles({
+  sourceFileIds
+}) {
+  return axiosInstance({
+    operationId: "deleteSourceFiles",
+    method: "delete",
+    url: "/source-files",
+    data: sourceFileIds
+  });
+}
+function downloadSourceFile({
+  source_file_id
+}) {
+  return axiosInstance({
+    operationId: "downloadSourceFile",
+    method: "get",
+    url: "/source-files/" + source_file_id,
+    responseType: "arraybuffer"
+  });
+}
+function getSourceFileDetails({
+  source_file_id
+}) {
+  return axiosInstance({
+    operationId: "getSourceFileDetails",
+    method: "get",
+    url: "/source-files/" + source_file_id + "/details"
+  });
+}
+function updateSourceFileDetails({
+  source_file_id,
+  source_file_name
+}) {
+  return axiosInstance({
+    operationId: "updateSourceFileDetails",
+    method: "patch",
+    url: "/source-files/" + source_file_id + "/details",
+    data: {
+      source_file_name
+    }
+  });
+}
+function getSourceFileAssets({
+  source_file_id
+}) {
+  return axiosInstance({
+    operationId: "getSourceFileAssets",
+    method: "get",
+    url: "/source-files/" + source_file_id + "/assets"
+  });
+}
+function getUploadTask({
+  upload_task_id
+}) {
+  return axiosInstance({
+    operationId: "getUploadTask",
+    method: "get",
+    url: "/upload-tasks/" + upload_task_id
+  });
+}
+function listAssets({
+  offset = 0,
+  limit = 10
+}) {
+  return axiosInstance({
+    operationId: "listAssets",
+    method: "get",
+    url: "/assets",
+    params: {
+      offset,
+      limit
+    }
+  });
+}
+function deleteAssets({
+  assetIds
+}) {
+  return axiosInstance({
+    operationId: "deleteAssets",
+    method: "delete",
+    url: "/assets",
+    data: assetIds
+  });
+}
+function deleteAsset({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "deleteAsset",
+    method: "delete",
+    url: "/assets/" + asset_container + "/" + asset_id
+  });
+}
+function getAssetSourceFile({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetSourceFile",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/source-file"
+  });
+}
+function getAssetDetails({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetDetails",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/details"
+  });
+}
+function getAssetFolder({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetFolder",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/folder"
+  });
+}
+function getAssetDependencies({
+  asset_container,
+  asset_id,
+  format = "flat",
+  depth = "all",
+  filter
+}) {
+  return axiosInstance({
+    operationId: "getAssetDependencies",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/dependencies",
+    params: {
+      format,
+      depth,
+      filter
+    }
+  });
+}
+function getAssetReferences({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetReferences",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/references"
+  });
+}
+function getAssetDescription({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetDescription",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/description"
+  });
+}
+function updateAssetDescription({
+  asset_container,
+  asset_id,
+  assetDescription
+}) {
+  return axiosInstance({
+    operationId: "updateAssetDescription",
+    method: "patch",
+    url: "/assets/" + asset_container + "/" + asset_id + "/description",
+    data: assetDescription
+  });
+}
+function getAssetPayload({
+  asset_container_with_payload,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetPayload",
+    method: "get",
+    url: "/assets/" + asset_container_with_payload + "/" + asset_id + "/payload",
+    responseType: "arraybuffer"
+  });
+}
+function getAssetHistory({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetHistory",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/history"
+  });
+}
+function getAssetMeta({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetMeta",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/meta"
+  });
+}
+function getAssetCode({
+  asset_container_with_code,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetCode",
+    method: "get",
+    url: "/assets/" + asset_container_with_code + "/" + asset_id + "/code"
+  });
+}
+function getAssetThumbnail({
+  asset_container,
+  asset_id,
+  size,
+  default_url
+}) {
+  return axiosInstance({
+    operationId: "getAssetThumbnail",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/thumbnail",
+    params: {
+      size,
+      default_url
+    }
+  });
+}
+function setAssetThumbnail({
+  asset_container,
+  asset_id,
+  body
+}, contentType) {
+  return axiosInstance({
+    operationId: "setAssetThumbnail",
+    method: "put",
+    url: "/assets/" + asset_container + "/" + asset_id + "/thumbnail",
+    headers: {
+      "Content-Type": contentType
+    },
+    data: body
+  });
+}
+function getAssetCustomTypes({
+  asset_container_with_custom_types,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "getAssetCustomTypes",
+    method: "get",
+    url: "/assets/" + asset_container_with_custom_types + "/" + asset_id + "/custom-types"
+  });
+}
+function packageAsset({
+  asset_container,
+  asset_id
+}) {
+  return axiosInstance({
+    operationId: "packageAsset",
+    method: "get",
+    url: "/assets/" + asset_container + "/" + asset_id + "/package",
+    responseType: "arraybuffer"
+  });
+}
+function exportAsset({
+  asset_container_exportable,
+  asset_id,
+  format,
+  scale = 1
+}) {
+  return axiosInstance({
+    operationId: "exportAsset",
+    method: "get",
+    url: "/assets/" + asset_container_exportable + "/" + asset_id + "/exports/" + format,
+    responseType: "arraybuffer",
+    params: {
+      scale
+    }
+  });
+}
+function getSceneSessions({
+  scene_id
+}) {
+  return axiosInstance({
+    operationId: "getSceneSessions",
+    method: "get",
+    url: "/assets/scenes/" + scene_id + "/sessions"
+  });
+}
+function getSceneAABB({
+  scene_id
+}) {
+  return axiosInstance({
+    operationId: "getSceneAABB",
+    method: "get",
+    url: "/assets/scenes/" + scene_id + "/aabb"
+  });
+}
+function getEntity({
+  scene_id,
+  entity_id,
+  compute_global_transform = false
+}) {
+  return axiosInstance({
+    operationId: "getEntity",
+    method: "get",
+    url: "/assets/scenes/" + scene_id + "/entities/" + entity_id,
+    params: {
+      compute_global_transform
+    }
+  });
+}
+function updateEntity({
+  scene_id,
+  entity_id,
+  entity
+}) {
+  return axiosInstance({
+    operationId: "updateEntity",
+    method: "patch",
+    url: "/assets/scenes/" + scene_id + "/entities/" + entity_id,
+    data: entity
+  });
+}
+function deleteEntity({
+  scene_id,
+  entity_id
+}) {
+  return axiosInstance({
+    operationId: "deleteEntity",
+    method: "delete",
+    url: "/assets/scenes/" + scene_id + "/entities/" + entity_id
+  });
+}
+function createSession({
+  scene_id
+}) {
+  return axiosInstance({
+    operationId: "createSession",
+    method: "post",
+    url: "/sessions",
+    data: {
+      scene_id
+    }
+  });
+}
+function getSession({
+  session_id
+}) {
+  return axiosInstance({
+    operationId: "getSession",
+    method: "get",
+    url: "/sessions/" + session_id
+  });
+}
+function killSession({
+  session_id
+}) {
+  return axiosInstance({
+    operationId: "killSession",
+    method: "delete",
+    url: "/sessions/" + session_id
+  });
+}
+function joinSession({
+  session_id
+}) {
+  return axiosInstance({
+    operationId: "joinSession",
+    method: "post",
+    url: "/sessions/" + session_id + "/clients"
+  });
+}
+function kickClientFromSession({
+  session_id,
+  client_id
+}) {
+  return axiosInstance({
+    operationId: "kickClientFromSession",
+    method: "delete",
+    url: "/sessions/" + session_id + "/clients/" + client_id
+  });
+}
+function joinSessionAsGuest() {
+  return axiosInstance({
+    operationId: "joinSessionAsGuest",
+    method: "post",
+    url: "/sessions/guests"
+  });
+}
+function generateGuestToken({
+  session_id
+}) {
+  return axiosInstance({
+    operationId: "generateGuestToken",
+    method: "post",
+    url: "/sessions/" + session_id + "/guests"
+  });
+}
+
+// index.ts
+function setApiKey(apiKey) {
+  axiosInstance.defaults.headers.common["api_key"] = apiKey;
+  delete axiosInstance.defaults.headers.common["user_token"];
+}
+function setUserToken(userToken) {
+  axiosInstance.defaults.headers.common["user_token"] = userToken;
+  delete axiosInstance.defaults.headers.common["api_key"];
+}
+function setBaseUrl(url) {
+  axiosInstance.defaults.baseURL = url;
+}
+var ServiceError = class extends Error {
+  errorCode;
+  httpCode;
+  message;
+  //--------------------------------------------------------------------------
+  constructor(errorCode, httpCode, message) {
+    super();
+    this.errorCode = errorCode;
+    this.httpCode = httpCode;
+    this.message = message;
+  }
+};
+var ApiError = class extends ServiceError {
+  serviceError;
+  constructor(errorCode, status, message, serviceError) {
+    super(errorCode, status, message);
+    this.serviceError = serviceError;
+  }
+};
+var UnexpectedServiceError = class extends ServiceError {
+  unexpectedError;
+  constructor(status, unexpectedError) {
+    super(0, status, "Unexpected service error error");
+    this.unexpectedError = unexpectedError;
+  }
+};
+function installInterceptors() {
+  const CLIENT_ERROR = 400;
+  const INTERNAL_SERVER_ERROR = 500;
+  axiosInstance.interceptors.response.use(
+    (successFulResponse) => {
+      if (successFulResponse.config.responseType === "stream") {
+        successFulResponse.data.pause();
+      }
+      return successFulResponse;
+    },
+    (error) => {
+      if (!error.response) {
+        return Promise.reject(error);
+      }
+      const axiosError = error;
+      const status = axiosError.response?.status || INTERNAL_SERVER_ERROR;
+      const errorData = axiosError.response?.data;
+      if (!errorData && axiosError.request.method === "HEAD" && status >= CLIENT_ERROR && status < INTERNAL_SERVER_ERROR) {
+        return axiosError.response;
+      }
+      if (!errorData || !("error" in errorData)) {
+        return Promise.reject(new UnexpectedServiceError(status, errorData));
+      }
+      const serviceError = errorData.error;
+      return Promise.reject(new ApiError(serviceError.errorCode, status, serviceError.message, serviceError));
+    }
+  );
+}
+installInterceptors();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  UnexpectedServiceError,
+  axiosInstance,
+  createAsset,
+  createFolder,
+  createGroup,
+  createSession,
+  createSubfolder,
+  deleteAsset,
+  deleteAssets,
+  deleteEntity,
+  deleteFolder,
+  deleteGroup,
+  deleteSourceFiles,
+  deleteUser,
+  downloadSourceFile,
+  exportAsset,
+  generateGuestToken,
+  generateUserToken,
+  getAssetCode,
+  getAssetCustomTypes,
+  getAssetDependencies,
+  getAssetDescription,
+  getAssetDetails,
+  getAssetFolder,
+  getAssetHistory,
+  getAssetMeta,
+  getAssetPayload,
+  getAssetReferences,
+  getAssetSourceFile,
+  getAssetThumbnail,
+  getEntity,
+  getFolderAssets,
+  getFolderInfo,
+  getGroup,
+  getSceneAABB,
+  getSceneSessions,
+  getSession,
+  getSessionsInFolder,
+  getSourceFileAssets,
+  getSourceFileDetails,
+  getSourceFilesInFolder,
+  getUploadTask,
+  getUploadTasksInFolder,
+  getUser,
+  getUserGroups,
+  getUserUploadTasks,
+  grantMemberAccessToFolder,
+  grantMemberAccessToGroup,
+  joinSession,
+  joinSessionAsGuest,
+  kickClientFromSession,
+  killSession,
+  listAssets,
+  listFolderAccesses,
+  listFolderSubFolders,
+  listFolders,
+  listSourceFiles,
+  listUsers,
+  moveAssets,
+  moveFolders,
+  moveSourceFiles,
+  packageAsset,
+  registerUser,
+  revokeMemberAccessToFolder,
+  revokeMemberAccessToGroup,
+  setApiKey,
+  setAssetThumbnail,
+  setBaseURL,
+  setBaseUrl,
+  setUserToken,
+  updateAssetDescription,
+  updateEntity,
+  updateFolder,
+  updateGroupDescription,
+  updateSourceFileDetails,
+  updateUser,
+  uploadSourceFiles
+});
+//# sourceMappingURL=index.js.map