@symbo.ls/sdk 3.1.1 → 3.2.3

package/dist/esm/services/BasedService.js

@@ -90,6 +90,122 @@ var buildUserQuery = (userId) => ({
     $all: true
   }
 });
+var buildGetUserDataQuery = (userId) => ({
+  $id: userId,
+  id: true,
+  name: true,
+  email: true,
+  username: true,
+  globalRole: true,
+  updatedAt: true,
+  createdAt: true,
+  memberProjects: {
+    $list: true,
+    id: true,
+    role: true,
+    createdAt: true,
+    updatedAt: true,
+    project: {
+      id: true,
+      key: true,
+      name: true,
+      thumbnail: true,
+      icon: true,
+      tier: true,
+      visibility: true,
+      access: true,
+      members: {
+        $list: true,
+        user: {
+          id: true,
+          name: true,
+          email: true,
+          globalRole: true
+        },
+        role: true,
+        updatedAt: true,
+        createdAt: true
+      }
+    }
+  }
+});
+var buildGetProjectsByKeysQuery = (keys) => ({
+  projects: {
+    id: true,
+    key: true,
+    name: true,
+    thumbnail: true,
+    icon: true,
+    tier: true,
+    visibility: true,
+    access: true,
+    members: {
+      $list: true,
+      user: {
+        id: true,
+        name: true,
+        email: true,
+        globalRole: true
+      },
+      role: true,
+      updatedAt: true,
+      createdAt: true
+    },
+    $list: {
+      $find: {
+        $traverse: "children",
+        $filter: [
+          { $field: "type", $operator: "=", $value: "project" },
+          { $field: "key", $operator: "=", $value: keys }
+        ]
+      }
+    }
+  }
+});
+var GetProjectFields = {
+  id: true,
+  name: true,
+  key: true,
+  tier: true,
+  projectType: true,
+  icon: true,
+  package: true,
+  seats: true,
+  projectPassword: true,
+  stripe: true,
+  payments: {
+    $list: true,
+    id: true,
+    name: true
+  },
+  access: true,
+  isSharedLibrary: true,
+  framework: true,
+  designTool: true,
+  language: true,
+  visibility: true,
+  domains: true,
+  subscription: { id: true },
+  members: {
+    $list: true,
+    user: { id: true, name: true, email: true },
+    role: true
+  }
+};
+var buildGetProjectDataQuery = (projectId) => ({
+  $id: projectId,
+  ...GetProjectFields
+});
+var buildGetProjectByKeyDataQuery = (key) => ({
+  ...GetProjectFields,
+  $find: {
+    $traverse: "children",
+    $filter: [
+      { $field: "type", $operator: "=", $value: "project" },
+      { $field: "key", $operator: "=", $value: key }
+    ]
+  }
+});
 
 // ../../../node_modules/@based/client/dist/src/websocket/urlLoader.js
 var urlLoader_default = (url, cb) => {
@@ -3869,6 +3985,7 @@ function based(opts, settings) {
 import { isFunction, isString } from "@domql/utils";
 
 // src/config/environment.js
+import { isDevelopment } from "@domql/utils";
 var CONFIG = {
   // Common defaults for all environments
   common: {
@@ -3882,17 +3999,14 @@ var CONFIG = {
   },
   // Environment-specific configurations
   local: {
-    baseUrl: "http://localhost:3000",
-    // For symstory api
+    // local
     socketUrl: "http://localhost:8080",
     // For socket api
-    routerUrl: "http://localhost:3090",
-    // For router api
-    apiUrl: "http://localhost:13335",
+    apiUrl: "http://localhost:8080",
     // For server api
     basedEnv: "development",
     // For based api
-    basedProject: "platform-v2",
+    basedProject: "platform-v2-sm",
     // For based api
     basedOrg: "symbols",
     // For based api
@@ -3905,41 +4019,44 @@ var CONFIG = {
     }
   },
   development: {
-    baseUrl: "https://story.symbo.ls",
-    socketUrl: "https://socket.symbols.app",
-    routerUrl: "https://router.symbols.app",
-    apiUrl: "https://api.symbols.app",
-    basedEnv: "development",
-    basedProject: "platform-v2",
+    socketUrl: "https://dev.api.symbols.app",
+    apiUrl: "https://dev.api.symbols.app",
+    githubClientId: "Ov23liHxyWFBxS8f1gnF"
+  },
+  testing: {
+    socketUrl: "https://test.api.symbols.app",
+    apiUrl: "https://test.api.symbols.app",
+    basedEnv: "testing",
+    basedProject: "platform-v2-sm",
     basedOrg: "symbols",
     githubClientId: "Ov23liHxyWFBxS8f1gnF"
   },
+  upcoming: {
+    socketUrl: "https://upcoming.api.symbols.app",
+    apiUrl: "https://upcoming.api.symbols.app",
+    githubClientId: "Ov23liWF7NvdZ056RV5J"
+  },
   staging: {
-    baseUrl: "https://staging.story.symbo.ls",
-    socketUrl: "https://staging.socket.symbols.app",
-    routerUrl: "https://staging.router.symbols.app",
+    socketUrl: "https://staging.api.symbols.app",
     apiUrl: "https://staging.api.symbols.app",
     basedEnv: "staging",
-    basedProject: "platform-v2",
+    basedProject: "platform-v2-sm",
     basedOrg: "symbols",
     githubClientId: "Ov23ligwZDQVD0VfuWNa"
   },
   production: {
-    baseUrl: "https://story.symbo.ls",
-    socketUrl: "https://socket.symbols.app",
-    routerUrl: "https://router.symbols.app",
+    socketUrl: "https://api.symbols.app",
     apiUrl: "https://api.symbols.app",
     basedEnv: "production",
-    basedProject: "platform-v2",
+    basedProject: "platform-v2-sm",
     basedOrg: "symbols",
     githubClientId: "Ov23liFAlOEIXtX3dBtR"
   }
 };
 var getEnvironment = () => {
-  const env2 = process.env.SYMBOLS_APP_ENV || "" || "development";
+  const env2 = process.env.SYMBOLS_APP_ENV || process.env.NODE_ENV;
   if (!CONFIG[env2]) {
-    console.warn(`Unknown environment "${env2}", falling back to development`);
-    return "development";
+    throw new Error(`Unknown environment "${env2}"`);
   }
   return env2;
 };
@@ -3949,25 +4066,21 @@ var getConfig = () => {
     const envConfig = { ...CONFIG.common, ...CONFIG[env2] };
     const finalConfig = {
       ...envConfig,
-      baseUrl: process.env.SYMBOLS_APP_BASE_URL || envConfig.baseUrl,
       socketUrl: process.env.SYMBOLS_APP_SOCKET_URL || envConfig.socketUrl,
-      routerUrl: process.env.SYMBOLS_APP_ROUTER_URL || envConfig.routerUrl,
       apiUrl: process.env.SYMBOLS_APP_API_URL || envConfig.apiUrl,
       basedEnv: process.env.SYMBOLS_APP_BASED_ENV || envConfig.basedEnv,
       basedProject: process.env.SYMBOLS_APP_BASED_PROJECT || envConfig.basedProject,
       basedOrg: process.env.SYMBOLS_APP_BASED_ORG || envConfig.basedOrg,
       githubClientId: process.env.SYMBOLS_APP_GITHUB_CLIENT_ID || envConfig.githubClientId,
-      isDevelopment: env2 === "development" || env2 === "local",
+      isDevelopment: isDevelopment(env2),
+      isTesting: env2 === "testing",
       isStaging: env2 === "staging",
       isProduction: env2 === "production"
+      // Store all environment variables for potential future use
     };
     const requiredFields = [
-      "baseUrl",
       "socketUrl",
       "apiUrl",
-      "basedEnv",
-      "basedProject",
-      "basedOrg",
       "githubClientId",
       "googleClientId"
     ];
@@ -3980,9 +4093,7 @@ var getConfig = () => {
     if (finalConfig.isDevelopment) {
       console.log(
         "environment in SDK:",
-        env2,
-        "",
-        process.env.SYMBOLS_APP_ENV
+        env2 || process.env.NODE_ENV || process.env.NODE_ENV
       );
       console.log(finalConfig);
     }
@@ -3990,14 +4101,7 @@ var getConfig = () => {
   } catch (error) {
     console.error("Failed to load environment configuration:", error);
     return {
-      baseUrl: "https://story.symbo.ls",
-      socketUrl: "https://socket.symbols.app",
-      routerUrl: "https://router.symbols.app",
-      apiUrl: "https://api.symbols.app",
-      basedEnv: "development",
-      basedProject: "platform-v2",
-      basedOrg: "symbols",
-      githubClientId: "Ov23liHxyWFBxS8f1gnF"
+      ...CONFIG.development
     };
   }
 };
@@ -4106,7 +4210,7 @@ var BasedService = class extends BaseService {
         role: obj.role,
         joinedAt: Date.now()
       });
-      await Promise.all([
+      return await Promise.all([
         this._client.call("db:set", {
           $id: userId,
           memberProjects: { $add: membershipId }
@@ -4116,7 +4220,6 @@ var BasedService = class extends BaseService {
           members: { $add: membershipId }
         })
       ]);
-      return await this._client.call("db:set", obj);
     } catch (error) {
       throw new Error(`Failed to set bucket: ${error.message}`);
     }
@@ -4154,6 +4257,7 @@ var BasedService = class extends BaseService {
       throw new Error(`Query failed: ${error.message}`);
     }
   }
+  // DEPRECATED
   async fetchUser(userId) {
     if (!userId) {
       throw new Error("User Id is required");
@@ -4161,15 +4265,113 @@ var BasedService = class extends BaseService {
     return await this.query("db", buildUserQuery(userId));
   }
   async getUser(userId) {
-    this._requireReady();
     if (!userId) {
-      throw new Error("User Id is required");
-    }
-    try {
-      return await this.call("users:get", { userId });
-    } catch (error) {
-      throw new Error(`Failed to get user: ${error.message}`);
-    }
+      throw new Error("UserId is required");
+    }
+    const userData = await this._client.query("db", 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 i2 = 0; i2 < keys.length; i2 += size) {
+        chunks.push(keys.slice(i2, i2 + size));
+      }
+      try {
+        const result = await this._client.query("db", 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();
@@ -4331,31 +4533,26 @@ var BasedService = class extends BaseService {
       throw new Error(`Failed to create project: ${error.message}`);
     }
   }
-  async getProject(projectId, fields = { $all: true }) {
+  async getProject(projectId) {
     this._requireReady();
     if (!projectId) {
       throw new Error("Project ID is required");
     }
     try {
-      return await this.call("projects:get", {
-        projectId,
-        fields: { ...fields }
-      });
+      return await this._client.query("db", buildGetProjectDataQuery(projectId)).get();
     } catch (error) {
       throw new Error(`Failed to get project: ${error.message}`);
     }
   }
-  async getProjectByKey(key, fields = { $all: true }) {
+  async getProjectByKey(key) {
     this._requireReady();
     try {
-      return await this.call("projects:get", {
-        key,
-        fields: { ...fields }
-      });
+      return await this._client.query("db", buildGetProjectByKeyDataQuery(key)).get();
     } catch (error) {
       throw new Error(`Failed to get project by key: ${error.message}`);
     }
   }
+  // DEPRECATED
   async fetchProject(projectId) {
     this._requireReady();
     if (!projectId) {
@@ -4436,7 +4633,9 @@ var BasedService = class extends BaseService {
     pkg = 2,
     seats = 1,
     interval = "monthly",
-    plan = "startup"
+    plan = "startup",
+    successUrl = `${window.location.origin}/success`,
+    cancelUrl = `${window.location.origin}/pricing`
   }) {
     this._requireReady();
     const prices = {
@@ -4458,7 +4657,9 @@ var BasedService = class extends BaseService {
       return await this.call("checkout", {
         price,
         seats,
-        projectId
+        projectId,
+        successUrl,
+        cancelUrl
       });
     } catch (error) {
       throw new Error(`Failed to checkout: ${error.message}`);
@@ -4633,19 +4834,429 @@ var BasedService = class extends BaseService {
    * @param {string} newKey - The new key of the project (optional)
    * @returns {Promise<Object>} The duplicated project
    */
-  async duplicateProject(projectId, newName, newKey) {
+  async duplicateProject(projectId, newName, newKey, targetUserId) {
     this._requireReady();
     try {
       return await this.call("projects:duplicate", {
         projectId,
         newName,
-        newKey
+        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}`);
+    }
+  }
 };
 export {
   BasedService
 };
+// @preserve-env