@rezamirzapour/pod-sdk 1.0.9 → 1.0.11

package/dist/index.js

@@ -259,10 +259,8 @@ var SsoService = class {
 var CaptchaService = class {
   http;
   clientId;
-  accessToken;
   constructor(options) {
     this.clientId = options.clientId;
-    this.accessToken = options.accessToken;
     this.http = http.createNextHttp({
       baseUrl: options.baseUrl,
       serviceName: "POD-CAPTCHA"
@@ -271,71 +269,66 @@ var CaptchaService = class {
   /**
    * Get a new captcha image
    */
-  async get(options) {
+  async get() {
     const params = {};
-    if (options?.width) params.width = options.width;
-    if (options?.height) params.height = options.height;
-    if (options?.length) params.length = options.length;
-    if (options?.type) params.type = options.type;
-    if (options?.format) params.format = options.format;
-    if (options?.noise !== void 0) params.noise = options.noise;
-    if (options?.bgColor) params.bgColor = options.bgColor;
-    if (options?.fontColor) params.fontColor = options.fontColor;
-    if (options?.fontSize) params.fontSize = options.fontSize;
     try {
-      const result = await this.http.post(
-        "/api/core/captchas/generate",
+      return await this.http.post(
+        "/api/core/captcha/get",
         void 0,
         {
           params,
           headers: {
             "Content-Type": "application/json",
             Accept: "application/json",
-            "Client-Id": this.clientId,
-            "Access-Token": this.accessToken
+            "Client-Id": this.clientId
           }
         }
       );
-      return {
-        hasError: false,
-        result
-      };
     } catch (err) {
       return {
+        referenceNumber: 0,
         hasError: true,
-        message: err.data?.message || err.message,
-        errorCode: err.status
+        errorCode: err.status || 500,
+        refId: "",
+        message: [err.data?.message || err.message],
+        count: 0,
+        aggregations: 0,
+        result: {
+          hash: "",
+          expireTime: 0,
+          challenge: "",
+          url: ""
+        },
+        metaData: []
       };
     }
   }
   /**
    * Check if the entered captcha value is valid
    */
-  async check(captchaId, options) {
+  async check(options) {
     try {
-      const result = await this.http.post(
-        `/api/core/captchas/check/${captchaId}`,
+      return await this.http.post(
+        `/api/core/captcha/check`,
         {
-          captchaValue: options.captchaValue
+          value: options.value,
+          hash: options.hash
         },
         {
           headers: {
             "Content-Type": "application/json",
             Accept: "application/json",
-            "Client-Id": this.clientId,
-            "Access-Token": this.accessToken
+            "Client-Id": this.clientId
           }
         }
       );
-      return {
-        hasError: false,
-        result
-      };
     } catch (err) {
       return {
         hasError: true,
-        message: err.data?.message || err.message,
-        errorCode: err.status
+        errorCode: err.status || 500,
+        message: [err.data?.message || err.message],
+        result: false,
+        metaData: []
       };
     }
   }
@@ -2689,8 +2682,37 @@ var CmsProductService = class {
     this.formatter = options.formatter || new CmsDataFormatter(options.podspaceUrl || "https://podspace.pod.ir");
     this.http = options.http || http.createNextHttp({
       baseUrl: options.baseUrl || "https://api.pod.ir/srv/cms-server",
-      serviceName: "POD-CMS-PRODUCT"
-    });
+      serviceName: "POD-CMS-PRODUCT",
+      queryArrayFormat: "brackets"
+    });
+  }
+  normalizeParams(params) {
+    const arrayFields = [
+      "fieldCode",
+      "fieldValue",
+      "excludeFieldCode",
+      "excludeFieldValue",
+      "tags",
+      "excludeTags",
+      "tagTrees",
+      "tagTreesCode",
+      "entityIds",
+      "postIds",
+      "notPostIds",
+      "productTypeUniqueIds",
+      "relatedContentId",
+      "relatedProductId",
+      "operationValuesArray",
+      "orderBy",
+      "sortBy"
+    ];
+    const result = { ...params };
+    for (const field of arrayFields) {
+      if (result[field] !== void 0 && result[field] !== null && !Array.isArray(result[field])) {
+        result[field] = [result[field]];
+      }
+    }
+    return result;
   }
   get commonHeaders() {
     return {
@@ -2709,15 +2731,16 @@ var CmsProductService = class {
    * Swagger: GET /api/core/products/enable
    */
   async getProducts(params = {}, options = {}) {
-    const transferParams = {
+    const transferParams = this.normalizeParams({
       size: 50,
       offset: 0,
       showDetail: true,
       ...params
-    };
+    });
     try {
       const res = await this.http.get("/api/core/products/enable", {
         params: transferParams,
+        queryArrayFormat: options.queryArrayFormat,
         headers: {
           ...this.commonHeaders,
           ...options.headers
@@ -2738,15 +2761,16 @@ var CmsProductService = class {
    * Swagger: GET /api/core/products
    */
   async getAllProducts(params = {}, options = {}) {
-    const transferParams = {
+    const transferParams = this.normalizeParams({
       size: 50,
       offset: 0,
       showDetail: true,
       ...params
-    };
+    });
     try {
       const res = await this.http.get("/api/core/products", {
         params: transferParams,
+        queryArrayFormat: options.queryArrayFormat,
         headers: {
           ...this.managingHeaders,
           ...options.headers
@@ -2767,15 +2791,16 @@ var CmsProductService = class {
    * Swagger: GET /api/core/products/manage
    */
   async getManageProducts(params = {}, options = {}) {
-    const transferParams = {
+    const transferParams = this.normalizeParams({
       size: 50,
       offset: 0,
       showDetail: true,
       ...params
-    };
+    });
     try {
       const res = await this.http.get("/api/core/products/manage", {
         params: transferParams,
+        queryArrayFormat: options.queryArrayFormat,
         headers: {
           ...this.managingHeaders,
           ...options.headers
@@ -2796,17 +2821,18 @@ var CmsProductService = class {
    * Swagger: GET /api/core/products/{productTypeUniqueId}
    */
   async getProductsByType(productTypeUniqueId, params = {}, options = {}) {
-    const transferParams = {
+    const transferParams = this.normalizeParams({
       size: 50,
       offset: 0,
       showDetail: true,
       ...params
-    };
+    });
     try {
       const res = await this.http.get(
         `/api/core/products/${productTypeUniqueId}`,
         {
           params: transferParams,
+          queryArrayFormat: options.queryArrayFormat,
           headers: {
             ...this.managingHeaders,
             ...options.headers
@@ -2906,7 +2932,8 @@ var CmsProductService = class {
       const res = await this.http.get(
         "/api/core/products/enable/search",
         {
-          params,
+          params: this.normalizeParams(params),
+          queryArrayFormat: options.queryArrayFormat,
           headers: {
             ...this.commonHeaders,
             ...options.headers
@@ -3112,7 +3139,8 @@ var CmsTagService = class {
     this.revalidate = Number(options.revalidate) || 0;
     this.http = options.http || http.createNextHttp({
       baseUrl: options.baseUrl || "https://api.pod.ir/srv/cms-server",
-      serviceName: "POD-CMS-TAGS"
+      serviceName: "POD-CMS-TAGS",
+      queryArrayFormat: "brackets"
     });
   }
   get commonHeaders() {
@@ -3518,7 +3546,8 @@ var CmsService = class {
     this.formatter = new CmsDataFormatter(options.podspaceUrl || "https://podspace.pod.ir");
     this.http = http.createNextHttp({
       baseUrl: options.baseUrl,
-      serviceName: "POD-CMS"
+      serviceName: "POD-CMS",
+      queryArrayFormat: "brackets"
     });
     this.products = new CmsProductService({
       http: this.http,
@@ -3534,6 +3563,29 @@ var CmsService = class {
       revalidate: this.revalidate
     });
   }
+  normalizeParams(params) {
+    const arrayFields = [
+      "fieldCode",
+      "fieldValue",
+      "excludeFieldCode",
+      "excludeFieldValue",
+      "tags",
+      "tagTrees",
+      "tagTreesCode",
+      "entityIds",
+      "postIds",
+      "notPostIds",
+      "operationValuesArray",
+      "orderBy"
+    ];
+    const result = { ...params };
+    for (const field of arrayFields) {
+      if (result[field] !== void 0 && result[field] !== null && !Array.isArray(result[field])) {
+        result[field] = [result[field]];
+      }
+    }
+    return result;
+  }
   get commonHeaders() {
     return {
       "Client-Id": this.clientId,
@@ -3554,15 +3606,16 @@ var CmsService = class {
    * Swagger: GET /api/core/contents/enable
    */
   async getContent(params = {}, options = {}) {
-    const transferParams = {
+    const transferParams = this.normalizeParams({
       size: 50,
       offset: 0,
       showDetail: true,
       ...params
-    };
+    });
     try {
       const res = await this.http.get("/api/core/contents/enable", {
         params: transferParams,
+        queryArrayFormat: options.queryArrayFormat,
         headers: {
           ...this.commonHeaders,
           ...options.headers
@@ -3583,15 +3636,16 @@ var CmsService = class {
    * Swagger: GET /api/core/contents
    */
   async getAllContents(params = {}, options = {}) {
-    const transferParams = {
+    const transferParams = this.normalizeParams({
       size: 50,
       offset: 0,
       showDetail: true,
       ...params
-    };
+    });
     try {
       const res = await this.http.get("/api/core/contents", {
         params: transferParams,
+        queryArrayFormat: options.queryArrayFormat,
         headers: {
           ...this.managingHeaders,
           ...options.headers
@@ -3612,15 +3666,16 @@ var CmsService = class {
    * Swagger: GET /api/core/contents/my
    */
   async getMyContents(params = {}, options = {}) {
-    const transferParams = {
+    const transferParams = this.normalizeParams({
       size: 50,
       offset: 0,
       showDetail: true,
       ...params
-    };
+    });
     try {
       const res = await this.http.get("/api/core/contents/my", {
         params: transferParams,
+        queryArrayFormat: options.queryArrayFormat,
         headers: {
           ...this.managingHeaders,
           ...options.headers
@@ -3641,17 +3696,18 @@ var CmsService = class {
    * Swagger: GET /api/core/contents/{contentTypeUniqueId}
    */
   async getContentsByType(contentTypeUniqueId, params = {}, options = {}) {
-    const transferParams = {
+    const transferParams = this.normalizeParams({
       size: 50,
       offset: 0,
       showDetail: true,
       ...params
-    };
+    });
     try {
       const res = await this.http.get(
         `/api/core/contents/${contentTypeUniqueId}`,
         {
           params: transferParams,
+          queryArrayFormat: options.queryArrayFormat,
           headers: {
             ...this.managingHeaders,
             ...options.headers
@@ -3729,7 +3785,8 @@ var CmsService = class {
   async searchContent(params = {}, options = {}) {
     try {
       const res = await this.http.get("/api/core/contents/search", {
-        params,
+        params: this.normalizeParams(params),
+        queryArrayFormat: options.queryArrayFormat,
         headers: {
           ...this.commonHeaders,
           ...options.headers
@@ -4253,8 +4310,12 @@ var PodSdk = class {
       websiteUrl: urls.website,
       revalidate
     });
+    const cmsUrl = (urls.cms || "https://api.pod.ir/srv/cms-server").replace(
+      /^http:\/\//i,
+      "https://"
+    );
     this.captcha = new CaptchaService({
-      baseUrl: urls.apiPod,
+      baseUrl: cmsUrl,
       clientId,
       accessToken: apiToken
     });
@@ -4309,6 +4370,491 @@ function createPodSdk(config) {
 }
 var client_default = PodSdk;
 
+// src/openapi.ts
+var e = (tag, method, path, operationId, summary, extras = {}) => ({ tag, method, path, operationId, summary, ...extras });
+var POD_OPENAPI_ENDPOINTS = [
+  // SSO
+  e("SSO", "post", "/oauth2/clients/handshake/{clientId}", "ssoHandshake", "Create an SSO handshake", {
+    query: ["device_type!", "algorithm!", "device_uid!", "device_client_ip!"],
+    security: "bearer"
+  }),
+  e("SSO", "post", "/oauth2/otp/authorize/{phoneNumber}", "ssoSendOtpCode", "Send an OTP code", {
+    query: ["identityType", "response_type", "referrerType", "linkDeliveryType", "scope", "redirect_uri"],
+    security: "signature"
+  }),
+  e("SSO", "post", "/oauth2/otp/verify/{phoneNumber}", "ssoVerifyOtpCode", "Verify an OTP code", {
+    query: ["otp!", "redirect_uri!"],
+    security: "signature"
+  }),
+  e("SSO", "post", "/oauth2/token", "ssoGenerateToken", "Exchange an authorization code or refresh token", {
+    query: ["grant_type!", "code", "redirect_uri", "refresh_token"],
+    security: "basic",
+    sdkMethods: ["generateToken", "refreshToken"]
+  }),
+  e("SSO", "get", "/users", "ssoGetUserProfile", "Get the authenticated SSO user profile", { security: "bearer" }),
+  // Captcha
+  e("Captcha", "post", "/api/core/captcha/get", "captchaGet", "Generate a captcha challenge", { security: "clientId" }),
+  e("Captcha", "post", "/api/core/captcha/check", "captchaCheck", "Validate a captcha challenge", { security: "clientId", body: "json", bodyRequired: true }),
+  // Custom Post
+  e("Custom Post", "get", "/srv/core/nzh/biz/searchTimelineByMetadata", "customPostSearchTimelineByMetadata", "Search timeline entries by metadata", {
+    query: ["metadata", "metaQuery", "offset", "size"],
+    security: "apiToken"
+  }),
+  e("Custom Post", "get", "/srv/core/nzh/biz/customPostList", "customPostGet", "List custom posts or get one post", {
+    query: ["entityId", "id", "uniqueId", "offset", "size"],
+    security: "apiToken",
+    sdkMethods: ["getCustomPost", "createCrud.getAll", "createCrud.getById"]
+  }),
+  e("Custom Post", "post", "/srv/core/nzh/biz/addCustomPost", "customPostCreate", "Create a custom post", {
+    body: "form",
+    bodyRequired: true,
+    security: "apiToken",
+    sdkMethods: ["addCustomPost", "addCustomPostList", "createCrud.create", "createCrud.createMultiple", "createCrud.createAndBindEntityId"]
+  }),
+  e("Custom Post", "post", "/srv/core/nzh/biz/updateCustomPost", "customPostUpdate", "Update a custom post", {
+    body: "form",
+    bodyRequired: true,
+    security: "apiToken",
+    sdkMethods: ["updateCustomPost", "createCrud.update", "createCrud.archive"]
+  }),
+  e("Custom Post", "post", "/srv/core/nzh/biz/deleteCustomPost", "customPostDelete", "Delete a custom post", {
+    query: ["entityId!"],
+    security: "apiToken",
+    sdkMethods: ["deleteCustomPost", "createCrud.delete"]
+  }),
+  // Notification and Social
+  e("Notification", "post", "/service/sms", "notificationSendSms", "Send an SMS notification", { body: "json", bodyRequired: true, security: "apiToken" }),
+  e("Social", "get", "/srv/core/nzh/commentList", "socialGetCommentList", "List comments for a subject", { query: ["postId", "subjectId", "offset", "size"], security: "apiToken" }),
+  e("Social", "get", "/srv/core/nzh/comment", "socialAddComment", "Add a comment to a subject", { query: ["postId", "subjectId", "content!"], security: "apiToken" }),
+  e("Social", "get", "/srv/core/nzh/likeComment", "socialLikeComment", "Like or dislike a comment", { query: ["commentId!", "dislike"], security: "apiToken" }),
+  e("Social", "get", "/srv/core/nzh/like", "socialLikePost", "Like or dislike a post", { query: ["postId!", "dislike"], security: "apiToken" }),
+  // IUMS exposes several SDK methods through one RPC-style HTTP endpoint.
+  e("IUMS", "get", "/", "iumsInvokeService", "Invoke an IUMS ExternalFacade method", {
+    query: ["data!"],
+    security: "clientId",
+    sdkMethods: ["getInfOfGraduatedByGraduateDate", "getSessionClassInCurrentDay", "getDetailsOfTermExam", "getStudentInformationByNumber", "getStudentInformationByNationalCode"]
+  }),
+  // PodForm
+  e("PodForm", "get", "/forms/{formId}", "podFormGetForm", "Get a form", { query: ["lockForEdit"], security: "podFormToken", sdkMethods: ["getForm", "getPodformById"] }),
+  e("PodForm", "get", "/forms/all", "podFormGetForms", "List forms", { query: ["page", "size", "folderId", "status", "search"], security: "podFormToken" }),
+  e("PodForm", "post", "/forms", "podFormCreateForm", "Create a form", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "patch", "/forms/{formId}", "podFormUpdateForm", "Update a form", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "delete", "/forms/{formId}", "podFormDeleteForm", "Delete a form", { query: ["removeFromTrash"], security: "podFormToken" }),
+  e("PodForm", "get", "/forms/{formId}/settings", "podFormGetSettings", "Get form settings", { query: ["password"], security: "podFormToken" }),
+  e("PodForm", "patch", "/forms/{formId}/settings", "podFormUpdateSettings", "Update form settings", { query: ["password"], body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "post", "/forms/{formId}/fields", "podFormAddField", "Add a field to a form", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "post", "/forms/{formId}/fields/batch", "podFormAddFields", "Add multiple fields to a form", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "patch", "/forms/{formId}/fields", "podFormUpdateFields", "Update form fields", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "delete", "/forms/{formId}/fields", "podFormDeleteFields", "Delete form fields", { query: ["fieldIds!"], security: "podFormToken" }),
+  e("PodForm", "get", "/forms/{formId}/preview", "podFormGetPreview", "Preview a form", { query: ["password", "language"], security: "podFormToken" }),
+  e("PodForm", "get", "/forms/{formHash}/previewByHash", "podFormGetPreviewByHash", "Preview a public form by hash", { query: ["password", "language"], security: "none" }),
+  e("PodForm", "get", "/forms/{formHash}/generateCaptcha", "podFormGenerateCaptcha", "Generate a public form captcha", { security: "none" }),
+  e("PodForm", "post", "/responses/{formHash}", "podFormSaveResponse", "Submit a form response", { query: ["password", "captchaValue", "captchaHash"], body: "json", bodyRequired: true, security: "none", sdkMethods: ["saveResponse", "sendForm"] }),
+  e("PodForm", "post", "/responses/{formId}/initiate", "podFormInitiateResponse", "Initiate a form response", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "get", "/responses/all/{formId}", "podFormGetResponses", "List form responses", { query: ["page", "size", "from", "to", "status"], security: "podFormToken" }),
+  e("PodForm", "get", "/responses/all/byFormHash/{formHash}", "podFormGetResponsesByHash", "List responses by form hash", { query: ["page", "size", "from", "to", "status"], security: "podFormToken" }),
+  e("PodForm", "get", "/responses/{responseId}", "podFormGetResponse", "Get a form response", { query: ["formId"], security: "podFormToken" }),
+  e("PodForm", "patch", "/responses/{responseId}", "podFormUpdateResponse", "Update response fields", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "delete", "/responses/{formId}", "podFormDeleteResponsesByQuery", "Delete responses by IDs in the query string", { query: ["responseIds!"], security: "podFormToken" }),
+  e("PodForm", "put", "/responses/{formId}", "podFormDeleteResponses", "Delete responses", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "get", "/templates", "podFormGetTemplates", "List form templates", { query: ["page", "size", "templateOwnership"], security: "podFormToken" }),
+  e("PodForm", "post", "/templates", "podFormCreateTemplate", "Create a form template", { query: ["templateOwnership"], body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "patch", "/templates/{templateId}", "podFormUpdateTemplate", "Update a form template", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "delete", "/templates/{templateId}", "podFormDeleteTemplate", "Delete a form template", { security: "podFormToken" }),
+  e("PodForm", "get", "/folders", "podFormGetFolders", "List form folders", { query: ["page", "size", "trash"], security: "podFormToken" }),
+  e("PodForm", "post", "/folders", "podFormCreateFolder", "Create a form folder", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "patch", "/folders/{folderId}", "podFormUpdateFolder", "Update a form folder", { body: "json", bodyRequired: true, security: "podFormToken" }),
+  e("PodForm", "delete", "/folders/{folderId}", "podFormDeleteFolder", "Delete a form folder", { query: ["removeFromTrash"], security: "podFormToken" }),
+  e("PodForm", "get", "/otp/{formHash}/send", "podFormSendOtp", "Send form OTP", { query: ["phoneNumber!", "email"], security: "none" }),
+  e("PodForm", "get", "/otp/{formHash}/validate", "podFormValidateOtp", "Validate form OTP", { query: ["phoneNumber!", "email", "code!"], security: "none" }),
+  e("PodForm", "get", "/user", "podFormGetUser", "Get the PodForm user", { security: "podFormToken" }),
+  e("PodForm", "get", "/user/getUploadLink", "podFormGetUploadLink", "Get a PodForm upload link", { security: "podFormToken" }),
+  e("PodForm", "get", "/user/getDownloadLink", "podFormGetDownloadLink", "Get a PodForm download link", { query: ["hash!", "fileName"], security: "podFormToken" }),
+  e("PodForm", "get", "/plans/all", "podFormGetPlans", "List PodForm plans", { query: ["page", "size"], security: "podFormToken" }),
+  e("PodForm", "get", "/plans", "podFormGetUserPlan", "Get the current PodForm plan", { security: "podFormToken" }),
+  e("PodForm", "get", "/responses/{formId}/export", "podFormExportResponses", "Export form responses", { query: ["type", "from", "to"], security: "podFormToken", response: "binary" }),
+  e("PodForm", "get", "/forms/{formId}/reports", "podFormGetReport", "Get a form report", { security: "podFormToken" }),
+  // CMS content
+  e("CMS Content", "get", "/api/core/contents/enable", "cmsGetContent", "List enabled content", { query: ["offset", "size", "showDetail", "contentTypeUniqueId", "tags"], security: "cmsPublic" }),
+  e("CMS Content", "get", "/api/core/contents", "cmsGetAllContents", "List all content", { query: ["offset", "size", "showDetail", "enable"], security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/my", "cmsGetMyContents", "List content owned by the current client", { query: ["offset", "size", "showDetail", "enable"], security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/{contentTypeUniqueId}", "cmsGetContentsByType", "List content by type", { query: ["offset", "size", "showDetail", "enable"], security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/enable/{entityId}", "cmsGetContentByEntityId", "Get enabled content by entity ID", { security: "cmsPublic" }),
+  e("CMS Content", "get", "/api/core/contents/{contentTypeUniqueId}/enable/{entityId}", "cmsGetTypedContentByEntityId", "Get enabled typed content by entity ID", { security: "cmsPublic", sdkMethods: ["getContentByEntityId"] }),
+  e("CMS Content", "get", "/api/core/contents/{contentUniqueId}/byContentUniqueId/enable", "cmsGetContentByUniqueId", "Get enabled content by unique ID", { security: "cmsPublic" }),
+  e("CMS Content", "get", "/api/core/contents/search", "cmsSearchContent", "Search enabled content", { query: ["query", "name", "offset", "size"], security: "cmsPublic" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/add-publish", "cmsAddContent", "Create and publish content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}", "cmsCreateContent", "Create unpublished content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/{entityId}/edit-publish", "cmsEditContent", "Update and publish content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/{entityId}", "cmsUpdateContent", "Replace content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "patch", "/api/core/contents/{contentTypeUniqueId}/{entityId}", "cmsPatchContent", "Partially update content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/publish/{entityId}", "cmsPublishContent", "Publish content", { security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/unpublish/{entityId}", "cmsUnpublishContent", "Unpublish content", { security: "cmsManage" }),
+  e("CMS Content", "put", "/api/core/contents/publish", "cmsBatchPublishAllTypes", "Batch publish content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "put", "/api/core/contents/{contentTypeUniqueId}/publish", "cmsBatchPublish", "Batch publish typed content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "put", "/api/core/contents/unpublish", "cmsBatchUnpublishAllTypes", "Batch unpublish content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "put", "/api/core/contents/{contentTypeUniqueId}/unpublish", "cmsBatchUnpublish", "Batch unpublish typed content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/archive", "cmsArchiveAllTypes", "Archive content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/archive", "cmsArchiveContent", "Archive typed content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/unarchive", "cmsUnarchiveAllTypes", "Unarchive content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/unarchive", "cmsUnarchiveContent", "Unarchive typed content", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/archive", "cmsGetArchivedContents", "List archived content", { query: ["offset", "size"], security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/{contentTypeUniqueId}/archive", "cmsGetArchivedContentsByType", "List archived content by type", { query: ["offset", "size"], security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/draft", "cmsGetDrafts", "List drafts", { query: ["offset", "size"], security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/{contentTypeUniqueId}/draft", "cmsGetDraftsByType", "List drafts by content type", { query: ["offset", "size"], security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/draft", "cmsCreateDraft", "Create a draft", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/{contentTypeUniqueId}/draft/{entityId}", "cmsGetDraftById", "Get a draft", { security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/draft/{entityId}", "cmsUpdateDraft", "Update a draft", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Content", "post", "/api/core/contents/{contentTypeUniqueId}/undraft/{entityId}", "cmsUndraftContent", "Convert a draft to regular content", { security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/{contentTypeUniqueId}/comments/{entityId}", "cmsGetComments", "List content comments", { query: ["offset", "size"], security: "cmsPublic" }),
+  e("CMS Content", "get", "/api/core/contents/{contentUniqueId}/like/{entityId}", "cmsGetLikes", "List content likes", { query: ["offset", "size"], security: "cmsPublic" }),
+  e("CMS Content", "get", "/api/core/contents/{contentUniqueId}/dislike/{entityId}", "cmsGetDislikes", "List content dislikes", { query: ["offset", "size"], security: "cmsPublic" }),
+  e("CMS Content", "get", "/api/core/content-types/{contentTypeUniqueId}", "cmsGetContentTypeDetail", "Get content type details", { security: "cmsManage" }),
+  e("CMS Content", "get", "/api/core/contents/ai/timeline-search/enable", "cmsTimelineSearch", "Run advanced content timeline search", { query: ["advance", "newVersion", "offset", "size"], security: "cmsPublic" }),
+  // CMS products
+  e("CMS Products", "get", "/api/core/products/enable", "cmsGetProducts", "List enabled products", { query: ["offset", "size", "showDetail", "productTypeUniqueId", "tags"], security: "cmsPublic" }),
+  e("CMS Products", "get", "/api/core/products", "cmsGetAllProducts", "List all products", { query: ["offset", "size", "showDetail", "enable"], security: "cmsManage" }),
+  e("CMS Products", "get", "/api/core/products/manage", "cmsGetManageProducts", "List products for management", { query: ["offset", "size", "showDetail", "enable"], security: "cmsManage" }),
+  e("CMS Products", "get", "/api/core/products/{productTypeUniqueId}", "cmsGetProductsByType", "List products by type", { query: ["offset", "size", "showDetail", "enable"], security: "cmsManage" }),
+  e("CMS Products", "get", "/api/core/products/enable/{entityId}", "cmsGetProductByEntityId", "Get enabled product by entity ID", { security: "cmsPublic" }),
+  e("CMS Products", "get", "/api/core/products/{productTypeUniqueId}/enable/{entityId}", "cmsGetTypedProductByEntityId", "Get enabled typed product by entity ID", { security: "cmsPublic", sdkMethods: ["getProductByEntityId"] }),
+  e("CMS Products", "get", "/api/core/products/{productUniqueId}/byProductUniqueId/enable", "cmsGetProductByUniqueId", "Get product by unique ID", { security: "cmsPublic" }),
+  e("CMS Products", "get", "/api/core/products/barcode/enable", "cmsGetProductByBarcode", "Get product by barcode", { query: ["barcode!"], security: "cmsPublic" }),
+  e("CMS Products", "get", "/api/core/products/enable/search", "cmsSearchProducts", "Search enabled products", { query: ["query", "name", "offset", "size"], security: "cmsPublic" }),
+  e("CMS Products", "post", "/api/core/products/{productTypeUniqueId}/add-publish", "cmsAddProduct", "Create and publish a product", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/{productTypeUniqueId}", "cmsCreateProduct", "Create an unpublished product", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/{productTypeUniqueId}/{entityId}/edit-publish", "cmsEditProduct", "Update and publish a product", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/{productTypeUniqueId}/{entityId}", "cmsUpdateProduct", "Replace a product", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "patch", "/api/core/products/{productTypeUniqueId}/{entityId}", "cmsPatchProduct", "Partially update a product", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/{productTypeUniqueId}/publish/{entityId}", "cmsPublishProduct", "Publish a product", { security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/{productTypeUniqueId}/unpublish/{entityId}", "cmsUnpublishProduct", "Unpublish a product", { security: "cmsManage" }),
+  e("CMS Products", "put", "/api/core/products/publish", "cmsBatchPublishAllProductTypes", "Batch publish products", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "put", "/api/core/products/{productTypeUniqueId}/publish", "cmsBatchPublishProducts", "Batch publish typed products", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "put", "/api/core/products/unpublish", "cmsBatchUnpublishAllProductTypes", "Batch unpublish products", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "put", "/api/core/products/{productTypeUniqueId}/unpublish", "cmsBatchUnpublishProducts", "Batch unpublish typed products", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/archive", "cmsArchiveAllProductTypes", "Archive products", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/{productTypeUniqueId}/archive", "cmsArchiveProducts", "Archive typed products", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/unarchive", "cmsUnarchiveAllProductTypes", "Unarchive products", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "post", "/api/core/products/{productTypeUniqueId}/unarchive", "cmsUnarchiveProducts", "Unarchive typed products", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Products", "get", "/api/core/products/archive", "cmsGetArchivedProducts", "List archived products", { query: ["offset", "size"], security: "cmsManage" }),
+  e("CMS Products", "get", "/api/core/products/{productTypeUniqueId}/archive", "cmsGetArchivedProductsByType", "List archived products by type", { query: ["offset", "size"], security: "cmsManage" }),
+  e("CMS Products", "get", "/api/core/products/ai/timeline-search/enable", "cmsProductTimelineSearch", "Run advanced product timeline search", { query: ["advance", "newVersion", "offset", "size"], security: "cmsPublic" }),
+  // CMS tags
+  e("CMS Tags", "get", "/api/core/tags/category", "cmsGetTagCategories", "List tag categories", { query: ["offset", "size", "enable"], security: "cmsPublic" }),
+  e("CMS Tags", "post", "/api/core/tags/category", "cmsCreateTagCategory", "Create a tag category", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Tags", "get", "/api/core/tags/category/{id}", "cmsGetTagCategory", "Get a tag category", { security: "cmsManage" }),
+  e("CMS Tags", "put", "/api/core/tags/category/{id}", "cmsUpdateTagCategory", "Update a tag category", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Tags", "put", "/api/core/tags/category/{id}/publish", "cmsPublishTagCategory", "Publish a tag category", { security: "cmsManage" }),
+  e("CMS Tags", "put", "/api/core/tags/category/{id}/unpublish", "cmsUnpublishTagCategory", "Unpublish a tag category", { security: "cmsManage" }),
+  e("CMS Tags", "get", "/api/core/tags/{categoryId}/tree/enable", "cmsGetTagTree", "Get the enabled tag tree", { query: ["offset", "size", "parentId", "level"], security: "cmsPublic", sdkMethods: ["getTagTree", "getCategories"] }),
+  e("CMS Tags", "get", "/api/core/tags/{categoryId}/tree/manage", "cmsGetManageTagTree", "Get the tag tree for management", { query: ["offset", "size", "parentId", "level"], security: "cmsManage" }),
+  e("CMS Tags", "post", "/api/core/tags/{categoryId}/tree", "cmsCreateTagTreeItem", "Create a tag tree item", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Tags", "get", "/api/core/tags/{categoryId}/tree/{id}/enable", "cmsGetTagTreeItem", "Get an enabled tag tree item", { security: "cmsPublic" }),
+  e("CMS Tags", "get", "/api/core/tags/{categoryId}/tree/{id}/manage", "cmsGetManageTagTreeItem", "Get a tag tree item for management", { security: "cmsManage" }),
+  e("CMS Tags", "put", "/api/core/tags/{categoryId}/tree/{id}", "cmsUpdateTagTreeItem", "Update a tag tree item", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Tags", "put", "/api/core/tags/{categoryId}/tree/publish/{id}", "cmsPublishTagTreeItem", "Publish a tag tree item", { security: "cmsManage" }),
+  e("CMS Tags", "put", "/api/core/tags/{categoryId}/tree/unpublish/{id}", "cmsUnpublishTagTreeItem", "Unpublish a tag tree item", { security: "cmsManage" }),
+  e("CMS Tags", "put", "/api/core/tags/{categoryId}/tree/parent/{id}", "cmsUpdateTagTreeParent", "Move a tag tree item", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  e("CMS Tags", "get", "/api/core/tags/{categoryId}/tree/parent/{id}/enable", "cmsGetTagTreeAncestors", "Get enabled tag ancestors", { query: ["includeCurrent"], security: "cmsPublic" }),
+  e("CMS Tags", "get", "/api/core/tags/{categoryId}/tree/parent/{id}/manage", "cmsGetManageTagTreeAncestors", "Get tag ancestors for management", { query: ["includeCurrent"], security: "cmsManage" }),
+  e("CMS Tags", "put", "/api/core/tags/{categoryId}/tree/code/{id}", "cmsUpdateTagTreeCode", "Update a tag tree code", { body: "json", bodyRequired: true, security: "cmsManage" }),
+  // Podspace upload, download and file operations
+  e("Podspace Files", "post", "/api/files", "podspaceUploadFile", "Upload a file", { query: ["path", "isPublic", "fileName", "parentHash"], body: "multipart", bodyRequired: true, security: "bearer" }),
+  e("Podspace Files", "post", "/api/files/multiple", "podspaceUploadMultipleFiles", "Upload multiple files", { query: ["path", "isPublic", "parentHash"], body: "multipart", bodyRequired: true, security: "bearer" }),
+  e("Podspace Files", "post", "/api/images/base64", "podspaceUploadImageBase64", "Upload a base64 image", { query: ["base64!", "fileName", "path", "isPublic"], security: "bearer" }),
+  e("Podspace Files", "put", "/api/files/{hash}", "podspaceReplaceFile", "Replace file contents", { query: ["fileName"], body: "multipart", bodyRequired: true, security: "bearer" }),
+  e("Podspace Files", "post", "/api/files/{hash}", "podspaceUploadByLink", "Upload file contents using an upload hash", { body: "multipart", bodyRequired: true, security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/{hash}", "podspaceDownloadFile", "Download a file", { query: ["download", "password", "shareHash"], security: "bearer", response: "binary" }),
+  e("Podspace Files", "get", "/api/v2/images/{hash}", "podspaceDownloadImage", "Download or transform an image", { query: ["width", "height", "crop", "quality", "format", "download"], security: "bearer", response: "binary" }),
+  e("Podspace Files", "get", "/api/files/{hash}/thumbnail", "podspaceDownloadThumbnail", "Download a file thumbnail", { query: ["width", "height", "quality"], security: "bearer", response: "binary" }),
+  e("Podspace Files", "get", "/api/files", "podspaceDownloadFilesAsZip", "Download entities as a ZIP archive", { query: ["hashes!", "fileName"], security: "bearer", response: "binary" }),
+  e("Podspace Files", "get", "/api/files/link", "podspaceGetUploadLink", "Get a pre-signed upload link", { query: ["fileName!", "path", "size", "parentHash"], security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/{hash}/detail", "podspaceGetFileDetail", "Get file or folder details", { query: ["password", "breadcrumb", "shareHash", "nativeMetadata", "includeSizeAndCount"], security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/details", "podspaceGetFileDetailByPath", "Get file details by path", { query: ["path!", "parentHash", "password", "entityType"], security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/{hash}/exist", "podspaceCheckEntityExist", "Check whether an entity exists", { query: ["fileName!", "uniqueName", "type"], security: "bearer" }),
+  e("Podspace Files", "put", "/api/files/{hash}/rename", "podspaceRenameEntity", "Rename a file or folder", { query: ["name!", "uniqueName"], security: "bearer" }),
+  e("Podspace Files", "put", "/api/files/{hash}/move", "podspaceMoveEntity", "Move a file or folder", { query: ["destFolderHash!", "policy", "uniqueName"], security: "bearer" }),
+  e("Podspace Files", "put", "/api/files/{hash}/copy", "podspaceCopyEntity", "Copy a file or folder", { query: ["destFolderHash!", "policy", "uniqueName", "copyType"], security: "bearer" }),
+  e("Podspace Files", "delete", "/api/files/{hash}", "podspaceTrashEntity", "Move a file or folder to trash", { security: "bearer", sdkMethods: ["trashEntity", "deleteFile"] }),
+  e("Podspace Files", "patch", "/api/files/{hash}", "podspaceUpdateFile", "Update file properties", { body: "json", bodyRequired: true, security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/search", "podspaceSearchFiles", "Search files and folders", { query: ["query", "name", "type", "start", "size", "parentHash"], security: "bearer" }),
+  e("Podspace Files", "get", "/api/v2/files/recent", "podspaceGetRecentFiles", "List recent files", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/v2/{hash}/versions", "podspaceGetFileVersions", "List file versions", { security: "bearer" }),
+  e("Podspace Files", "patch", "/api/files/versions/{hash}", "podspaceRestoreFileVersion", "Restore a file version", { security: "bearer" }),
+  e("Podspace Files", "get", "/api/v2/files/{hash}/native/metadata", "podspaceGetNativeMetadata", "Get native file metadata", { security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/{hash}/convert", "podspaceConvertFile", "Convert and download a file", { query: ["format!", "password"], security: "bearer", response: "binary" }),
+  e("Podspace Files", "get", "/api/files/{hash}/breadcrumb", "podspaceGetBreadcrumb", "Get file breadcrumbs", { security: "bearer" }),
+  e("Podspace Files", "post", "/api/files/compress", "podspaceCompressFiles", "Compress files", { query: ["hashes!", "fileName", "parentHash"], security: "bearer" }),
+  e("Podspace Files", "put", "/api/files/{hash}/extract", "podspaceExtractArchive", "Extract an archive", { query: ["destinationHash", "password", "overwrite"], security: "bearer" }),
+  e("Podspace Files", "put", "/api/files/{hash}/cachePolicy", "podspaceSetCachePolicy", "Set file cache policy", { query: ["cachePolicy!"], security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/{hash}/activities", "podspaceGetActivities", "List file activities", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/{hash}/activities/{activity}", "podspaceGetActivityUsers", "List users for a file activity", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Files", "get", "/api/files/{hash}/activities/{activity}/count", "podspaceGetActivityCount", "Count a file activity", { security: "bearer" }),
+  // Podspace folders
+  e("Podspace Folders", "post", "/api/folders", "podspaceCreateFolder", "Create a folder", { query: ["name!", "parentHash", "isPublic", "description"], security: "bearer" }),
+  e("Podspace Folders", "post", "/api/folders/{hash}/directories", "podspaceCreateDirectories", "Create nested directories", { query: ["directories!"], security: "bearer" }),
+  e("Podspace Folders", "get", "/api/folders/{hash}/children", "podspaceGetFolderChildren", "List folder children", { query: ["start", "size", "sort", "order", "type"], security: "bearer" }),
+  e("Podspace Folders", "get", "/api/v2/folders/recent", "podspaceGetRecentFolders", "List recent folders", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Folders", "get", "/api/folders/{hash}/check/upload", "podspaceCheckFolderUpload", "Check folder upload permission", { query: ["size"], security: "bearer" }),
+  e("Podspace Folders", "get", "/api/folders/{folderHash}/actions", "podspaceGetFolderActions", "List allowed folder actions", { security: "bearer" }),
+  // Podspace resumable uploads
+  e("Podspace Resumable", "post", "/api/files/resumable", "podspaceCreateResumableUpload", "Create a resumable upload", { query: ["fileName!", "fileSize!", "parentHash", "contentType"], security: "bearer" }),
+  e("Podspace Resumable", "patch", "/api/files/resumable/{id}", "podspaceAppendResumableChunk", "Append a resumable upload chunk", { query: ["offset!"], body: "binary", bodyRequired: true, security: "bearer" }),
+  e("Podspace Resumable", "head", "/api/files/resumable/{id}", "podspaceGetResumableStatus", "Get resumable upload status", { security: "bearer", response: "empty" }),
+  e("Podspace Resumable", "post", "/api/files/resumable/{id}/finalize", "podspaceFinalizeResumableUpload", "Finalize a resumable upload", { query: ["fileName", "parentHash", "isPublic"], security: "bearer" }),
+  // Podspace links and shares
+  e("Podspace Links", "get", "/api/links/files/{hash}", "podspaceCreateLink", "Create a public file link", { query: ["expireTime", "download", "password"], security: "bearer" }),
+  e("Podspace Links", "get", "/api/links", "podspaceGetUserLinks", "List user links", { query: ["start", "size", "status"], security: "bearer" }),
+  e("Podspace Links", "get", "/api/links/{link}/detail", "podspaceGetLinkDetail", "Get link details", { security: "bearer" }),
+  e("Podspace Links", "patch", "/api/links/{link}", "podspaceUpdateLink", "Update a public link", { query: ["expireTime", "password", "download"], security: "bearer" }),
+  e("Podspace Links", "delete", "/api/links/{link}", "podspaceRevokeLink", "Revoke a public link", { security: "bearer" }),
+  e("Podspace Links", "get", "/api/links/{hash}", "podspaceDownloadFileByLink", "Download a file via public link", { query: ["password", "download"], security: "none", response: "binary" }),
+  e("Podspace Shares", "post", "/api/files/{hash}/shares/users/{identity}", "podspaceShareWithUser", "Share an entity with a user", { query: ["permission!", "expireTime", "notify"], security: "bearer" }),
+  e("Podspace Shares", "delete", "/api/files/{hash}/shares/users/{identity}", "podspaceRemoveShareWithUser", "Remove a user share", { security: "bearer" }),
+  e("Podspace Shares", "post", "/api/files/{hash}/public", "podspaceMakePublic", "Make an entity public", { query: ["isPublic!", "password", "expireTime"], security: "bearer" }),
+  e("Podspace Shares", "get", "/api/shares", "podspaceGetSharedWithMe", "List entities shared with the current user", { query: ["start", "size", "status"], security: "bearer" }),
+  e("Podspace Shares", "get", "/api/shares/{shareHash}", "podspaceGetShareDetail", "Get share details", { security: "bearer" }),
+  e("Podspace Shares", "delete", "/api/shares/{shareHash}", "podspaceRevokeShare", "Revoke a share", { security: "bearer" }),
+  e("Podspace Shares", "get", "/api/files/{hash}/shares", "podspaceGetFileShares", "List shares for an entity", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Shares", "put", "/api/shares/{shareHash}/password", "podspaceSetSharePassword", "Set a share password", { query: ["password!"], security: "bearer" }),
+  e("Podspace Shares", "put", "/api/files/{entityHash}/shares/password", "podspaceSetEntityPassword", "Set an entity share password", { query: ["password!"], security: "bearer" }),
+  // Podspace trash, tags, bookmarks and metadata
+  e("Podspace Trash", "get", "/api/trashes", "podspaceGetTrashList", "List trash entries", { query: ["start", "size", "sort", "order"], security: "bearer" }),
+  e("Podspace Trash", "put", "/api/trashes/{hash}/restore", "podspaceRestoreTrash", "Restore a trash entry", { security: "bearer" }),
+  e("Podspace Trash", "post", "/api/trashes/restore", "podspaceRestoreAllTrash", "Restore all trash entries", { security: "bearer" }),
+  e("Podspace Trash", "delete", "/api/trashes/{hash}", "podspaceDeletePermanently", "Permanently delete a trash entry", { security: "bearer" }),
+  e("Podspace Trash", "delete", "/api/trashes", "podspaceEmptyTrash", "Empty trash", { security: "bearer" }),
+  e("Podspace Trash", "post", "/api/trashes/periods/{period}", "podspaceSetAutoCleanupPeriod", "Set the trash auto-cleanup period", { security: "bearer" }),
+  e("Podspace Tags", "post", "/api/tags", "podspaceAddTags", "Add tags to entities", { query: ["hashes!", "tags!"], security: "bearer" }),
+  e("Podspace Tags", "delete", "/api/tags", "podspaceDeleteTags", "Remove tags from entities", { query: ["hashes!", "tags!"], security: "bearer" }),
+  e("Podspace Tags", "get", "/api/tags/entities/{hash}", "podspaceGetEntityTags", "List tags for an entity", { security: "bearer" }),
+  e("Podspace Tags", "get", "/api/tags/search/{tagName}", "podspaceSearchTags", "Search tags", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Tags", "get", "/api/tags/{tagName}", "podspaceGetEntitiesByTag", "List entities by tag", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Bookmarks", "get", "/api/bookmarks", "podspaceGetBookmarks", "List bookmarks", { query: ["start", "size", "sort", "order"], security: "bearer" }),
+  e("Podspace Bookmarks", "post", "/api/bookmarks", "podspaceAddBookmark", "Add a bookmark", { query: ["hash!"], security: "bearer" }),
+  e("Podspace Bookmarks", "delete", "/api/bookmarks", "podspaceRemoveBookmark", "Remove a bookmark", { query: ["hash!"], security: "bearer" }),
+  e("Podspace Metadata", "get", "/api/files/{hash}/metadata", "podspaceGetMetadata", "Get custom metadata", { query: ["key"], security: "bearer" }),
+  e("Podspace Metadata", "put", "/api/files/{hash}/metadata", "podspaceSetMetadata", "Set custom metadata", { body: "json", bodyRequired: true, security: "bearer" }),
+  e("Podspace Metadata", "delete", "/api/files/{hash}/metadata", "podspaceDeleteMetadata", "Delete custom metadata", { query: ["keys"], security: "bearer" }),
+  e("Podspace Metadata", "post", "/api/files/metadata/search", "podspaceSearchMetadata", "Search custom metadata", { body: "json", bodyRequired: true, security: "bearer" }),
+  e("Podspace Metadata", "get", "/api/files/description", "podspaceGetDescription", "Get an entity description", { query: ["hash!"], security: "bearer" }),
+  e("Podspace Metadata", "put", "/api/files/description", "podspaceSetDescription", "Set an entity description", { query: ["hash!", "description!"], security: "bearer" }),
+  e("Podspace Metadata", "delete", "/api/files/description", "podspaceDeleteDescription", "Delete an entity description", { query: ["hash!"], security: "bearer" }),
+  // Podspace user groups, workspaces and account
+  e("Podspace User Groups", "post", "/api/usergroups", "podspaceCreateUserGroup", "Create a user group", { query: ["name!", "description"], security: "bearer" }),
+  e("Podspace User Groups", "get", "/api/usergroups/{userGroupHash}", "podspaceGetUserGroup", "Get a user group", { security: "bearer" }),
+  e("Podspace User Groups", "delete", "/api/usergroups/{userGroupHash}", "podspaceDeleteUserGroup", "Delete a user group", { security: "bearer" }),
+  e("Podspace User Groups", "get", "/api/usergroups/{userGroupHash}/users", "podspaceGetUserGroupUsers", "List user group members", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace User Groups", "post", "/api/usergroups/{userGroupHash}/users", "podspaceAddUserToGroup", "Add a user to a group", { query: ["identity!", "role"], security: "bearer" }),
+  e("Podspace User Groups", "delete", "/api/usergroups/{userGroupHash}/users", "podspaceRemoveUserFromGroup", "Remove a user from a group", { query: ["identity!"], security: "bearer" }),
+  e("Podspace User Groups", "get", "/api/usergroups/{userGroupHash}/files", "podspaceGetUserGroupFiles", "List user group files", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace User Groups", "post", "/api/usergroups/{userGroupHash}/files", "podspaceUploadToUserGroup", "Upload a file to a user group", { body: "multipart", bodyRequired: true, security: "bearer" }),
+  e("Podspace User Groups", "post", "/api/usergroups/{userGroupHash}/images", "podspaceUploadImageToUserGroup", "Upload an image to a user group", { body: "multipart", bodyRequired: true, security: "bearer" }),
+  e("Podspace User Groups", "get", "/api/usergroups/{userGroupHash}/usage", "podspaceGetUserGroupUsage", "Get user group storage usage", { security: "bearer" }),
+  e("Podspace Workspaces", "post", "/api/workspaces", "podspaceCreateWorkspace", "Create a workspace", { query: ["name!", "description"], security: "bearer" }),
+  e("Podspace Workspaces", "get", "/api/workspaces/{identity}", "podspaceGetWorkspace", "Get a workspace", { query: ["identityType"], security: "bearer" }),
+  e("Podspace Workspaces", "patch", "/api/workspaces/{identity}", "podspaceUpdateWorkspace", "Update a workspace", { query: ["name", "description"], security: "bearer" }),
+  e("Podspace Workspaces", "get", "/api/workspaces/{identity}/members", "podspaceGetWorkspaceMembers", "List workspace members", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Workspaces", "put", "/api/workspaces/{identity}/members/{userIdentity}", "podspaceUpdateWorkspaceMember", "Update a workspace member", { query: ["role!", "identityType"], security: "bearer" }),
+  e("Podspace Workspaces", "delete", "/api/workspaces/{identity}/members/{userIdentity}", "podspaceRemoveWorkspaceMember", "Remove a workspace member", { query: ["identityType"], security: "bearer" }),
+  e("Podspace Account", "get", "/api/me", "podspaceGetUser", "Get the current Podspace user", { security: "bearer" }),
+  e("Podspace Account", "get", "/api/me/workspaces", "podspaceGetUserWorkspaces", "List current user workspaces", { query: ["start", "size"], security: "bearer" }),
+  e("Podspace Account", "get", "/api/me/status", "podspaceGetUserStatus", "Get current user status", { security: "bearer" }),
+  e("Podspace Account", "get", "/api/me/scope", "podspaceGetUserScope", "Get current user scopes", { security: "bearer" }),
+  e("Podspace Account", "get", "/api/me/reports/usage", "podspaceGetUserUsageReport", "Get current user usage report", { query: ["from", "to"], security: "bearer" }),
+  e("Podspace Account", "get", "/api/me/plans", "podspaceGetUserPlans", "List current user plans", { security: "bearer" }),
+  e("Podspace Account", "get", "/api/me/folder", "podspaceGetPersonalFolder", "Get the personal folder", { security: "bearer" }),
+  e("Podspace Account", "get", "/api/me/folders/chat", "podspaceGetOrCreateChatFolder", "Get or create the chat folder", { security: "bearer" }),
+  e("Podspace Account", "get", "/api/me/avatar", "podspaceGetUserAvatar", "Download the current user avatar", { security: "bearer", response: "binary" })
+];
+var TAG_DESCRIPTIONS = {
+  SSO: "Authentication, OTP, token and user-profile operations.",
+  Captcha: "POD captcha generation and validation.",
+  "Custom Post": "Custom post and metadata timeline operations.",
+  Notification: "Notification delivery operations.",
+  Social: "Comments and reactions.",
+  IUMS: "IUMS RPC-style academic information operations.",
+  PodForm: "Forms, fields, responses, templates, folders, OTP and plans.",
+  "CMS Content": "CMS content lifecycle and discovery.",
+  "CMS Products": "CMS product lifecycle and discovery.",
+  "CMS Tags": "CMS tag categories and tag trees.",
+  "Podspace Files": "File upload, download and management.",
+  "Podspace Folders": "Folder hierarchy operations.",
+  "Podspace Resumable": "Resumable file uploads.",
+  "Podspace Links": "Public download links.",
+  "Podspace Shares": "Sharing and permissions.",
+  "Podspace Trash": "Trash and recovery.",
+  "Podspace Tags": "File and folder tags.",
+  "Podspace Bookmarks": "File and folder bookmarks.",
+  "Podspace Metadata": "Custom metadata and descriptions.",
+  "Podspace User Groups": "Team user groups and their files.",
+  "Podspace Workspaces": "Workspace and membership operations.",
+  "Podspace Account": "Current user, plan and quota operations."
+};
+var SERVICE_URL = {
+  SSO: "accounts",
+  Captcha: "cms",
+  "Custom Post": "apiPod",
+  Notification: "notification",
+  Social: "apiPod",
+  IUMS: "iums",
+  PodForm: "podform",
+  "CMS Content": "cms",
+  "CMS Products": "cms",
+  "CMS Tags": "cms",
+  "Podspace Files": "podspace",
+  "Podspace Folders": "podspace",
+  "Podspace Resumable": "podspace",
+  "Podspace Links": "podspace",
+  "Podspace Shares": "podspace",
+  "Podspace Trash": "podspace",
+  "Podspace Tags": "podspace",
+  "Podspace Bookmarks": "podspace",
+  "Podspace Metadata": "podspace",
+  "Podspace User Groups": "podspace",
+  "Podspace Workspaces": "podspace",
+  "Podspace Account": "podspace"
+};
+function securityRequirement(kind = "apiToken") {
+  switch (kind) {
+    case "none":
+      return [];
+    case "bearer":
+      return [{ BearerAuth: [] }];
+    case "basic":
+      return [{ BasicAuth: [] }];
+    case "clientId":
+      return [{ ClientId: [] }];
+    case "podFormToken":
+      return [{ PodFormToken: [] }];
+    case "cmsPublic":
+      return [{ ClientId: [] }];
+    case "cmsManage":
+      return [{ ClientId: [], CmsAccessToken: [] }];
+    case "signature":
+      return [{ SignatureAuth: [] }];
+    default:
+      return [{ PodApiToken: [] }];
+  }
+}
+function pathParameters(path) {
+  return Array.from(path.matchAll(/\{([^}]+)\}/g), ([, name]) => ({
+    name,
+    in: "path",
+    required: true,
+    schema: /(^id$|Id$|entityId$|period$)/.test(name) ? { type: "integer" } : { type: "string" }
+  }));
+}
+function queryParameters(query = []) {
+  return query.map((rawName) => {
+    const required = rawName.endsWith("!");
+    const name = required ? rawName.slice(0, -1) : rawName;
+    const arrayLike = /^(hashes|tags|keys|fieldIds|responseIds|directories)$/.test(name);
+    const booleanLike = /^(enable|showDetail|lockForEdit|removeFromTrash|isPublic|uniqueName|download|breadcrumb|nativeMetadata|includeSizeAndCount|notify|overwrite|dislike|newVersion|includeCurrent)$/.test(name);
+    const integerLike = /^(offset|start|size|page|width|height|quality|period|fileSize)$/.test(name);
+    return {
+      name,
+      in: "query",
+      required,
+      schema: arrayLike ? { type: "array", items: { type: "string" } } : booleanLike ? { type: "boolean" } : integerLike ? { type: "integer" } : { type: "string" }
+    };
+  });
+}
+function requestBody(kind, required = false) {
+  if (!kind) return void 0;
+  const contentType = kind === "form" ? "application/x-www-form-urlencoded" : kind === "multipart" ? "multipart/form-data" : kind === "binary" ? "application/octet-stream" : "application/json";
+  const schema = kind === "binary" ? { type: "string", format: "binary" } : kind === "multipart" ? { $ref: "#/components/schemas/MultipartUpload" } : { $ref: "#/components/schemas/GenericObject" };
+  return { required, content: { [contentType]: { schema } } };
+}
+function responses(kind = "json") {
+  const success = kind === "binary" ? { description: "Binary response", content: { "application/octet-stream": { schema: { type: "string", format: "binary" } } } } : kind === "empty" ? { description: "Successful response" } : { description: "Successful response", content: { "application/json": { schema: { $ref: "#/components/schemas/ApiResponse" } } } };
+  return {
+    "200": success,
+    "400": { $ref: "#/components/responses/BadRequest" },
+    "401": { $ref: "#/components/responses/Unauthorized" },
+    "500": { $ref: "#/components/responses/ServerError" }
+  };
+}
+function createPodOpenApiDocument(options = {}) {
+  const urls = resolvePodUrls(options.urls, options.sandbox);
+  const paths = {};
+  for (const endpoint of POD_OPENAPI_ENDPOINTS) {
+    const parameters = [...pathParameters(endpoint.path), ...queryParameters(endpoint.query)];
+    const operation = {
+      tags: [endpoint.tag],
+      summary: endpoint.summary,
+      operationId: endpoint.operationId,
+      security: securityRequirement(endpoint.security),
+      servers: [{ url: urls[SERVICE_URL[endpoint.tag]] }],
+      responses: responses(endpoint.response),
+      "x-sdk-methods": endpoint.sdkMethods || [endpoint.operationId.replace(/^[a-z]+/, (value) => value)]
+    };
+    if (parameters.length) operation.parameters = parameters;
+    const body = requestBody(endpoint.body, endpoint.bodyRequired);
+    if (body) operation.requestBody = body;
+    if (endpoint.deprecated) operation.deprecated = true;
+    paths[endpoint.path] ||= {};
+    if (paths[endpoint.path][endpoint.method]) {
+      throw new Error(`Duplicate OpenAPI operation: ${endpoint.method.toUpperCase()} ${endpoint.path}`);
+    }
+    paths[endpoint.path][endpoint.method] = operation;
+  }
+  return {
+    openapi: "3.0.3",
+    info: {
+      title: options.title || "POD SDK Services API",
+      version: options.version || "1.0.10",
+      description: "Swagger/OpenAPI documentation for every remote HTTP operation exposed by @rezamirzapour/pod-sdk.",
+      license: { name: "MIT", url: "https://opensource.org/licenses/MIT" }
+    },
+    tags: Object.entries(TAG_DESCRIPTIONS).map(([name, description]) => ({ name, description })),
+    paths,
+    components: {
+      securitySchemes: {
+        PodApiToken: { type: "apiKey", in: "header", name: "_token_", description: "POD API token." },
+        BearerAuth: { type: "http", scheme: "bearer", bearerFormat: "POD token" },
+        BasicAuth: { type: "http", scheme: "basic" },
+        SignatureAuth: { type: "apiKey", in: "header", name: "Authorization", description: "Signature generated by the SSO handshake key." },
+        ClientId: { type: "apiKey", in: "header", name: "Client-Id" },
+        CmsAccessToken: { type: "apiKey", in: "header", name: "Access-Token" },
+        PodFormToken: { type: "apiKey", in: "header", name: "token" }
+      },
+      schemas: {
+        GenericObject: { type: "object", additionalProperties: true },
+        MultipartUpload: {
+          type: "object",
+          properties: { file: { type: "string", format: "binary" }, files: { type: "array", items: { type: "string", format: "binary" } } },
+          additionalProperties: true
+        },
+        ApiResponse: {
+          type: "object",
+          properties: {
+            hasError: { type: "boolean" },
+            result: {},
+            message: { type: "string" },
+            errorCode: { type: "integer" },
+            count: { type: "integer" },
+            referenceNumber: { type: "string" }
+          },
+          additionalProperties: true
+        },
+        ErrorResponse: {
+          type: "object",
+          properties: { hasError: { type: "boolean", example: true }, message: { type: "string" }, errorCode: { type: "integer" } },
+          additionalProperties: true
+        }
+      },
+      responses: {
+        BadRequest: { description: "Invalid request", content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+        Unauthorized: { description: "Authentication failed", content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+        ServerError: { description: "Remote service error", content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+      }
+    }
+  };
+}
+var POD_OPENAPI_DOCUMENT = createPodOpenApiDocument();
+var podSwaggerDocument = POD_OPENAPI_DOCUMENT;
+
 exports.CaptchaService = CaptchaService;
 exports.CmsDataFormatter = CmsDataFormatter;
 exports.CmsProductService = CmsProductService;
@@ -4319,6 +4865,8 @@ exports.CustomPostService = CustomPostService;
 exports.DEFAULT_POD_URLS = DEFAULT_POD_URLS;
 exports.IumsService = IumsService;
 exports.NotificationService = NotificationService;
+exports.POD_OPENAPI_DOCUMENT = POD_OPENAPI_DOCUMENT;
+exports.POD_OPENAPI_ENDPOINTS = POD_OPENAPI_ENDPOINTS;
 exports.PodFormService = PodFormService;
 exports.PodSdk = PodSdk;
 exports.PodspaceBookmarksService = PodspaceBookmarksService;
@@ -4338,10 +4886,12 @@ exports.PodspaceWorkspacesService = PodspaceWorkspacesService;
 exports.SANDBOX_POD_URLS = SANDBOX_POD_URLS;
 exports.SocialService = SocialService;
 exports.SsoService = SsoService;
+exports.createPodOpenApiDocument = createPodOpenApiDocument;
 exports.createPodSdk = createPodSdk;
 exports.default = client_default;
 exports.encodeBase64 = encodeBase64;
 exports.generatePodSignatureHeader = generatePodSignatureHeader;
+exports.podSwaggerDocument = podSwaggerDocument;
 exports.resolvePodUrls = resolvePodUrls;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map