@waffo/pancake-ts 0.1.1

package/dist/index.cjs

@@ -0,0 +1,757 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BillingPeriod: () => BillingPeriod,
+  CheckoutSessionProductType: () => CheckoutSessionProductType,
+  EntityStatus: () => EntityStatus,
+  Environment: () => Environment,
+  ErrorLayer: () => ErrorLayer,
+  MediaType: () => MediaType,
+  OnetimeOrderStatus: () => OnetimeOrderStatus,
+  PaymentStatus: () => PaymentStatus,
+  ProductVersionStatus: () => ProductVersionStatus,
+  RefundStatus: () => RefundStatus,
+  RefundTicketStatus: () => RefundTicketStatus,
+  StoreRole: () => StoreRole,
+  SubscriptionOrderStatus: () => SubscriptionOrderStatus,
+  TaxCategory: () => TaxCategory,
+  WaffoPancake: () => WaffoPancake,
+  WaffoPancakeError: () => WaffoPancakeError,
+  WebhookEventType: () => WebhookEventType,
+  verifyWebhook: () => verifyWebhook
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http-client.ts
+var import_node_crypto2 = require("crypto");
+
+// src/errors.ts
+var WaffoPancakeError = class extends Error {
+  status;
+  errors;
+  constructor(status, errors) {
+    const rootCause = errors[0]?.message ?? "Unknown error";
+    super(rootCause);
+    this.name = "WaffoPancakeError";
+    this.status = status;
+    this.errors = errors;
+  }
+};
+
+// src/signing.ts
+var import_node_crypto = require("crypto");
+function signRequest(method, path, timestamp, body, privateKey) {
+  const bodyHash = (0, import_node_crypto.createHash)("sha256").update(body).digest("hex");
+  const canonicalRequest = `${method}
+${path}
+${timestamp}
+${bodyHash}`;
+  const sign = (0, import_node_crypto.createSign)("sha256");
+  sign.update(canonicalRequest);
+  return sign.sign(privateKey, "base64");
+}
+
+// src/http-client.ts
+var DEFAULT_BASE_URL = "https://waffo-pancake-auth-service.vercel.app";
+var HttpClient = class {
+  merchantId;
+  privateKey;
+  baseUrl;
+  _fetch;
+  constructor(config) {
+    this.merchantId = config.merchantId;
+    this.privateKey = config.privateKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this._fetch = config.fetch ?? fetch;
+  }
+  /**
+   * Send a signed POST request and return the parsed `data` field.
+   *
+   * Behavior:
+   * - Generates a deterministic `X-Idempotency-Key` from `merchantId + path + body` (same request produces same key)
+   * - Auto-builds RSA-SHA256 signature (`X-Merchant-Id` / `X-Timestamp` / `X-Signature`)
+   * - Unwraps the response envelope: returns `data` on success, throws `WaffoPancakeError` on failure
+   *
+   * @param path - API path (e.g. `/v1/actions/store/create-store`)
+   * @param body - Request body object
+   * @returns Parsed `data` field from the response
+   * @throws {WaffoPancakeError} When the API returns errors
+   */
+  async post(path, body) {
+    const bodyStr = JSON.stringify(body);
+    const timestamp = Math.floor(Date.now() / 1e3).toString();
+    const signature = signRequest("POST", path, timestamp, bodyStr, this.privateKey);
+    const response = await this._fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Merchant-Id": this.merchantId,
+        "X-Timestamp": timestamp,
+        "X-Signature": signature,
+        "X-Idempotency-Key": (0, import_node_crypto2.createHash)("sha256").update(`${this.merchantId}:${path}:${bodyStr}`).digest("hex")
+      },
+      body: bodyStr
+    });
+    const result = await response.json();
+    if ("errors" in result && result.errors) {
+      throw new WaffoPancakeError(response.status, result.errors);
+    }
+    return result.data;
+  }
+};
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Issue a session token for a buyer.
+   *
+   * @param params - Token issuance parameters
+   * @returns Issued session token with expiration
+   *
+   * @example
+   * const { token, expiresAt } = await client.auth.issueSessionToken({
+   *   storeId: "store_xxx",
+   *   buyerIdentity: "customer@example.com",
+   * });
+   */
+  async issueSessionToken(params) {
+    return this.http.post("/v1/actions/auth/issue-session-token", params);
+  }
+};
+
+// src/resources/checkout.ts
+var CheckoutResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a checkout session. Returns a URL to redirect the customer to.
+   *
+   * @param params - Checkout session parameters
+   * @returns Session ID, checkout URL, and expiration
+   *
+   * @example
+   * const session = await client.checkout.createSession({
+   *   storeId: "store_xxx",
+   *   productId: "prod_xxx",
+   *   productType: "onetime",
+   *   currency: "USD",
+   *   buyerEmail: "customer@example.com",
+   * });
+   * // Redirect to session.checkoutUrl
+   */
+  async createSession(params) {
+    return this.http.post("/v1/actions/checkout/create-session", params);
+  }
+};
+
+// src/resources/graphql.ts
+var GraphQLResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Execute a GraphQL query (Query only, no Mutations).
+   *
+   * @param params - GraphQL query and optional variables
+   * @returns GraphQL response with data and optional errors
+   *
+   * @example
+   * const result = await client.graphql.query<{ stores: Array<{ id: string; name: string }> }>({
+   *   query: `query { stores { id name status } }`,
+   * });
+   * console.log(result.data?.stores);
+   *
+   * @example
+   * const result = await client.graphql.query({
+   *   query: `query ($id: ID!) { onetimeProduct(id: $id) { id name prices } }`,
+   *   variables: { id: "prod_xxx" },
+   * });
+   */
+  async query(params) {
+    return this.http.post("/v1/graphql", params);
+  }
+};
+
+// src/resources/onetime-products.ts
+var OnetimeProductsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a one-time product with multi-currency pricing.
+   *
+   * @param params - Product creation parameters
+   * @returns Created product detail
+   *
+   * @example
+   * const { product } = await client.onetimeProducts.create({
+   *   storeId: "store_xxx",
+   *   name: "E-Book",
+   *   prices: { USD: { amount: 2900, taxIncluded: false, taxCategory: "digital_goods" } },
+   * });
+   */
+  async create(params) {
+    return this.http.post("/v1/actions/onetime-product/create-product", params);
+  }
+  /**
+   * Update a one-time product. Creates a new version; skips if unchanged.
+   *
+   * @param params - Product update parameters (all content fields required)
+   * @returns Updated product detail
+   *
+   * @example
+   * const { product } = await client.onetimeProducts.update({
+   *   id: "prod_xxx",
+   *   name: "E-Book v2",
+   *   prices: { USD: { amount: 3900, taxIncluded: false, taxCategory: "digital_goods" } },
+   * });
+   */
+  async update(params) {
+    return this.http.post("/v1/actions/onetime-product/update-product", params);
+  }
+  /**
+   * Publish a one-time product's test version to production.
+   *
+   * @param params - Product to publish
+   * @returns Published product detail
+   *
+   * @example
+   * const { product } = await client.onetimeProducts.publish({ id: "prod_xxx" });
+   */
+  async publish(params) {
+    return this.http.post("/v1/actions/onetime-product/publish-product", params);
+  }
+  /**
+   * Update a one-time product's status (active/inactive).
+   *
+   * @param params - Status update parameters
+   * @returns Updated product detail
+   *
+   * @example
+   * const { product } = await client.onetimeProducts.updateStatus({
+   *   id: "prod_xxx",
+   *   status: ProductVersionStatus.Inactive,
+   * });
+   */
+  async updateStatus(params) {
+    return this.http.post("/v1/actions/onetime-product/update-status", params);
+  }
+};
+
+// src/resources/orders.ts
+var OrdersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Cancel a subscription order.
+   *
+   * - pending -> canceled (immediate)
+   * - active/trialing -> canceling (PSP cancel, webhook updates later)
+   *
+   * @param params - Order to cancel
+   * @returns Order ID and resulting status
+   *
+   * @example
+   * const { orderId, status } = await client.orders.cancelSubscription({
+   *   orderId: "order_xxx",
+   * });
+   * // status: "canceled" or "canceling"
+   */
+  async cancelSubscription(params) {
+    return this.http.post("/v1/actions/subscription-order/cancel-order", params);
+  }
+};
+
+// src/resources/store-merchants.ts
+var StoreMerchantsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Add a merchant to a store.
+   *
+   * @param params - Merchant addition parameters
+   * @returns Added merchant details
+   *
+   * @example
+   * const result = await client.storeMerchants.add({
+   *   storeId: "store_xxx",
+   *   email: "member@example.com",
+   *   role: "admin",
+   * });
+   */
+  async add(params) {
+    return this.http.post("/v1/actions/store-merchant/add-merchant", params);
+  }
+  /**
+   * Remove a merchant from a store.
+   *
+   * @param params - Merchant removal parameters
+   * @returns Removal confirmation
+   *
+   * @example
+   * const result = await client.storeMerchants.remove({
+   *   storeId: "store_xxx",
+   *   merchantId: "merchant_xxx",
+   * });
+   */
+  async remove(params) {
+    return this.http.post("/v1/actions/store-merchant/remove-merchant", params);
+  }
+  /**
+   * Update a merchant's role in a store.
+   *
+   * @param params - Role update parameters
+   * @returns Updated role details
+   *
+   * @example
+   * const result = await client.storeMerchants.updateRole({
+   *   storeId: "store_xxx",
+   *   merchantId: "merchant_xxx",
+   *   role: "member",
+   * });
+   */
+  async updateRole(params) {
+    return this.http.post("/v1/actions/store-merchant/update-role", params);
+  }
+};
+
+// src/resources/stores.ts
+var StoresResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new store. Slug is auto-generated from the name.
+   *
+   * @param params - Store creation parameters
+   * @returns Created store entity
+   *
+   * @example
+   * const { store } = await client.stores.create({ name: "My Store" });
+   */
+  async create(params) {
+    return this.http.post("/v1/actions/store/create-store", params);
+  }
+  /**
+   * Update an existing store's settings.
+   *
+   * @param params - Fields to update (only provided fields are changed)
+   * @returns Updated store entity
+   *
+   * @example
+   * const { store } = await client.stores.update({
+   *   id: "store_xxx",
+   *   name: "Updated Name",
+   *   supportEmail: "help@example.com",
+   * });
+   */
+  async update(params) {
+    return this.http.post("/v1/actions/store/update-store", params);
+  }
+  /**
+   * Soft-delete a store. Only the owner can delete.
+   *
+   * @param params - Store to delete
+   * @returns Deleted store entity (with `deletedAt` set)
+   *
+   * @example
+   * const { store } = await client.stores.delete({ id: "store_xxx" });
+   */
+  async delete(params) {
+    return this.http.post("/v1/actions/store/delete-store", params);
+  }
+};
+
+// src/resources/subscription-product-groups.ts
+var SubscriptionProductGroupsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a subscription product group for shared-trial or plan switching.
+   *
+   * @param params - Group creation parameters
+   * @returns Created group entity
+   *
+   * @example
+   * const { group } = await client.subscriptionProductGroups.create({
+   *   storeId: "store_xxx",
+   *   name: "Pro Plans",
+   *   rules: { sharedTrial: true },
+   *   productIds: ["prod_aaa", "prod_bbb"],
+   * });
+   */
+  async create(params) {
+    return this.http.post("/v1/actions/subscription-product-group/create-group", params);
+  }
+  /**
+   * Update a subscription product group. `productIds` is a full replacement.
+   *
+   * @param params - Group update parameters
+   * @returns Updated group entity
+   *
+   * @example
+   * const { group } = await client.subscriptionProductGroups.update({
+   *   id: "group_xxx",
+   *   productIds: ["prod_aaa", "prod_bbb", "prod_ccc"],
+   * });
+   */
+  async update(params) {
+    return this.http.post("/v1/actions/subscription-product-group/update-group", params);
+  }
+  /**
+   * Hard-delete a subscription product group.
+   *
+   * @param params - Group to delete
+   * @returns Deleted group entity
+   *
+   * @example
+   * const { group } = await client.subscriptionProductGroups.delete({ id: "group_xxx" });
+   */
+  async delete(params) {
+    return this.http.post("/v1/actions/subscription-product-group/delete-group", params);
+  }
+  /**
+   * Publish a test-environment group to production (upsert).
+   *
+   * @param params - Group to publish
+   * @returns Published group entity
+   *
+   * @example
+   * const { group } = await client.subscriptionProductGroups.publish({ id: "group_xxx" });
+   */
+  async publish(params) {
+    return this.http.post("/v1/actions/subscription-product-group/publish-group", params);
+  }
+};
+
+// src/resources/subscription-products.ts
+var SubscriptionProductsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a subscription product with billing period and multi-currency pricing.
+   *
+   * @param params - Product creation parameters
+   * @returns Created product detail
+   *
+   * @example
+   * const { product } = await client.subscriptionProducts.create({
+   *   storeId: "store_xxx",
+   *   name: "Pro Plan",
+   *   billingPeriod: "monthly",
+   *   prices: { USD: { amount: 999, taxIncluded: false, taxCategory: "saas" } },
+   * });
+   */
+  async create(params) {
+    return this.http.post("/v1/actions/subscription-product/create-product", params);
+  }
+  /**
+   * Update a subscription product. Creates a new version; skips if unchanged.
+   *
+   * @param params - Product update parameters (all content fields required)
+   * @returns Updated product detail
+   *
+   * @example
+   * const { product } = await client.subscriptionProducts.update({
+   *   id: "prod_xxx",
+   *   name: "Pro Plan v2",
+   *   billingPeriod: "monthly",
+   *   prices: { USD: { amount: 1499, taxIncluded: false, taxCategory: "saas" } },
+   * });
+   */
+  async update(params) {
+    return this.http.post("/v1/actions/subscription-product/update-product", params);
+  }
+  /**
+   * Publish a subscription product's test version to production.
+   *
+   * @param params - Product to publish
+   * @returns Published product detail
+   *
+   * @example
+   * const { product } = await client.subscriptionProducts.publish({ id: "prod_xxx" });
+   */
+  async publish(params) {
+    return this.http.post("/v1/actions/subscription-product/publish-product", params);
+  }
+  /**
+   * Update a subscription product's status (active/inactive).
+   *
+   * @param params - Status update parameters
+   * @returns Updated product detail
+   *
+   * @example
+   * const { product } = await client.subscriptionProducts.updateStatus({
+   *   id: "prod_xxx",
+   *   status: ProductVersionStatus.Active,
+   * });
+   */
+  async updateStatus(params) {
+    return this.http.post("/v1/actions/subscription-product/update-status", params);
+  }
+};
+
+// src/client.ts
+var WaffoPancake = class {
+  http;
+  auth;
+  stores;
+  storeMerchants;
+  onetimeProducts;
+  subscriptionProducts;
+  subscriptionProductGroups;
+  orders;
+  checkout;
+  graphql;
+  constructor(config) {
+    this.http = new HttpClient(config);
+    this.auth = new AuthResource(this.http);
+    this.stores = new StoresResource(this.http);
+    this.storeMerchants = new StoreMerchantsResource(this.http);
+    this.onetimeProducts = new OnetimeProductsResource(this.http);
+    this.subscriptionProducts = new SubscriptionProductsResource(this.http);
+    this.subscriptionProductGroups = new SubscriptionProductGroupsResource(this.http);
+    this.orders = new OrdersResource(this.http);
+    this.checkout = new CheckoutResource(this.http);
+    this.graphql = new GraphQLResource(this.http);
+  }
+};
+
+// src/webhooks.ts
+var import_node_crypto3 = require("crypto");
+var DEFAULT_TOLERANCE_MS = 5 * 60 * 1e3;
+var TEST_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxnmRY6yMMA3lVqmAU6ZG
+b1sjL/+r/z6E+ZjkXaDAKiqOhk9rpazni0bNsGXwmftTPk9jy2wn+j6JHODD/WH/
+SCnSfvKkLIjy4Hk7BuCgB174C0ydan7J+KgXLkOwgCAxxB68t2tezldwo74ZpXgn
+F49opzMvQ9prEwIAWOE+kV9iK6gx/AckSMtHIHpUesoPDkldpmFHlB2qpf1vsFTZ
+5kD6DmGl+2GIVK01aChy2lk8pLv0yUMu18v44sLkO5M44TkGPJD9qG09wrvVG2wp
+OTVCn1n5pP8P+HRLcgzbUB3OlZVfdFurn6EZwtyL4ZD9kdkQ4EZE/9inKcp3c1h4
+xwIDAQAB
+-----END PUBLIC KEY-----`;
+var PROD_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+xApdTIb4ua+DgZKQ54
+iBsD82ybyhGCLRETONW4Jgbb3A8DUM1LqBk6r/CmTOCHqLalTQHNigvP3R5zkDNX
+iRJz6gA4MJ/+8K0+mnEE2RISQzN+Qu65TNd6svb+INm/kMaftY4uIXr6y6kchtTJ
+dwnQhcKdAL2v7h7IFnkVelQsKxDdb2PqX8xX/qwd01iXvMcpCCaXovUwZsxH2QN5
+ZKBTseJivbhUeyJCco4fdUyxOMHe2ybCVhyvim2uxAl1nkvL5L8RCWMCAV55LLo0
+9OhmLahz/DYNu13YLVP6dvIT09ZFBYU6Owj1NxdinTynlJCFS9VYwBgmftosSE1U
+dwIDAQAB
+-----END PUBLIC KEY-----`;
+function parseSignatureHeader(header) {
+  let t = "";
+  let v1 = "";
+  for (const pair of header.split(",")) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = pair.slice(0, eqIdx).trim();
+    const value = pair.slice(eqIdx + 1).trim();
+    if (key === "t") t = value;
+    else if (key === "v1") v1 = value;
+  }
+  return { t, v1 };
+}
+function rsaVerify(signatureInput, v1, publicKey) {
+  const verifier = (0, import_node_crypto3.createVerify)("RSA-SHA256");
+  verifier.update(signatureInput);
+  return verifier.verify(publicKey, v1, "base64");
+}
+function verifyWebhook(payload, signatureHeader, options) {
+  if (!signatureHeader) {
+    throw new Error("Missing X-Waffo-Signature header");
+  }
+  const { t, v1 } = parseSignatureHeader(signatureHeader);
+  if (!t || !v1) {
+    throw new Error("Malformed X-Waffo-Signature header: missing t or v1");
+  }
+  const toleranceMs = options?.toleranceMs ?? DEFAULT_TOLERANCE_MS;
+  if (toleranceMs > 0) {
+    const timestampMs = Number(t);
+    if (Number.isNaN(timestampMs)) {
+      throw new Error("Invalid timestamp in X-Waffo-Signature header");
+    }
+    if (Math.abs(Date.now() - timestampMs) > toleranceMs) {
+      throw new Error("Webhook timestamp outside tolerance window (possible replay attack)");
+    }
+  }
+  const signatureInput = `${t}.${payload}`;
+  const env = options?.environment;
+  if (env === "test") {
+    if (!rsaVerify(signatureInput, v1, TEST_PUBLIC_KEY)) {
+      throw new Error("Invalid webhook signature (test key)");
+    }
+  } else if (env === "prod") {
+    if (!rsaVerify(signatureInput, v1, PROD_PUBLIC_KEY)) {
+      throw new Error("Invalid webhook signature (prod key)");
+    }
+  } else {
+    const prodValid = rsaVerify(signatureInput, v1, PROD_PUBLIC_KEY);
+    if (!prodValid) {
+      const testValid = rsaVerify(signatureInput, v1, TEST_PUBLIC_KEY);
+      if (!testValid) {
+        throw new Error("Invalid webhook signature (tried both prod and test keys)");
+      }
+    }
+  }
+  return JSON.parse(payload);
+}
+
+// src/types.ts
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["Test"] = "test";
+  Environment2["Prod"] = "prod";
+  return Environment2;
+})(Environment || {});
+var TaxCategory = /* @__PURE__ */ ((TaxCategory2) => {
+  TaxCategory2["DigitalGoods"] = "digital_goods";
+  TaxCategory2["SaaS"] = "saas";
+  TaxCategory2["Software"] = "software";
+  TaxCategory2["Ebook"] = "ebook";
+  TaxCategory2["OnlineCourse"] = "online_course";
+  TaxCategory2["Consulting"] = "consulting";
+  TaxCategory2["ProfessionalService"] = "professional_service";
+  return TaxCategory2;
+})(TaxCategory || {});
+var BillingPeriod = /* @__PURE__ */ ((BillingPeriod2) => {
+  BillingPeriod2["Weekly"] = "weekly";
+  BillingPeriod2["Monthly"] = "monthly";
+  BillingPeriod2["Quarterly"] = "quarterly";
+  BillingPeriod2["Yearly"] = "yearly";
+  return BillingPeriod2;
+})(BillingPeriod || {});
+var ProductVersionStatus = /* @__PURE__ */ ((ProductVersionStatus2) => {
+  ProductVersionStatus2["Active"] = "active";
+  ProductVersionStatus2["Inactive"] = "inactive";
+  return ProductVersionStatus2;
+})(ProductVersionStatus || {});
+var EntityStatus = /* @__PURE__ */ ((EntityStatus2) => {
+  EntityStatus2["Active"] = "active";
+  EntityStatus2["Inactive"] = "inactive";
+  EntityStatus2["Suspended"] = "suspended";
+  return EntityStatus2;
+})(EntityStatus || {});
+var StoreRole = /* @__PURE__ */ ((StoreRole2) => {
+  StoreRole2["Owner"] = "owner";
+  StoreRole2["Admin"] = "admin";
+  StoreRole2["Member"] = "member";
+  return StoreRole2;
+})(StoreRole || {});
+var OnetimeOrderStatus = /* @__PURE__ */ ((OnetimeOrderStatus2) => {
+  OnetimeOrderStatus2["Pending"] = "pending";
+  OnetimeOrderStatus2["Completed"] = "completed";
+  OnetimeOrderStatus2["Canceled"] = "canceled";
+  return OnetimeOrderStatus2;
+})(OnetimeOrderStatus || {});
+var SubscriptionOrderStatus = /* @__PURE__ */ ((SubscriptionOrderStatus2) => {
+  SubscriptionOrderStatus2["Pending"] = "pending";
+  SubscriptionOrderStatus2["Active"] = "active";
+  SubscriptionOrderStatus2["Canceling"] = "canceling";
+  SubscriptionOrderStatus2["Canceled"] = "canceled";
+  SubscriptionOrderStatus2["PastDue"] = "past_due";
+  SubscriptionOrderStatus2["Expired"] = "expired";
+  return SubscriptionOrderStatus2;
+})(SubscriptionOrderStatus || {});
+var PaymentStatus = /* @__PURE__ */ ((PaymentStatus2) => {
+  PaymentStatus2["Pending"] = "pending";
+  PaymentStatus2["Succeeded"] = "succeeded";
+  PaymentStatus2["Failed"] = "failed";
+  PaymentStatus2["Canceled"] = "canceled";
+  return PaymentStatus2;
+})(PaymentStatus || {});
+var RefundTicketStatus = /* @__PURE__ */ ((RefundTicketStatus2) => {
+  RefundTicketStatus2["Pending"] = "pending";
+  RefundTicketStatus2["Approved"] = "approved";
+  RefundTicketStatus2["Rejected"] = "rejected";
+  RefundTicketStatus2["Processing"] = "processing";
+  RefundTicketStatus2["Succeeded"] = "succeeded";
+  RefundTicketStatus2["Failed"] = "failed";
+  return RefundTicketStatus2;
+})(RefundTicketStatus || {});
+var RefundStatus = /* @__PURE__ */ ((RefundStatus2) => {
+  RefundStatus2["Succeeded"] = "succeeded";
+  RefundStatus2["Failed"] = "failed";
+  return RefundStatus2;
+})(RefundStatus || {});
+var MediaType = /* @__PURE__ */ ((MediaType2) => {
+  MediaType2["Image"] = "image";
+  MediaType2["Video"] = "video";
+  return MediaType2;
+})(MediaType || {});
+var CheckoutSessionProductType = /* @__PURE__ */ ((CheckoutSessionProductType2) => {
+  CheckoutSessionProductType2["Onetime"] = "onetime";
+  CheckoutSessionProductType2["Subscription"] = "subscription";
+  return CheckoutSessionProductType2;
+})(CheckoutSessionProductType || {});
+var ErrorLayer = /* @__PURE__ */ ((ErrorLayer2) => {
+  ErrorLayer2["Gateway"] = "gateway";
+  ErrorLayer2["User"] = "user";
+  ErrorLayer2["Store"] = "store";
+  ErrorLayer2["Product"] = "product";
+  ErrorLayer2["Order"] = "order";
+  ErrorLayer2["GraphQL"] = "graphql";
+  ErrorLayer2["Resource"] = "resource";
+  ErrorLayer2["Email"] = "email";
+  return ErrorLayer2;
+})(ErrorLayer || {});
+var WebhookEventType = /* @__PURE__ */ ((WebhookEventType2) => {
+  WebhookEventType2["OrderCompleted"] = "order.completed";
+  WebhookEventType2["SubscriptionActivated"] = "subscription.activated";
+  WebhookEventType2["SubscriptionPaymentSucceeded"] = "subscription.payment_succeeded";
+  WebhookEventType2["SubscriptionCanceling"] = "subscription.canceling";
+  WebhookEventType2["SubscriptionUncanceled"] = "subscription.uncanceled";
+  WebhookEventType2["SubscriptionUpdated"] = "subscription.updated";
+  WebhookEventType2["SubscriptionCanceled"] = "subscription.canceled";
+  WebhookEventType2["SubscriptionPastDue"] = "subscription.past_due";
+  WebhookEventType2["RefundSucceeded"] = "refund.succeeded";
+  WebhookEventType2["RefundFailed"] = "refund.failed";
+  return WebhookEventType2;
+})(WebhookEventType || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BillingPeriod,
+  CheckoutSessionProductType,
+  EntityStatus,
+  Environment,
+  ErrorLayer,
+  MediaType,
+  OnetimeOrderStatus,
+  PaymentStatus,
+  ProductVersionStatus,
+  RefundStatus,
+  RefundTicketStatus,
+  StoreRole,
+  SubscriptionOrderStatus,
+  TaxCategory,
+  WaffoPancake,
+  WaffoPancakeError,
+  WebhookEventType,
+  verifyWebhook
+});
+//# sourceMappingURL=index.cjs.map