@symbo.ls/sdk 3.2.3 → 3.2.7

package/dist/cjs/services/BasedService.js

@@ -1,1185 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var BasedService_exports = {};
-__export(BasedService_exports, {
-  BasedService: () => BasedService
-});
-module.exports = __toCommonJS(BasedService_exports);
-var import_BaseService = require("./BaseService.js");
-var import_basedQuerys = require("../utils/basedQuerys.js");
-var import_client = __toESM(require("@based/client"), 1);
-var import_utils = require("@domql/utils");
-var import_environment = __toESM(require("../config/environment.js"), 1);
-class BasedService extends import_BaseService.BaseService {
-  constructor(config) {
-    super(config);
-    this._client = null;
-    this._subscriptions = /* @__PURE__ */ new Map();
-  }
-  init({ context }) {
-    try {
-      const { env, org, project } = context.based || {
-        env: import_environment.default.basedEnv,
-        org: import_environment.default.basedOrg,
-        project: import_environment.default.basedProject
-      };
-      if (!env || !org || !project) {
-        throw new Error("Based configuration missing required parameters");
-      }
-      this._client = new import_client.default({
-        env,
-        org,
-        project
-      });
-      this._info = {
-        config: {
-          env,
-          org: this._maskString(org),
-          project: this._maskString(project)
-        }
-      };
-      this._setReady();
-    } catch (error) {
-      this._setError(error);
-      throw error;
-    }
-  }
-  // Helper method to mask sensitive strings
-  _maskString(str) {
-    if (!str) {
-      return "";
-    }
-    return `${str.substr(0, 4)}...${str.substr(-4)}`;
-  }
-  updateContext(context) {
-    var _a;
-    this._context = { ...this._context, ...context };
-    if (this._context.authToken && ((_a = this._context.user) == null ? void 0 : _a.id)) {
-      this.setAuthState(this._context.authToken, this._context.user.id);
-    }
-  }
-  async setAuthState(authState) {
-    this._requireReady();
-    const newAuthState = {
-      ...authState,
-      persistent: true
-    };
-    try {
-      return await this._client.setAuthState(newAuthState);
-    } catch (error) {
-      throw new Error(`Failed to set auth state: ${error.message}`);
-    }
-  }
-  async setBucket(bucketId, callback) {
-    this._requireReady();
-    if (!(0, import_utils.isString)(bucketId)) {
-      throw new Error("Invalid type of bucket ID", bucketId);
-    }
-    if (!this._context.project) {
-      throw new Error("Project is undefined");
-    }
-    try {
-      const obj = {
-        $id: this._context.project.id,
-        // TODO: change to getProjectId
-        bucket: bucketId
-      };
-      if ((0, import_utils.isFunction)(callback)) {
-        const data = await this._client.call("db:set", obj);
-        return callback(data);
-      }
-      return await this._client.call("db:set", obj);
-    } catch (error) {
-      throw new Error(`Failed to set bucket: ${error.message}`);
-    }
-  }
-  async setUserForced(userId, obj) {
-    this._requireReady();
-    try {
-      await this._client.query("db", {
-        $id: obj.projectId,
-        members: {
-          $list: true,
-          user: {
-            id: true
-          }
-        }
-      }).get();
-      const { id: membershipId } = await this._client.call("db:set", {
-        type: "projectMember",
-        user: userId,
-        project: obj.projectId,
-        role: obj.role,
-        joinedAt: Date.now()
-      });
-      return await Promise.all([
-        this._client.call("db:set", {
-          $id: userId,
-          memberProjects: { $add: membershipId }
-        }),
-        this._client.call("db:set", {
-          $id: obj.projectId,
-          members: { $add: membershipId }
-        })
-      ]);
-    } catch (error) {
-      throw new Error(`Failed to set bucket: ${error.message}`);
-    }
-  }
-  async query(collection, query, options = {}) {
-    this._requireReady();
-    try {
-      return await this._client.query(collection, query, {
-        ...options,
-        context: this._context
-      }).get();
-    } catch (error) {
-      throw new Error(`Query failed: ${error.message}`);
-    }
-  }
-  async setProject(params) {
-    this._requireReady();
-    try {
-      return await this._client.call("db:set", {
-        type: "project",
-        ...params
-      });
-    } catch (error) {
-      throw new Error(`Query failed: ${error.message}`);
-    }
-  }
-  async setUser(params) {
-    this._requireReady();
-    try {
-      return await this._client.call("db:set", {
-        type: "user",
-        ...params
-      });
-    } catch (error) {
-      throw new Error(`Query failed: ${error.message}`);
-    }
-  }
-  // DEPRECATED
-  async fetchUser(userId) {
-    if (!userId) {
-      throw new Error("User Id is required");
-    }
-    return await this.query("db", (0, import_basedQuerys.buildUserQuery)(userId));
-  }
-  async getUser(userId) {
-    if (!userId) {
-      throw new Error("UserId is required");
-    }
-    const userData = await this._client.query("db", (0, import_basedQuerys.buildGetUserDataQuery)(userId)).get();
-    const user = {
-      id: userData.id,
-      name: userData.name,
-      email: userData.email,
-      username: userData.username,
-      globalRole: userData.globalRole,
-      createdAt: userData.createdAt,
-      updatedAt: userData.updatedAt
-    };
-    if (!user) {
-      throw new Error("User not found");
-    }
-    let memberProjects = [];
-    if (userData.memberProjects && userData.memberProjects.length > 0) {
-      const projectKeys = userData.memberProjects.filter((membership) => membership.project && membership.project.key).map((membership) => membership.project.key);
-      if (projectKeys.length > 0) {
-        const allProjects = await this._fetchProjectsByKeysInChunks(projectKeys);
-        memberProjects = userData.memberProjects.filter((membership) => membership.project && membership.project.key).map((membership) => {
-          const projectKey = membership.project.key;
-          const correctProject = allProjects.find(
-            (p) => p.key === projectKey
-          );
-          return {
-            project: correctProject || membership.project,
-            role: membership.role,
-            updatedAt: membership.updatedAt,
-            createdAt: membership.createdAt
-          };
-        });
-      }
-    } else {
-      console.log(`[getUser] No member projects found with ID: ${userId}`);
-    }
-    const formattedProjects = memberProjects.filter((membership) => membership.project).map((membership) => ({
-      id: membership.project.id,
-      name: membership.project.name,
-      key: membership.project.key,
-      thumbnail: membership.project.thumbnail,
-      icon: membership.project.icon,
-      tier: membership.project.tier,
-      visibility: membership.project.visibility,
-      access: membership.project.access,
-      role: membership.role,
-      joinedAt: membership.createdAt,
-      updatedAt: membership.updatedAt,
-      members: membership.project.members
-    })) || [];
-    return {
-      id: userId,
-      name: user.name,
-      email: user.email,
-      username: user.username,
-      globalRole: user.globalRole,
-      projects: formattedProjects,
-      createdAt: user.createdAt,
-      updatedAt: user.updatedAt
-    };
-  }
-  /**
-   * Fetches projects by keys in chunks with adaptive chunk sizing
-   * @param {Array<string>} allKeys - All project keys to fetch
-   * @returns {Promise<Array>} - All projects found
-   */
-  async _fetchProjectsByKeysInChunks(allKeys) {
-    if (!allKeys.length) {
-      return [];
-    }
-    const INITIAL_CHUNK_SIZE = 50;
-    const MAX_CHUNK_SIZE = 1e3;
-    const MIN_CHUNK_SIZE = 10;
-    const optimalChunkSize = INITIAL_CHUNK_SIZE;
-    const processChunks = async (keys, size) => {
-      if (!keys.length) {
-        return [];
-      }
-      const chunks = [];
-      for (let i = 0; i < keys.length; i += size) {
-        chunks.push(keys.slice(i, i + size));
-      }
-      try {
-        const result = await this._client.query("db", (0, import_basedQuerys.buildGetProjectsByKeysQuery)(chunks[0])).get();
-        const newSize = Math.min(Math.floor(size * 1.5), MAX_CHUNK_SIZE);
-        const firstChunkProjects = result.projects || [];
-        const remainingKeys = keys.slice(chunks[0].length);
-        const remainingProjects = await processChunks(remainingKeys, newSize);
-        return [...firstChunkProjects, ...remainingProjects];
-      } catch (error) {
-        if (error.message && error.message.includes("PayloadTooLarge")) {
-          const newSize = Math.max(Math.floor(size / 2), MIN_CHUNK_SIZE);
-          console.warn(`Reducing chunk size to ${newSize} due to PayloadTooLarge error`);
-          if (newSize === MIN_CHUNK_SIZE && chunks[0].length <= MIN_CHUNK_SIZE) {
-            console.error(`Cannot process chunk, skipping ${chunks[0].length} keys`);
-            const remainingKeys2 = keys.slice(chunks[0].length);
-            return processChunks(remainingKeys2, newSize);
-          }
-          return processChunks(keys, newSize);
-        }
-        console.error(`Error fetching projects: ${error.message}`);
-        const remainingKeys = keys.slice(chunks[0].length);
-        return processChunks(remainingKeys, size);
-      }
-    };
-    return await processChunks(allKeys, optimalChunkSize);
-  }
-  async getUserByEmail(email) {
-    this._requireReady();
-    if (!email) {
-      throw new Error("Email is required");
-    }
-    try {
-      return await this.call("users:get-by", { email });
-    } catch (error) {
-      throw new Error(`Failed to get user: ${error.message}`);
-    }
-  }
-  async setProjectDomains(projectId, domains) {
-    this._requireReady();
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      return await this.call("projects:update-domains", { projectId, domains });
-    } catch (error) {
-      throw new Error(`Failed to set project domains: ${error.message}`);
-    }
-  }
-  async checkProjectKeyAvailability(key) {
-    this._requireReady();
-    try {
-      return await this.call("projects:check-key", { key });
-    } catch (error) {
-      throw new Error(
-        `Failed to check project key availability: ${error.message}`
-      );
-    }
-  }
-  async removeProject(projectId) {
-    this._requireReady();
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      return await this.call("projects:remove", { projectId });
-    } catch (error) {
-      throw new Error(`Failed to remove project: ${error.message}`);
-    }
-  }
-  async getAvailableLibraries(params) {
-    this._requireReady();
-    const defaultParams = {
-      page: 1,
-      limit: 20,
-      search: "",
-      framework: "",
-      language: ""
-    };
-    try {
-      return await this.call("projects:get-available-libraries", {
-        ...defaultParams,
-        ...params
-      });
-    } catch (error) {
-      throw new Error(`Failed to get available libraries: ${error.message}`);
-    }
-  }
-  async addProjectLibraries(projectId, libraryIds) {
-    this._requireReady();
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      return await this.call("projects:add-libraries", {
-        projectId,
-        libraryIds
-      });
-    } catch (error) {
-      throw new Error(`Failed to add project libraries: ${error.message}`);
-    }
-  }
-  async removeProjectLibraries(projectId, libraryIds) {
-    this._requireReady();
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      return await this.call("projects:remove-libraries", {
-        projectId,
-        libraryIds
-      });
-    } catch (error) {
-      throw new Error(`Failed to remove project libraries: ${error.message}`);
-    }
-  }
-  async getProjectLibraries(projectId) {
-    this._requireReady();
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      return await this.call("projects:get-libraries", { projectId });
-    } catch (error) {
-      throw new Error(`Failed to get project libraries: ${error.message}`);
-    }
-  }
-  subscribe(collection, query, callback, options = {}) {
-    this._requireReady();
-    const subscriptionKey = JSON.stringify({ collection, query });
-    if (this._subscriptions.has(subscriptionKey)) {
-      return this._subscriptions.get(subscriptionKey);
-    }
-    try {
-      const unsubscribe = this._client.query(collection, query, {
-        ...options,
-        context: this._context
-      }).subscribe(callback);
-      this._subscriptions.set(subscriptionKey, unsubscribe);
-      return () => {
-        unsubscribe();
-        this._subscriptions.delete(subscriptionKey);
-      };
-    } catch (error) {
-      throw new Error(`Subscription failed: ${error.message}`);
-    }
-  }
-  subscribeChannel(name, params, callback) {
-    this._requireReady();
-    try {
-      return this._client.channel(name, params).subscribe(callback);
-    } catch (error) {
-      throw new Error(`Channel subscription failed: ${error.message}`);
-    }
-  }
-  publishToChannel(name, params, data) {
-    this._requireReady();
-    try {
-      return this._client.channel(name, params).publish(data);
-    } catch (error) {
-      throw new Error(`Channel publish failed: ${error.message}`);
-    }
-  }
-  async call(functionName, params = {}) {
-    this._requireReady();
-    try {
-      return await this._client.call(functionName, params);
-    } catch (error) {
-      throw new Error(`Function call failed: ${error.message}`);
-    }
-  }
-  async updateSchema(schema) {
-    this._requireReady();
-    try {
-      return await this._client.call("db:update-schema", schema);
-    } catch (error) {
-      throw new Error(`Schema update failed: ${error.message}`);
-    }
-  }
-  async createProject(projectData) {
-    this._requireReady();
-    try {
-      return await this.call("projects:create", projectData);
-    } catch (error) {
-      throw new Error(`Failed to create project: ${error.message}`);
-    }
-  }
-  async getProject(projectId) {
-    this._requireReady();
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      return await this._client.query("db", (0, import_basedQuerys.buildGetProjectDataQuery)(projectId)).get();
-    } catch (error) {
-      throw new Error(`Failed to get project: ${error.message}`);
-    }
-  }
-  async getProjectByKey(key) {
-    this._requireReady();
-    try {
-      return await this._client.query("db", (0, import_basedQuerys.buildGetProjectByKeyDataQuery)(key)).get();
-    } catch (error) {
-      throw new Error(`Failed to get project by key: ${error.message}`);
-    }
-  }
-  // DEPRECATED
-  async fetchProject(projectId) {
-    this._requireReady();
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    return await this.query("db", (0, import_basedQuerys.buildProjectQuery)(projectId));
-  }
-  async chooseProject({
-    username = ((_a) => (_a = this._context.user) == null ? void 0 : _a.username)(),
-    projectId,
-    activeProject
-  }) {
-    this._requireReady();
-    try {
-      await this.call("fetchProject", {
-        username,
-        projectId,
-        activeProject
-      });
-      await this._client.call("setCookie", "activeProject", activeProject);
-    } catch (error) {
-      throw new Error(`Failed to choose project: ${error.message}`);
-    }
-  }
-  destroy() {
-    for (const unsubscribe of this._subscriptions.values()) {
-      unsubscribe();
-    }
-    this._subscriptions.clear();
-    this._client = null;
-    this._setReady(false);
-  }
-  // New helper methods for state management
-  async updateState(changes) {
-    if (!changes || Object.keys(changes).length === 0) {
-      return;
-    }
-    try {
-      await this._client.call("state:update", changes);
-    } catch (error) {
-      throw new Error(`Failed to update state: ${error.message}`);
-    }
-  }
-  async getState() {
-    try {
-      return await this._client.call("state:get");
-    } catch (error) {
-      throw new Error(`Failed to get state: ${error.message}`);
-    }
-  }
-  /**
-   * Upload a file to the database
-   * @param {File} file - The file to upload
-   * @param {Object} options - The options for the upload
-   * @returns {Promise<string>} The source of the uploaded file
-   * @example
-   * const fileInput = document.querySelector('input[type="file"]')
-   * const file = fileInput.files[0]
-   * const { id, src } = await basedService.uploadFile(file)
-   */
-  async uploadFile(file, options = {}) {
-    this._requireReady();
-    if (!file) {
-      throw new Error("File is required for upload");
-    }
-    try {
-      const { id, src } = await this._client.stream("db:file-upload", {
-        contents: file,
-        ...options
-      });
-      return { id, src };
-    } catch (error) {
-      throw new Error(`File upload failed: ${error.message}`);
-    }
-  }
-  async checkout({
-    projectId,
-    pkg = 2,
-    seats = 1,
-    interval = "monthly",
-    plan = "startup",
-    successUrl = `${window.location.origin}/success`,
-    cancelUrl = `${window.location.origin}/pricing`
-  }) {
-    this._requireReady();
-    const prices = {
-      999: { startup: "unlimited_startup", agency: "unlimited_agency" },
-      2: { monthly: "starter_monthly", yearly: "starter_yearly" },
-      3: { monthly: "growth_monthly", yearly: "growth_yearly" }
-    };
-    if (!projectId) {
-      throw new Error("Project ID is required for checkout");
-    }
-    if (!prices[pkg]) {
-      throw new Error(`Invalid package type: ${pkg}`);
-    }
-    try {
-      const price = prices[pkg][interval] || prices[pkg][plan];
-      if (!price) {
-        throw new Error(`Invalid interval/plan combination for package ${pkg}`);
-      }
-      return await this.call("checkout", {
-        price,
-        seats,
-        projectId,
-        successUrl,
-        cancelUrl
-      });
-    } catch (error) {
-      throw new Error(`Failed to checkout: ${error.message}`);
-    }
-  }
-  async updateProject(projectId, data) {
-    this._requireReady();
-    try {
-      return await this.call("projects:update", { projectId, data });
-    } catch (error) {
-      throw new Error(`Failed to update project: ${error.message}`);
-    }
-  }
-  async updateProjectComponents(projectId, components) {
-    this._requireReady();
-    try {
-      return await this.call("projects:update-components", {
-        projectId,
-        components
-      });
-    } catch (error) {
-      throw new Error(`Failed to update project components: ${error.message}`);
-    }
-  }
-  async updateProjectSettings(projectId, settings) {
-    this._requireReady();
-    try {
-      return await this.call("projects:update-settings", {
-        projectId,
-        settings
-      });
-    } catch (error) {
-      throw new Error(`Failed to update project settings: ${error.message}`);
-    }
-  }
-  async updateProjectName(projectId, name) {
-    this._requireReady();
-    try {
-      return await this.call("projects:update", { projectId, name });
-    } catch (error) {
-      throw new Error(`Failed to update project name: ${error.message}`);
-    }
-  }
-  async updateProjectPackage(projectId, pkg) {
-    this._requireReady();
-    try {
-      return await this.call("projects:update", {
-        projectId,
-        data: { package: pkg }
-      });
-    } catch (error) {
-      throw new Error(`Failed to update project package: ${error.message}`);
-    }
-  }
-  /**
-   * Update the icon of a project
-   * @param {string} projectId - The ID of the project to update
-   * @param {id, src} icon - The icon to update the project with
-   * @returns {Promise<Object>} The updated project
-   */
-  async updateProjectIcon(projectId, icon) {
-    this._requireReady();
-    try {
-      return await this.call("projects:update", {
-        projectId,
-        data: {
-          icon: {
-            $id: icon.id,
-            src: icon.src
-          }
-        }
-      });
-    } catch (error) {
-      throw new Error(`Failed to update project icon: ${error.message}`);
-    }
-  }
-  async createDnsRecord(domain) {
-    this._requireReady();
-    try {
-      return await this.call("dns:create-record", { domain });
-    } catch (error) {
-      throw new Error(`Failed to create DNS record: ${error.message}`);
-    }
-  }
-  async getDnsRecord(domain) {
-    this._requireReady();
-    try {
-      return await this.call("dns:get-record", { domain });
-    } catch (error) {
-      throw new Error(`Failed to get DNS records: ${error.message}`);
-    }
-  }
-  async removeDnsRecord(domain) {
-    this._requireReady();
-    try {
-      return await this.call("dns:remove-record", { domain });
-    } catch (error) {
-      throw new Error(`Failed to delete DNS record: ${error.message}`);
-    }
-  }
-  async createStorageBucket(key) {
-    this._requireReady();
-    try {
-      const randomString = Math.random().toString(36).slice(2, 15);
-      const bucket = `symbols-bucket-${key}-${randomString}`;
-      return await this.call("storage:create-bucket", {
-        bucketName: bucket,
-        clientName: key.split(".")[0]
-      });
-    } catch (error) {
-      throw new Error(`Failed to create storage bucket: ${error.message}`);
-    }
-  }
-  async getStorageBucket(bucketName) {
-    this._requireReady();
-    try {
-      return await this.call("storage:get-bucket", { bucketName });
-    } catch (error) {
-      throw new Error(`Failed to get storage bucket: ${error.message}`);
-    }
-  }
-  async removeStorageBucket(bucketName) {
-    this._requireReady();
-    try {
-      return await this.call("storage:remove-bucket", { bucketName });
-    } catch (error) {
-      throw new Error(`Failed to remove storage bucket: ${error.message}`);
-    }
-  }
-  /**
-   * Request a password change
-   * @returns {Promise<boolean>} True if the request was successful, false otherwise
-   */
-  async requestPasswordChange() {
-    this._requireReady();
-    try {
-      return await this.call("users:request-password-change", {});
-    } catch (error) {
-      throw new Error(`Failed to request password change: ${error.message}`);
-    }
-  }
-  /**
-   * Confirm a password change
-   * @param {string} verificationCode - The verification code
-   * @param {string} newPassword - The new password
-   * @param {string} confirmPassword - The confirmation password
-   * @returns {Promise<boolean>} True if the password was changed, false otherwise
-   */
-  async confirmPasswordChange(verificationCode, newPassword, confirmPassword) {
-    try {
-      return await this.call("users:confirm-password-change", {
-        verificationCode,
-        newPassword,
-        confirmPassword
-      });
-    } catch (error) {
-      throw new Error(`Failed to confirm password change: ${error.message}`);
-    }
-  }
-  async updateUserProfile(profileData) {
-    this._requireReady();
-    try {
-      return await this.call("users:update-profile", profileData);
-    } catch (error) {
-      throw new Error(`Failed to update user profile: ${error.message}`);
-    }
-  }
-  /**
-   * Duplicate a project
-   * @param {string} projectId - The ID of the project to duplicate
-   * @param {string} newName - The new name of the project (optional)
-   * @param {string} newKey - The new key of the project (optional)
-   * @returns {Promise<Object>} The duplicated project
-   */
-  async duplicateProject(projectId, newName, newKey, targetUserId) {
-    this._requireReady();
-    try {
-      return await this.call("projects:duplicate", {
-        projectId,
-        newName,
-        newKey,
-        targetUserId
-      });
-    } catch (error) {
-      throw new Error(`Failed to duplicate project: ${error.message}`);
-    }
-  }
-  /**
-   * List available subscription plans
-   * @param {Object} options - Options for filtering plans
-   * @param {number} options.page - Page number (default: 1)
-   * @param {number} options.limit - Number of plans per page (default: 20)
-   * @param {string} options.status - Filter plans by status (admin only)
-   * @param {boolean} options.includeSubscriptionCounts - Include subscription counts (admin only)
-   * @param {string} options.sortBy - Field to sort by (default: 'displayOrder')
-   * @param {string} options.sortOrder - Sort order ('asc' or 'desc', default: 'asc')
-   * @returns {Promise<Object>} List of plans with pagination info
-   */
-  async listPlans(options = {}) {
-    this._requireReady();
-    try {
-      return await this.call("plans:list", options);
-    } catch (error) {
-      throw new Error(`Failed to list plans: ${error.message}`);
-    }
-  }
-  /**
-   * Subscribe to a plan
-   * @param {string} planId - ID of the plan to subscribe to
-   * @param {Object} options - Options for the subscription
-   * @param {string} options.paymentMethod - Payment method
-   * @param {Object} options.billingAddress - Billing address
-   * @param {string} options.stripeCustomerId - Stripe customer ID
-   * @param {string} options.stripeSubscriptionId - Stripe subscription ID
-   * @returns {Promise<Object>} Subscription details
-   */
-  async subscribeToPlan(planId, options = {}) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:create", { planId, ...options });
-    } catch (error) {
-      throw new Error(`Failed to subscribe to plan: ${error.message}`);
-    }
-  }
-  /**
-   * Get details of user's current subscription
-   * @param {string} subscriptionId - ID of the subscription to get details for
-   * @returns {Promise<Object>} Subscription details
-   */
-  async getSubscriptionDetails(subscriptionId) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:details", {
-        subscriptionId
-      });
-    } catch (error) {
-      throw new Error(`Failed to get subscription details: ${error.message}`);
-    }
-  }
-  /**
-   * Check if the current subscription is active
-   * @param {string} subscriptionId - ID of the subscription to check
-   * @returns {Promise<Object>} Subscription status info
-   */
-  async checkSubscriptionStatus(subscriptionId) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:check-status", {
-        subscriptionId
-      });
-    } catch (error) {
-      throw new Error(`Failed to check subscription status: ${error.message}`);
-    }
-  }
-  /**
-   * Upgrade the current subscription to a new plan
-   * @param {string} planId - ID of the plan to upgrade to
-   * @param {string} stripeSubscriptionId - ID of the Stripe subscription to upgrade
-   * @returns {Promise<Object>} Updated subscription details
-   */
-  async upgradeSubscription(planId, stripeSubscriptionId) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:upgrade", {
-        planId,
-        stripeSubscriptionId
-      });
-    } catch (error) {
-      throw new Error(`Failed to upgrade subscription: ${error.message}`);
-    }
-  }
-  /**
-   * Downgrade the current subscription to a new plan
-   * @param {string} planId - ID of the plan to downgrade to
-   * @param {boolean} applyImmediately - Whether to apply the downgrade immediately
-   * @param {string} stripeSubscriptionId - ID of the Stripe subscription to downgrade
-   * @returns {Promise<Object>} Updated subscription details
-   */
-  async downgradeSubscription(planId, stripeSubscriptionId, applyImmediately = false) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:downgrade", {
-        planId,
-        applyImmediately,
-        stripeSubscriptionId
-      });
-    } catch (error) {
-      throw new Error(`Failed to downgrade subscription: ${error.message}`);
-    }
-  }
-  /**
-   * Cancel the current subscription
-   * @param {boolean} cancelImmediately - Whether to cancel immediately or at period end
-   * @param {string} reason - Reason for cancellation
-   * @returns {Promise<Object>} Result of cancellation
-   */
-  async cancelSubscription(cancelImmediately = false, reason = "") {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:cancel", {
-        cancelImmediately,
-        reason
-      });
-    } catch (error) {
-      throw new Error(`Failed to cancel subscription: ${error.message}`);
-    }
-  }
-  /**
-   * Reactivate a subscription that was scheduled for cancellation
-   * @returns {Promise<Object>} Updated subscription details
-   */
-  async reactivateSubscription(stripeSubscriptionId) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:reactivate", {
-        stripeSubscriptionId
-      });
-    } catch (error) {
-      throw new Error(`Failed to reactivate subscription: ${error.message}`);
-    }
-  }
-  /**
-   * Generate an invoice for the current subscription
-   * @param {string} subscriptionId - ID of the subscription to generate the invoice for
-   * @param {boolean} forceGenerate - Whether to force the generation of the invoice
-   * @param {Array} customItems - Custom items to add to the invoice
-   * @returns {Promise<Object>} Generated invoice
-   */
-  async generateInvoice(subscriptionId, forceGenerate = false, customItems = []) {
-    this._requireReady();
-    try {
-      return await this.call("billing:generate-invoice", {
-        subscriptionId,
-        forceGenerate,
-        customItems
-      });
-    } catch (error) {
-      throw new Error(`Failed to generate invoice: ${error.message}`);
-    }
-  }
-  /**
-   * Get usage report for the current subscription
-   * @param {string} subscriptionId - ID of the subscription to get the usage report for
-   * @param {boolean} forceRefresh - Whether to force the refresh of the usage report
-   * @returns {Promise<Object>} Usage report
-   */
-  async getUsageReport(subscriptionId, forceRefresh = false) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:get-usage-report", {
-        subscriptionId,
-        forceRefresh
-      });
-    } catch (error) {
-      throw new Error(`Failed to get usage report: ${error.message}`);
-    }
-  }
-  /**
-   * Invite a user to be an account owner for the current subscription
-   * @param {string} email - Email of the user to invite
-   * @param {string} name - Name of the user to invite
-   * @param {string} callbackUrl - URL to redirect the user to after accepting the invitation
-   * @returns {Promise<Object>} Result of invitation
-   */
-  async inviteAccountOwner(email, name, callbackUrl) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:invite", {
-        email,
-        name,
-        callbackUrl
-      });
-    } catch (error) {
-      throw new Error(`Failed to invite account owner: ${error.message}`);
-    }
-  }
-  /**
-   * Accept an invitation to become an account owner
-   * @param {string} token - Invitation token
-   * @returns {Promise<Object>} Result of accepting invitation
-   */
-  async acceptOwnerInvitation(token) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:accept-owner-invitation", {
-        token
-      });
-    } catch (error) {
-      throw new Error(`Failed to accept owner invitation: ${error.message}`);
-    }
-  }
-  /**
-   * Remove an account owner from the current subscription
-   * @param {string} userId - ID of the user to remove
-   * @returns {Promise<Object>} Result of removal
-   */
-  async removeAccountOwner(userId) {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:remove-account-owner", {
-        targetUserId: userId
-      });
-    } catch (error) {
-      throw new Error(`Failed to remove account owner: ${error.message}`);
-    }
-  }
-  /**
-   * Check if a resource limit has been reached
-   * @param {string} resourceType - Type of resource to check
-   * @param {string} projectId - ID of the project to check the resource limit for
-   * @param {number} quantity - Amount being requested
-   * @param {string} userId - ID of user to check (admin only, defaults to current user)
-   * @returns {Promise<Object>} Result of check
-   */
-  async checkResourceLimit(resourceType, projectId, quantity = 1, userId = "") {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:check-resource-limit", {
-        resourceType,
-        projectId,
-        quantity,
-        userId
-      });
-    } catch (error) {
-      throw new Error(`Failed to check resource limit: ${error.message}`);
-    }
-  }
-  /**
-   * Check if a user has access to a feature
-   * @param {string} featureKey - Key of the feature to check
-   * @param {string} userId - ID of user to check (admin only, defaults to current user)
-   * @returns {Promise<Object>} Access check result
-   */
-  async checkFeatureAccess(featureKey, userId) {
-    this._requireReady();
-    try {
-      return await this.call("features:check-access", {
-        featureKey,
-        userId
-      });
-    } catch (error) {
-      throw new Error(`Failed to check feature access: ${error.message}`);
-    }
-  }
-  /**
-   * Get all features available to the current user
-   * @returns {Promise<Object>} Available features
-   */
-  async getUserFeatures() {
-    this._requireReady();
-    try {
-      return await this.call("subscriptions:get-user-features", {});
-    } catch (error) {
-      throw new Error(`Failed to get user features: ${error.message}`);
-    }
-  }
-  /**
-   * Get all available features across all plans
-   * @param {string} subscriptionId - ID of the subscription to get the available features for
-   * @param {string} userId - ID of user to get the available features for (admin only, defaults to current user)
-   * @param {boolean} includeDetails - Whether to include details about the features
-   * @returns {Promise<Object>} Available features
-   */
-  async getAvailableFeatures(subscriptionId, userId = "", includeDetails = false) {
-    this._requireReady();
-    try {
-      return await this.call("features:get-available", {
-        subscriptionId,
-        userId,
-        includeDetails
-      });
-    } catch (error) {
-      throw new Error(`Failed to get available features: ${error.message}`);
-    }
-  }
-  /**
-   * List all feature flags (admin only)
-   * @param {Object} options - Options for listing feature flags
-   * @param {number} options.page - Page number
-   * @param {number} options.limit - Number of items per page
-   * @param {string} options.status - Filter by status
-   * @returns {Promise<Object>} List of feature flags
-   */
-  async listFeatureFlags(options = {}) {
-    this._requireReady();
-    try {
-      return await this.call("features:list", options);
-    } catch (error) {
-      throw new Error(`Failed to list feature flags: ${error.message}`);
-    }
-  }
-  /**
-   * Update a feature flag (admin only)
-   * @param {string} flagId - ID of the feature flag to update
-   * @param {Object} options - Update data
-   * @param {string} options.key - Key of the feature flag
-   * @param {string} options.name - Name of the feature flag
-   * @param {string} options.description - Description of the feature flag
-   * @param {string} options.defaultValue - Default value of the feature flag
-   * @param {Object} options.planOverrides - Plan overrides for the feature flag
-   * @param {Object} options.userOverrides - User overrides for the feature flag
-   * @param {string} options.status - Status of the feature flag
-   * @returns {Promise<Object>} Updated feature flag
-   */
-  async updateFeatureFlag(flagId, options) {
-    this._requireReady();
-    try {
-      return await this.call("features:update", {
-        flagId,
-        ...options
-      });
-    } catch (error) {
-      throw new Error(`Failed to update feature flag: ${error.message}`);
-    }
-  }
-  /**
-   * Remove a feature flag (admin only)
-   * @param {string} flagId - ID of the feature flag to remove
-   * @returns {Promise<Object>} Result of removal
-   */
-  async removeFeatureFlag(flagId) {
-    this._requireReady();
-    try {
-      return await this.call("features:remove", {
-        flagId
-      });
-    } catch (error) {
-      throw new Error(`Failed to remove feature flag: ${error.message}`);
-    }
-  }
-  /**
-   * Batch update feature flags (admin only)
-   * @param {Array} operations - Array of feature flag operations
-   * @param {string} operations.flagId - ID of the feature flag to update
-   * @param {string} operations.key - Key of the feature flag
-   * @param {string} operations.name - Name of the feature flag
-   * @param {string} operations.description - Description of the feature flag
-   * @param {boolean} operations.defaultValue - Default value of the feature flag
-   * @param {Object} operations.planOverrides - Plan overrides for the feature flag
-   * @param {Object} operations.userOverrides - User overrides for the feature flag
-   * @param {string} operations.status - Status of the feature flag
-   * @returns {Promise<Object>} Result of batch update
-   */
-  async batchUpdateFeatureFlags(operations) {
-    this._requireReady();
-    try {
-      return await this.call("features:batch-update", {
-        operations
-      });
-    } catch (error) {
-      throw new Error(`Failed to batch update feature flags: ${error.message}`);
-    }
-  }
-  /**
-   * Update plan details (admin only)
-   * @param {string} planId - ID of the plan to update
-   * @param {Object} data - Update data
-   * @param {string} data.name - Display name (e.g., "Pro", "Team")
-   * @param {string} data.description - Marketing description
-   * @param {number} data.price - Monthly price in cents
-   * @param {number} data.annualPrice - Annual price in cents (discounted)
-   * @param {number} data.lifetimePrice - One-time lifetime price in cents
-   * @param {string} data.billingType - Payment type
-   * @param {string} data.status - Status
-   * @param {Object} data.features - Detailed feature configuration
-   * @returns {Promise<Object>} Updated plan
-   */
-  async updatePlanDetails(planId, data) {
-    this._requireReady();
-    try {
-      return await this.call("plans:update-details", {
-        planId,
-        data
-      });
-    } catch (error) {
-      throw new Error(`Failed to update plan details: ${error.message}`);
-    }
-  }
-  /**
-   * Update plan status (admin only)
-   * @param {string} planId - ID of the plan to update
-   * @param {string} status - New status
-   * @returns {Promise<Object>} Updated plan
-   */
-  async updatePlanStatus(planId, status) {
-    this._requireReady();
-    try {
-      return await this.call("plans:update-status", {
-        planId,
-        status
-      });
-    } catch (error) {
-      throw new Error(`Failed to update plan status: ${error.message}`);
-    }
-  }
-}