@rezamirzapour/pod-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1096 @@
+import { createNextHttp } from '@rezamirzapour/http';
+
+// src/services/sso/index.ts
+
+// src/utils/crypto.ts
+function encodeBase64(str) {
+  if (typeof btoa === "function") {
+    return btoa(str);
+  }
+  return Buffer.from(str).toString("base64");
+}
+async function createRsaSignature(value, privateKeyPem, encoding = "base64") {
+  const pemHeader = "-----BEGIN PRIVATE KEY-----";
+  const pemFooter = "-----END PRIVATE KEY-----";
+  const pemContents = privateKeyPem.replace(pemHeader, "").replace(pemFooter, "").replace(/\s+/g, "");
+  const binaryString = typeof atob === "function" ? atob(pemContents) : Buffer.from(pemContents, "base64").toString("binary");
+  const binaryDer = Uint8Array.from(binaryString, (c) => c.charCodeAt(0));
+  const cryptoKey = await crypto.subtle.importKey(
+    "pkcs8",
+    binaryDer.buffer,
+    {
+      name: "RSASSA-PKCS1-v1_5",
+      hash: "SHA-256"
+    },
+    false,
+    ["sign"]
+  );
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", cryptoKey, data);
+  const rawBytes = new Uint8Array(signature);
+  if (encoding === "base64") {
+    if (typeof btoa === "function") {
+      return btoa(String.fromCharCode(...rawBytes));
+    }
+    return Buffer.from(rawBytes).toString("base64");
+  }
+  return Array.from(rawBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function generatePodSignatureHeader(keyId, privateKeyPem) {
+  if (!privateKeyPem) return "";
+  const sign = await createRsaSignature("host: accounts.pod.ir", privateKeyPem, "base64");
+  return `Signature keyId=${keyId}, signature=${sign}, headers=host`;
+}
+
+// src/services/sso/index.ts
+var SsoService = class {
+  http;
+  clientId;
+  clientSecret;
+  apiToken;
+  privateKeyPem;
+  websiteUrl;
+  revalidate;
+  constructor(options) {
+    this.clientId = options.clientId || "";
+    this.clientSecret = options.clientSecret || "";
+    this.apiToken = options.apiToken || "";
+    this.privateKeyPem = options.privateKeyPem || "";
+    this.websiteUrl = options.websiteUrl || "";
+    this.revalidate = Number(options.revalidate) || 0;
+    this.http = createNextHttp({
+      baseUrl: options.baseUrl,
+      serviceName: "POD-SSO"
+    });
+  }
+  /**
+   * Performs handshake with POD SSO to obtain a keyId for OTP signing.
+   */
+  async handshake(deviceUid, ip) {
+    const params = {
+      device_type: "Desktop",
+      algorithm: "rsa-sha256",
+      device_uid: deviceUid,
+      device_client_ip: ip
+    };
+    try {
+      const result = await this.http.post(
+        `/oauth2/clients/handshake/${this.clientId}`,
+        void 0,
+        {
+          params,
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
+            Accept: "application/json; charset=utf-8",
+            Authorization: `Bearer ${this.apiToken}`
+          }
+        }
+      );
+      return {
+        hasError: false,
+        result
+      };
+    } catch (err) {
+      return {
+        hasError: true,
+        message: err.data?.error_description || err.message,
+        errorCode: err.status
+      };
+    }
+  }
+  /**
+   * Sends an OTP SMS to the specified phone number.
+   */
+  async sendOtpCode(keyId, phoneNumber, options) {
+    try {
+      const authorization = await generatePodSignatureHeader(keyId, this.privateKeyPem);
+      const params = {
+        identityType: options?.identityType || "phone_number",
+        response_type: options?.response_type || "code",
+        referrerType: options?.referrerType || "username",
+        linkDeliveryType: options?.linkDeliveryType || "SMS",
+        scope: options?.scope || "phone profile",
+        redirect_uri: options?.redirect_uri || `${this.websiteUrl}/login`
+      };
+      const result = await this.http.post(`/oauth2/otp/authorize/${phoneNumber}`, void 0, {
+        params,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
+          Accept: "application/json; charset=utf-8",
+          Authorization: authorization
+        }
+      });
+      return {
+        hasError: false,
+        authorization,
+        identity: phoneNumber,
+        result
+      };
+    } catch (err) {
+      return {
+        hasError: true,
+        message: err.data?.error_description || err.message
+      };
+    }
+  }
+  /**
+   * Verifies an OTP code received by SMS.
+   */
+  async verifyOtpCode(authorization, phoneNumber, code, redirectUri) {
+    const params = {
+      otp: code,
+      redirect_uri: redirectUri || `${this.websiteUrl}/login`
+    };
+    try {
+      const result = await this.http.post(
+        `/oauth2/otp/verify/${phoneNumber}`,
+        void 0,
+        {
+          params,
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
+            Accept: "application/json; charset=utf-8",
+            Authorization: authorization
+          }
+        }
+      );
+      return {
+        hasError: false,
+        result
+      };
+    } catch (err) {
+      return {
+        hasError: true,
+        message: err.data?.error_description || err.data?.error || err.message,
+        errorCode: err.status
+      };
+    }
+  }
+  /**
+   * Exchanges authorization code for access & refresh tokens.
+   */
+  async generateToken(code, redirectUri) {
+    const clientSignature = encodeBase64(`${this.clientId}:${this.clientSecret}`);
+    const params = {
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri || `${this.websiteUrl}/login`
+    };
+    try {
+      const result = await this.http.post("/oauth2/token", void 0, {
+        params,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
+          Accept: "application/json; charset=utf-8",
+          Authorization: `Basic ${clientSignature}`
+        }
+      });
+      return {
+        hasError: false,
+        result
+      };
+    } catch (err) {
+      return {
+        hasError: true,
+        message: err.data?.error_description || err.message,
+        errorCode: err.status
+      };
+    }
+  }
+  /**
+   * Refreshes an expired access token using a refresh token.
+   */
+  async refreshToken(refreshToken) {
+    const clientSignature = encodeBase64(`${this.clientId}:${this.clientSecret}`);
+    const params = {
+      grant_type: "refresh_token",
+      refresh_token: refreshToken
+    };
+    try {
+      const result = await this.http.post("/oauth2/token", void 0, {
+        params,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json",
+          Authorization: `Basic ${clientSignature}`
+        }
+      });
+      return {
+        hasError: false,
+        result
+      };
+    } catch (err) {
+      return {
+        hasError: true,
+        message: err.data?.error_description || err.message,
+        errorCode: err.status
+      };
+    }
+  }
+  /**
+   * Fetches user profile from SSO using the access token.
+   */
+  async getUserProfile(accessToken) {
+    try {
+      const result = await this.http.get("/users", {
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        },
+        next: this.revalidate ? { revalidate: this.revalidate } : void 0
+      });
+      return {
+        hasError: false,
+        result
+      };
+    } catch (err) {
+      return {
+        hasError: true,
+        message: err.message,
+        errorCode: err.status
+      };
+    }
+  }
+};
+
+// src/services/customPost/crud.ts
+var CustomPostCrudService = class {
+  constructor(service, config) {
+    this.service = service;
+    this.config = config;
+  }
+  service;
+  config;
+  buildMetadata(data) {
+    return {
+      objectInfo: {
+        type: this.config.type,
+        detailedType: this.config.detailedType
+      },
+      data
+    };
+  }
+  /**
+   * Searches and retrieves all entities matching the query.
+   */
+  async getAll(params, options) {
+    return this.service.searchTimelineByMetadata(
+      params || {},
+      options
+    );
+  }
+  /**
+   * Retrieves a single entity by its numerical ID.
+   */
+  async getById(id, options) {
+    return this.service.getCustomPost(
+      { id, offset: 0, size: 1 },
+      options
+    );
+  }
+  /**
+   * Creates a new entity.
+   */
+  async create(data, options) {
+    return this.service.addCustomPost(
+      {
+        name: this.config.name,
+        content: this.config.content || " ",
+        metadata: this.buildMetadata(data)
+      },
+      options
+    );
+  }
+  /**
+   * Creates multiple entities in batch.
+   */
+  async createMultiple(dataList, options) {
+    const items = dataList.map((data) => ({
+      name: this.config.name,
+      content: this.config.content || " ",
+      metadata: this.buildMetadata(data)
+    }));
+    return this.service.addCustomPostList(items, options);
+  }
+  /**
+   * Updates an existing entity by entityId.
+   */
+  async update(entityId, data, enable = true, options) {
+    return this.service.updateCustomPost(
+      {
+        entityId,
+        name: this.config.name,
+        content: this.config.content || " ",
+        metadata: this.buildMetadata(data),
+        enable
+      },
+      options
+    );
+  }
+  /**
+   * Creates a post and automatically updates it by binding the generated entityId into the record data.
+   */
+  async createAndBindEntityId(data, options) {
+    const createResponse = await this.create(data, options);
+    if (!createResponse.hasError && createResponse.result?.entityId) {
+      return this.update(
+        createResponse.result.entityId,
+        {
+          ...data,
+          entityId: createResponse.result.entityId
+        },
+        true,
+        options
+      );
+    }
+    return createResponse;
+  }
+  /**
+   * Archives (disables) an entity without deleting its history.
+   */
+  async archive(entityId, data, options) {
+    return this.update(entityId, data, false, options);
+  }
+  /**
+   * Deletes an entity permanently.
+   */
+  async delete(entityId, options) {
+    return this.service.deleteCustomPost(entityId, options);
+  }
+};
+
+// src/services/customPost/index.ts
+var CustomPostService = class {
+  http;
+  apiToken;
+  revalidate;
+  constructor(options) {
+    this.apiToken = options.apiToken || "";
+    this.revalidate = Number(options.revalidate) || 0;
+    this.http = createNextHttp({
+      baseUrl: options.baseUrl,
+      serviceName: "POD-CustomPost",
+      headers: {
+        _token_: this.apiToken
+      }
+    });
+  }
+  safeParseJson(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+  /**
+   * Searches timeline entries by structured metadata query, returning typed items.
+   */
+  async searchTimelineByMetadata(params, options) {
+    const rawParams = {
+      ...params,
+      ...params.metadata ? { metadata: typeof params.metadata === "object" ? JSON.stringify(params.metadata) : params.metadata } : {},
+      ...params.metaQuery ? { metaQuery: typeof params.metaQuery === "object" ? JSON.stringify(params.metaQuery) : params.metaQuery } : {}
+    };
+    const response = await this.http.get(
+      "/srv/core/nzh/biz/searchTimelineByMetadata",
+      {
+        ...options,
+        params: rawParams,
+        next: this.revalidate ? { revalidate: this.revalidate, ...options?.next || {} } : options?.next
+      }
+    );
+    if (response?.result && Array.isArray(response.result)) {
+      response.result = response.result.map((el) => {
+        if (el?.item?.metadata) {
+          el.item.metadata = this.safeParseJson(el.item.metadata);
+        }
+        return el;
+      });
+    }
+    return response;
+  }
+  /**
+   * Retrieves custom posts list or a single post by entityId/id with typed metadata.
+   */
+  async getCustomPost(params, options) {
+    const response = await this.http.get(
+      "/srv/core/nzh/biz/customPostList",
+      {
+        ...options,
+        params,
+        next: this.revalidate ? { revalidate: this.revalidate, ...options?.next || {} } : options?.next
+      }
+    );
+    if (response?.result && Array.isArray(response.result)) {
+      response.result = response.result.map((el) => {
+        if (el?.metadata) {
+          el.metadata = this.safeParseJson(el.metadata);
+        }
+        return el;
+      });
+    }
+    return response;
+  }
+  /**
+   * Creates a new custom post with strongly typed metadata.
+   */
+  async addCustomPost(params, options) {
+    const payload = {
+      ...params,
+      metadata: typeof params.metadata === "object" ? JSON.stringify(params.metadata) : params.metadata,
+      content: params.content || " "
+    };
+    const response = await this.http.post(
+      "/srv/core/nzh/biz/addCustomPost",
+      new URLSearchParams(payload),
+      {
+        ...options,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          _token_: this.apiToken,
+          ...options?.headers
+        }
+      }
+    );
+    if (response?.result?.metadata) {
+      response.result.metadata = this.safeParseJson(response.result.metadata);
+    }
+    return response;
+  }
+  /**
+   * Creates multiple custom posts in bulk.
+   */
+  async addCustomPostList(items, options) {
+    const promises = items.map((item) => this.addCustomPost(item, options));
+    return Promise.all(promises);
+  }
+  /**
+   * Updates an existing custom post by its entityId with typed metadata.
+   */
+  async updateCustomPost(params, options) {
+    const payload = {
+      ...params,
+      ...params.metadata ? { metadata: typeof params.metadata === "object" ? JSON.stringify(params.metadata) : params.metadata } : {},
+      ...params.entityId ? { entityId: params.entityId.toString() } : {}
+    };
+    const response = await this.http.post(
+      "/srv/core/nzh/biz/updateCustomPost",
+      new URLSearchParams(payload),
+      {
+        ...options,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          _token_: this.apiToken,
+          ...options?.headers
+        }
+      }
+    );
+    if (response?.result?.metadata) {
+      response.result.metadata = this.safeParseJson(response.result.metadata);
+    }
+    return response;
+  }
+  /**
+   * Deletes a custom post by entityId.
+   */
+  async deleteCustomPost(entityId, options) {
+    return this.http.post(
+      "/srv/core/nzh/biz/deleteCustomPost",
+      void 0,
+      {
+        ...options,
+        params: { entityId }
+      }
+    );
+  }
+  /**
+   * Factory method to create a high-level Generic CRUD repository for any entity type.
+   */
+  createCrud(config) {
+    return new CustomPostCrudService(this, config);
+  }
+};
+var PodspaceService = class {
+  http;
+  apiToken;
+  baseUrl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.apiToken = options.apiToken || "";
+    this.http = createNextHttp({
+      baseUrl: options.baseUrl,
+      serviceName: "POD-Podspace",
+      headers: {
+        Authorization: `Bearer ${this.apiToken}`
+      }
+    });
+  }
+  /**
+   * Uploads a file (via FormData) to the POD Podspace storage.
+   */
+  async uploadFile(formData, path = "/", isPublic = true) {
+    const params = {
+      path,
+      isPublic
+    };
+    return this.http.post("/api/files", formData, {
+      params
+    });
+  }
+  /**
+   * Builds the public or private URL to download/view a file.
+   */
+  getFileUrl(hash, isPublic = true) {
+    return `${this.baseUrl}/api/files/${hash}?isPublic=${isPublic}`;
+  }
+};
+var PodFormService = class {
+  http;
+  apiToken;
+  revalidate;
+  constructor(options) {
+    this.apiToken = options.apiToken || "";
+    this.revalidate = Number(options.revalidate) || 0;
+    this.http = createNextHttp({
+      baseUrl: options.baseUrl,
+      serviceName: "POD-PodForm",
+      headers: {
+        token: this.apiToken,
+        accept: "*/*"
+      }
+    });
+  }
+  /**
+   * Submits responses/answers to a POD Form.
+   */
+  async sendForm(formId, data) {
+    const payload = new URLSearchParams({
+      ...data,
+      userResponseTimeMilliSeconds: "230000"
+    });
+    return this.http.post(`/responses/${formId}`, payload, {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+  }
+  /**
+   * Retrieves a form and its questions by ID.
+   */
+  async getPodformById(id, options) {
+    return this.http.get(`/responses/all/${id}`, {
+      ...options,
+      next: this.revalidate ? { revalidate: this.revalidate, ...options?.next || {} } : options?.next
+    });
+  }
+};
+var NotificationService = class {
+  http;
+  apiToken;
+  constructor(options) {
+    this.apiToken = options.apiToken || "";
+    this.http = createNextHttp({
+      baseUrl: options.baseUrl,
+      serviceName: "POD-Notification",
+      headers: {
+        apiToken: this.apiToken
+      }
+    });
+  }
+  /**
+   * Sends an SMS notification to one or multiple mobile numbers.
+   */
+  async sendSms(params) {
+    const payload = {
+      content: {
+        content: params.content,
+        mobileNumbers: params.mobileNumbers,
+        receiverType: "MOBILE"
+      }
+    };
+    return this.http.post("/service/sms", payload);
+  }
+};
+var SocialService = class {
+  http;
+  apiToken;
+  revalidate;
+  constructor(options) {
+    this.apiToken = options.apiToken || "";
+    this.revalidate = Number(options.revalidate) || 0;
+    this.http = createNextHttp({
+      baseUrl: options.baseUrl,
+      serviceName: "POD-Social",
+      headers: {
+        _token_: this.apiToken,
+        _token_issuer_: "1"
+      }
+    });
+  }
+  /**
+   * Retrieves comments for a specific post or subject ID.
+   */
+  async getCommentList(params, options) {
+    return this.http.get("/srv/core/nzh/commentList", {
+      ...options,
+      params,
+      next: this.revalidate ? { revalidate: this.revalidate, ...options?.next || {} } : options?.next
+    });
+  }
+  /**
+   * Adds a new comment to a subject.
+   */
+  async addComment(params) {
+    return this.http.get("/srv/core/nzh/comment", {
+      params
+    });
+  }
+  /**
+   * Likes or dislikes a comment.
+   */
+  async likeComment(params) {
+    return this.http.get("/srv/core/nzh/likeComment", {
+      params
+    });
+  }
+  /**
+   * Likes or dislikes a post.
+   */
+  async likePost(params) {
+    return this.http.get("/srv/core/nzh/like", {
+      params
+    });
+  }
+};
+
+// src/services/cms/formatter.ts
+var CmsDataFormatter = class {
+  podspaceUrl;
+  constructor(podspaceUrl = "https://podspace.pod.ir") {
+    this.podspaceUrl = podspaceUrl;
+  }
+  generateImage(hash, defaultSrc = "") {
+    return hash ? `${this.podspaceUrl}/api/images/${hash}?dl=1` : defaultSrc;
+  }
+  formatContentItem(item, normalizer) {
+    if (typeof item === "number" || !item || typeof item !== "object") {
+      return item;
+    }
+    const newItem = {
+      ...JSON.parse(JSON.stringify(item)),
+      formatted: {},
+      __normalized: {}
+    };
+    const formatted = {};
+    if (Array.isArray(item?.metadata?.content)) {
+      item.metadata.content.forEach((detail) => {
+        switch (detail.type) {
+          case "IMAGE_TYPE": {
+            formatted[detail.code] = Array.isArray(detail.value) ? detail.value.map((v) => this.generateImage(v)) : this.generateImage(detail.value);
+            break;
+          }
+          default:
+            formatted[detail.code] = detail.value !== void 0 ? detail.value : "";
+        }
+      });
+    }
+    if (Array.isArray(item?.metadata?.content_related)) {
+      item.metadata.content_related.forEach((detail) => {
+        if (detail?.uniqueId && Array.isArray(detail.values)) {
+          formatted[detail.uniqueId] = detail.values.map(
+            (val) => this.formatContentItem(val)
+          );
+        }
+      });
+    }
+    newItem.formatted = formatted;
+    if (typeof normalizer === "function") {
+      newItem.__normalized = normalizer(newItem);
+    }
+    return newItem;
+  }
+  formatGetContentResponse(response, normalizer) {
+    if (response && Array.isArray(response.result)) {
+      const result = response.result.map(
+        (item) => this.formatContentItem(item, normalizer)
+      );
+      return {
+        ...response,
+        result
+      };
+    }
+    return response || {};
+  }
+};
+
+// src/services/cms/index.ts
+var CmsService = class {
+  http;
+  formatter;
+  clientId;
+  apiToken;
+  revalidate;
+  constructor(options) {
+    this.clientId = options.clientId || "";
+    this.apiToken = options.apiToken || "";
+    this.revalidate = Number(options.revalidate) || 0;
+    this.formatter = new CmsDataFormatter(options.podspaceUrl || "https://podspace.pod.ir");
+    this.http = createNextHttp({
+      baseUrl: options.baseUrl,
+      serviceName: "POD-CMS"
+    });
+  }
+  get commonHeaders() {
+    return {
+      "Client-Id": this.clientId,
+      "Content-Type": "application/json"
+    };
+  }
+  get managingHeaders() {
+    return {
+      ...this.commonHeaders,
+      "Access-Token": this.apiToken
+    };
+  }
+  /**
+   * Retrieves enabled published content from CMS, formatted with generic metadata type T and optional normalized type P.
+   */
+  async getContent(params = {}, options = {}) {
+    const transferParams = {
+      size: 50,
+      offset: 0,
+      showDetail: true,
+      ...params
+    };
+    try {
+      const res = await this.http.get("/api/core/contents/enable", {
+        params: transferParams,
+        headers: {
+          ...this.commonHeaders,
+          ...options.headers
+        },
+        cache: options.cache,
+        signal: options.signal,
+        next: {
+          revalidate: options.revalidate !== void 0 ? options.revalidate === false ? 0 : options.revalidate : this.revalidate
+        }
+      });
+      return this.formatter.formatGetContentResponse(res, options.normalizer);
+    } catch {
+      return { hasError: true, result: [] };
+    }
+  }
+  /**
+   * Retrieves content using managing credentials (Access-Token).
+   */
+  async getContent2(params = {}, options = {}) {
+    const transferParams = {
+      size: 50,
+      offset: 0,
+      showDetail: true,
+      ...params
+    };
+    try {
+      const res = await this.http.get("/api/core/contents", {
+        params: transferParams,
+        headers: {
+          ...this.managingHeaders,
+          ...options.headers
+        },
+        cache: options.cache,
+        signal: options.signal,
+        next: {
+          revalidate: options.revalidate !== void 0 ? options.revalidate === false ? 0 : options.revalidate : this.revalidate
+        }
+      });
+      return this.formatter.formatGetContentResponse(res, options.normalizer);
+    } catch {
+      return { hasError: true, result: [] };
+    }
+  }
+  /**
+   * Retrieves unpublished/draft content (enable: false).
+   */
+  async getUnpublishedContent(params = {}, options = {}) {
+    const transferParams = {
+      size: 50,
+      offset: 0,
+      showDetail: true,
+      enable: false,
+      ...params
+    };
+    try {
+      const res = await this.http.get("/api/core/contents", {
+        params: transferParams,
+        headers: {
+          ...this.managingHeaders,
+          ...options.headers
+        },
+        cache: options.cache,
+        signal: options.signal,
+        next: {
+          revalidate: options.revalidate !== void 0 ? options.revalidate === false ? 0 : options.revalidate : this.revalidate
+        }
+      });
+      return this.formatter.formatGetContentResponse(res, options.normalizer);
+    } catch {
+      return { hasError: true, result: [] };
+    }
+  }
+  /**
+   * Retrieves single content by entityId and optional contentTypeUniqueId.
+   */
+  async getContentByEntityId(params, options = {}) {
+    const url = params.contentTypeUniqueId ? `/api/core/contents/${params.contentTypeUniqueId}/enable/${params.entityId}` : `/api/core/contents/enable/${params.entityId}`;
+    try {
+      const res = await this.http.get(url, {
+        headers: {
+          ...this.commonHeaders,
+          ...options.headers
+        },
+        cache: options.cache,
+        signal: options.signal,
+        next: {
+          revalidate: options.revalidate !== void 0 ? options.revalidate === false ? 0 : options.revalidate : this.revalidate
+        }
+      });
+      return this.formatter.formatGetContentResponse(res, options.normalizer);
+    } catch {
+      return { hasError: true, result: [] };
+    }
+  }
+  /**
+   * Retrieves tag/category tree.
+   */
+  async getCategories(params = {}, options = {}) {
+    try {
+      return await this.http.get("/api/core/tags/root/tree/enable", {
+        params,
+        headers: {
+          ...this.commonHeaders,
+          ...options.headers
+        },
+        cache: options.cache,
+        signal: options.signal,
+        next: {
+          revalidate: options.revalidate !== void 0 ? options.revalidate === false ? 0 : options.revalidate : this.revalidate
+        }
+      });
+    } catch {
+      return { hasError: true, result: [] };
+    }
+  }
+  /**
+   * Retrieves details of a content type structure.
+   */
+  async getContentTypeDetail(contentTypeUniqueId) {
+    try {
+      return await this.http.get(`/api/core/content-types/${contentTypeUniqueId}`, {
+        headers: this.managingHeaders
+      });
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Adds and publishes new content to CMS.
+   */
+  async addContent(params, options = {}) {
+    const res = await this.http.post(
+      `/api/core/contents/${params.contentTypeUniqueId}/add-publish`,
+      params.body,
+      {
+        headers: this.managingHeaders
+      }
+    );
+    return this.formatter.formatGetContentResponse(res, options.normalizer);
+  }
+  /**
+   * Edits and publishes existing content by entityId.
+   */
+  async editContent(entityId, params, options = {}) {
+    const res = await this.http.post(
+      `/api/core/contents/${params.contentTypeUniqueId}/${entityId}/edit-publish`,
+      params.body,
+      {
+        headers: this.managingHeaders
+      }
+    );
+    return this.formatter.formatGetContentResponse(res, options.normalizer);
+  }
+  /**
+   * Performs advanced AI timeline search.
+   */
+  async timelineSearch(query) {
+    const params = {};
+    if (query?.advance) {
+      params.advance = JSON.stringify(query.advance);
+      params.newVersion = true;
+    }
+    if (query?.offset) {
+      params.offset = query.offset;
+    }
+    return this.http.get("/api/core/ai-service/timeline-search/enable", {
+      params,
+      headers: this.commonHeaders
+    });
+  }
+};
+var IumsService = class {
+  http;
+  clientId;
+  revalidate;
+  constructor(options) {
+    this.clientId = options.clientId || "";
+    this.revalidate = Number(options.revalidate) || 0;
+    this.http = createNextHttp({
+      baseUrl: options.baseUrl,
+      serviceName: "POD-IUMS",
+      headers: {
+        "Client-Id": this.clientId
+      }
+    });
+  }
+  generateIumsDataPayload(method, parameters = [], service = "ExternalFacade") {
+    const paramsString = parameters.length > 0 ? "[" + parameters.map((v) => `\\\\\\\\\\\\\\"${v}\\\\\\\\\\\\\\"`) + "]" : null;
+    return `{"type":3,"content":"{\\"peerName\\":\\"khatam_eng_hq\\",\\"receivers\\":[],\\"collapseId\\":null,\\"groupId\\":null,\\"index\\":null,\\"messageId\\":\\"8657270951\\",\\"ttl\\":60000,\\"content\\":\\"{\\\\\\"requestHeader\\\\\\":{\\\\\\"trackerId\\\\\\":null,\\\\\\"token\\\\\\":null,\\\\\\"id_token\\\\\\":null,\\\\\\"pod_token\\\\\\":null,\\\\\\"ssoToken\\\\\\":null,\\\\\\"requesterPostId\\\\\\":0,\\\\\\"userIds\\\\\\":null,\\\\\\"ssoIds\\\\\\":null},\\\\\\"messageType\\\\\\":\\\\\\"INVOKE_SERVICE\\\\\\",\\\\\\"processData\\\\\\":[],\\\\\\"content\\\\\\":\\\\\\"{\\\\\\\\\\\\\\"service\\\\\\\\\\\\\\":\\\\\\\\\\\\\\"${service}\\\\\\\\\\\\\\",\\\\\\\\\\\\\\"serviceMethod\\\\\\\\\\\\\\":\\\\\\\\\\\\\\"${method}\\\\\\\\\\\\\\",\\\\\\\\\\\\\\"parameters\\\\\\\\\\\\\\":${paramsString ?? "null"},\\\\\\\\\\\\\\"returnedVarType\\\\\\\\\\\\\\":null,\\\\\\\\\\\\\\"returnedVarJson\\\\\\\\\\\\\\":null,\\\\\\\\\\\\\\"genericType\\\\\\\\\\\\\\":null}\\\\\\",\\\\\\"engineName\\\\\\":null,\\\\\\"peerId\\\\\\":null,\\\\\\"asyncTracker\\\\\\":0,\\\\\\"trackerId\\\\\\":null}\\"}","trackerId":null}`;
+  }
+  formatIumsResponse(response) {
+    const content = response?.content;
+    if (!content) return response;
+    try {
+      let data = JSON.parse(content);
+      if (data?.content) {
+        data = JSON.parse(data.content);
+      }
+      if (data?.returnedVarJson) {
+        return JSON.parse(data.returnedVarJson);
+      }
+      return data;
+    } catch {
+      return response;
+    }
+  }
+  async request(serviceMethod, params = [], options) {
+    const dataPayload = this.generateIumsDataPayload(serviceMethod, params);
+    const response = await this.http.get("/srv", {
+      ...options,
+      params: { data: dataPayload },
+      next: this.revalidate ? { revalidate: this.revalidate, ...options?.next || {} } : options?.next
+    });
+    return this.formatIumsResponse(response);
+  }
+  async getInfOfGraduatedByGraduateDate(startDate = "20240521", endDate = "20250621", options) {
+    return this.request(
+      "getInfOfGraduatedByGraduateDate3",
+      [startDate, endDate],
+      options
+    );
+  }
+  async getSessionClassInCurrentDay(options) {
+    return this.request(
+      "getSessionCalssInCurrentDay",
+      [],
+      options
+    );
+  }
+  async getDetailsOfTermExam(options) {
+    return this.request("getDetailsOfTermExam", [], options);
+  }
+  async getStudentInformationByNumber(studentNumber, options) {
+    return this.request("getStudentInformationByNumber", [Number(studentNumber)], options);
+  }
+  async getStudentInformationByNationalCode(nationalCode, options) {
+    return this.request("getStudentInformationByNationalCode", [Number(nationalCode)], options);
+  }
+};
+
+// src/client.ts
+var PodSdk = class {
+  sso;
+  customPost;
+  podspace;
+  podform;
+  notification;
+  social;
+  cms;
+  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
+    };
+    const apiToken = config.apiToken || "";
+    const clientId = config.clientId || "";
+    const clientSecret = config.clientSecret || "";
+    const privateKeyPem = config.privateKeyPem || "";
+    const revalidate = config.revalidate;
+    this.sso = new SsoService({
+      baseUrl: urls.accounts,
+      clientId,
+      clientSecret,
+      apiToken,
+      privateKeyPem,
+      websiteUrl: urls.website,
+      revalidate
+    });
+    this.customPost = new CustomPostService({
+      baseUrl: urls.apiPod,
+      apiToken,
+      revalidate
+    });
+    this.podspace = new PodspaceService({
+      baseUrl: urls.podspace,
+      apiToken
+    });
+    this.podform = new PodFormService({
+      baseUrl: urls.podform,
+      apiToken,
+      revalidate
+    });
+    this.notification = new NotificationService({
+      baseUrl: urls.notification,
+      apiToken
+    });
+    this.social = new SocialService({
+      baseUrl: urls.apiPod,
+      apiToken,
+      revalidate
+    });
+    this.cms = new CmsService({
+      baseUrl: urls.cms || urls.apiPod,
+      apiToken,
+      clientId,
+      podspaceUrl: urls.podspace,
+      revalidate
+    });
+    this.iums = new IumsService({
+      baseUrl: urls.iums,
+      clientId,
+      revalidate
+    });
+  }
+  /**
+   * Helper shortcut to instantiate a Generic CRUD repository for any entity type on POD CustomPost.
+   */
+  createCrud(config) {
+    return this.customPost.createCrud(config);
+  }
+};
+function createPodSdk(config) {
+  return new PodSdk(config);
+}
+var client_default = PodSdk;
+
+export { CmsDataFormatter, CmsService, CustomPostCrudService, CustomPostService, IumsService, NotificationService, PodFormService, PodSdk, PodspaceService, SocialService, SsoService, createPodSdk, client_default as default, encodeBase64, generatePodSignatureHeader };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map