perspectapi-ts-sdk 1.1.1

package/dist/index.mjs

@@ -0,0 +1,1727 @@
+// src/utils/http-client.ts
+var HttpClient = class {
+  baseUrl;
+  defaultHeaders;
+  timeout;
+  retries;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.timeout = config.timeout || 3e4;
+    this.retries = config.retries || 3;
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      "User-Agent": "perspectapi-ts-sdk/1.0.0",
+      ...config.headers
+    };
+    if (config.apiKey) {
+      this.defaultHeaders["X-API-Key"] = config.apiKey;
+    }
+    if (config.jwt) {
+      this.defaultHeaders["Authorization"] = `Bearer ${config.jwt}`;
+    }
+  }
+  /**
+   * Update authentication token
+   */
+  setAuth(jwt) {
+    this.defaultHeaders["Authorization"] = `Bearer ${jwt}`;
+  }
+  /**
+   * Update API key
+   */
+  setApiKey(apiKey) {
+    this.defaultHeaders["X-API-Key"] = apiKey;
+  }
+  /**
+   * Remove authentication
+   */
+  clearAuth() {
+    delete this.defaultHeaders["Authorization"];
+    delete this.defaultHeaders["X-API-Key"];
+  }
+  /**
+   * Make HTTP request with retry logic
+   */
+  async request(endpoint, options = {}) {
+    const url = this.buildUrl(endpoint, options.params);
+    const requestOptions = this.buildRequestOptions(options);
+    console.log(`[HTTP Client] Making ${options.method || "GET"} request to: ${url}`);
+    console.log(`[HTTP Client] Base URL: ${this.baseUrl}`);
+    console.log(`[HTTP Client] Endpoint: ${endpoint}`);
+    console.log(`[HTTP Client] Full URL: ${url}`);
+    if (options.params) {
+      console.log(`[HTTP Client] Query params:`, options.params);
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, requestOptions);
+        return await this.handleResponse(response);
+      } catch (error) {
+        lastError = error;
+        if (error && typeof error === "object" && "status" in error && typeof error.status === "number" && error.status < 500) {
+          throw error;
+        }
+        if (attempt === this.retries) {
+          break;
+        }
+        await this.delay(Math.pow(2, attempt) * 1e3);
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, params) {
+    return this.request(endpoint, { method: "GET", params });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request(endpoint, { method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request(endpoint, { method: "PUT", body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(endpoint, body) {
+    return this.request(endpoint, { method: "PATCH", body });
+  }
+  /**
+   * Build full URL with query parameters
+   */
+  buildUrl(endpoint, params) {
+    const url = `${this.baseUrl}${endpoint.startsWith("/") ? "" : "/"}${endpoint}`;
+    if (!params || Object.keys(params).length === 0) {
+      return url;
+    }
+    const searchParams = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        searchParams.append(key, String(value));
+      }
+    });
+    return `${url}?${searchParams.toString()}`;
+  }
+  /**
+   * Build request options
+   */
+  buildRequestOptions(options) {
+    const headers = {
+      ...this.defaultHeaders,
+      ...options.headers
+    };
+    const requestOptions = {
+      method: options.method || "GET",
+      headers
+    };
+    if (options.body && options.method !== "GET") {
+      if (typeof options.body === "string") {
+        requestOptions.body = options.body;
+      } else {
+        requestOptions.body = JSON.stringify(options.body);
+      }
+    }
+    return requestOptions;
+  }
+  /**
+   * Fetch with timeout support
+   */
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Handle response and errors
+   */
+  async handleResponse(response) {
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    let data;
+    try {
+      data = isJson ? await response.json() : await response.text();
+    } catch (error) {
+      data = null;
+    }
+    if (!response.ok) {
+      const error = {
+        message: data?.error || data?.message || `HTTP ${response.status}: ${response.statusText}`,
+        status: response.status,
+        code: data?.code,
+        details: data
+      };
+      throw error;
+    }
+    if (isJson && typeof data === "object") {
+      if ("data" in data || "message" in data || "error" in data) {
+        return data;
+      }
+      return { data, success: true };
+    }
+    return { data, success: true };
+  }
+  /**
+   * Delay utility for retries
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createApiError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return error;
+  }
+  return {
+    message: "Unknown error occurred",
+    details: error
+  };
+}
+
+// src/client/base-client.ts
+var BaseClient = class {
+  http;
+  basePath;
+  constructor(http, basePath) {
+    this.http = http;
+    this.basePath = basePath;
+  }
+  /**
+   * Build a site-scoped endpoint relative to the API base path
+   */
+  siteScopedEndpoint(siteName, endpoint = "", options) {
+    if (!siteName || !siteName.trim()) {
+      throw new Error("siteName is required");
+    }
+    const encodedSiteName = encodeURIComponent(siteName.trim());
+    const cleanEndpoint = endpoint.replace(/^\//, "");
+    const includeSitesSegment = options?.includeSitesSegment ?? true;
+    const baseSegment = includeSitesSegment ? `sites/${encodedSiteName}` : encodedSiteName;
+    const suffix = cleanEndpoint ? `/${cleanEndpoint}` : "";
+    return `/${baseSegment}${suffix}`;
+  }
+  /**
+   * Build endpoint path
+   */
+  buildPath(endpoint) {
+    const cleanBasePath = this.basePath.replace(/\/$/, "");
+    const cleanEndpoint = endpoint.replace(/^\//, "");
+    return `${cleanBasePath}/${cleanEndpoint}`;
+  }
+  /**
+   * Handle paginated responses
+   */
+  async getPaginated(endpoint, params) {
+    return this.http.get(this.buildPath(endpoint), params);
+  }
+  /**
+   * Handle single resource responses
+   */
+  async getSingle(endpoint) {
+    return this.http.get(this.buildPath(endpoint));
+  }
+  /**
+   * Handle create operations
+   */
+  async create(endpoint, data) {
+    return this.http.post(this.buildPath(endpoint), data);
+  }
+  /**
+   * Handle update operations
+   */
+  async update(endpoint, data) {
+    return this.http.put(this.buildPath(endpoint), data);
+  }
+  /**
+   * Handle partial update operations
+   */
+  async patch(endpoint, data) {
+    return this.http.patch(this.buildPath(endpoint), data);
+  }
+  /**
+   * Handle delete operations
+   */
+  async delete(endpoint) {
+    return this.http.delete(this.buildPath(endpoint));
+  }
+};
+
+// src/client/auth-client.ts
+var AuthClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get CSRF token
+   */
+  async getCsrfToken() {
+    return this.http.get(this.buildPath("/csrf"));
+  }
+  /**
+   * Sign up a new user
+   */
+  async signUp(data) {
+    return this.create("/signup", data);
+  }
+  /**
+   * Sign in user
+   */
+  async signIn(data) {
+    const response = await this.create("/authenticate", data);
+    if (response.data && "token" in response.data && response.data.token) {
+      this.http.setAuth(response.data.token);
+    }
+    return response;
+  }
+  /**
+   * Activate user account
+   */
+  async activateAccount(activationKey) {
+    return this.getSingle(`/activate/${activationKey}`);
+  }
+  /**
+   * Request password reset
+   */
+  async forgotPassword(email) {
+    return this.create("/forgotpassword", { email });
+  }
+  /**
+   * Reset password with token
+   */
+  async resetPassword(resetToken, password) {
+    return this.create(
+      `/passwordreset/${resetToken}`,
+      { password }
+    );
+  }
+  /**
+   * Get current user profile
+   */
+  async getUserProfile() {
+    return this.getSingle("/userprofile");
+  }
+  /**
+   * Sign out (clear local auth)
+   */
+  signOut() {
+    this.http.clearAuth();
+  }
+};
+
+// src/client/content-client.ts
+var ContentClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get all content with pagination and filtering for a site
+   */
+  async getContent(siteName, params) {
+    return this.http.get(this.buildPath(this.siteScopedEndpoint(siteName)), params);
+  }
+  /**
+   * Get content by ID
+   */
+  async getContentById(id) {
+    return this.getSingle(`/content/${id}`);
+  }
+  /**
+   * Get content by slug for a site
+   */
+  async getContentBySlug(siteName, slug) {
+    return this.http.get(this.buildPath(
+      this.siteScopedEndpoint(siteName, `/slug/${encodeURIComponent(slug)}`)
+    ));
+  }
+  /**
+   * Create new content
+   */
+  async createContent(data) {
+    return this.create("/content", data);
+  }
+  /**
+   * Update content
+   */
+  async updateContent(id, data) {
+    return this.update(`/content/${id}`, data);
+  }
+  /**
+   * Partially update content
+   */
+  async patchContent(id, data) {
+    return this.patch(`/content/${id}`, data);
+  }
+  /**
+   * Delete content
+   */
+  async deleteContent(id) {
+    return this.delete(`/content/${id}`);
+  }
+  /**
+   * Publish content
+   */
+  async publishContent(id) {
+    return this.create(`/content/${id}/publish`, { action: "publish" });
+  }
+  /**
+   * Unpublish content
+   */
+  async unpublishContent(id) {
+    return this.create(`/content/${id}/publish`, { action: "unpublish" });
+  }
+  /**
+   * Move content to trash
+   */
+  async trashContent(id) {
+    return this.create(`/content/${id}/publish`, { action: "trash" });
+  }
+  /**
+   * Restore content from trash
+   */
+  async restoreContent(id) {
+    return this.create(`/content/${id}/publish`, { action: "restore" });
+  }
+  /**
+   * Get content revisions
+   */
+  async getContentRevisions(id) {
+    return this.getSingle(`/content/${id}/revisions`);
+  }
+  /**
+   * Duplicate content
+   */
+  async duplicateContent(id) {
+    return this.create(`/content/${id}/duplicate`, {});
+  }
+};
+
+// src/client/api-keys-client.ts
+var ApiKeysClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get all API keys
+   */
+  async getApiKeys(params) {
+    return this.getPaginated("/keys", params);
+  }
+  /**
+   * Get API key by ID
+   */
+  async getApiKeyById(id) {
+    return this.getSingle(`/keys/${id}`);
+  }
+  /**
+   * Create new API key
+   */
+  async createApiKey(data) {
+    return this.create("/keys", data);
+  }
+  /**
+   * Update API key
+   */
+  async updateApiKey(id, data) {
+    return this.update(`/keys/${id}`, data);
+  }
+  /**
+   * Delete API key
+   */
+  async deleteApiKey(id) {
+    return this.delete(`/keys/${id}`);
+  }
+  /**
+   * Regenerate API key
+   */
+  async regenerateApiKey(id) {
+    return this.create(`/keys/${id}/regenerate`, {});
+  }
+  /**
+   * Activate API key
+   */
+  async activateApiKey(id) {
+    return this.patch(`/keys/${id}`, { isActive: true });
+  }
+  /**
+   * Deactivate API key
+   */
+  async deactivateApiKey(id) {
+    return this.patch(`/keys/${id}`, { isActive: false });
+  }
+  /**
+   * Get API key usage statistics
+   */
+  async getApiKeyStats(id) {
+    return this.getSingle(`/keys/${id}/stats`);
+  }
+  /**
+   * Test API key validity
+   */
+  async testApiKey(key) {
+    return this.create("/keys/test", { key });
+  }
+};
+
+// src/client/organizations-client.ts
+var OrganizationsClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get all organizations
+   */
+  async getOrganizations(params) {
+    return this.getPaginated("/organizations", params);
+  }
+  /**
+   * Get organization by ID
+   */
+  async getOrganizationById(id) {
+    return this.getSingle(`/organizations/${id}`);
+  }
+  /**
+   * Create new organization
+   */
+  async createOrganization(data) {
+    return this.create("/organizations", data);
+  }
+  /**
+   * Update organization
+   */
+  async updateOrganization(id, data) {
+    return this.update(`/organizations/${id}`, data);
+  }
+  /**
+   * Delete organization
+   */
+  async deleteOrganization(id) {
+    return this.delete(`/organizations/${id}`);
+  }
+  /**
+   * Get organization members
+   */
+  async getOrganizationMembers(id) {
+    return this.getSingle(`/organizations/${id}/members`);
+  }
+  /**
+   * Add member to organization
+   */
+  async addOrganizationMember(id, data) {
+    return this.create(`/organizations/${id}/members`, data);
+  }
+  /**
+   * Update organization member role
+   */
+  async updateOrganizationMember(id, userId, data) {
+    return this.update(`/organizations/${id}/members/${userId}`, data);
+  }
+  /**
+   * Remove member from organization
+   */
+  async removeOrganizationMember(id, userId) {
+    return this.delete(`/organizations/${id}/members/${userId}`);
+  }
+  /**
+   * Get organization settings
+   */
+  async getOrganizationSettings(id) {
+    return this.getSingle(`/organizations/${id}/settings`);
+  }
+  /**
+   * Update organization settings
+   */
+  async updateOrganizationSettings(id, settings) {
+    return this.update(`/organizations/${id}/settings`, settings);
+  }
+};
+
+// src/client/sites-client.ts
+var SitesClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get all sites
+   */
+  async getSites(params) {
+    return this.getPaginated("/sites", params);
+  }
+  /**
+   * Get site by ID
+   */
+  async getSiteById(id) {
+    return this.getSingle(`/sites/${id}`);
+  }
+  /**
+   * Get site by name
+   */
+  async getSiteByName(name) {
+    return this.getSingle(`/sites/name/${name}`);
+  }
+  /**
+   * Create new site
+   */
+  async createSite(data) {
+    return this.create("/sites", data);
+  }
+  /**
+   * Update site
+   */
+  async updateSite(id, data) {
+    return this.update(`/sites/${id}`, data);
+  }
+  /**
+   * Delete site
+   */
+  async deleteSite(id) {
+    return this.delete(`/sites/${id}`);
+  }
+  /**
+   * Activate site
+   */
+  async activateSite(id) {
+    return this.patch(`/sites/${id}`, { isActive: true });
+  }
+  /**
+   * Deactivate site
+   */
+  async deactivateSite(id) {
+    return this.patch(`/sites/${id}`, { isActive: false });
+  }
+  /**
+   * Get site configuration
+   */
+  async getSiteConfig(id) {
+    return this.getSingle(`/sites/${id}/config`);
+  }
+  /**
+   * Update site configuration
+   */
+  async updateSiteConfig(id, config) {
+    return this.update(`/sites/${id}/config`, config);
+  }
+  /**
+   * Get site analytics
+   */
+  async getSiteAnalytics(id, params) {
+    return this.http.get(`/sites/${id}/analytics`, params);
+  }
+  /**
+   * Get site domains
+   */
+  async getSiteDomains(id) {
+    return this.getSingle(`/sites/${id}/domains`);
+  }
+  /**
+   * Add domain to site
+   */
+  async addSiteDomain(id, data) {
+    return this.create(`/sites/${id}/domains`, data);
+  }
+  /**
+   * Remove domain from site
+   */
+  async removeSiteDomain(id, domain) {
+    return this.delete(`/sites/${id}/domains/${encodeURIComponent(domain)}`);
+  }
+  /**
+   * Verify domain ownership
+   */
+  async verifySiteDomain(id, domain) {
+    return this.create(`/sites/${id}/domains/${encodeURIComponent(domain)}/verify`, {});
+  }
+};
+
+// src/client/products-client.ts
+var ProductsClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get all products for a site
+   */
+  async getProducts(siteName, params) {
+    const normalizeList = (value) => {
+      if (value === void 0 || value === null) {
+        return void 0;
+      }
+      const values = Array.isArray(value) ? value : [value];
+      const normalized = values.map((item) => String(item).trim()).filter((item) => item.length > 0);
+      return normalized.length > 0 ? normalized.join(",") : void 0;
+    };
+    const normalizedParams = params ? { ...params } : void 0;
+    if (normalizedParams) {
+      const normalizedCategories = normalizeList(normalizedParams.category);
+      if (normalizedCategories !== void 0) {
+        normalizedParams.category = normalizedCategories;
+      } else {
+        delete normalizedParams.category;
+      }
+      const normalizedCategoryIds = normalizeList(normalizedParams.category_id);
+      if (normalizedCategoryIds !== void 0) {
+        normalizedParams.category_id = normalizedCategoryIds;
+      } else {
+        delete normalizedParams.category_id;
+      }
+    }
+    return this.http.get(this.buildPath(this.siteScopedEndpoint(siteName, "/products")), normalizedParams);
+  }
+  /**
+   * Get product by ID
+   */
+  async getProductById(id) {
+    return this.getSingle(`/products/${id}`);
+  }
+  /**
+   * Get product by SKU
+   */
+  async getProductBySku(sku) {
+    return this.getSingle(`/products/sku/${sku}`);
+  }
+  /**
+   * Get product by slug and site name
+   */
+  async getProductBySlug(siteName, slug) {
+    return this.http.get(this.buildPath(
+      this.siteScopedEndpoint(siteName, `/products/slug/${encodeURIComponent(slug)}`)
+    ));
+  }
+  /**
+   * Create new product
+   */
+  async createProduct(data) {
+    return this.create("/products", data);
+  }
+  /**
+   * Update product
+   */
+  async updateProduct(id, data) {
+    return this.update(`/products/${id}`, data);
+  }
+  /**
+   * Delete product
+   */
+  async deleteProduct(id) {
+    return this.delete(`/products/${id}`);
+  }
+  /**
+   * Activate product
+   */
+  async activateProduct(id) {
+    return this.patch(`/products/${id}`, { isActive: true });
+  }
+  /**
+   * Deactivate product
+   */
+  async deactivateProduct(id) {
+    return this.patch(`/products/${id}`, { isActive: false });
+  }
+  /**
+   * Get product variants
+   */
+  async getProductVariants(id) {
+    return this.getSingle(`/products/${id}/variants`);
+  }
+  /**
+   * Add product variant
+   */
+  async addProductVariant(id, data) {
+    return this.create(`/products/${id}/variants`, data);
+  }
+  /**
+   * Update product variant
+   */
+  async updateProductVariant(id, variantId, data) {
+    return this.update(`/products/${id}/variants/${variantId}`, data);
+  }
+  /**
+   * Delete product variant
+   */
+  async deleteProductVariant(id, variantId) {
+    return this.delete(`/products/${id}/variants/${variantId}`);
+  }
+  /**
+   * Get product inventory
+   */
+  async getProductInventory(id) {
+    return this.getSingle(`/products/${id}/inventory`);
+  }
+  /**
+   * Update product inventory
+   */
+  async updateProductInventory(id, data) {
+    return this.create(`/products/${id}/inventory`, data);
+  }
+  /**
+   * Get product categories
+   */
+  async getProductCategories(id) {
+    return this.getSingle(`/products/${id}/categories`);
+  }
+  /**
+   * Add product to category
+   */
+  async addProductToCategory(id, categoryId) {
+    return this.create(`/products/${id}/categories`, { categoryId });
+  }
+  /**
+   * Remove product from category
+   */
+  async removeProductFromCategory(id, categoryId) {
+    return this.delete(`/products/${id}/categories/${categoryId}`);
+  }
+  /**
+   * Get products by category slug
+   */
+  async getProductsByCategorySlug(siteName, categorySlug, params) {
+    const queryParams = params ? {
+      limit: params.limit,
+      offset: params.page ? (params.page - 1) * (params.limit || 20) : void 0,
+      published: params.published,
+      search: params.search
+    } : void 0;
+    return this.http.get(this.buildPath(
+      this.siteScopedEndpoint(siteName, `/products/category/${encodeURIComponent(categorySlug)}`)
+    ), queryParams);
+  }
+};
+
+// src/client/categories-client.ts
+var CategoriesClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get all categories
+   */
+  async getCategories(params) {
+    return this.getPaginated("/categories", params);
+  }
+  /**
+   * Get category by ID
+   */
+  async getCategoryById(id) {
+    return this.getSingle(`/categories/${id}`);
+  }
+  /**
+   * Get category by slug
+   */
+  async getCategoryBySlug(slug) {
+    return this.getSingle(`/categories/slug/${slug}`);
+  }
+  /**
+   * Get product category by slug (for products)
+   */
+  async getProductCategoryBySlug(siteName, slug) {
+    return this.http.get(this.buildPath(
+      this.siteScopedEndpoint(siteName, `/product_category/slug/${encodeURIComponent(slug)}`)
+    ));
+  }
+  /**
+   * Create new category
+   */
+  async createCategory(data) {
+    return this.create("/categories", data);
+  }
+  /**
+   * Update category
+   */
+  async updateCategory(id, data) {
+    return this.update(`/categories/${id}`, data);
+  }
+  /**
+   * Delete category
+   */
+  async deleteCategory(id) {
+    return this.delete(`/categories/${id}`);
+  }
+  /**
+   * Get category tree (hierarchical structure)
+   */
+  async getCategoryTree(rootId) {
+    const endpoint = rootId ? `/categories/tree/${rootId}` : "/categories/tree";
+    return this.getSingle(endpoint);
+  }
+  /**
+   * Get category children
+   */
+  async getCategoryChildren(id) {
+    return this.getSingle(`/categories/${id}/children`);
+  }
+  /**
+   * Get category parent
+   */
+  async getCategoryParent(id) {
+    return this.getSingle(`/categories/${id}/parent`);
+  }
+  /**
+   * Move category to new parent
+   */
+  async moveCategoryToParent(id, parentId) {
+    return this.patch(`/categories/${id}`, { parentId });
+  }
+  /**
+   * Get category breadcrumb path
+   */
+  async getCategoryBreadcrumb(id) {
+    return this.getSingle(`/categories/${id}/breadcrumb`);
+  }
+  /**
+   * Get category content/products
+   */
+  async getCategoryContent(id, params) {
+    return this.http.get(`/categories/${id}/content`, params);
+  }
+  /**
+   * Bulk update category order
+   */
+  async updateCategoryOrder(updates) {
+    return this.create("/categories/reorder", { updates });
+  }
+  /**
+   * Search categories
+   */
+  async searchCategories(query, params) {
+    return this.http.get(`/categories/search`, { q: query, ...params });
+  }
+};
+
+// src/client/webhooks-client.ts
+var WebhooksClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get all webhooks
+   */
+  async getWebhooks(params) {
+    return this.getPaginated("/webhooks", params);
+  }
+  /**
+   * Get webhook by ID
+   */
+  async getWebhookById(id) {
+    return this.getSingle(`/webhooks/${id}`);
+  }
+  /**
+   * Create new webhook
+   */
+  async createWebhook(data) {
+    return this.create("/webhooks", data);
+  }
+  /**
+   * Update webhook
+   */
+  async updateWebhook(id, data) {
+    return this.update(`/webhooks/${id}`, data);
+  }
+  /**
+   * Delete webhook
+   */
+  async deleteWebhook(id) {
+    return this.delete(`/webhooks/${id}`);
+  }
+  /**
+   * Activate webhook
+   */
+  async activateWebhook(id) {
+    return this.patch(`/webhooks/${id}`, { isActive: true });
+  }
+  /**
+   * Deactivate webhook
+   */
+  async deactivateWebhook(id) {
+    return this.patch(`/webhooks/${id}`, { isActive: false });
+  }
+  /**
+   * Test webhook
+   */
+  async testWebhook(id, data) {
+    return this.create(`/webhooks/${id}/test`, data || {});
+  }
+  /**
+   * Get webhook events
+   */
+  async getWebhookEvents(id, params) {
+    return this.getPaginated(`/webhooks/${id}/events`, params);
+  }
+  /**
+   * Get webhook logs
+   */
+  async getWebhookLogs(id, params) {
+    return this.getPaginated(`/webhooks/${id}/logs`, params);
+  }
+  /**
+   * Get webhook statistics
+   */
+  async getWebhookStats(id) {
+    const endpoint = id ? `/webhooks/${id}/stats` : "/webhooks/stats";
+    return this.getSingle(endpoint);
+  }
+  /**
+   * Get supported webhook providers
+   */
+  async getWebhookProviders() {
+    return this.getSingle("/webhooks/providers");
+  }
+  /**
+   * Retry failed webhook event
+   */
+  async retryWebhookEvent(webhookId, eventId) {
+    return this.create(`/webhooks/${webhookId}/events/${eventId}/retry`, {});
+  }
+  /**
+   * Bulk retry failed webhook events
+   */
+  async bulkRetryWebhookEvents(webhookId, eventIds) {
+    return this.create(`/webhooks/${webhookId}/events/bulk-retry`, { eventIds });
+  }
+  /**
+   * Get webhook delivery attempts
+   */
+  async getWebhookDeliveryAttempts(webhookId, eventId) {
+    return this.getSingle(`/webhooks/${webhookId}/events/${eventId}/attempts`);
+  }
+};
+
+// src/client/checkout-client.ts
+var CheckoutClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Get CSRF token for a specific site
+   * @param siteName - The site name to get CSRF token for
+   */
+  async getCsrfToken(siteName) {
+    return this.http.get(`/api/v1/csrf/token/${siteName}`);
+  }
+  /**
+   * Create Stripe checkout session with CSRF protection
+   * @param siteName - The site name for the checkout session
+   * @param data - Checkout session data (can include priceId for single item or line_items for multiple)
+   * @param csrfToken - Optional CSRF token (if not provided, will fetch automatically)
+   */
+  async createCheckoutSession(siteName, data, csrfToken) {
+    let token = csrfToken;
+    if (!token) {
+      const csrfResponse = await this.getCsrfToken(siteName);
+      const csrfToken2 = csrfResponse.data?.csrf_token;
+      if (!csrfToken2) {
+        throw new Error("Failed to obtain CSRF token");
+      }
+      token = csrfToken2;
+    }
+    return this.http.request(this.buildPath(
+      this.siteScopedEndpoint(siteName, "/checkout/create-session")
+    ), {
+      method: "POST",
+      body: data,
+      headers: {
+        "X-CSRF-Token": token
+      }
+    });
+  }
+  /**
+   * Get checkout session by ID
+   */
+  async getCheckoutSession(sessionId) {
+    return this.getSingle(`/checkout/sessions/${sessionId}`);
+  }
+  /**
+   * Get checkout sessions for organization
+   */
+  async getCheckoutSessions(params) {
+    return this.getPaginated("/checkout/sessions", params);
+  }
+  /**
+   * Cancel checkout session
+   */
+  async cancelCheckoutSession(sessionId) {
+    return this.create(`/checkout/sessions/${sessionId}/cancel`, {});
+  }
+  /**
+   * Expire checkout session
+   */
+  async expireCheckoutSession(sessionId) {
+    return this.create(`/checkout/sessions/${sessionId}/expire`, {});
+  }
+  /**
+   * Get Stripe publishable key
+   */
+  async getStripePublishableKey() {
+    return this.getSingle("/checkout/stripe/config");
+  }
+  /**
+   * Create payment intent (for custom checkout flows)
+   */
+  async createPaymentIntent(data) {
+    return this.create("/checkout/payment-intent", data);
+  }
+  /**
+   * Confirm payment intent
+   */
+  async confirmPaymentIntent(paymentIntentId, data) {
+    return this.create(`/checkout/payment-intent/${paymentIntentId}/confirm`, data);
+  }
+  /**
+   * Get payment methods for customer
+   */
+  async getPaymentMethods(customerId) {
+    return this.getSingle(`/checkout/customers/${customerId}/payment-methods`);
+  }
+  /**
+   * Create customer
+   */
+  async createCustomer(data) {
+    return this.create("/checkout/customers", data);
+  }
+  /**
+   * Get customer by ID
+   */
+  async getCustomer(customerId) {
+    return this.getSingle(`/checkout/customers/${customerId}`);
+  }
+  /**
+   * Update customer
+   */
+  async updateCustomer(customerId, data) {
+    return this.update(`/checkout/customers/${customerId}`, data);
+  }
+  /**
+   * Get invoices for customer
+   */
+  async getCustomerInvoices(customerId, params) {
+    return this.getPaginated(`/checkout/customers/${customerId}/invoices`, params);
+  }
+};
+
+// src/client/contact-client.ts
+var ContactClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Build a contact endpoint scoped to a site (without /sites prefix)
+   */
+  contactEndpoint(siteName, endpoint) {
+    return this.siteScopedEndpoint(siteName, endpoint, { includeSitesSegment: false });
+  }
+  /**
+   * Submit contact form
+   */
+  async submitContact(siteName, data) {
+    return this.create(this.contactEndpoint(siteName, "/contact/submit"), data);
+  }
+  /**
+   * Get contact submission status
+   */
+  async getContactStatus(siteName, id) {
+    return this.getSingle(this.contactEndpoint(siteName, `/contact/status/${encodeURIComponent(id)}`));
+  }
+  /**
+   * Get all contact submissions (admin only)
+   */
+  async getContactSubmissions(siteName, params) {
+    return this.getPaginated(this.contactEndpoint(siteName, "/contact/list"), params);
+  }
+  /**
+   * Get contact submission by ID (admin only)
+   */
+  async getContactSubmissionById(siteName, id) {
+    return this.getSingle(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`));
+  }
+  /**
+   * Update contact submission status (admin only)
+   */
+  async updateContactStatus(siteName, id, status, notes) {
+    return this.patch(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`), { status, notes });
+  }
+  /**
+   * Mark contact as read (admin only)
+   */
+  async markContactAsRead(siteName, id) {
+    return this.patch(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`), { status: "read" });
+  }
+  /**
+   * Mark contact as unread (admin only)
+   */
+  async markContactAsUnread(siteName, id) {
+    return this.patch(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`), { status: "unread" });
+  }
+  /**
+   * Archive contact submission (admin only)
+   */
+  async archiveContact(siteName, id) {
+    return this.patch(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`), { status: "archived" });
+  }
+  /**
+   * Delete contact submission (admin only)
+   */
+  async deleteContact(siteName, id) {
+    return this.delete(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`));
+  }
+  /**
+   * Bulk update contact submissions (admin only)
+   */
+  async bulkUpdateContacts(siteName, data) {
+    return this.create(this.contactEndpoint(siteName, "/contact/bulk-update"), data);
+  }
+  /**
+   * Get contact form statistics (admin only)
+   */
+  async getContactStats(siteName, params) {
+    return this.http.get(this.buildPath(this.contactEndpoint(siteName, "/contact/stats")), params);
+  }
+  /**
+   * Export contact submissions (admin only)
+   */
+  async exportContacts(siteName, params) {
+    return this.create(this.contactEndpoint(siteName, "/contact/export"), params || {});
+  }
+  /**
+   * Get contact form configuration
+   */
+  async getContactConfig(siteName) {
+    return this.getSingle(this.contactEndpoint(siteName, "/contact/config"));
+  }
+  /**
+   * Update contact form configuration (admin only)
+   */
+  async updateContactConfig(siteName, data) {
+    return this.update(this.contactEndpoint(siteName, "/contact/config"), data);
+  }
+};
+
+// src/perspect-api-client.ts
+var PerspectApiClient = class {
+  http;
+  // Service clients
+  auth;
+  content;
+  apiKeys;
+  organizations;
+  sites;
+  products;
+  categories;
+  webhooks;
+  checkout;
+  contact;
+  constructor(config) {
+    if (!config.baseUrl) {
+      throw new Error("baseUrl is required in PerspectApiConfig");
+    }
+    this.http = new HttpClient(config);
+    this.auth = new AuthClient(this.http);
+    this.content = new ContentClient(this.http);
+    this.apiKeys = new ApiKeysClient(this.http);
+    this.organizations = new OrganizationsClient(this.http);
+    this.sites = new SitesClient(this.http);
+    this.products = new ProductsClient(this.http);
+    this.categories = new CategoriesClient(this.http);
+    this.webhooks = new WebhooksClient(this.http);
+    this.checkout = new CheckoutClient(this.http);
+    this.contact = new ContactClient(this.http);
+  }
+  /**
+   * Update authentication token
+   */
+  setAuth(jwt) {
+    this.http.setAuth(jwt);
+  }
+  /**
+   * Update API key
+   */
+  setApiKey(apiKey) {
+    this.http.setApiKey(apiKey);
+  }
+  /**
+   * Clear authentication
+   */
+  clearAuth() {
+    this.http.clearAuth();
+  }
+  /**
+   * Health check endpoint
+   */
+  async health() {
+    return this.http.get("/health");
+  }
+  /**
+   * Get API version info
+   */
+  async getVersion() {
+    return this.http.get("/api/v1/version");
+  }
+  /**
+   * Get API status and statistics
+   */
+  async getStatus() {
+    return this.http.get("/api/v1/status");
+  }
+  /**
+   * Test API connectivity and authentication
+   */
+  async test() {
+    return this.http.get("/api/v1/test");
+  }
+  /**
+   * Get CSRF token (for form submissions)
+   * @param siteName - Optional site name for site-specific token (recommended for development)
+   */
+  async getCsrfToken(siteName) {
+    if (siteName) {
+      return this.http.get(`/api/v1/csrf/token/${siteName}`);
+    }
+    return this.http.get("/api/v1/csrf/token");
+  }
+  /**
+   * Validate CSRF token
+   */
+  async validateCsrfToken(token) {
+    return this.http.post("/api/v1/csrf/validate", { token });
+  }
+};
+function createPerspectApiClient(config) {
+  return new PerspectApiClient(config);
+}
+var perspect_api_client_default = PerspectApiClient;
+
+// src/loaders.ts
+var noopLogger = {};
+var log = (logger, level, ...args) => {
+  const target = logger?.[level];
+  if (typeof target === "function") {
+    target(...args);
+  }
+};
+var isMediaItem = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const media = value;
+  return typeof media.link === "string" && typeof media.media_id === "string";
+};
+var normalizeMediaList = (rawMedia) => {
+  if (!Array.isArray(rawMedia)) {
+    return [];
+  }
+  if (rawMedia.length > 0 && Array.isArray(rawMedia[0])) {
+    return rawMedia.flat().filter(isMediaItem);
+  }
+  return rawMedia.filter(isMediaItem);
+};
+var normalizeQueryParamList = (value) => {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const values = Array.isArray(value) ? value : [value];
+  const normalized = values.map((item) => String(item).trim()).filter((item) => item.length > 0);
+  return normalized.length > 0 ? normalized.join(",") : void 0;
+};
+var transformProduct = (perspectProduct, logger) => {
+  const rawProduct = perspectProduct ?? {};
+  const productId = rawProduct.product_id ?? rawProduct.id ?? rawProduct.sku ?? "unknown";
+  const productName = rawProduct.product ?? rawProduct.name ?? rawProduct.title ?? "Untitled";
+  const productSlug = rawProduct.slug ?? rawProduct.product_slug ?? (productId ? `product-${productId}` : "product");
+  const slugPrefix = rawProduct.slug_prefix ?? rawProduct.slugPrefix ?? rawProduct.category ?? "artwork";
+  const mediaItems = normalizeMediaList(rawProduct.media);
+  const primaryImage = mediaItems[0]?.link ?? rawProduct.image ?? rawProduct.image_url ?? rawProduct.thumbnail ?? "";
+  log(logger, "debug", "[PerspectAPI] Transform product", {
+    productId,
+    productSlug,
+    mediaCount: mediaItems.length
+  });
+  return {
+    id: typeof productId === "string" ? productId : String(productId),
+    product: productName,
+    name: productName,
+    slug: productSlug,
+    slug_prefix: slugPrefix,
+    price: typeof rawProduct.price === "number" ? rawProduct.price : Number(rawProduct.price ?? 0),
+    currency: rawProduct.currency ?? "USD",
+    description: rawProduct.description ?? "",
+    description_markdown: rawProduct.description_markdown ?? rawProduct.description ?? "",
+    image: primaryImage,
+    media: mediaItems,
+    gateway_product_id_live: rawProduct.gateway_product_id_live,
+    gateway_product_id_test: rawProduct.gateway_product_id_test,
+    stripe_product_id_live: rawProduct.stripe_product_id_live,
+    stripe_product_id_test: rawProduct.stripe_product_id_test,
+    isActive: rawProduct.isActive ?? rawProduct.is_active ?? true,
+    // Preserve original payload for advanced consumers
+    ...rawProduct
+  };
+};
+var transformContent = (perspectContent) => {
+  const raw = perspectContent ?? {};
+  return {
+    id: typeof raw.id === "string" ? raw.id : String(raw.id ?? ""),
+    slug: raw.slug ?? `post-${raw.id ?? "unknown"}`,
+    slug_prefix: raw.slug_prefix ?? (raw.pageType === "post" ? "blog" : "page"),
+    page_type: raw.pageType,
+    title: raw.pageTitle,
+    content: raw.pageContent,
+    excerpt: typeof raw.pageContent === "string" ? `${raw.pageContent.slice(0, 200)}...` : void 0,
+    published: raw.pageStatus === "publish",
+    created_at: raw.createdAt,
+    updated_at: raw.updatedAt,
+    description: raw.description,
+    published_date: raw.published_date,
+    author: raw.author,
+    tags: raw.tags,
+    image: raw.image
+  };
+};
+var getDefaultFallbackProducts = (siteName) => {
+  const safeSite = siteName.replace(/\s+/g, "-").toLowerCase();
+  const mediaSamples = [
+    {
+      media_id: `${safeSite}-media-1`,
+      attachment_id: 1001,
+      file_name: "sample-artwork-1.jpg",
+      link: "https://picsum.photos/1200/800?random=1",
+      content_type: "image/jpeg",
+      width: 1200,
+      height: 800,
+      filesize: 245760,
+      r2_key: `${safeSite}/artwork-1.jpg`,
+      site_name: siteName
+    },
+    {
+      media_id: `${safeSite}-media-2`,
+      attachment_id: 1002,
+      file_name: "sample-artwork-2.jpg",
+      link: "https://picsum.photos/1200/800?random=2",
+      content_type: "image/jpeg",
+      width: 1200,
+      height: 800,
+      filesize: 312480,
+      r2_key: `${safeSite}/artwork-2.jpg`,
+      site_name: siteName
+    }
+  ];
+  return [
+    {
+      id: `${safeSite}-product-1`,
+      product: `${siteName} Sample Artwork 1`,
+      slug: `${safeSite}-sample-artwork-1`,
+      slug_prefix: "artwork",
+      price: 299,
+      description: `Beautiful artwork from ${siteName}`,
+      description_markdown: `Beautiful artwork from **${siteName}**`,
+      image: "https://picsum.photos/800/600?random=1",
+      media: mediaSamples
+    },
+    {
+      id: `${safeSite}-product-2`,
+      product: `${siteName} Sample Artwork 2`,
+      slug: `${safeSite}-sample-artwork-2`,
+      slug_prefix: "artwork",
+      price: 499,
+      description: `Exquisite piece from ${siteName} collection`,
+      description_markdown: `Exquisite piece from **${siteName}** collection`,
+      image: "https://picsum.photos/800/600?random=2",
+      media: mediaSamples
+    }
+  ];
+};
+var getDefaultFallbackPosts = (siteName) => {
+  return [
+    {
+      id: `${siteName}-post-1`,
+      slug: "welcome-post",
+      slug_prefix: "blog",
+      page_type: "post",
+      title: `Welcome to ${siteName}`,
+      content: `<p>Welcome to our ${siteName} blog. Here you'll find articles about art, culture, and our collections.</p>`,
+      excerpt: `Welcome to our ${siteName} blog.`,
+      published: true,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  ];
+};
+var resolveFallbackProducts = ({ siteName, fallbackProducts }) => {
+  if (fallbackProducts && fallbackProducts.length > 0) {
+    return fallbackProducts;
+  }
+  return getDefaultFallbackProducts(siteName);
+};
+var resolveFallbackPosts = ({ siteName, fallbackPosts }) => {
+  if (fallbackPosts && fallbackPosts.length > 0) {
+    return fallbackPosts;
+  }
+  return getDefaultFallbackPosts(siteName);
+};
+async function loadProducts(options) {
+  const {
+    client,
+    siteName,
+    logger = noopLogger,
+    fallbackProducts,
+    limit = 100,
+    offset,
+    search,
+    category,
+    categoryIds
+  } = options;
+  if (!client) {
+    log(logger, "warn", "[PerspectAPI] No client configured, using fallback products");
+    return resolveFallbackProducts({ siteName, fallbackProducts });
+  }
+  try {
+    log(logger, "info", `[PerspectAPI] Loading products for site "${siteName}"`);
+    const queryParams = {
+      isActive: true,
+      limit,
+      offset,
+      search
+    };
+    const normalizedCategory = normalizeQueryParamList(category);
+    if (normalizedCategory) {
+      queryParams.category = normalizedCategory;
+    }
+    const normalizedCategoryIds = normalizeQueryParamList(categoryIds);
+    if (normalizedCategoryIds) {
+      queryParams.category_id = normalizedCategoryIds;
+    }
+    const response = await client.products.getProducts(siteName, queryParams);
+    if (!response.data) {
+      log(logger, "warn", "[PerspectAPI] Products response missing data, returning fallback set");
+      return resolveFallbackProducts({ siteName, fallbackProducts });
+    }
+    log(logger, "debug", `[PerspectAPI] Found ${response.data.length} products, transforming...`);
+    return response.data.map((product) => transformProduct(product, logger));
+  } catch (error) {
+    log(logger, "error", "[PerspectAPI] Error loading products", error);
+    return resolveFallbackProducts({ siteName, fallbackProducts });
+  }
+}
+async function loadProductBySlug(options) {
+  const {
+    client,
+    siteName,
+    slug,
+    logger = noopLogger,
+    fallbackProducts
+  } = options;
+  if (!client) {
+    log(logger, "warn", "[PerspectAPI] No client configured, searching fallback products");
+    const fallback = resolveFallbackProducts({ siteName, fallbackProducts });
+    return fallback.find((product) => product.slug === slug) ?? null;
+  }
+  try {
+    log(logger, "info", `[PerspectAPI] Loading product "${slug}" for site "${siteName}"`);
+    const response = await client.products.getProductBySlug(siteName, slug);
+    if (!response.data) {
+      log(logger, "warn", `[PerspectAPI] Product not found for slug "${slug}"`);
+      return null;
+    }
+    return transformProduct(response.data, logger);
+  } catch (error) {
+    log(logger, "error", `[PerspectAPI] Error loading product slug "${slug}"`, error);
+    return null;
+  }
+}
+async function loadPages(options) {
+  const { client, siteName, logger = noopLogger, params, fallbackPosts } = options;
+  if (!client) {
+    log(logger, "warn", "[PerspectAPI] No client configured, using fallback posts for pages");
+    return resolveFallbackPosts({ siteName, fallbackPosts }).filter(
+      (post) => post.page_type !== "post"
+    );
+  }
+  try {
+    log(logger, "info", `[PerspectAPI] Loading pages for site "${siteName}"`);
+    const response = await client.content.getContent(
+      siteName,
+      {
+        ...params,
+        page_status: params?.page_status ?? "publish",
+        page_type: params?.page_type ?? "page",
+        limit: options.limit ?? params?.limit ?? 100
+      }
+    );
+    if (!response.data) {
+      return [];
+    }
+    return response.data.map((content) => transformContent(content));
+  } catch (error) {
+    log(logger, "error", "[PerspectAPI] Error loading pages", error);
+    return [];
+  }
+}
+async function loadPosts(options) {
+  const { client, siteName, logger = noopLogger, params, fallbackPosts } = options;
+  if (!client) {
+    log(logger, "warn", "[PerspectAPI] No client configured, using fallback posts");
+    return resolveFallbackPosts({ siteName, fallbackPosts });
+  }
+  try {
+    log(logger, "info", `[PerspectAPI] Loading posts for site "${siteName}"`);
+    const response = await client.content.getContent(
+      siteName,
+      {
+        ...params,
+        page_status: params?.page_status ?? "publish",
+        page_type: params?.page_type ?? "post",
+        limit: options.limit ?? params?.limit ?? 100
+      }
+    );
+    if (!response.data) {
+      log(logger, "warn", "[PerspectAPI] Posts response missing data");
+      return [];
+    }
+    return response.data.map((content) => transformContent(content));
+  } catch (error) {
+    log(logger, "error", "[PerspectAPI] Error loading posts", error);
+    return [];
+  }
+}
+async function loadContentBySlug(options) {
+  const {
+    client,
+    siteName,
+    slug,
+    logger = noopLogger,
+    fallbackPosts
+  } = options;
+  if (!client) {
+    log(logger, "warn", "[PerspectAPI] No client configured, searching fallback posts");
+    const fallback = resolveFallbackPosts({ siteName, fallbackPosts });
+    return fallback.find((post) => post.slug === slug) ?? null;
+  }
+  try {
+    log(logger, "info", `[PerspectAPI] Loading content slug "${slug}" for site "${siteName}"`);
+    const response = await client.content.getContentBySlug(siteName, slug);
+    if (!response.data) {
+      log(logger, "warn", `[PerspectAPI] Content not found for slug "${slug}"`);
+      return null;
+    }
+    return transformContent(response.data);
+  } catch (error) {
+    log(logger, "error", `[PerspectAPI] Error loading content slug "${slug}"`, error);
+    return null;
+  }
+}
+async function loadAllContent(options) {
+  const { logger = noopLogger } = options;
+  const [pages, posts] = await Promise.all([
+    loadPages(options),
+    loadPosts(options)
+  ]);
+  log(logger, "debug", `[PerspectAPI] Loaded ${pages.length + posts.length} total content items`);
+  return [...pages, ...posts];
+}
+async function createCheckoutSession(options) {
+  const {
+    client,
+    siteName,
+    items,
+    successUrl,
+    cancelUrl,
+    customerEmail,
+    mode = "live",
+    logger = noopLogger,
+    fallbackProducts,
+    metadata,
+    priceIdResolver
+  } = options;
+  if (!client) {
+    log(logger, "error", "[PerspectAPI] Cannot create checkout session without SDK client");
+    return { error: "PerspectAPI client not configured" };
+  }
+  try {
+    const products = await loadProducts({
+      client,
+      siteName,
+      logger,
+      limit: 200,
+      fallbackProducts
+    });
+    const productMap = new Map(
+      products.map((product) => [String(product.id), product])
+    );
+    const line_items = items.map((item) => {
+      const product = productMap.get(String(item.productId));
+      if (!product) {
+        throw new Error(`Product ${item.productId} not found while building checkout session`);
+      }
+      const resolvedPrice = priceIdResolver?.(product, mode) ?? (mode === "test" ? product.stripe_product_id_test ?? product.gateway_product_id_test : product.stripe_product_id_live ?? product.gateway_product_id_live);
+      if (!resolvedPrice) {
+        throw new Error(`Missing Stripe price ID for product ${item.productId} (${product.product ?? product.name ?? "unknown"})`);
+      }
+      return {
+        price: resolvedPrice,
+        quantity: item.quantity
+      };
+    });
+    const checkoutData = {
+      line_items,
+      successUrl,
+      cancelUrl,
+      success_url: successUrl,
+      cancel_url: cancelUrl,
+      customerEmail,
+      customer_email: customerEmail,
+      mode: mode === "test" ? "payment" : "payment",
+      metadata
+    };
+    log(logger, "info", "[PerspectAPI] Creating checkout session");
+    return client.checkout.createCheckoutSession(siteName, checkoutData);
+  } catch (error) {
+    log(logger, "error", "[PerspectAPI] Failed to create checkout session", error);
+    return { error: error instanceof Error ? error.message : "Unknown error creating checkout session" };
+  }
+}
+export {
+  ApiKeysClient,
+  AuthClient,
+  BaseClient,
+  CategoriesClient,
+  CheckoutClient,
+  ContactClient,
+  ContentClient,
+  HttpClient,
+  OrganizationsClient,
+  PerspectApiClient,
+  ProductsClient,
+  SitesClient,
+  WebhooksClient,
+  createApiError,
+  createCheckoutSession,
+  createPerspectApiClient,
+  perspect_api_client_default as default,
+  loadAllContent,
+  loadContentBySlug,
+  loadPages,
+  loadPosts,
+  loadProductBySlug,
+  loadProducts,
+  transformContent,
+  transformProduct
+};