fresh-squeezy 0.1.13 → 0.1.15

package/dist/index.cjs

@@ -32,19 +32,32 @@ __export(src_exports, {
   SUPPORTED_RESOURCES: () => SUPPORTED_RESOURCES,
   buildResult: () => buildResult,
   buildSubscriptionItemUpdateBody: () => buildSubscriptionItemUpdateBody,
+  cancelSubscription: () => cancelSubscription,
   checkDiscount: () => checkDiscount,
   checkLicenseKey: () => checkLicenseKey,
   checkProduct: () => checkProduct,
   checkSubscriptionPlan: () => checkSubscriptionPlan,
+  createCheckout: () => createCheckout,
+  createCustomer: () => createCustomer,
+  createDiscount: () => createDiscount,
   createFreshSqueezy: () => createFreshSqueezy,
+  createUsageRecord: () => createUsageRecord,
+  createWebhook: () => createWebhook,
+  deleteDiscount: () => deleteDiscount,
+  deleteWebhook: () => deleteWebhook,
   doctor: () => doctor,
   fetchActualMode: () => fetchActualMode,
+  findResourceVerb: () => findResourceVerb,
+  generateOrderInvoice: () => generateOrderInvoice,
+  generateSubscriptionInvoice: () => generateSubscriptionInvoice,
   getAffiliate: () => getAffiliate,
   getAuthenticatedUser: () => getAuthenticatedUser,
   getCheckout: () => getCheckout,
   getCustomer: () => getCustomer,
+  getDiscount: () => getDiscount,
   getDiscountRedemption: () => getDiscountRedemption,
   getFile: () => getFile,
+  getLicenseKey: () => getLicenseKey,
   getLicenseKeyInstance: () => getLicenseKeyInstance,
   getOrder: () => getOrder,
   getOrderItem: () => getOrderItem,
@@ -54,27 +67,44 @@ __export(src_exports, {
   getSubscription: () => getSubscription,
   getSubscriptionInvoice: () => getSubscriptionInvoice,
   getSubscriptionItem: () => getSubscriptionItem,
+  getSubscriptionItemCurrentUsage: () => getSubscriptionItemCurrentUsage,
   getUsageRecord: () => getUsageRecord,
   getVariant: () => getVariant,
+  getWebhook: () => getWebhook,
+  invokeOp: () => invokeOp,
   isOk: () => isOk,
   issue: () => issue,
   listAffiliatesForStore: () => listAffiliatesForStore,
   listCheckoutsForStore: () => listCheckoutsForStore,
   listCustomersForStore: () => listCustomersForStore,
   listDiscountRedemptionsForDiscount: () => listDiscountRedemptionsForDiscount,
+  listDiscountsForStore: () => listDiscountsForStore,
   listFilesForVariant: () => listFilesForVariant,
   listLicenseKeyInstancesForLicenseKey: () => listLicenseKeyInstancesForLicenseKey,
+  listLicenseKeysForStore: () => listLicenseKeysForStore,
   listOrderItemsForOrder: () => listOrderItemsForOrder,
+  listOrdersForStore: () => listOrdersForStore,
+  listPricesForVariant: () => listPricesForVariant,
   listProducts: () => listProducts,
+  listRegisteredResources: () => listRegisteredResources,
   listStores: () => listStores,
   listSubscriptionInvoicesForSubscription: () => listSubscriptionInvoicesForSubscription,
   listSubscriptionItemsForSubscription: () => listSubscriptionItemsForSubscription,
+  listSubscriptionsForStore: () => listSubscriptionsForStore,
   listUsageRecordsForSubscriptionItem: () => listUsageRecordsForSubscriptionItem,
   listVariantsForProduct: () => listVariantsForProduct,
   listWebhooksForStore: () => listWebhooksForStore,
+  refundOrder: () => refundOrder,
+  refundSubscriptionInvoice: () => refundSubscriptionInvoice,
   resolveActualMode: () => resolveActualMode,
   resolveConfig: () => resolveConfig,
+  resourceRegistry: () => resourceRegistry,
   sameWebhookUrl: () => sameWebhookUrl,
+  updateCustomer: () => updateCustomer,
+  updateLicenseKey: () => updateLicenseKey,
+  updateSubscription: () => updateSubscription,
+  updateSubscriptionItem: () => updateSubscriptionItem,
+  updateWebhook: () => updateWebhook,
   userResource: () => userResource,
   validateConnection: () => validateConnection,
   validateDiscount: () => validateDiscount,
@@ -108,7 +138,7 @@ var ENV_KEYS = {
   storeId: "LEMON_SQUEEZY_STORE_ID",
   mode: "LEMON_SQUEEZY_MODE"
 };
-function resolveConfig(input = {}) {
+var resolveConfig = (input = {}) => {
   const apiKey = input.apiKey ?? process.env[ENV_KEYS.apiKey];
   if (!apiKey) {
     throw new FreshSqueezyError({
@@ -125,14 +155,14 @@ function resolveConfig(input = {}) {
     baseUrl: input.baseUrl ?? DEFAULT_BASE_URL,
     fetch: input.fetch ?? globalThis.fetch
   };
-}
-function normalizeMode(value) {
+};
+var normalizeMode = (value) => {
   if (value === "test" || value === "live") return value;
   throw new FreshSqueezyError({
     code: "INVALID_MODE",
     message: `Mode must be "test" or "live", got "${value}".`
   });
-}
+};
 
 // src/core/http.ts
 var HttpClient = class {
@@ -178,6 +208,37 @@ var HttpClient = class {
     const doc = await this.request({ path });
     return doc.data;
   }
+  /**
+   * POST a JSON:API document and return the created `data` resource.
+   *
+   * @param path - API path starting with `/v1/...`.
+   * @param body - JSON:API create document.
+   * @returns The created resource.
+   */
+  async postResource(path, body) {
+    const doc = await this.request({ method: "POST", path, body });
+    return doc.data;
+  }
+  /**
+   * PATCH a JSON:API document and return the updated `data` resource.
+   *
+   * @param path - API path starting with `/v1/...`.
+   * @param body - JSON:API update document.
+   * @returns The updated resource.
+   */
+  async patchResource(path, body) {
+    const doc = await this.request({ method: "PATCH", path, body });
+    return doc.data;
+  }
+  /**
+   * DELETE a resource. Lemon Squeezy often returns an empty body on success.
+   *
+   * @param path - API path starting with `/v1/...`.
+   * @returns Nothing — single void return, not a multi-field bag.
+   */
+  async deleteResource(path) {
+    await this.request({ method: "DELETE", path });
+  }
   /**
    * Fetch a single page of a JSON:API collection. Most callers want
    * `paginate()` instead — this method is kept for one-shot lookups where
@@ -225,51 +286,922 @@ var HttpClient = class {
     return url.toString();
   }
 };
-function safeJsonParse(text) {
+var safeJsonParse = (text) => {
   try {
     return JSON.parse(text);
   } catch {
     return text;
   }
-}
-function toApiError(status, body) {
+};
+var toApiError = (status, body) => {
   const errors = extractJsonApiErrors(body);
   const first = errors[0];
   const code = status === 401 ? "UNAUTHORIZED" : status === 404 ? "NOT_FOUND" : status === 429 ? "RATE_LIMITED" : first?.code ?? `HTTP_${status}`;
   const message = first?.detail ?? first?.title ?? `Lemon Squeezy request failed with status ${status}`;
   return new FreshSqueezyError({ code, status, message, detail: body });
-}
-function extractJsonApiErrors(body) {
+};
+var extractJsonApiErrors = (body) => {
   if (!body || typeof body !== "object") return [];
   const errors = body.errors;
   if (!Array.isArray(errors)) return [];
   return errors.filter(
     (entry) => typeof entry === "object" && entry !== null
   );
-}
+};
 
-// src/core/mode.ts
-function resolveActualMode(testMode) {
-  if (testMode === true) return "test";
-  if (testMode === false) return "live";
-  return void 0;
-}
+// src/resources/affiliates.ts
+var getAffiliate = async (http, affiliateId) => {
+  return http.getResource(`/v1/affiliates/${affiliateId}`);
+};
+var listAffiliatesForStore = async (http, storeId) => {
+  return http.paginate("/v1/affiliates", {
+    "filter[store_id]": String(storeId)
+  });
+};
+
+// src/resources/checkouts.ts
+var getCheckout = async (http, checkoutId) => {
+  return http.getResource(`/v1/checkouts/${checkoutId}`);
+};
+var listCheckoutsForStore = async (http, storeId) => {
+  return http.paginate("/v1/checkouts", {
+    "filter[store_id]": String(storeId)
+  });
+};
+var createCheckout = async (http, body) => {
+  return http.postResource("/v1/checkouts", body);
+};
+
+// src/resources/customers.ts
+var getCustomer = async (http, customerId) => {
+  return http.getResource(`/v1/customers/${customerId}`);
+};
+var listCustomersForStore = async (http, storeId) => {
+  return http.paginate("/v1/customers", {
+    "filter[store_id]": String(storeId)
+  });
+};
+var createCustomer = async (http, body) => {
+  return http.postResource("/v1/customers", body);
+};
+var updateCustomer = async (http, customerId, body) => {
+  return http.patchResource(`/v1/customers/${customerId}`, body);
+};
+
+// src/resources/discountRedemptions.ts
+var getDiscountRedemption = async (http, discountRedemptionId) => {
+  return http.getResource(
+    `/v1/discount-redemptions/${discountRedemptionId}`
+  );
+};
+var listDiscountRedemptionsForDiscount = async (http, discountId) => {
+  return http.paginate("/v1/discount-redemptions", {
+    "filter[discount_id]": String(discountId)
+  });
+};
+
+// src/resources/discounts.ts
+var getDiscount = async (http, discountId) => {
+  return http.getResource(`/v1/discounts/${discountId}`);
+};
+var listDiscountsForStore = async (http, storeId) => {
+  return http.paginate("/v1/discounts", {
+    "filter[store_id]": String(storeId)
+  });
+};
+var createDiscount = async (http, body) => {
+  return http.postResource("/v1/discounts", body);
+};
+var deleteDiscount = async (http, discountId) => {
+  await http.deleteResource(`/v1/discounts/${discountId}`);
+};
+
+// src/resources/files.ts
+var getFile = async (http, fileId) => {
+  return http.getResource(`/v1/files/${fileId}`);
+};
+var listFilesForVariant = async (http, variantId) => {
+  return http.paginate("/v1/files", {
+    "filter[variant_id]": String(variantId)
+  });
+};
+
+// src/resources/licenseKeyInstances.ts
+var getLicenseKeyInstance = async (http, licenseKeyInstanceId) => {
+  return http.getResource(
+    `/v1/license-key-instances/${licenseKeyInstanceId}`
+  );
+};
+var listLicenseKeyInstancesForLicenseKey = async (http, licenseKeyId) => {
+  return http.paginate("/v1/license-key-instances", {
+    "filter[license_key_id]": String(licenseKeyId)
+  });
+};
+
+// src/resources/licenseKeys.ts
+var getLicenseKey = async (http, licenseKeyId) => {
+  return http.getResource(`/v1/license-keys/${licenseKeyId}`);
+};
+var listLicenseKeysForStore = async (http, storeId) => {
+  return http.paginate("/v1/license-keys", {
+    "filter[store_id]": String(storeId)
+  });
+};
+var updateLicenseKey = async (http, licenseKeyId, body) => {
+  return http.patchResource(`/v1/license-keys/${licenseKeyId}`, body);
+};
+
+// src/resources/orderItems.ts
+var getOrderItem = async (http, orderItemId) => {
+  return http.getResource(`/v1/order-items/${orderItemId}`);
+};
+var listOrderItemsForOrder = async (http, orderId) => {
+  return http.paginate("/v1/order-items", {
+    "filter[order_id]": String(orderId)
+  });
+};
+
+// src/resources/orders.ts
+var getOrder = async (http, orderId) => {
+  return http.getResource(`/v1/orders/${orderId}`);
+};
+var listOrdersForStore = async (http, storeId) => {
+  return http.paginate("/v1/orders", {
+    "filter[store_id]": String(storeId)
+  });
+};
+var refundOrder = async (http, orderId, body) => {
+  return http.postResource(`/v1/orders/${orderId}/refund`, body ?? {});
+};
+var generateOrderInvoice = async (http, orderId, body) => {
+  return http.request({
+    method: "POST",
+    path: `/v1/orders/${orderId}/generate-invoice`,
+    body: body ?? {}
+  });
+};
+
+// src/resources/prices.ts
+var getPrice = async (http, priceId) => {
+  return http.getResource(`/v1/prices/${priceId}`);
+};
+var listPricesForVariant = async (http, variantId) => {
+  return http.paginate("/v1/prices", {
+    "filter[variant_id]": String(variantId)
+  });
+};
+
+// src/resources/products.ts
+var getProduct = async (http, productId) => {
+  return http.getResource(`/v1/products/${productId}`);
+};
+var listProducts = async (http, storeId) => {
+  return http.paginate("/v1/products", {
+    "filter[store_id]": String(storeId)
+  });
+};
+
+// src/resources/registry.ts
+var resourceRegistry = [
+  // users
+  { resource: "user", verb: "get", docsPath: "users/retrieve-user", body: "none", idRole: "none" },
+  // stores (read-only)
+  { resource: "store", verb: "get", docsPath: "stores/retrieve-store", body: "none", idRole: "id" },
+  {
+    resource: "store",
+    verb: "list",
+    docsPath: "stores/list-all-stores",
+    body: "none",
+    idRole: "none"
+  },
+  // products (read-only)
+  {
+    resource: "product",
+    verb: "get",
+    docsPath: "products/retrieve-product",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "product",
+    verb: "list",
+    docsPath: "products/list-all-products",
+    body: "none",
+    idRole: "store"
+  },
+  // variants (read-only)
+  {
+    resource: "variant",
+    verb: "get",
+    docsPath: "variants/retrieve-variant",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "variant",
+    verb: "list",
+    docsPath: "variants/list-all-variants",
+    body: "none",
+    idRole: "parent"
+  },
+  // prices (read-only)
+  { resource: "price", verb: "get", docsPath: "prices/retrieve-price", body: "none", idRole: "id" },
+  {
+    resource: "price",
+    verb: "list",
+    docsPath: "prices/list-all-prices",
+    body: "none",
+    idRole: "parent"
+  },
+  // files (read-only)
+  { resource: "file", verb: "get", docsPath: "files/retrieve-file", body: "none", idRole: "id" },
+  {
+    resource: "file",
+    verb: "list",
+    docsPath: "files/list-all-files",
+    body: "none",
+    idRole: "parent"
+  },
+  // customers
+  {
+    resource: "customer",
+    verb: "get",
+    docsPath: "customers/retrieve-customer",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "customer",
+    verb: "list",
+    docsPath: "customers/list-all-customers",
+    body: "none",
+    idRole: "store"
+  },
+  {
+    resource: "customer",
+    verb: "create",
+    docsPath: "customers/create-customer",
+    body: "required",
+    idRole: "none"
+  },
+  {
+    resource: "customer",
+    verb: "update",
+    docsPath: "customers/update-customer",
+    body: "required",
+    idRole: "id"
+  },
+  // orders
+  { resource: "order", verb: "get", docsPath: "orders/retrieve-order", body: "none", idRole: "id" },
+  {
+    resource: "order",
+    verb: "list",
+    docsPath: "orders/list-all-orders",
+    body: "none",
+    idRole: "store"
+  },
+  {
+    resource: "order",
+    verb: "refund",
+    docsPath: "orders/issue-refund",
+    body: "optional",
+    destructive: true,
+    idRole: "id"
+  },
+  {
+    resource: "order",
+    verb: "generate-invoice",
+    docsPath: "orders/generate-order-invoice",
+    body: "optional",
+    idRole: "id"
+  },
+  // order-items (read-only)
+  {
+    resource: "order-item",
+    verb: "get",
+    docsPath: "order-items/retrieve-order-item",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "order-item",
+    verb: "list",
+    docsPath: "order-items/list-all-order-items",
+    body: "none",
+    idRole: "parent"
+  },
+  // subscriptions
+  {
+    resource: "subscription",
+    verb: "get",
+    docsPath: "subscriptions/retrieve-subscription",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "subscription",
+    verb: "list",
+    docsPath: "subscriptions/list-all-subscriptions",
+    body: "none",
+    idRole: "store"
+  },
+  {
+    resource: "subscription",
+    verb: "update",
+    docsPath: "subscriptions/update-subscription",
+    body: "required",
+    idRole: "id"
+  },
+  {
+    resource: "subscription",
+    verb: "cancel",
+    docsPath: "subscriptions/cancel-subscription",
+    body: "none",
+    destructive: true,
+    idRole: "id"
+  },
+  // subscription-items
+  {
+    resource: "subscription-item",
+    verb: "get",
+    docsPath: "subscription-items/retrieve-subscription-item",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "subscription-item",
+    verb: "list",
+    docsPath: "subscription-items/list-all-subscription-items",
+    body: "none",
+    idRole: "parent"
+  },
+  {
+    resource: "subscription-item",
+    verb: "update",
+    docsPath: "subscription-items/update-subscription-item",
+    body: "required",
+    idRole: "id"
+  },
+  {
+    resource: "subscription-item",
+    verb: "current-usage",
+    docsPath: "subscription-items/retrieve-subscription-item-current-usage",
+    body: "none",
+    idRole: "id"
+  },
+  // subscription-invoices
+  {
+    resource: "subscription-invoice",
+    verb: "get",
+    docsPath: "subscription-invoices/retrieve-subscription-invoice",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "subscription-invoice",
+    verb: "list",
+    docsPath: "subscription-invoices/list-all-subscription-invoices",
+    body: "none",
+    idRole: "parent"
+  },
+  {
+    resource: "subscription-invoice",
+    verb: "refund",
+    docsPath: "subscription-invoices/issue-refund",
+    body: "optional",
+    destructive: true,
+    idRole: "id"
+  },
+  {
+    resource: "subscription-invoice",
+    verb: "generate-invoice",
+    docsPath: "subscription-invoices/generate-subscription-invoice",
+    body: "optional",
+    idRole: "id"
+  },
+  // usage-records
+  {
+    resource: "usage-record",
+    verb: "get",
+    docsPath: "usage-records/retrieve-usage-record",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "usage-record",
+    verb: "list",
+    docsPath: "usage-records/list-all-usage-records",
+    body: "none",
+    idRole: "parent"
+  },
+  {
+    resource: "usage-record",
+    verb: "create",
+    docsPath: "usage-records/create-usage-record",
+    body: "required",
+    idRole: "none"
+  },
+  // discounts
+  {
+    resource: "discount",
+    verb: "get",
+    docsPath: "discounts/retrieve-discount",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "discount",
+    verb: "list",
+    docsPath: "discounts/list-all-discounts",
+    body: "none",
+    idRole: "store"
+  },
+  {
+    resource: "discount",
+    verb: "create",
+    docsPath: "discounts/create-discount",
+    body: "required",
+    idRole: "none"
+  },
+  {
+    resource: "discount",
+    verb: "delete",
+    docsPath: "discounts/delete-discount",
+    body: "none",
+    destructive: true,
+    idRole: "id"
+  },
+  // discount-redemptions (read-only)
+  {
+    resource: "discount-redemption",
+    verb: "get",
+    docsPath: "discount-redemptions/retrieve-discount-redemption",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "discount-redemption",
+    verb: "list",
+    docsPath: "discount-redemptions/list-all-discount-redemptions",
+    body: "none",
+    idRole: "parent"
+  },
+  // license-keys
+  {
+    resource: "license-key",
+    verb: "get",
+    docsPath: "license-keys/retrieve-license-key",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "license-key",
+    verb: "list",
+    docsPath: "license-keys/list-all-license-keys",
+    body: "none",
+    idRole: "store"
+  },
+  {
+    resource: "license-key",
+    verb: "update",
+    docsPath: "license-keys/update-license-key",
+    body: "required",
+    idRole: "id"
+  },
+  // license-key-instances (read-only)
+  {
+    resource: "license-key-instance",
+    verb: "get",
+    docsPath: "license-key-instances/retrieve-license-key-instance",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "license-key-instance",
+    verb: "list",
+    docsPath: "license-key-instances/list-all-license-key-instances",
+    body: "none",
+    idRole: "parent"
+  },
+  // checkouts
+  {
+    resource: "checkout",
+    verb: "get",
+    docsPath: "checkouts/retrieve-checkout",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "checkout",
+    verb: "list",
+    docsPath: "checkouts/list-all-checkouts",
+    body: "none",
+    idRole: "store"
+  },
+  {
+    resource: "checkout",
+    verb: "create",
+    docsPath: "checkouts/create-checkout",
+    body: "required",
+    idRole: "none"
+  },
+  // webhooks
+  {
+    resource: "webhook",
+    verb: "get",
+    docsPath: "webhooks/retrieve-webhook",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "webhook",
+    verb: "list",
+    docsPath: "webhooks/list-all-webhooks",
+    body: "none",
+    idRole: "store"
+  },
+  {
+    resource: "webhook",
+    verb: "create",
+    docsPath: "webhooks/create-webhook",
+    body: "required",
+    idRole: "none"
+  },
+  {
+    resource: "webhook",
+    verb: "update",
+    docsPath: "webhooks/update-webhook",
+    body: "required",
+    idRole: "id"
+  },
+  {
+    resource: "webhook",
+    verb: "delete",
+    docsPath: "webhooks/delete-webhook",
+    body: "none",
+    destructive: true,
+    idRole: "id"
+  },
+  // affiliates (read-only)
+  {
+    resource: "affiliate",
+    verb: "get",
+    docsPath: "affiliates/retrieve-affiliate",
+    body: "none",
+    idRole: "id"
+  },
+  {
+    resource: "affiliate",
+    verb: "list",
+    docsPath: "affiliates/list-all-affiliates",
+    body: "none",
+    idRole: "store"
+  }
+];
+var findResourceVerb = (resource, verb) => {
+  const normalized = resource.replace(/_/g, "-").toLowerCase();
+  const singular = normalized.endsWith("s") && normalized !== "status" ? normalized.slice(0, -1) : normalized;
+  const aliases = {
+    products: "product",
+    stores: "store",
+    customers: "customer",
+    orders: "order",
+    "order-items": "order-item",
+    subscriptions: "subscription",
+    "subscription-items": "subscription-item",
+    "subscription-invoices": "subscription-invoice",
+    "usage-records": "usage-record",
+    discounts: "discount",
+    "discount-redemptions": "discount-redemption",
+    "license-keys": "license-key",
+    "license-key-instances": "license-key-instance",
+    checkouts: "checkout",
+    webhooks: "webhook",
+    affiliates: "affiliate",
+    variants: "variant",
+    prices: "price",
+    files: "file",
+    users: "user"
+  };
+  const key = aliases[normalized] ?? singular;
+  return resourceRegistry.find((entry) => entry.resource === key && entry.verb === verb);
+};
+var listRegisteredResources = () => {
+  return [...new Set(resourceRegistry.map((entry) => entry.resource))].sort();
+};
 
 // src/resources/stores.ts
-async function getStore(http, storeId) {
+var getStore = async (http, storeId) => {
   return http.getResource(`/v1/stores/${storeId}`);
-}
-async function listStores(http) {
+};
+var listStores = async (http) => {
   return http.paginate("/v1/stores");
-}
+};
+
+// src/resources/subscriptionInvoices.ts
+var getSubscriptionInvoice = async (http, subscriptionInvoiceId) => {
+  return http.getResource(
+    `/v1/subscription-invoices/${subscriptionInvoiceId}`
+  );
+};
+var listSubscriptionInvoicesForSubscription = async (http, subscriptionId) => {
+  return http.paginate("/v1/subscription-invoices", {
+    "filter[subscription_id]": String(subscriptionId)
+  });
+};
+var refundSubscriptionInvoice = async (http, subscriptionInvoiceId, body) => {
+  return http.postResource(
+    `/v1/subscription-invoices/${subscriptionInvoiceId}/refund`,
+    body ?? {}
+  );
+};
+var generateSubscriptionInvoice = async (http, subscriptionInvoiceId, body) => {
+  return http.request({
+    method: "POST",
+    path: `/v1/subscription-invoices/${subscriptionInvoiceId}/generate-invoice`,
+    body: body ?? {}
+  });
+};
+
+// src/resources/subscriptionItems.ts
+var getSubscriptionItem = async (http, subscriptionItemId) => {
+  return http.getResource(
+    `/v1/subscription-items/${subscriptionItemId}`
+  );
+};
+var listSubscriptionItemsForSubscription = async (http, subscriptionId) => {
+  return http.paginate("/v1/subscription-items", {
+    "filter[subscription_id]": String(subscriptionId)
+  });
+};
+var buildSubscriptionItemUpdateBody = (subscriptionItemId, attributes) => {
+  return {
+    data: {
+      type: "subscription-items",
+      id: String(subscriptionItemId),
+      attributes
+    }
+  };
+};
+var updateSubscriptionItem = async (http, subscriptionItemId, body) => {
+  return http.patchResource(
+    `/v1/subscription-items/${subscriptionItemId}`,
+    body
+  );
+};
+var getSubscriptionItemCurrentUsage = async (http, subscriptionItemId) => {
+  return http.request({
+    path: `/v1/subscription-items/${subscriptionItemId}/current-usage`
+  });
+};
+
+// src/resources/subscriptions.ts
+var getSubscription = async (http, subscriptionId) => {
+  return http.getResource(`/v1/subscriptions/${subscriptionId}`);
+};
+var listSubscriptionsForStore = async (http, storeId) => {
+  return http.paginate("/v1/subscriptions", {
+    "filter[store_id]": String(storeId)
+  });
+};
+var updateSubscription = async (http, subscriptionId, body) => {
+  return http.patchResource(`/v1/subscriptions/${subscriptionId}`, body);
+};
+var cancelSubscription = async (http, subscriptionId) => {
+  const doc = await http.request({
+    method: "DELETE",
+    path: `/v1/subscriptions/${subscriptionId}`
+  });
+  return doc?.data;
+};
+
+// src/resources/usageRecords.ts
+var getUsageRecord = async (http, usageRecordId) => {
+  return http.getResource(`/v1/usage-records/${usageRecordId}`);
+};
+var listUsageRecordsForSubscriptionItem = async (http, subscriptionItemId) => {
+  return http.paginate("/v1/usage-records", {
+    "filter[subscription_item_id]": String(subscriptionItemId)
+  });
+};
+var createUsageRecord = async (http, body) => {
+  return http.postResource("/v1/usage-records", body);
+};
 
 // src/resources/users.ts
-async function getAuthenticatedUser(http) {
+var getAuthenticatedUser = async (http) => {
   return http.request({ path: "/v1/users/me" });
-}
-function userResource(doc) {
+};
+var userResource = (doc) => {
   return doc.data;
-}
+};
+
+// src/resources/variants.ts
+var getVariant = async (http, variantId) => {
+  return http.getResource(`/v1/variants/${variantId}`);
+};
+var listVariantsForProduct = async (http, productId) => {
+  return http.paginate("/v1/variants", {
+    "filter[product_id]": String(productId)
+  });
+};
+
+// src/resources/webhooks.ts
+var getWebhook = async (http, webhookId) => {
+  return http.getResource(`/v1/webhooks/${webhookId}`);
+};
+var listWebhooksForStore = async (http, storeId) => {
+  return http.paginate("/v1/webhooks", {
+    "filter[store_id]": String(storeId)
+  });
+};
+var createWebhook = async (http, body) => {
+  return http.postResource("/v1/webhooks", body);
+};
+var updateWebhook = async (http, webhookId, body) => {
+  return http.patchResource(`/v1/webhooks/${webhookId}`, body);
+};
+var deleteWebhook = async (http, webhookId) => {
+  await http.deleteResource(`/v1/webhooks/${webhookId}`);
+};
+
+// src/resources/invokeOp.ts
+var invokeOp = async (http, resource, verb, args = {}) => {
+  const spec = findResourceVerb(resource, verb);
+  if (!spec) {
+    throw new FreshSqueezyError({
+      code: "UNKNOWN_OP",
+      message: `Unknown or unsupported op: ${verb} ${resource}. Run \`fresh-squeezy ops --list\`.`
+    });
+  }
+  const key = `${spec.resource}:${spec.verb}`;
+  switch (key) {
+    case "user:get":
+      return userResource(await getAuthenticatedUser(http));
+    case "store:get":
+      return getStore(http, requireId(args, "store"));
+    case "store:list":
+      return listStores(http);
+    case "product:get":
+      return getProduct(http, requireId(args, "product"));
+    case "product:list":
+      return listProducts(http, requireStore(args));
+    case "variant:get":
+      return getVariant(http, requireId(args, "variant"));
+    case "variant:list":
+      return listVariantsForProduct(http, requireParent(args, "product"));
+    case "price:get":
+      return getPrice(http, requireId(args, "price"));
+    case "price:list":
+      return listPricesForVariant(http, requireParent(args, "variant"));
+    case "file:get":
+      return getFile(http, requireId(args, "file"));
+    case "file:list":
+      return listFilesForVariant(http, requireParent(args, "variant"));
+    case "customer:get":
+      return getCustomer(http, requireId(args, "customer"));
+    case "customer:list":
+      return listCustomersForStore(http, requireStore(args));
+    case "customer:create":
+      return createCustomer(http, requireBody(args));
+    case "customer:update":
+      return updateCustomer(http, requireId(args, "customer"), requireBody(args));
+    case "order:get":
+      return getOrder(http, requireId(args, "order"));
+    case "order:list":
+      return listOrdersForStore(http, requireStore(args));
+    case "order:refund":
+      return refundOrder(http, requireId(args, "order"), args.body);
+    case "order:generate-invoice":
+      return generateOrderInvoice(http, requireId(args, "order"), args.body);
+    case "order-item:get":
+      return getOrderItem(http, requireId(args, "order-item"));
+    case "order-item:list":
+      return listOrderItemsForOrder(http, requireParent(args, "order"));
+    case "subscription:get":
+      return getSubscription(http, requireId(args, "subscription"));
+    case "subscription:list":
+      return listSubscriptionsForStore(http, requireStore(args));
+    case "subscription:update":
+      return updateSubscription(http, requireId(args, "subscription"), requireBody(args));
+    case "subscription:cancel":
+      return cancelSubscription(http, requireId(args, "subscription"));
+    case "subscription-item:get":
+      return getSubscriptionItem(http, requireId(args, "subscription-item"));
+    case "subscription-item:list":
+      return listSubscriptionItemsForSubscription(http, requireParent(args, "subscription"));
+    case "subscription-item:update":
+      return updateSubscriptionItem(http, requireId(args, "subscription-item"), requireBody(args));
+    case "subscription-item:current-usage":
+      return getSubscriptionItemCurrentUsage(http, requireId(args, "subscription-item"));
+    case "subscription-invoice:get":
+      return getSubscriptionInvoice(http, requireId(args, "subscription-invoice"));
+    case "subscription-invoice:list":
+      return listSubscriptionInvoicesForSubscription(http, requireParent(args, "subscription"));
+    case "subscription-invoice:refund":
+      return refundSubscriptionInvoice(http, requireId(args, "subscription-invoice"), args.body);
+    case "subscription-invoice:generate-invoice":
+      return generateSubscriptionInvoice(http, requireId(args, "subscription-invoice"), args.body);
+    case "usage-record:get":
+      return getUsageRecord(http, requireId(args, "usage-record"));
+    case "usage-record:list":
+      return listUsageRecordsForSubscriptionItem(http, requireParent(args, "subscription-item"));
+    case "usage-record:create":
+      return createUsageRecord(http, requireBody(args));
+    case "discount:get":
+      return getDiscount(http, requireId(args, "discount"));
+    case "discount:list":
+      return listDiscountsForStore(http, requireStore(args));
+    case "discount:create":
+      return createDiscount(http, requireBody(args));
+    case "discount:delete":
+      await deleteDiscount(http, requireId(args, "discount"));
+      return void 0;
+    case "discount-redemption:get":
+      return getDiscountRedemption(http, requireId(args, "discount-redemption"));
+    case "discount-redemption:list":
+      return listDiscountRedemptionsForDiscount(http, requireParent(args, "discount"));
+    case "license-key:get":
+      return getLicenseKey(http, requireId(args, "license-key"));
+    case "license-key:list":
+      return listLicenseKeysForStore(http, requireStore(args));
+    case "license-key:update":
+      return updateLicenseKey(http, requireId(args, "license-key"), requireBody(args));
+    case "license-key-instance:get":
+      return getLicenseKeyInstance(http, requireId(args, "license-key-instance"));
+    case "license-key-instance:list":
+      return listLicenseKeyInstancesForLicenseKey(http, requireParent(args, "license-key"));
+    case "checkout:get":
+      return getCheckout(http, requireId(args, "checkout"));
+    case "checkout:list":
+      return listCheckoutsForStore(http, requireStore(args));
+    case "checkout:create":
+      return createCheckout(http, requireBody(args));
+    case "webhook:get":
+      return getWebhook(http, requireId(args, "webhook"));
+    case "webhook:list":
+      return listWebhooksForStore(http, requireStore(args));
+    case "webhook:create":
+      return createWebhook(http, requireBody(args));
+    case "webhook:update":
+      return updateWebhook(http, requireId(args, "webhook"), requireBody(args));
+    case "webhook:delete":
+      await deleteWebhook(http, requireId(args, "webhook"));
+      return void 0;
+    case "affiliate:get":
+      return getAffiliate(http, requireId(args, "affiliate"));
+    case "affiliate:list":
+      return listAffiliatesForStore(http, requireStore(args));
+    default:
+      throw new FreshSqueezyError({
+        code: "UNKNOWN_OP",
+        message: `Op registered but not wired: ${key}`
+      });
+  }
+};
+var requireId = (args, label) => {
+  if (args.id === void 0 || args.id === "") {
+    throw new FreshSqueezyError({
+      code: "MISSING_ARG",
+      message: `--id is required for this ${label} operation.`
+    });
+  }
+  return args.id;
+};
+var requireStore = (args) => {
+  if (args.storeId === void 0 || args.storeId === "") {
+    throw new FreshSqueezyError({
+      code: "MISSING_ARG",
+      message: "--store-ids (or store id) is required for this list operation."
+    });
+  }
+  return args.storeId;
+};
+var requireParent = (args, label) => {
+  if (args.parentId === void 0 || args.parentId === "") {
+    throw new FreshSqueezyError({
+      code: "MISSING_ARG",
+      message: `--parent-id (${label} id) is required for this list operation.`
+    });
+  }
+  return args.parentId;
+};
+var requireBody = (args) => {
+  if (args.body === void 0) {
+    throw new FreshSqueezyError({
+      code: "MISSING_ARG",
+      message: "A JSON body is required (--body, --body-file, or stdin)."
+    });
+  }
+  return args.body;
+};
+
+// src/core/mode.ts
+var resolveActualMode = (testMode) => {
+  if (testMode === true) return "test";
+  if (testMode === false) return "live";
+  return void 0;
+};
 
 // src/validate/rules.ts
 var ISSUE_CODES = {
@@ -308,16 +1240,16 @@ var ISSUE_CODES = {
   NETWORK_ERROR: "NETWORK_ERROR",
   UNKNOWN: "UNKNOWN"
 };
-function issue(code, severity, message, extras = {}) {
+var issue = (code, severity, message, extras = {}) => {
   const base = { code, severity, message };
   if (extras.suggestedFix !== void 0) base.suggestedFix = extras.suggestedFix;
   if (extras.context !== void 0) base.context = extras.context;
   return base;
-}
-function isOk(issues) {
+};
+var isOk = (issues) => {
   return !issues.some((entry) => entry.severity === "error");
-}
-function buildResult(name, mode, issues, resource, target) {
+};
+var buildResult = (name, mode, issues, resource, target) => {
   const result = {
     name,
     ok: isOk(issues),
@@ -327,10 +1259,10 @@ function buildResult(name, mode, issues, resource, target) {
   if (resource !== void 0) result.resource = resource;
   if (target !== void 0) result.target = target;
   return result;
-}
+};
 
 // src/validate/probe.ts
-function mapErrorToIssue(err, mapping = {}) {
+var mapErrorToIssue = (err, mapping = {}) => {
   if (err instanceof FreshSqueezyError) {
     if (mapping.unauthorized && (err.status === 401 || err.code === "UNAUTHORIZED")) {
       return issue(mapping.unauthorized.code, "error", mapping.unauthorized.message, {
@@ -357,8 +1289,8 @@ function mapErrorToIssue(err, mapping = {}) {
   }
   const message = err instanceof Error ? err.message : "Unknown error";
   return issue(ISSUE_CODES.UNKNOWN, "error", message);
-}
-async function probeFetch(fetcher, options) {
+};
+var probeFetch = async (fetcher, options) => {
   return probeCollection(fetcher, {
     notFound: {
       code: options.notFoundCode,
@@ -367,15 +1299,15 @@ async function probeFetch(fetcher, options) {
       ...options.notFoundContext !== void 0 ? { context: options.notFoundContext } : {}
     }
   });
-}
-async function probeCollection(fetcher, mapping = {}) {
+};
+var probeCollection = async (fetcher, mapping = {}) => {
   try {
     return { ok: true, resource: await fetcher() };
   } catch (err) {
     return { ok: false, issue: mapErrorToIssue(err, mapping) };
   }
-}
-function checkStoreOwnership(check) {
+};
+var checkStoreOwnership = (check) => {
   const expected = String(check.expectedStoreId);
   const actual = String(check.actualStoreId);
   if (expected === actual) return null;
@@ -393,10 +1325,10 @@ function checkStoreOwnership(check) {
       context
     }
   );
-}
+};
 
 // src/validate/connection.ts
-async function validateConnection(http, mode) {
+var validateConnection = async (http, mode) => {
   const issues = [];
   const fetched = await probeCollection(
     async () => {
@@ -449,19 +1381,14 @@ async function validateConnection(http, mode) {
     );
   }
   return buildResult("connection", mode, issues, summary);
-}
-async function fetchActualMode(http) {
+};
+var fetchActualMode = async (http) => {
   const doc = await getAuthenticatedUser(http);
   return resolveActualMode(doc.meta?.test_mode);
-}
-
-// src/resources/discounts.ts
-async function getDiscount(http, discountId) {
-  return http.getResource(`/v1/discounts/${discountId}`);
-}
+};
 
 // src/validate/discount.ts
-async function validateDiscount(http, mode, options) {
+var validateDiscount = async (http, mode, options) => {
   const issues = [];
   const fetched = await probeFetch(() => getDiscount(http, options.discountId), {
     notFoundCode: ISSUE_CODES.DISCOUNT_NOT_FOUND,
@@ -482,8 +1409,8 @@ async function validateDiscount(http, mode, options) {
     label: `${attrs.name} (${attrs.code})`,
     id: String(options.discountId)
   });
-}
-function checkDiscount(attrs, options) {
+};
+var checkDiscount = (attrs, options) => {
   const issues = [];
   const mismatch = checkStoreOwnership({
     expectedStoreId: options.storeId,
@@ -572,15 +1499,10 @@ function checkDiscount(attrs, options) {
     );
   }
   return issues;
-}
-
-// src/resources/licenseKeys.ts
-async function getLicenseKey(http, licenseKeyId) {
-  return http.getResource(`/v1/license-keys/${licenseKeyId}`);
-}
+};
 
 // src/validate/licenseKey.ts
-async function validateLicenseKey(http, mode, options) {
+var validateLicenseKey = async (http, mode, options) => {
   const issues = [];
   const fetched = await probeFetch(() => getLicenseKey(http, options.licenseKeyId), {
     notFoundCode: ISSUE_CODES.LICENSE_KEY_NOT_FOUND,
@@ -601,8 +1523,8 @@ async function validateLicenseKey(http, mode, options) {
     label: attrs.key_short,
     id: String(options.licenseKeyId)
   });
-}
-function checkLicenseKey(attrs, options) {
+};
+var checkLicenseKey = (attrs, options) => {
   const issues = [];
   const mismatch = checkStoreOwnership({
     expectedStoreId: options.storeId,
@@ -656,30 +1578,10 @@ function checkLicenseKey(attrs, options) {
     );
   }
   return issues;
-}
-
-// src/resources/products.ts
-async function getProduct(http, productId) {
-  return http.getResource(`/v1/products/${productId}`);
-}
-async function listProducts(http, storeId) {
-  return http.paginate("/v1/products", {
-    "filter[store_id]": String(storeId)
-  });
-}
-
-// src/resources/variants.ts
-async function getVariant(http, variantId) {
-  return http.getResource(`/v1/variants/${variantId}`);
-}
-async function listVariantsForProduct(http, productId) {
-  return http.paginate("/v1/variants", {
-    "filter[product_id]": String(productId)
-  });
-}
+};
 
 // src/validate/product.ts
-async function validateProduct(http, mode, options) {
+var validateProduct = async (http, mode, options) => {
   const issues = [];
   const fetched = await probeFetch(() => getProduct(http, options.productId), {
     notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
@@ -725,8 +1627,8 @@ async function validateProduct(http, mode, options) {
     label: attrs.name,
     id: String(options.productId)
   });
-}
-function checkProduct(attrs, options = {}) {
+};
+var checkProduct = (attrs, options = {}) => {
   const issues = [];
   if (options.expectedStoreId !== void 0) {
     const mismatch = checkStoreOwnership({
@@ -762,10 +1664,10 @@ function checkProduct(attrs, options = {}) {
     );
   }
   return issues;
-}
+};
 
 // src/validate/store.ts
-async function validateStore(http, mode, storeId) {
+var validateStore = async (http, mode, storeId) => {
   const issues = [];
   const fetched = await probeFetch(() => getStore(http, storeId), {
     notFoundCode: ISSUE_CODES.STORE_NOT_FOUND,
@@ -784,11 +1686,11 @@ async function validateStore(http, mode, storeId) {
     label: fetched.resource.attributes.name,
     id: String(storeId)
   });
-}
+};
 
 // src/validate/subscriptionPlan.ts
 var VALID_INTERVALS = /* @__PURE__ */ new Set(["day", "week", "month", "year"]);
-async function validateSubscriptionPlan(http, mode, options) {
+var validateSubscriptionPlan = async (http, mode, options) => {
   const issues = [];
   const fetched = await probeFetch(
     () => getVariant(http, options.variantId),
@@ -834,8 +1736,8 @@ async function validateSubscriptionPlan(http, mode, options) {
     label: attrs.name,
     id: String(options.variantId)
   });
-}
-function checkSubscriptionPlan(attrs, options) {
+};
+var checkSubscriptionPlan = (attrs, options) => {
   const issues = [];
   if (!attrs.is_subscription) {
     issues.push(
@@ -919,22 +1821,15 @@ function checkSubscriptionPlan(attrs, options) {
     );
   }
   return issues;
-}
+};
 
 // src/core/equality.ts
-function sameWebhookUrl(a, b) {
+var sameWebhookUrl = (a, b) => {
   return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
-}
-function normalizeWebhookUrl(raw) {
+};
+var normalizeWebhookUrl = (raw) => {
   return raw.replace(/\/+$/, "").toLowerCase();
-}
-
-// src/resources/webhooks.ts
-async function listWebhooksForStore(http, storeId) {
-  return http.paginate("/v1/webhooks", {
-    "filter[store_id]": String(storeId)
-  });
-}
+};
 
 // src/generated/lemonSqueezyApiTypes.ts
 var GENERATED_LEMON_SQUEEZY_RESOURCES = [
@@ -1110,7 +2005,7 @@ var ACKNOWLEDGED_CHANGELOG_ENTRIES = [
 ];
 
 // src/validate/webhook.ts
-async function validateWebhook(http, mode, options) {
+var validateWebhook = async (http, mode, options) => {
   const issues = [];
   const fetched = await probeCollection(() => listWebhooksForStore(http, options.storeId));
   if (!fetched.ok) {
@@ -1170,7 +2065,7 @@ async function validateWebhook(http, mode, options) {
     id: match.id,
     url: match.attributes.url
   });
-}
+};
 
 // src/validate/doctor.ts
 var DEFAULT_VALIDATORS = {
@@ -1182,7 +2077,7 @@ var DEFAULT_VALIDATORS = {
   licenseKey: validateLicenseKey,
   subscriptionPlan: validateSubscriptionPlan
 };
-async function doctor(http, mode, options = {}, validators = DEFAULT_VALIDATORS) {
+var doctor = async (http, mode, options = {}, validators = DEFAULT_VALIDATORS) => {
   assertOptionsCoherent(options);
   const results = [];
   const productIds = collectValues(options.productId, options.productIds);
@@ -1248,8 +2143,8 @@ async function doctor(http, mode, options = {}, validators = DEFAULT_VALIDATORS)
   }
   const ok = results.every((result) => result.ok);
   return { ok, mode, results };
-}
-function assertOptionsCoherent(options) {
+};
+var assertOptionsCoherent = (options) => {
   if (options.storeId !== void 0) return;
   const dependent = [];
   if (hasAny(options.webhookUrl, options.webhookUrls)) dependent.push("webhookUrl");
@@ -1261,23 +2156,24 @@ function assertOptionsCoherent(options) {
     code: "DOCTOR_OPTIONS_INVALID",
     message: `doctor() received ${dependent.join(", ")} without storeId. These validators cannot run without a store; pass \`storeId\` or remove the dependent options.`
   });
-}
-function collectValues(single, many) {
+};
+var collectValues = (single, many) => {
   const values = /* @__PURE__ */ new Set();
   if (single !== void 0) values.add(single);
   for (const value of many ?? []) {
     if (value !== void 0) values.add(value);
   }
   return Array.from(values);
-}
-function hasAny(single, many) {
+};
+var hasAny = (single, many) => {
   return single !== void 0 || (many?.length ?? 0) > 0;
-}
+};
 
 // src/createFreshSqueezy.ts
-function createFreshSqueezy(config = {}) {
+var createFreshSqueezy = (config = {}) => {
   const resolved = resolveConfig(config);
   const http = new HttpClient(resolved);
+  const op = (resource, verb, args = {}) => invokeOp(http, resource, verb, args);
   return {
     mode: resolved.mode,
     request: (options) => http.request(options),
@@ -1300,141 +2196,106 @@ function createFreshSqueezy(config = {}) {
       licenseKeyIds: options?.licenseKeyIds,
       variantId: options?.variantId,
       variantIds: options?.variantIds
-    })
-  };
-}
-
-// src/resources/affiliates.ts
-async function getAffiliate(http, affiliateId) {
-  return http.getResource(`/v1/affiliates/${affiliateId}`);
-}
-async function listAffiliatesForStore(http, storeId) {
-  return http.paginate("/v1/affiliates", {
-    "filter[store_id]": String(storeId)
-  });
-}
-
-// src/resources/checkouts.ts
-async function getCheckout(http, checkoutId) {
-  return http.getResource(`/v1/checkouts/${checkoutId}`);
-}
-async function listCheckoutsForStore(http, storeId) {
-  return http.paginate("/v1/checkouts", {
-    "filter[store_id]": String(storeId)
-  });
-}
-
-// src/resources/customers.ts
-async function getCustomer(http, customerId) {
-  return http.getResource(`/v1/customers/${customerId}`);
-}
-async function listCustomersForStore(http, storeId) {
-  return http.paginate("/v1/customers", {
-    "filter[store_id]": String(storeId)
-  });
-}
-
-// src/resources/discountRedemptions.ts
-async function getDiscountRedemption(http, discountRedemptionId) {
-  return http.getResource(
-    `/v1/discount-redemptions/${discountRedemptionId}`
-  );
-}
-async function listDiscountRedemptionsForDiscount(http, discountId) {
-  return http.paginate("/v1/discount-redemptions", {
-    "filter[discount_id]": String(discountId)
-  });
-}
-
-// src/resources/files.ts
-async function getFile(http, fileId) {
-  return http.getResource(`/v1/files/${fileId}`);
-}
-async function listFilesForVariant(http, variantId) {
-  return http.paginate("/v1/files", {
-    "filter[variant_id]": String(variantId)
-  });
-}
-
-// src/resources/licenseKeyInstances.ts
-async function getLicenseKeyInstance(http, licenseKeyInstanceId) {
-  return http.getResource(
-    `/v1/license-key-instances/${licenseKeyInstanceId}`
-  );
-}
-async function listLicenseKeyInstancesForLicenseKey(http, licenseKeyId) {
-  return http.paginate("/v1/license-key-instances", {
-    "filter[license_key_id]": String(licenseKeyId)
-  });
-}
-
-// src/resources/orderItems.ts
-async function getOrderItem(http, orderItemId) {
-  return http.getResource(`/v1/order-items/${orderItemId}`);
-}
-async function listOrderItemsForOrder(http, orderId) {
-  return http.paginate("/v1/order-items", {
-    "filter[order_id]": String(orderId)
-  });
-}
-
-// src/resources/orders.ts
-async function getOrder(http, orderId) {
-  return http.getResource(`/v1/orders/${orderId}`);
-}
-
-// src/resources/prices.ts
-async function getPrice(http, priceId) {
-  return http.getResource(`/v1/prices/${priceId}`);
-}
-
-// src/resources/subscriptions.ts
-async function getSubscription(http, subscriptionId) {
-  return http.getResource(`/v1/subscriptions/${subscriptionId}`);
-}
-
-// src/resources/subscriptionInvoices.ts
-async function getSubscriptionInvoice(http, subscriptionInvoiceId) {
-  return http.getResource(
-    `/v1/subscription-invoices/${subscriptionInvoiceId}`
-  );
-}
-async function listSubscriptionInvoicesForSubscription(http, subscriptionId) {
-  return http.paginate("/v1/subscription-invoices", {
-    "filter[subscription_id]": String(subscriptionId)
-  });
-}
-
-// src/resources/subscriptionItems.ts
-async function getSubscriptionItem(http, subscriptionItemId) {
-  return http.getResource(
-    `/v1/subscription-items/${subscriptionItemId}`
-  );
-}
-async function listSubscriptionItemsForSubscription(http, subscriptionId) {
-  return http.paginate("/v1/subscription-items", {
-    "filter[subscription_id]": String(subscriptionId)
-  });
-}
-function buildSubscriptionItemUpdateBody(subscriptionItemId, attributes) {
-  return {
-    data: {
-      type: "subscription-items",
-      id: String(subscriptionItemId),
-      attributes
+    }),
+    users: {
+      me: () => op("user", "get")
+    },
+    stores: {
+      get: (id) => op("store", "get", { id }),
+      list: () => op("store", "list")
+    },
+    products: {
+      get: (id) => op("product", "get", { id }),
+      list: (storeId) => op("product", "list", { storeId })
+    },
+    variants: {
+      get: (id) => op("variant", "get", { id }),
+      list: (productId) => op("variant", "list", { parentId: productId })
+    },
+    prices: {
+      get: (id) => op("price", "get", { id }),
+      list: (variantId) => op("price", "list", { parentId: variantId })
+    },
+    files: {
+      get: (id) => op("file", "get", { id }),
+      list: (variantId) => op("file", "list", { parentId: variantId })
+    },
+    customers: {
+      get: (id) => op("customer", "get", { id }),
+      list: (storeId) => op("customer", "list", { storeId }),
+      create: (body) => op("customer", "create", { body }),
+      update: (id, body) => op("customer", "update", { id, body })
+    },
+    orders: {
+      get: (id) => op("order", "get", { id }),
+      list: (storeId) => op("order", "list", { storeId }),
+      refund: (id, body) => op("order", "refund", { id, body }),
+      generateInvoice: (id, body) => op("order", "generate-invoice", { id, body })
+    },
+    orderItems: {
+      get: (id) => op("order-item", "get", { id }),
+      list: (orderId) => op("order-item", "list", { parentId: orderId })
+    },
+    subscriptions: {
+      get: (id) => op("subscription", "get", { id }),
+      list: (storeId) => op("subscription", "list", { storeId }),
+      update: (id, body) => op("subscription", "update", { id, body }),
+      cancel: (id) => op("subscription", "cancel", { id })
+    },
+    subscriptionItems: {
+      get: (id) => op("subscription-item", "get", { id }),
+      list: (subscriptionId) => op("subscription-item", "list", { parentId: subscriptionId }),
+      update: (id, body) => op("subscription-item", "update", { id, body }),
+      currentUsage: (id) => op("subscription-item", "current-usage", { id })
+    },
+    subscriptionInvoices: {
+      get: (id) => op("subscription-invoice", "get", { id }),
+      list: (subscriptionId) => op("subscription-invoice", "list", { parentId: subscriptionId }),
+      refund: (id, body) => op("subscription-invoice", "refund", { id, body }),
+      generateInvoice: (id, body) => op("subscription-invoice", "generate-invoice", { id, body })
+    },
+    usageRecords: {
+      get: (id) => op("usage-record", "get", { id }),
+      list: (subscriptionItemId) => op("usage-record", "list", { parentId: subscriptionItemId }),
+      create: (body) => op("usage-record", "create", { body })
+    },
+    discounts: {
+      get: (id) => op("discount", "get", { id }),
+      list: (storeId) => op("discount", "list", { storeId }),
+      create: (body) => op("discount", "create", { body }),
+      delete: (id) => op("discount", "delete", { id })
+    },
+    discountRedemptions: {
+      get: (id) => op("discount-redemption", "get", { id }),
+      list: (discountId) => op("discount-redemption", "list", { parentId: discountId })
+    },
+    licenseKeys: {
+      get: (id) => op("license-key", "get", { id }),
+      list: (storeId) => op("license-key", "list", { storeId }),
+      update: (id, body) => op("license-key", "update", { id, body })
+    },
+    licenseKeyInstances: {
+      get: (id) => op("license-key-instance", "get", { id }),
+      list: (licenseKeyId) => op("license-key-instance", "list", { parentId: licenseKeyId })
+    },
+    checkouts: {
+      get: (id) => op("checkout", "get", { id }),
+      list: (storeId) => op("checkout", "list", { storeId }),
+      create: (body) => op("checkout", "create", { body })
+    },
+    webhooks: {
+      get: (id) => op("webhook", "get", { id }),
+      list: (storeId) => op("webhook", "list", { storeId }),
+      create: (body) => op("webhook", "create", { body }),
+      update: (id, body) => op("webhook", "update", { id, body }),
+      delete: (id) => op("webhook", "delete", { id })
+    },
+    affiliates: {
+      get: (id) => op("affiliate", "get", { id }),
+      list: (storeId) => op("affiliate", "list", { storeId })
     }
   };
-}
-
-// src/resources/usageRecords.ts
-async function getUsageRecord(http, usageRecordId) {
-  return http.getResource(`/v1/usage-records/${usageRecordId}`);
-}
-async function listUsageRecordsForSubscriptionItem(http, subscriptionItemId) {
-  return http.paginate("/v1/usage-records", {
-    "filter[subscription_item_id]": String(subscriptionItemId)
-  });
-}
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACKNOWLEDGED_CHANGELOG_ENTRIES,
@@ -1449,19 +2310,32 @@ async function listUsageRecordsForSubscriptionItem(http, subscriptionItemId) {
   SUPPORTED_RESOURCES,
   buildResult,
   buildSubscriptionItemUpdateBody,
+  cancelSubscription,
   checkDiscount,
   checkLicenseKey,
   checkProduct,
   checkSubscriptionPlan,
+  createCheckout,
+  createCustomer,
+  createDiscount,
   createFreshSqueezy,
+  createUsageRecord,
+  createWebhook,
+  deleteDiscount,
+  deleteWebhook,
   doctor,
   fetchActualMode,
+  findResourceVerb,
+  generateOrderInvoice,
+  generateSubscriptionInvoice,
   getAffiliate,
   getAuthenticatedUser,
   getCheckout,
   getCustomer,
+  getDiscount,
   getDiscountRedemption,
   getFile,
+  getLicenseKey,
   getLicenseKeyInstance,
   getOrder,
   getOrderItem,
@@ -1471,27 +2345,44 @@ async function listUsageRecordsForSubscriptionItem(http, subscriptionItemId) {
   getSubscription,
   getSubscriptionInvoice,
   getSubscriptionItem,
+  getSubscriptionItemCurrentUsage,
   getUsageRecord,
   getVariant,
+  getWebhook,
+  invokeOp,
   isOk,
   issue,
   listAffiliatesForStore,
   listCheckoutsForStore,
   listCustomersForStore,
   listDiscountRedemptionsForDiscount,
+  listDiscountsForStore,
   listFilesForVariant,
   listLicenseKeyInstancesForLicenseKey,
+  listLicenseKeysForStore,
   listOrderItemsForOrder,
+  listOrdersForStore,
+  listPricesForVariant,
   listProducts,
+  listRegisteredResources,
   listStores,
   listSubscriptionInvoicesForSubscription,
   listSubscriptionItemsForSubscription,
+  listSubscriptionsForStore,
   listUsageRecordsForSubscriptionItem,
   listVariantsForProduct,
   listWebhooksForStore,
+  refundOrder,
+  refundSubscriptionInvoice,
   resolveActualMode,
   resolveConfig,
+  resourceRegistry,
   sameWebhookUrl,
+  updateCustomer,
+  updateLicenseKey,
+  updateSubscription,
+  updateSubscriptionItem,
+  updateWebhook,
   userResource,
   validateConnection,
   validateDiscount,