@rezamirzapour/pod-sdk 1.0.4 → 1.0.7

package/dist/index.js

@@ -517,38 +517,1656 @@ var CustomPostService = class {
     return new CustomPostCrudService(this, config);
   }
 };
+
+// src/services/podspace/uploadDownload.ts
+var PodspaceUploadDownloadService = class {
+  http;
+  baseUrl;
+  revalidate;
+  constructor(options) {
+    this.http = options.http;
+    this.baseUrl = options.baseUrl;
+    this.revalidate = options.revalidate || 0;
+  }
+  /**
+   * Upload a single file via FormData to POD Podspace storage.
+   * Swagger: POST /api/files
+   */
+  async uploadFile(formData, paramsOrPath = "/", isPublic = true, options = {}) {
+    const queryParams = typeof paramsOrPath === "string" ? { path: paramsOrPath, isPublic } : { path: "/", isPublic: true, ...paramsOrPath };
+    if (Array.isArray(queryParams.tags)) {
+      queryParams.tags = queryParams.tags.join(",");
+    }
+    if (typeof queryParams.userMetadata === "object") {
+      queryParams.userMetadata = JSON.stringify(queryParams.userMetadata);
+    }
+    if (Array.isArray(queryParams.zoneNames)) {
+      queryParams.zoneNames = queryParams.zoneNames.join(",");
+    }
+    return this.http.post("/api/files", formData, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Upload multiple files simultaneously using FormData.
+   * Swagger: POST /api/files/multiple
+   */
+  async uploadMultipleFiles(formData, params = {}, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.tags)) {
+      queryParams.tags = queryParams.tags.join(",");
+    }
+    if (typeof queryParams.userMetadata === "object") {
+      queryParams.userMetadata = JSON.stringify(queryParams.userMetadata);
+    }
+    if (Array.isArray(queryParams.zoneNames)) {
+      queryParams.zoneNames = queryParams.zoneNames.join(",");
+    }
+    return this.http.post("/api/files/multiple", formData, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Upload an image formatted as Base64 string.
+   * Swagger: POST /api/images/base64
+   */
+  async uploadImageBase64(params, options = {}) {
+    const { filename, file, ...rest } = params;
+    const queryParams = {
+      filename,
+      file,
+      ...rest
+    };
+    if (Array.isArray(queryParams.tags)) {
+      queryParams.tags = queryParams.tags.join(",");
+    }
+    if (typeof queryParams.userMetadata === "object") {
+      queryParams.userMetadata = JSON.stringify(queryParams.userMetadata);
+    }
+    return this.http.post("/api/images/base64", {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Replace the content of an existing file.
+   * Swagger: PUT /api/files/{hash}
+   */
+  async replaceFile(hash, formData, params = {}, options = {}) {
+    return this.http.put(`/api/files/${hash}`, formData, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Upload a file into an existing reserved link hash.
+   * Swagger: POST /api/files/{hash}
+   */
+  async uploadByLink(hash, formData, params = {}, options = {}) {
+    return this.http.post(`/api/files/${hash}`, formData, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Downloads raw file data.
+   * Swagger: GET /api/files/{hash}
+   */
+  async downloadFile(hash, params = {}, options = {}) {
+    return this.http.get(`/api/files/${hash}`, {
+      params,
+      headers: options.headers,
+      signal: options.signal,
+      responseType: "blob"
+    });
+  }
+  /**
+   * Downloads processed image with optional resize, crop, or format conversion.
+   * Swagger: GET /api/v2/images/{hash}
+   */
+  async downloadImage(hash, params = {}, options = {}) {
+    return this.http.get(`/api/v2/images/${hash}`, {
+      params,
+      headers: options.headers,
+      signal: options.signal,
+      responseType: "blob"
+    });
+  }
+  /**
+   * Downloads file thumbnail.
+   * Swagger: GET /api/files/{hash}/thumbnail
+   */
+  async downloadThumbnail(hash, params = {}, options = {}) {
+    return this.http.get(`/api/files/${hash}/thumbnail`, {
+      params,
+      headers: options.headers,
+      signal: options.signal,
+      responseType: "blob"
+    });
+  }
+  /**
+   * Downloads multiple files and folders compressed into a single zip file.
+   * Swagger: GET /api/files
+   */
+  async downloadFilesAsZip(params, options = {}) {
+    const entityHashes = Array.isArray(params.entityHashes) ? params.entityHashes.join(",") : params.entityHashes;
+    return this.http.get("/api/files", {
+      params: {
+        entityHashes,
+        customName: params.customName,
+        password: params.password
+      },
+      headers: options.headers,
+      signal: options.signal,
+      responseType: "blob"
+    });
+  }
+  /**
+   * Obtains a pre-signed upload link.
+   * Swagger: GET /api/files/link
+   */
+  async getUploadLink(params, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.zoneNames)) {
+      queryParams.zoneNames = queryParams.zoneNames.join(",");
+    }
+    if (Array.isArray(queryParams.fileTypeLimits)) {
+      queryParams.fileTypeLimits = queryParams.fileTypeLimits.join(",");
+    }
+    if (typeof queryParams.userMetadata === "object") {
+      queryParams.userMetadata = JSON.stringify(queryParams.userMetadata);
+    }
+    return this.http.get("/api/files/link", {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Builds the direct URL to view or download a file.
+   */
+  getFileUrl(hash, isPublic = true) {
+    return `${this.baseUrl}/api/files/${hash}?isPublic=${isPublic}`;
+  }
+  /**
+   * Builds URL to view/download an image with optional dimensions/crops.
+   */
+  getImageUrl(hash, params = {}) {
+    const search = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0 && v !== null) {
+        search.append(k, String(v));
+      }
+    }
+    const qs = search.toString();
+    return `${this.baseUrl}/api/v2/images/${hash}${qs ? "?" + qs : ""}`;
+  }
+  /**
+   * Builds URL for a file thumbnail.
+   */
+  getThumbnailUrl(hash, params = {}) {
+    const search = new URLSearchParams();
+    if (params.password) search.append("password", params.password);
+    if (params.cachePolicy) search.append("cachePolicy", params.cachePolicy);
+    if (params.accessLevel) search.append("accessLevel", params.accessLevel);
+    const qs = search.toString();
+    return `${this.baseUrl}/api/files/${hash}/thumbnail${qs ? "?" + qs : ""}`;
+  }
+};
+
+// src/services/podspace/files.ts
+var PodspaceFilesService = class {
+  http;
+  revalidate;
+  constructor(options) {
+    this.http = options.http;
+    this.revalidate = options.revalidate || 0;
+  }
+  /**
+   * Retrieves full detail of a file or folder by its hash.
+   * Swagger: GET /api/files/{hash}/detail
+   */
+  async getFileDetail(hash, params = {}, options = {}) {
+    return this.http.get(`/api/files/${hash}/detail`, {
+      params,
+      headers: options.headers,
+      signal: options.signal,
+      next: {
+        revalidate: options.revalidate !== void 0 ? options.revalidate === false ? 0 : options.revalidate : this.revalidate
+      }
+    });
+  }
+  /**
+   * Retrieves file details using its storage path.
+   * Swagger: GET /api/files/details
+   */
+  async getFileDetailByPath(path, params = {}, options = {}) {
+    return this.http.get("/api/files/details", {
+      params: { path, ...params },
+      headers: options.headers,
+      signal: options.signal,
+      next: {
+        revalidate: options.revalidate !== void 0 ? options.revalidate === false ? 0 : options.revalidate : this.revalidate
+      }
+    });
+  }
+  /**
+   * Checks if an entity with given name exists in the folder.
+   * Swagger: GET /api/files/{hash}/exist
+   */
+  async checkEntityExist(hash, fileName, params = {}, options = {}) {
+    return this.http.get(`/api/files/${hash}/exist`, {
+      params: { fileName, ...params },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Renames a file or folder.
+   * Swagger: PUT /api/files/{hash}/rename
+   */
+  async renameEntity(hash, newName, uniqueName, options = {}) {
+    return this.http.put(`/api/files/${hash}/rename`, {}, {
+      params: { newName, uniqueName },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Moves a file or folder to a new destination folder.
+   * Swagger: PUT /api/files/{hash}/move
+   */
+  async moveEntity(hash, destFolderHash, params = {}, options = {}) {
+    return this.http.put(`/api/files/${hash}/move`, {}, {
+      params: { destFolderHash, ...params },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Copies a file or folder to a specified destination folder.
+   * Swagger: PUT /api/files/{hash}/copy
+   */
+  async copyEntity(hash, destFolderHash, params = {}, options = {}) {
+    return this.http.put(`/api/files/${hash}/copy`, {}, {
+      params: { destFolderHash, ...params },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Moves a file or folder to the trash.
+   * Swagger: DELETE /api/files/{hash}
+   */
+  async trashEntity(hash, options = {}) {
+    return this.http.delete(`/api/files/${hash}`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Updates file attributes (e.g. streamable flag).
+   * Swagger: PATCH /api/files/{hash}
+   */
+  async updateFile(hash, params, options = {}) {
+    return this.http.patch(`/api/files/${hash}`, {}, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Searches across user files content and folder names.
+   * Swagger: GET /api/files/search
+   */
+  async searchFiles(params = {}, options = {}) {
+    return this.http.get("/api/files/search", {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves list of recently accessed/uploaded files.
+   * Swagger: GET /api/v2/files/recent
+   */
+  async getRecentFiles(params = {}, options = {}) {
+    return this.http.get("/api/v2/files/recent", {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves versions history of a file.
+   * Swagger: GET /api/files/v2/{hash}/versions
+   */
+  async getFileVersions(hash, options = {}) {
+    return this.http.get(`/api/files/v2/${hash}/versions`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Rolls back a file to its previous version.
+   * Swagger: PATCH /api/files/versions/{hash}
+   */
+  async rollbackFileVersion(hash, options = {}) {
+    return this.http.patch(`/api/files/versions/${hash}`, {}, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves native metadata of a file.
+   * Swagger: GET /api/v2/files/{hash}/native/metadata
+   */
+  async getFileNativeMetadata(hash, options = {}) {
+    return this.http.get(`/api/v2/files/${hash}/native/metadata`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Converts supported document file to PDF.
+   * Swagger: GET /api/files/{hash}/convert
+   */
+  async convertFileToPdf(hash, convertType = "pdf", options = {}) {
+    return this.http.get(`/api/files/${hash}/convert`, {
+      params: { convertType },
+      headers: options.headers,
+      signal: options.signal,
+      responseType: "blob"
+    });
+  }
+  /**
+   * Retrieves breadcrumb path for a file or folder.
+   * Swagger: GET /api/files/{hash}/breadcrumb
+   */
+  async getFileBreadcrumb(hash, params = {}, options = {}) {
+    return this.http.get(`/api/files/${hash}/breadcrumb`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Compresses multiple files and folders into a zip archive on the cloud.
+   * Swagger: POST /api/files/compress
+   */
+  async compressToZip(params, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.fileHashes)) queryParams.fileHashes = queryParams.fileHashes.join(",");
+    if (Array.isArray(queryParams.folderHashes)) queryParams.folderHashes = queryParams.folderHashes.join(",");
+    if (Array.isArray(queryParams.zoneNames)) queryParams.zoneNames = queryParams.zoneNames.join(",");
+    return this.http.post("/api/files/compress", {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Extracts a zip archive to a destination folder.
+   * Swagger: PUT /api/files/{hash}/extract
+   */
+  async extractZip(hash, params = {}, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.zoneNames)) queryParams.zoneNames = queryParams.zoneNames.join(",");
+    return this.http.put(`/api/files/${hash}/extract`, {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Sets or updates the cache policy for a file.
+   * Swagger: PUT /api/files/{hash}/cachePolicy
+   */
+  async setCachePolicy(hash, cachePolicy, options = {}) {
+    return this.http.put(`/api/files/${hash}/cachePolicy`, {}, {
+      params: { cachePolicy },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves recent actions and activities done on a file or folder.
+   * Swagger: GET /api/files/{hash}/activities
+   */
+  async getFileActivities(hash, params = {}, options = {}) {
+    return this.http.get(`/api/files/${hash}/activities`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves specific activity log by type.
+   * Swagger: GET /api/files/{hash}/activities/{activity}
+   */
+  async getSpecificActivities(hash, activity, params = {}, options = {}) {
+    return this.http.get(`/api/files/${hash}/activities/${activity}`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves count of specific activities done on file/folder.
+   * Swagger: GET /api/files/{hash}/activities/{activity}/count
+   */
+  async getActivitiesCount(hash, activity, options = {}) {
+    return this.http.get(`/api/files/${hash}/activities/${activity}/count`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/folders.ts
+var PodspaceFoldersService = class {
+  http;
+  revalidate;
+  constructor(options) {
+    this.http = options.http;
+    this.revalidate = options.revalidate || 0;
+  }
+  /**
+   * Creates a new folder.
+   * Swagger: POST /api/folders
+   */
+  async createFolder(params, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.zoneNames)) queryParams.zoneNames = queryParams.zoneNames.join(",");
+    if (Array.isArray(queryParams.tags)) queryParams.tags = queryParams.tags.join(",");
+    if (typeof queryParams.userMetadata === "object") {
+      queryParams.userMetadata = JSON.stringify(queryParams.userMetadata);
+    }
+    return this.http.post("/api/folders", {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Creates nested directories inside a parent folder.
+   * Swagger: POST /api/folders/{hash}/directories
+   */
+  async createDirectories(hash, directories, options = {}) {
+    const dirParam = Array.isArray(directories) ? directories.join(",") : directories;
+    return this.http.post(`/api/folders/${hash}/directories`, {}, {
+      params: { directories: dirParam },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves subfolders and files inside a specified folder.
+   * Swagger: GET /api/folders/{hash}/children
+   */
+  async getFolderChildren(hash, params = {}, options = {}) {
+    return this.http.get(`/api/folders/${hash}/children`, {
+      params,
+      headers: options.headers,
+      signal: options.signal,
+      next: {
+        revalidate: options.revalidate !== void 0 ? options.revalidate === false ? 0 : options.revalidate : this.revalidate
+      }
+    });
+  }
+  /**
+   * Retrieves recent folders accessed or created by user.
+   * Swagger: GET /api/v2/folders/recent
+   */
+  async getRecentFolders(params = {}, options = {}) {
+    return this.http.get("/api/v2/folders/recent", {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Checks if user has enough space and permission to upload a file into the folder.
+   * Swagger: GET /api/folders/{hash}/check/upload
+   */
+  async checkFolderUploadAccess(hash, size, options = {}) {
+    return this.http.get(`/api/folders/${hash}/check/upload`, {
+      params: { size },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves folder actions summary for a specific date.
+   * Swagger: GET /api/folders/{folderHash}/actions
+   */
+  async getFolderActions(folderHash, date, options = {}) {
+    return this.http.get(`/api/folders/${folderHash}/actions`, {
+      params: { date },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/resumable.ts
+var PodspaceResumableService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Initiates a resumable upload session.
+   * Swagger: POST /api/files/resumable
+   */
+  async create(headers = {}, options = {}) {
+    return this.http.post("/api/files/resumable", {}, {
+      headers: { ...headers, ...options.headers },
+      signal: options.signal
+    });
+  }
+  /**
+   * Uploads a binary chunk to a resumable upload session.
+   * Swagger: PATCH /api/files/resumable/{id}
+   */
+  async append(id, chunk, offset, options = {}) {
+    return this.http.patch(`/api/files/resumable/${id}`, chunk, {
+      headers: {
+        "Upload-Offset": String(offset),
+        "Content-Type": "application/offset+octet-stream",
+        ...options.headers
+      },
+      signal: options.signal
+    });
+  }
+  /**
+   * Checks current uploaded byte offset for a resumable session.
+   * Swagger: HEAD /api/files/resumable/{id}
+   */
+  async getStatus(id, options = {}) {
+    const res = await this.http.head(`/api/files/resumable/${id}`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+    const offset = res?.headers?.get ? res.headers.get("upload-offset") : res?.headers?.["upload-offset"];
+    return offset ? parseInt(offset, 10) : 0;
+  }
+  /**
+   * Finalizes resumable upload and creates the file entity in the user's storage.
+   * Swagger: POST /api/files/resumable/{id}/finalize
+   */
+  async finalizeUpload(id, params, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.tags)) queryParams.tags = queryParams.tags.join(",");
+    if (typeof queryParams.userMetadata === "object") {
+      queryParams.userMetadata = JSON.stringify(queryParams.userMetadata);
+    }
+    return this.http.post(`/api/files/resumable/${id}/finalize`, {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/links.ts
+var PodspaceLinksService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Generates a download or integration public link for a file.
+   * Swagger: GET /api/links/files/{hash}
+   */
+  async createLink(hash, params = {}, options = {}) {
+    return this.http.get(`/api/links/files/${hash}`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves list of links created by current user.
+   * Swagger: GET /api/links
+   */
+  async getUserLinks(params, options = {}) {
+    return this.http.get("/api/links", {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves details of a specific link.
+   * Swagger: GET /api/links/{link}/detail
+   */
+  async getLinkDetail(link, options = {}) {
+    return this.http.get(`/api/links/${link}/detail`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Updates settings and permissions of a link.
+   * Swagger: PATCH /api/links/{link}
+   */
+  async updateLink(link, params, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.fileTypeLimits)) {
+      queryParams.fileTypeLimits = queryParams.fileTypeLimits.join(",");
+    }
+    if (typeof queryParams.userMetadata === "object") {
+      queryParams.userMetadata = JSON.stringify(queryParams.userMetadata);
+    }
+    return this.http.patch(`/api/links/${link}`, {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Revokes an existing link.
+   * Swagger: DELETE /api/links/{link}
+   */
+  async revokeLink(link, options = {}) {
+    return this.http.delete(`/api/links/${link}`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Downloads a file using its public shared link.
+   * Swagger: GET /api/links/{hash}
+   */
+  async downloadFileByLink(hash, params = {}, options = {}) {
+    return this.http.get(`/api/links/${hash}`, {
+      params,
+      headers: options.headers,
+      signal: options.signal,
+      responseType: "blob"
+    });
+  }
+};
+
+// src/services/podspace/shares.ts
+var PodspaceSharesService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Shares a file or folder with a user by their identity (username/ssoId).
+   * Swagger: POST /api/files/{hash}/shares/users/{identity}
+   */
+  async shareWithUser(hash, identity, params, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.access)) queryParams.access = queryParams.access.join(",");
+    return this.http.post(`/api/files/${hash}/shares/users/${identity}`, {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Removes share for a specific user identity.
+   * Swagger: DELETE /api/files/{hash}/shares/users/{identity}
+   */
+  async removeShareWithUser(hash, identity, identityType, options = {}) {
+    return this.http.delete(`/api/files/${hash}/shares/users/${identity}`, {
+      params: { identityType },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Makes a file or folder public with optional password and expiration.
+   * Swagger: POST /api/files/{hash}/public
+   */
+  async makePublic(hash, params, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.access)) queryParams.access = queryParams.access.join(",");
+    return this.http.post(`/api/files/${hash}/public`, {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves list of files and folders shared with current user.
+   * Swagger: GET /api/shares
+   */
+  async getSharedWithMe(params = {}, options = {}) {
+    return this.http.get("/api/shares", {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves details of a share by its share hash.
+   * Swagger: GET /api/shares/{shareHash}
+   */
+  async getShareDetail(shareHash, password, options = {}) {
+    return this.http.get(`/api/shares/${shareHash}`, {
+      params: { password },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Revokes a share by its share hash.
+   * Swagger: DELETE /api/shares/{shareHash}
+   */
+  async revokeShare(shareHash, options = {}) {
+    return this.http.delete(`/api/shares/${shareHash}`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves shares list of a specific file or folder.
+   * Swagger: GET /api/files/{hash}/shares
+   */
+  async getFileShares(hash, params = {}, options = {}) {
+    return this.http.get(`/api/files/${hash}/shares`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Sets or removes password for a share using the share hash.
+   * Swagger: PUT /api/shares/{hash}/password
+   */
+  async setSharePassword(shareHash, password, options = {}) {
+    return this.http.put(`/api/shares/${shareHash}/password`, {}, {
+      params: { password },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Sets or removes password for a share using the entity hash.
+   * Swagger: PUT /api/files/{hash}/shares/password
+   */
+  async setEntityPassword(entityHash, password, options = {}) {
+    return this.http.put(`/api/files/${entityHash}/shares/password`, {}, {
+      params: { password },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/trash.ts
+var PodspaceTrashService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Retrieves list of trashed files and folders.
+   * Swagger: GET /api/trashes
+   */
+  async getTrashList(params = {}, options = {}) {
+    return this.http.get("/api/trashes", {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Restores a single file or folder from the trash.
+   * Swagger: PUT /api/trashes/{hash}/restore
+   */
+  async restore(hash, options = {}) {
+    return this.http.put(`/api/trashes/${hash}/restore`, {}, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Restores all entities from trash.
+   * Swagger: POST /api/trashes/restore
+   */
+  async restoreAll(options = {}) {
+    return this.http.post("/api/trashes/restore", {}, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Permanently deletes a single file or folder from the trash.
+   * Swagger: DELETE /api/trashes/{hash}
+   */
+  async deletePermanently(hash, force, options = {}) {
+    return this.http.delete(`/api/trashes/${hash}`, {
+      params: { force },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Permanently empties all files and folders from the trash.
+   * Swagger: DELETE /api/trashes
+   */
+  async emptyTrash(options = {}) {
+    return this.http.delete("/api/trashes", {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Sets auto clean-up period for trash in days.
+   * Swagger: POST /api/trashes/periods/{period}
+   */
+  async setAutoCleanUpPeriod(period, options = {}) {
+    return this.http.post(`/api/trashes/periods/${period}`, {}, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/tags.ts
+var PodspaceTagsService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Adds tags to a file or folder.
+   * Swagger: POST /api/tags
+   */
+  async addTags(hash, tags, options = {}) {
+    const tagsParam = Array.isArray(tags) ? tags.join(",") : tags;
+    return this.http.post("/api/tags", {}, {
+      params: { hash, tags: tagsParam },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Deletes tags from a file or folder.
+   * Swagger: DELETE /api/tags
+   */
+  async deleteTags(hash, tags, options = {}) {
+    const tagsParam = Array.isArray(tags) ? tags.join(",") : tags;
+    return this.http.delete("/api/tags", {
+      params: { hash, tags: tagsParam },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves tags of a file or folder.
+   * Swagger: GET /api/tags/entities/{hash}
+   */
+  async getEntityTags(hash, password, options = {}) {
+    return this.http.get(`/api/tags/entities/${hash}`, {
+      params: { password },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Searches for existing tags with autocomplete.
+   * Swagger: GET /api/tags/search/{tagName}
+   */
+  async searchTags(tagName, params = {}, options = {}) {
+    return this.http.get(`/api/tags/search/${tagName}`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves list of files/folders that contain a specific tag.
+   * Swagger: GET /api/tags/{tagName}
+   */
+  async getEntitiesByTag(tagName, params = {}, options = {}) {
+    return this.http.get(`/api/tags/${tagName}`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/bookmarks.ts
+var PodspaceBookmarksService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Retrieves list of bookmarked files and folders.
+   * Swagger: GET /api/bookmarks
+   */
+  async getBookmarks(params = {}, options = {}) {
+    return this.http.get("/api/bookmarks", {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Adds a file or folder to bookmarks.
+   * Swagger: POST /api/bookmarks
+   */
+  async addBookmark(hash, options = {}) {
+    return this.http.post("/api/bookmarks", {}, {
+      params: { hash },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Removes a file or folder from bookmarks.
+   * Swagger: DELETE /api/bookmarks
+   */
+  async removeBookmark(hash, options = {}) {
+    return this.http.delete("/api/bookmarks", {
+      params: { hash },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/metadata.ts
+var PodspaceMetadataService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Retrieves metadata key-value dictionary for a file.
+   * Swagger: GET /api/files/{hash}/metadata
+   */
+  async getMetadata(hash, keys, options = {}) {
+    const keysParam = Array.isArray(keys) ? keys.join(",") : keys;
+    return this.http.get(`/api/files/${hash}/metadata`, {
+      params: { keys: keysParam },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Adds or updates metadata dictionary for a file.
+   * Swagger: PUT /api/files/{hash}/metadata
+   */
+  async setMetadata(hash, metadata, options = {}) {
+    return this.http.put(`/api/files/${hash}/metadata`, metadata, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Deletes specific metadata keys from a file.
+   * Swagger: DELETE /api/files/{hash}/metadata
+   */
+  async deleteMetadata(hash, keys, options = {}) {
+    const keysParam = Array.isArray(keys) ? keys.join(",") : keys;
+    return this.http.delete(`/api/files/${hash}/metadata`, {
+      params: { keys: keysParam },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Searches metadata across files with specified parent.
+   * Swagger: POST /api/files/metadata/search
+   */
+  async searchMetadata(queryBody, params = {}, options = {}) {
+    return this.http.post("/api/files/metadata/search", queryBody, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves description of a file or folder.
+   * Swagger: GET /api/files/description
+   */
+  async getDescription(hash, options = {}) {
+    return this.http.get("/api/files/description", {
+      params: { hash },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Adds or updates description of a file or folder.
+   * Swagger: PUT /api/files/description
+   */
+  async setDescription(hash, description, options = {}) {
+    return this.http.put("/api/files/description", {}, {
+      params: { hash, description },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Deletes description of a file or folder.
+   * Swagger: DELETE /api/files/description
+   */
+  async deleteDescription(hash, options = {}) {
+    return this.http.delete("/api/files/description", {
+      params: { hash },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/userGroups.ts
+var PodspaceUserGroupsService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Creates a new user group for team collaboration.
+   * Swagger: POST /api/usergroups
+   */
+  async createUserGroup(params, options = {}) {
+    const queryParams = { ...params };
+    if (Array.isArray(queryParams.zoneNames)) queryParams.zoneNames = queryParams.zoneNames.join(",");
+    if (typeof queryParams.metadata === "object") queryParams.metadata = JSON.stringify(queryParams.metadata);
+    return this.http.post("/api/usergroups", {}, {
+      params: queryParams,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves user group info by hash.
+   * Swagger: GET /api/usergroups/{userGroupHash}
+   */
+  async getUserGroup(userGroupHash, options = {}) {
+    return this.http.get(`/api/usergroups/${userGroupHash}`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Deletes a user group.
+   * Swagger: DELETE /api/usergroups/{userGroupHash}
+   */
+  async deleteUserGroup(userGroupHash, options = {}) {
+    return this.http.delete(`/api/usergroups/${userGroupHash}`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves list of users in a user group.
+   * Swagger: GET /api/usergroups/{userGroupHash}/users
+   */
+  async getUserGroupUsers(userGroupHash, params = {}, options = {}) {
+    return this.http.get(`/api/usergroups/${userGroupHash}/users`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Adds a user to the user group.
+   * Swagger: POST /api/usergroups/{userGroupHash}/users
+   */
+  async addUserToGroup(userGroupHash, identity, identityType, options = {}) {
+    return this.http.post(`/api/usergroups/${userGroupHash}/users`, {}, {
+      params: { identity, identityType },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Removes a user from the user group.
+   * Swagger: DELETE /api/usergroups/{userGroupHash}/users
+   */
+  async removeUserFromGroup(userGroupHash, identity, identityType, options = {}) {
+    return this.http.delete(`/api/usergroups/${userGroupHash}/users`, {
+      params: { identity, identityType },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves list of files belonging to user group.
+   * Swagger: GET /api/usergroups/{usergroupHash}/files
+   */
+  async getUserGroupFiles(userGroupHash, params = {}, options = {}) {
+    return this.http.get(`/api/usergroups/${userGroupHash}/files`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Uploads a file directly into a user group.
+   * Swagger: POST /api/usergroups/{userGroupHash}/files
+   */
+  async uploadToUserGroup(userGroupHash, formData, options = {}) {
+    return this.http.post(`/api/usergroups/${userGroupHash}/files`, formData, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Uploads an image directly into a user group.
+   * Swagger: POST /api/usergroups/{userGroupHash}/images
+   */
+  async uploadImageToUserGroup(userGroupHash, formData, options = {}) {
+    return this.http.post(`/api/usergroups/${userGroupHash}/images`, formData, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves storage usage report for a user group.
+   * Swagger: GET /api/usergroups/{userGroupHash}/usage
+   */
+  async getUserGroupUsage(userGroupHash, options = {}) {
+    return this.http.get(`/api/usergroups/${userGroupHash}/usage`, {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/workspaces.ts
+var PodspaceWorkspacesService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Creates a new collaborative Workspace.
+   * Swagger: POST /api/workspaces
+   */
+  async createWorkspace(params, options = {}) {
+    return this.http.post("/api/workspaces", {}, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves workspace details by its identity/username.
+   * Swagger: GET /api/workspaces/{identity}
+   */
+  async getWorkspace(identity, identityType, options = {}) {
+    return this.http.get(`/api/workspaces/${identity}`, {
+      params: { identityType },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Updates workspace information.
+   * Swagger: PATCH /api/workspaces/{identity}
+   */
+  async updateWorkspace(identity, params = {}, options = {}) {
+    return this.http.patch(`/api/workspaces/${identity}`, {}, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves members list of a workspace.
+   * Swagger: GET /api/workspaces/{identity}/members
+   */
+  async getWorkspaceMembers(identity, identityType, options = {}) {
+    return this.http.get(`/api/workspaces/${identity}/members`, {
+      params: { identityType },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Adds or updates a member's access level in a workspace.
+   * Swagger: PUT /api/workspaces/{identity}/members/{userIdentity}
+   */
+  async updateWorkspaceMember(identity, userIdentity, accessLevel, params = {}, options = {}) {
+    return this.http.put(`/api/workspaces/${identity}/members/${userIdentity}`, {}, {
+      params: { accessLevel, ...params },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Removes a member from a workspace.
+   * Swagger: DELETE /api/workspaces/{identity}/members/{userIdentity}
+   */
+  async removeWorkspaceMember(identity, userIdentity, params = {}, options = {}) {
+    return this.http.delete(`/api/workspaces/${identity}/members/${userIdentity}`, {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+};
+
+// src/services/podspace/me.ts
+var PodspaceMeService = class {
+  http;
+  constructor(options) {
+    this.http = options.http;
+  }
+  /**
+   * Retrieves profile information of current authenticated user.
+   * Swagger: GET /api/me
+   */
+  async getUser(options = {}) {
+    return this.http.get("/api/me", {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves workspaces accessible to the user.
+   * Swagger: GET /api/me/workspaces
+   */
+  async getUserWorkspaces(params = {}, options = {}) {
+    return this.http.get("/api/me/workspaces", {
+      params,
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves user account status on PodSpace.
+   * Swagger: GET /api/me/status
+   */
+  async getUserStatus(options = {}) {
+    return this.http.get("/api/me/status", {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves user OAuth scopes.
+   * Swagger: GET /api/me/scope
+   */
+  async getUserScope(options = {}) {
+    return this.http.get("/api/me/scope", {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves storage usage report for current user.
+   * Swagger: GET /api/me/reports/usage
+   */
+  async getUserUsageReport(majorType, options = {}) {
+    return this.http.get("/api/me/reports/usage", {
+      params: { majorType },
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves user storage plans and quota limits.
+   * Swagger: GET /api/me/plans
+   */
+  async getUserPlans(options = {}) {
+    return this.http.get("/api/me/plans", {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves or creates the user's personal root folder.
+   * Swagger: GET /api/me/folder
+   */
+  async getPersonalFolder(options = {}) {
+    return this.http.get("/api/me/folder", {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves or creates the user's dedicated chat attachments folder.
+   * Swagger: GET /api/me/folders/chat
+   */
+  async getOrCreateChatFolder(options = {}) {
+    return this.http.get("/api/me/folders/chat", {
+      headers: options.headers,
+      signal: options.signal
+    });
+  }
+  /**
+   * Retrieves the user's avatar image binary or URL.
+   * Swagger: GET /api/me/avatar
+   */
+  async getUserAvatar(options = {}) {
+    return this.http.get("/api/me/avatar", {
+      headers: options.headers,
+      signal: options.signal,
+      responseType: "blob"
+    });
+  }
+};
+
+// src/services/podspace/index.ts
 var PodspaceService = class {
   http;
   apiToken;
   baseUrl;
+  revalidate;
+  /** Upload & Download sub-service */
+  uploadDownload;
+  /** Files management sub-service */
+  files;
+  /** Folders management sub-service */
+  folders;
+  /** Resumable upload sub-service */
+  resumable;
+  /** Links & Public Access sub-service */
+  links;
+  /** Shares & Permissions sub-service */
+  shares;
+  /** Trash & Permanent Delete sub-service */
+  trash;
+  /** Tags sub-service */
+  tags;
+  /** Bookmarks sub-service */
+  bookmarks;
+  /** Metadata & Descriptions sub-service */
+  metadata;
+  /** Team User Groups sub-service */
+  userGroups;
+  /** Workspaces sub-service */
+  workspaces;
+  /** User Account & Quota sub-service */
+  me;
   constructor(options) {
     this.baseUrl = options.baseUrl;
     this.apiToken = options.apiToken || "";
-    this.http = http.createNextHttp({
+    this.revalidate = Number(options.revalidate) || 0;
+    const authHeader = this.apiToken ? this.apiToken.startsWith("Bearer ") ? this.apiToken : `Bearer ${this.apiToken}` : "";
+    this.http = options.http || http.createNextHttp({
       baseUrl: options.baseUrl,
       serviceName: "POD-Podspace",
       headers: {
-        Authorization: `Bearer ${this.apiToken}`
+        ...authHeader ? { Authorization: authHeader, _token_: this.apiToken } : {}
       }
     });
+    this.uploadDownload = new PodspaceUploadDownloadService({
+      http: this.http,
+      baseUrl: this.baseUrl,
+      revalidate: this.revalidate
+    });
+    this.files = new PodspaceFilesService({
+      http: this.http,
+      revalidate: this.revalidate
+    });
+    this.folders = new PodspaceFoldersService({
+      http: this.http,
+      revalidate: this.revalidate
+    });
+    this.resumable = new PodspaceResumableService({
+      http: this.http
+    });
+    this.links = new PodspaceLinksService({
+      http: this.http
+    });
+    this.shares = new PodspaceSharesService({
+      http: this.http
+    });
+    this.trash = new PodspaceTrashService({
+      http: this.http
+    });
+    this.tags = new PodspaceTagsService({
+      http: this.http
+    });
+    this.bookmarks = new PodspaceBookmarksService({
+      http: this.http
+    });
+    this.metadata = new PodspaceMetadataService({
+      http: this.http
+    });
+    this.userGroups = new PodspaceUserGroupsService({
+      http: this.http
+    });
+    this.workspaces = new PodspaceWorkspacesService({
+      http: this.http
+    });
+    this.me = new PodspaceMeService({
+      http: this.http
+    });
   }
+  // =========================================================================
+  // TOP-LEVEL CONVENIENCE DELEGATES
+  // =========================================================================
   /**
-   * Uploads a file (via FormData) to the POD Podspace storage.
+   * Uploads a single file (via FormData) to POD Podspace storage.
+   * Maintains 100% backward compatibility with `uploadFile(formData, path, isPublic)`.
+   * Swagger: POST /api/files
    */
-  async uploadFile(formData, path = "/", isPublic = true) {
-    const params = {
-      path,
-      isPublic
-    };
-    return this.http.post("/api/files", formData, {
-      params
-    });
+  async uploadFile(formData, paramsOrPath = "/", isPublic = true, options = {}) {
+    return this.uploadDownload.uploadFile(formData, paramsOrPath, isPublic, options);
+  }
+  /**
+   * Uploads multiple files simultaneously.
+   * Swagger: POST /api/files/multiple
+   */
+  async uploadMultipleFiles(formData, params = {}, options = {}) {
+    return this.uploadDownload.uploadMultipleFiles(formData, params, options);
+  }
+  /**
+   * Uploads an image from a base64 string.
+   * Swagger: POST /api/images/base64
+   */
+  async uploadImageBase64(params, options = {}) {
+    return this.uploadDownload.uploadImageBase64(params, options);
   }
   /**
-   * Builds the public or private URL to download/view a file.
+   * Replaces the content of an existing file.
+   * Swagger: PUT /api/files/{hash}
+   */
+  async replaceFile(hash, formData, params = {}, options = {}) {
+    return this.uploadDownload.replaceFile(hash, formData, params, options);
+  }
+  /**
+   * Downloads raw file data.
+   * Swagger: GET /api/files/{hash}
+   */
+  async downloadFile(hash, params = {}, options = {}) {
+    return this.uploadDownload.downloadFile(hash, params, options);
+  }
+  /**
+   * Downloads processed image (with resize, crop, format options).
+   * Swagger: GET /api/v2/images/{hash}
+   */
+  async downloadImage(hash, params = {}, options = {}) {
+    return this.uploadDownload.downloadImage(hash, params, options);
+  }
+  /**
+   * Downloads file thumbnail.
+   * Swagger: GET /api/files/{hash}/thumbnail
+   */
+  async downloadThumbnail(hash, params = {}, options = {}) {
+    return this.uploadDownload.downloadThumbnail(hash, params, options);
+  }
+  /**
+   * Downloads multiple files and folders compressed into a zip file.
+   * Swagger: GET /api/files
+   */
+  async downloadFilesAsZip(params, options = {}) {
+    return this.uploadDownload.downloadFilesAsZip(params, options);
+  }
+  /**
+   * Obtains a pre-signed upload link.
+   * Swagger: GET /api/files/link
+   */
+  async getUploadLink(params, options = {}) {
+    return this.uploadDownload.getUploadLink(params, options);
+  }
+  /**
+   * Builds direct view or download URL for a file.
    */
   getFileUrl(hash, isPublic = true) {
-    return `${this.baseUrl}/api/files/${hash}?isPublic=${isPublic}`;
+    return this.uploadDownload.getFileUrl(hash, isPublic);
+  }
+  /**
+   * Builds direct view URL for an image with crop/dimensions.
+   */
+  getImageUrl(hash, params = {}) {
+    return this.uploadDownload.getImageUrl(hash, params);
+  }
+  /**
+   * Builds thumbnail URL for a file.
+   */
+  getThumbnailUrl(hash, params = {}) {
+    return this.uploadDownload.getThumbnailUrl(hash, params);
+  }
+  // Folders delegates
+  /**
+   * Creates a new folder.
+   * Swagger: POST /api/folders
+   */
+  async createFolder(params, options = {}) {
+    return this.folders.createFolder(params, options);
+  }
+  /**
+   * Creates nested directories in a parent folder.
+   * Swagger: POST /api/folders/{hash}/directories
+   */
+  async createDirectories(hash, directories, options = {}) {
+    return this.folders.createDirectories(hash, directories, options);
+  }
+  /**
+   * Retrieves subfolders and files inside a folder.
+   * Swagger: GET /api/folders/{hash}/children
+   */
+  async getFolderChildren(hash, params = {}, options = {}) {
+    return this.folders.getFolderChildren(hash, params, options);
+  }
+  // Files delegates
+  /**
+   * Retrieves details of a file or folder.
+   * Swagger: GET /api/files/{hash}/detail
+   */
+  async getFileDetail(hash, params = {}, options = {}) {
+    return this.files.getFileDetail(hash, params, options);
+  }
+  /**
+   * Retrieves file details using its storage path.
+   * Swagger: GET /api/files/details
+   */
+  async getFileDetailByPath(path, params = {}, options = {}) {
+    return this.files.getFileDetailByPath(path, params, options);
+  }
+  /**
+   * Checks if a file or folder exists.
+   * Swagger: GET /api/files/{hash}/exist
+   */
+  async checkEntityExist(hash, fileName, params = {}, options = {}) {
+    return this.files.checkEntityExist(hash, fileName, params, options);
+  }
+  /**
+   * Renames a file or folder.
+   * Swagger: PUT /api/files/{hash}/rename
+   */
+  async renameEntity(hash, newName, uniqueName, options = {}) {
+    return this.files.renameEntity(hash, newName, uniqueName, options);
+  }
+  /**
+   * Moves a file or folder.
+   * Swagger: PUT /api/files/{hash}/move
+   */
+  async moveEntity(hash, destFolderHash, params = {}, options = {}) {
+    return this.files.moveEntity(hash, destFolderHash, params, options);
+  }
+  /**
+   * Copies a file or folder.
+   * Swagger: PUT /api/files/{hash}/copy
+   */
+  async copyEntity(hash, destFolderHash, params = {}, options = {}) {
+    return this.files.copyEntity(hash, destFolderHash, params, options);
+  }
+  /**
+   * Moves a file or folder to trash.
+   * Swagger: DELETE /api/files/{hash}
+   */
+  async trashEntity(hash, options = {}) {
+    return this.files.trashEntity(hash, options);
+  }
+  /**
+   * Alias for `trashEntity`.
+   */
+  async deleteFile(hash, options = {}) {
+    return this.trashEntity(hash, options);
+  }
+  /**
+   * Searches files content and folders.
+   * Swagger: GET /api/files/search
+   */
+  async searchFiles(params = {}, options = {}) {
+    return this.files.searchFiles(params, options);
+  }
+  /**
+   * Retrieves recent files.
+   * Swagger: GET /api/v2/files/recent
+   */
+  async getRecentFiles(params = {}, options = {}) {
+    return this.files.getRecentFiles(params, options);
+  }
+  // Sharing & Links delegates
+  /**
+   * Creates a download or integration public link for a file.
+   * Swagger: GET /api/links/files/{hash}
+   */
+  async createLink(hash, params = {}, options = {}) {
+    return this.links.createLink(hash, params, options);
+  }
+  /**
+   * Shares a file or folder with another user.
+   * Swagger: POST /api/files/{hash}/shares/users/{identity}
+   */
+  async shareWithUser(hash, identity, params, options = {}) {
+    return this.shares.shareWithUser(hash, identity, params, options);
+  }
+  /**
+   * Makes a file or folder publicly accessible.
+   * Swagger: POST /api/files/{hash}/public
+   */
+  async makePublic(hash, params, options = {}) {
+    return this.shares.makePublic(hash, params, options);
+  }
+  // Bookmarks delegates
+  /**
+   * Retrieves bookmarked entities.
+   * Swagger: GET /api/bookmarks
+   */
+  async getBookmarks(params = {}, options = {}) {
+    return this.bookmarks.getBookmarks(params, options);
+  }
+  /**
+   * Bookmarks a file or folder.
+   * Swagger: POST /api/bookmarks
+   */
+  async addBookmark(hash, options = {}) {
+    return this.bookmarks.addBookmark(hash, options);
+  }
+  /**
+   * Removes bookmark from a file or folder.
+   * Swagger: DELETE /api/bookmarks
+   */
+  async removeBookmark(hash, options = {}) {
+    return this.bookmarks.removeBookmark(hash, options);
   }
 };
 var PodFormService = class {
@@ -597,7 +2215,7 @@ var NotificationService = class {
   constructor(options) {
     this.apiToken = options.apiToken || "";
     this.http = http.createNextHttp({
-      baseUrl: options.baseUrl,
+      baseUrl: options.baseUrl || "https://api.pod.ir/srv/notification",
       serviceName: "POD-Notification",
       headers: {
         apiToken: this.apiToken
@@ -767,7 +2385,7 @@ var CmsProductService = class {
     this.revalidate = Number(options.revalidate) || 0;
     this.formatter = options.formatter || new CmsDataFormatter(options.podspaceUrl || "https://podspace.pod.ir");
     this.http = options.http || http.createNextHttp({
-      baseUrl: options.baseUrl || "https://cms.pod.ir",
+      baseUrl: options.baseUrl || "https://api.pod.ir/srv/cms-server",
       serviceName: "POD-CMS-PRODUCT"
     });
   }
@@ -1190,7 +2808,7 @@ var CmsTagService = class {
     this.apiToken = options.apiToken || "";
     this.revalidate = Number(options.revalidate) || 0;
     this.http = options.http || http.createNextHttp({
-      baseUrl: options.baseUrl || "https://cms.pod.ir",
+      baseUrl: options.baseUrl || "https://api.pod.ir/srv/cms-server",
       serviceName: "POD-CMS-TAGS"
     });
   }
@@ -2166,13 +3784,15 @@ var CmsService = class {
 };
 var IumsService = class {
   http;
+  baseUrl;
   clientId;
   revalidate;
   constructor(options) {
     this.clientId = options.clientId || "";
     this.revalidate = Number(options.revalidate) || 0;
+    this.baseUrl = options.baseUrl || "https://indra.khatam.ac.ir/srv";
     this.http = http.createNextHttp({
-      baseUrl: options.baseUrl,
+      baseUrl: this.baseUrl,
       serviceName: "POD-IUMS",
       headers: {
         "Client-Id": this.clientId
@@ -2201,7 +3821,8 @@ var IumsService = class {
   }
   async request(serviceMethod, params = [], options) {
     const dataPayload = this.generateIumsDataPayload(serviceMethod, params);
-    const response = await this.http.get("/srv", {
+    const endpoint = this.baseUrl.replace(/\/+$/, "").endsWith("/srv") ? "" : "/srv";
+    const response = await this.http.get(endpoint, {
       ...options,
       params: { data: dataPayload },
       next: this.revalidate ? { revalidate: this.revalidate, ...options?.next || {} } : options?.next
@@ -2233,6 +3854,71 @@ var IumsService = class {
   }
 };
 
+// src/constants.ts
+var DEFAULT_POD_URLS = {
+  accounts: "https://accounts.pod.ir",
+  apiPod: "https://api.pod.ir",
+  apiPodSandbox: "https://api.sandpod.ir",
+  cms: "https://api.pod.ir/srv/cms-server",
+  iums: "https://indra.khatam.ac.ir/srv",
+  notification: "https://api.pod.ir/srv/notification",
+  podreport: "https://reporting.pod.ir",
+  podspace: "https://podspace.pod.ir",
+  podform: "https://podform.pod.ir",
+  sandboxCms: "http://api.sandpod.ir/srv/cms-sandbox",
+  sandboxCmsClient: "https://api.sandpod.ir/srv/cms-sandbox",
+  sandboxPodspace: "http://podspace.sandpod.ir",
+  sandboxStream: "https://sandbox-offline-stream.sandpod.ir",
+  stream: "https://sandbox-offline-stream.sandpod.ir",
+  website: ""
+};
+var SANDBOX_POD_URLS = {
+  accounts: "https://accounts.pod.ir",
+  apiPod: "https://api.sandpod.ir",
+  apiPodSandbox: "https://api.sandpod.ir",
+  cms: "https://api.sandpod.ir/srv/cms-sandbox",
+  iums: "https://indra.khatam.ac.ir/srv",
+  notification: "https://api.pod.ir/srv/notification",
+  podreport: "https://reporting.pod.ir",
+  podspace: "http://podspace.sandpod.ir",
+  podform: "https://podform.pod.ir",
+  sandboxCms: "http://api.sandpod.ir/srv/cms-sandbox",
+  sandboxCmsClient: "https://api.sandpod.ir/srv/cms-sandbox",
+  sandboxPodspace: "http://podspace.sandpod.ir",
+  sandboxStream: "https://sandbox-offline-stream.sandpod.ir",
+  stream: "https://sandbox-offline-stream.sandpod.ir",
+  website: ""
+};
+function getEnv(key) {
+  if (typeof process !== "undefined" && process?.env && process.env[key]) {
+    const val = process.env[key]?.trim();
+    if (val && val.length > 0) {
+      return val;
+    }
+  }
+  return void 0;
+}
+function resolvePodUrls(urls, sandbox = false) {
+  const defaults = sandbox ? SANDBOX_POD_URLS : DEFAULT_POD_URLS;
+  return {
+    accounts: urls?.accounts || getEnv("NEXT_PUBLIC_ACCOUNTS_URL") || defaults.accounts,
+    apiPod: urls?.apiPod || (sandbox ? getEnv("NEXT_PUBLIC_API_POD_SANDBOX_URL") || defaults.apiPod : getEnv("NEXT_PUBLIC_API_POD_URL") || defaults.apiPod),
+    apiPodSandbox: urls?.apiPodSandbox || getEnv("NEXT_PUBLIC_API_POD_SANDBOX_URL") || defaults.apiPodSandbox,
+    cms: urls?.cms || (sandbox ? getEnv("NEXT_PUBLIC_SANDBOX_CMS_CLIENT_URL") || getEnv("NEXT_PUBLIC_SANDBOX_CMS_URL") || defaults.cms : getEnv("NEXT_PUBLIC_CMS_URL") || defaults.cms),
+    iums: urls?.iums || getEnv("NEXT_PUBLIC_IUMS_URL") || defaults.iums,
+    notification: urls?.notification || getEnv("NEXT_PUBLIC_NOTIFICATION_URL") || defaults.notification,
+    podreport: urls?.podreport || getEnv("NEXT_PUBLIC_PODREPORT_URL") || defaults.podreport,
+    podspace: urls?.podspace || (sandbox ? getEnv("NEXT_PUBLIC_SANDBOX_PODSPACE_URL") || defaults.podspace : getEnv("NEXT_PUBLIC_PODSPACE_URL") || defaults.podspace),
+    podform: urls?.podform || getEnv("NEXT_PUBLIC_PODFORM_URL") || defaults.podform,
+    sandboxCms: urls?.sandboxCms || getEnv("NEXT_PUBLIC_SANDBOX_CMS_URL") || defaults.sandboxCms,
+    sandboxCmsClient: urls?.sandboxCmsClient || getEnv("NEXT_PUBLIC_SANDBOX_CMS_CLIENT_URL") || defaults.sandboxCmsClient,
+    sandboxPodspace: urls?.sandboxPodspace || getEnv("NEXT_PUBLIC_SANDBOX_PODSPACE_URL") || defaults.sandboxPodspace,
+    sandboxStream: urls?.sandboxStream || urls?.stream || getEnv("NEXT_PUBLIC_SANDBOX_STREAM_URL") || defaults.sandboxStream,
+    stream: urls?.stream || urls?.sandboxStream || getEnv("NEXT_PUBLIC_SANDBOX_STREAM_URL") || defaults.stream,
+    website: urls?.website || getEnv("NEXT_PUBLIC_WEBSITE_URL") || defaults.website
+  };
+}
+
 // src/client.ts
 var PodSdk = class {
   sso;
@@ -2245,17 +3931,10 @@ var PodSdk = class {
   product;
   tags;
   iums;
-  constructor(config) {
-    const urls = {
-      accounts: "https://accounts.pod.ir",
-      apiPod: "https://api.pod.ir",
-      cms: "https://cms.pod.ir",
-      podspace: "https://podspace.pod.ir",
-      podform: "https://podform.pod.ir",
-      notification: "https://notification.pod.ir",
-      iums: "https://iums.pod.ir",
-      ...config.urls
-    };
+  urls;
+  constructor(config = {}) {
+    const urls = resolvePodUrls(config.urls, config.sandbox);
+    this.urls = urls;
     const apiToken = config.apiToken || "";
     const clientId = config.clientId || "";
     const clientSecret = config.clientSecret || "";
@@ -2277,7 +3956,8 @@ var PodSdk = class {
     });
     this.podspace = new PodspaceService({
       baseUrl: urls.podspace,
-      apiToken
+      apiToken,
+      revalidate
     });
     this.podform = new PodFormService({
       baseUrl: urls.podform,
@@ -2326,16 +4006,32 @@ exports.CmsService = CmsService;
 exports.CmsTagService = CmsTagService;
 exports.CustomPostCrudService = CustomPostCrudService;
 exports.CustomPostService = CustomPostService;
+exports.DEFAULT_POD_URLS = DEFAULT_POD_URLS;
 exports.IumsService = IumsService;
 exports.NotificationService = NotificationService;
 exports.PodFormService = PodFormService;
 exports.PodSdk = PodSdk;
+exports.PodspaceBookmarksService = PodspaceBookmarksService;
+exports.PodspaceFilesService = PodspaceFilesService;
+exports.PodspaceFoldersService = PodspaceFoldersService;
+exports.PodspaceLinksService = PodspaceLinksService;
+exports.PodspaceMeService = PodspaceMeService;
+exports.PodspaceMetadataService = PodspaceMetadataService;
+exports.PodspaceResumableService = PodspaceResumableService;
 exports.PodspaceService = PodspaceService;
+exports.PodspaceSharesService = PodspaceSharesService;
+exports.PodspaceTagsService = PodspaceTagsService;
+exports.PodspaceTrashService = PodspaceTrashService;
+exports.PodspaceUploadDownloadService = PodspaceUploadDownloadService;
+exports.PodspaceUserGroupsService = PodspaceUserGroupsService;
+exports.PodspaceWorkspacesService = PodspaceWorkspacesService;
+exports.SANDBOX_POD_URLS = SANDBOX_POD_URLS;
 exports.SocialService = SocialService;
 exports.SsoService = SsoService;
 exports.createPodSdk = createPodSdk;
 exports.default = client_default;
 exports.encodeBase64 = encodeBase64;
 exports.generatePodSignatureHeader = generatePodSignatureHeader;
+exports.resolvePodUrls = resolvePodUrls;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map