fresh-squeezy 0.2.0 → 0.3.0

package/dist/index.js

@@ -92,597 +92,95 @@ var normalizeMode = (value) => {
   });
 };
 
-// src/core/equality.ts
-var sameWebhookUrl = (a, b) => {
-  return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
-};
-var normalizeWebhookUrl = (raw) => {
-  return raw.replace(/\/+$/, "").toLowerCase();
-};
-
-// src/core/mode.ts
-var 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/attributes.ts
+var buildSubscriptionItemUpdateBody = (subscriptionItemId, attributes) => {
+  return {
+    data: {
+      type: "subscription-items",
+      id: String(subscriptionItemId),
+      attributes
+    }
+  };
 };
 
 // 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",
+var VERB_RULES = {
+  get: { method: "GET", path: "/{id}", docs: "retrieve-{r}", body: "none" },
+  list: { method: "GET", path: "", docs: "list-all-{r}s", body: "none" },
+  create: { method: "POST", path: "", docs: "create-{r}", body: "required" },
+  update: { method: "PATCH", path: "/{id}", docs: "update-{r}", body: "required" },
+  delete: { method: "DELETE", path: "/{id}", docs: "delete-{r}", body: "none", destructive: true },
+  cancel: { method: "DELETE", path: "/{id}", docs: "cancel-{r}", body: "none", destructive: true },
+  refund: {
+    method: "POST",
+    path: "/{id}/refund",
+    docs: "issue-refund",
     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"
+    destructive: true
   },
-  {
-    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"
+  "generate-invoice": {
+    method: "POST",
+    path: "/{id}/generate-invoice",
+    docs: "generate-{r}-invoice",
+    body: "optional"
+  },
+  "current-usage": {
+    method: "GET",
+    path: "/{id}/current-usage",
+    docs: "retrieve-{r}-current-usage",
+    body: "none"
   }
+};
+var RESOURCES = [
+  ["user", ["get"]],
+  ["store", ["get", "list"]],
+  ["product", ["get", "list"], "store"],
+  ["variant", ["get", "list"], "product"],
+  ["price", ["get", "list"], "variant"],
+  ["file", ["get", "list"], "variant"],
+  ["customer", ["get", "list", "create", "update"], "store"],
+  ["order", ["get", "list", "refund", "generate-invoice"], "store"],
+  ["order-item", ["get", "list"], "order"],
+  ["subscription", ["get", "list", "update", "cancel"], "store"],
+  ["subscription-item", ["get", "list", "update", "current-usage"], "subscription"],
+  ["subscription-invoice", ["get", "list", "refund", "generate-invoice"], "subscription"],
+  ["usage-record", ["get", "list", "create"], "subscription-item"],
+  ["discount", ["get", "list", "create", "delete"], "store"],
+  ["discount-redemption", ["get", "list"], "discount"],
+  ["license-key", ["get", "list", "update"], "store"],
+  ["license-key-instance", ["get", "list"], "license-key"],
+  ["checkout", ["get", "list", "create"], "store"],
+  ["webhook", ["get", "list", "create", "update", "delete"], "store"],
+  ["affiliate", ["get", "list"], "store"]
 ];
-var RESOURCE_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"
+var DOCS_PATH_EXCEPTIONS = {
+  "subscription-invoice:generate-invoice": "subscription-invoices/generate-subscription-invoice"
+};
+var USER_ME_PATH = "/v1/users/me";
+var listIdRole = (listScope) => {
+  if (!listScope) return "none";
+  return listScope === "store" ? "store" : "parent";
+};
+var toSpec = (resource, verb, listScope) => {
+  const rule = VERB_RULES[verb];
+  const docsPath = DOCS_PATH_EXCEPTIONS[`${resource}:${verb}`] ?? `${resource}s/${rule.docs.replaceAll("{r}", resource)}`;
+  let idRole = rule.path.includes("{id}") ? "id" : "none";
+  if (verb === "list") idRole = listIdRole(listScope);
+  if (resource === "user") idRole = "none";
+  return {
+    resource,
+    verb,
+    docsPath,
+    body: rule.body,
+    ...rule.destructive ? { destructive: true } : {},
+    idRole
+  };
 };
+var resourceRegistry = RESOURCES.flatMap(
+  ([resource, verbs, listScope]) => verbs.map((verb) => toSpec(resource, verb, listScope))
+);
 var normalizeResourceName = (resource) => {
   const normalized = resource.replace(/_/g, "-").toLowerCase();
-  if (RESOURCE_ALIASES[normalized]) {
-    return RESOURCE_ALIASES[normalized];
-  }
   if (normalized.endsWith("s") && normalized !== "status") {
     return normalized.slice(0, -1);
   }
@@ -699,280 +197,11 @@ var listRegisteredVerbs = (resource) => {
   const key = normalizeResourceName(resource);
   return resourceRegistry.filter((entry) => entry.resource === key).map((entry) => entry.verb).sort();
 };
-
-// src/resources/stores.ts
-var getStore = async (http, storeId) => {
-  return http.getResource(`/v1/stores/${storeId}`);
-};
-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
-var getAuthenticatedUser = async (http) => {
-  return http.request({ path: "/v1/users/me" });
-};
-
-// 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": {
-      const doc = await getAuthenticatedUser(http);
-      return doc.data;
-    }
-    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) => {
+var requireId = (args, spec) => {
   if (args.id === void 0 || args.id === "") {
     throw new FreshSqueezyError({
       code: "MISSING_ARG",
-      message: `--id is required for this ${label} operation.`
+      message: `--id is required for this ${spec.resource} operation.`
     });
   }
   return args.id;
@@ -986,11 +215,11 @@ var requireStore = (args) => {
   }
   return args.storeId;
 };
-var requireParent = (args, label) => {
+var requireParent = (args, parent) => {
   if (args.parentId === void 0 || args.parentId === "") {
     throw new FreshSqueezyError({
       code: "MISSING_ARG",
-      message: `--parent-id (${label} id) is required for this list operation.`
+      message: `--parent-id (${parent} id) is required for this list operation.`
     });
   }
   return args.parentId;
@@ -1004,8 +233,44 @@ var requireBody = (args) => {
   }
   return args.body;
 };
+var listFilter = (spec, args) => {
+  const listScope = RESOURCES.find(([resource]) => resource === spec.resource)?.[2];
+  if (!listScope) return void 0;
+  const scopeId = listScope === "store" ? requireStore(args) : requireParent(args, listScope);
+  return { [`filter[${listScope.replace(/-/g, "_")}_id]`]: String(scopeId) };
+};
+var requestBody = (rule, args) => {
+  if (rule.body === "required") return requireBody(args);
+  if (rule.body === "optional") return args.body ?? {};
+  return void 0;
+};
+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\`.`
+    });
+  }
+  if (spec.resource === "user") {
+    const doc2 = await http.request({ path: USER_ME_PATH });
+    return doc2.data;
+  }
+  const collectionPath = `/v1/${spec.resource}s`;
+  if (spec.verb === "list") {
+    return http.paginate(collectionPath, listFilter(spec, args));
+  }
+  const rule = VERB_RULES[spec.verb];
+  const path = collectionPath + rule.path.replace("{id}", () => String(requireId(args, spec)));
+  const doc = await http.request({
+    method: rule.method,
+    path,
+    body: requestBody(rule, args)
+  });
+  return doc?.data ?? doc;
+};
 
-// src/validate/rules.ts
+// src/validate/issues.ts
 var ISSUE_CODES = {
   AUTH_FAILED: "AUTH_FAILED",
   MODE_MISMATCH: "MODE_MISMATCH",
@@ -1129,11 +394,19 @@ var checkStoreOwnership = (check) => {
 };
 
 // src/validate/connection.ts
+var resolveActualMode = (testMode) => {
+  if (testMode === true) return "test";
+  if (testMode === false) return "live";
+  return void 0;
+};
+var fetchUserDocument = (http) => {
+  return http.request({ path: "/v1/users/me" });
+};
 var validateConnection = async (http, mode) => {
   const fetched = await probeCollection(
     async () => {
-      const userDoc2 = await getAuthenticatedUser(http);
-      const stores2 = await listStores(http);
+      const userDoc2 = await fetchUserDocument(http);
+      const stores2 = await http.paginate("/v1/stores");
       return { userDoc: userDoc2, stores: stores2 };
     },
     {
@@ -1183,7 +456,7 @@ var validateConnection = async (http, mode) => {
   return buildResult("connection", mode, issues, summary);
 };
 var fetchActualMode = async (http) => {
-  const doc = await getAuthenticatedUser(http);
+  const doc = await fetchUserDocument(http);
   return resolveActualMode(doc.meta?.test_mode);
 };
 
@@ -1193,12 +466,15 @@ var validateDiscount = async (http, mode, options) => {
     label: `discount ${options.discountId}`,
     id: String(options.discountId)
   };
-  const fetched = await probeFetch(() => getDiscount(http, options.discountId), {
-    notFoundCode: ISSUE_CODES.DISCOUNT_NOT_FOUND,
-    notFoundMessage: `Discount ${options.discountId} not found.`,
-    notFoundFix: "Verify the discount ID in the Lemon Squeezy dashboard.",
-    notFoundContext: { discountId: String(options.discountId) }
-  });
+  const fetched = await probeFetch(
+    () => http.getResource(`/v1/discounts/${options.discountId}`),
+    {
+      notFoundCode: ISSUE_CODES.DISCOUNT_NOT_FOUND,
+      notFoundMessage: `Discount ${options.discountId} not found.`,
+      notFoundFix: "Verify the discount ID in the Lemon Squeezy dashboard.",
+      notFoundContext: { discountId: String(options.discountId) }
+    }
+  );
   if (!fetched.ok) {
     return buildResult("discount", mode, [fetched.issue], void 0, target);
   }
@@ -1305,12 +581,15 @@ var validateLicenseKey = async (http, mode, options) => {
     label: `license key ${options.licenseKeyId}`,
     id: String(options.licenseKeyId)
   };
-  const fetched = await probeFetch(() => getLicenseKey(http, options.licenseKeyId), {
-    notFoundCode: ISSUE_CODES.LICENSE_KEY_NOT_FOUND,
-    notFoundMessage: `License key ${options.licenseKeyId} not found.`,
-    notFoundFix: "Verify the license key ID in the Lemon Squeezy dashboard.",
-    notFoundContext: { licenseKeyId: String(options.licenseKeyId) }
-  });
+  const fetched = await probeFetch(
+    () => http.getResource(`/v1/license-keys/${options.licenseKeyId}`),
+    {
+      notFoundCode: ISSUE_CODES.LICENSE_KEY_NOT_FOUND,
+      notFoundMessage: `License key ${options.licenseKeyId} not found.`,
+      notFoundFix: "Verify the license key ID in the Lemon Squeezy dashboard.",
+      notFoundContext: { licenseKeyId: String(options.licenseKeyId) }
+    }
+  );
   if (!fetched.ok) {
     return buildResult(
       "licenseKey",
@@ -1392,19 +671,24 @@ var validateProduct = async (http, mode, options) => {
     label: `product ${options.productId}`,
     id: String(options.productId)
   };
-  const fetched = await probeFetch(() => getProduct(http, options.productId), {
-    notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
-    notFoundMessage: `Product ${options.productId} not found.`,
-    notFoundFix: "Verify the product ID in the Lemon Squeezy dashboard.",
-    notFoundContext: { productId: String(options.productId) }
-  });
+  const fetched = await probeFetch(
+    () => http.getResource(`/v1/products/${options.productId}`),
+    {
+      notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
+      notFoundMessage: `Product ${options.productId} not found.`,
+      notFoundFix: "Verify the product ID in the Lemon Squeezy dashboard.",
+      notFoundContext: { productId: String(options.productId) }
+    }
+  );
   if (!fetched.ok) {
     return buildResult("product", mode, [fetched.issue], void 0, target);
   }
   const attrs = fetched.resource.attributes;
   issues.push(...checkProduct(attrs, { expectedStoreId: options.expectedStoreId }));
   const variantsProbed = await probeCollection(
-    () => listVariantsForProduct(http, options.productId)
+    () => http.paginate("/v1/variants", {
+      "filter[product_id]": String(options.productId)
+    })
   );
   if (!variantsProbed.ok) {
     issues.push({ ...variantsProbed.issue, severity: "warning" });
@@ -1473,12 +757,15 @@ var checkProduct = (attrs, options = {}) => {
 // src/validate/store.ts
 var validateStore = async (http, mode, storeId) => {
   const target = { label: `store ${storeId}`, id: String(storeId) };
-  const fetched = await probeFetch(() => getStore(http, storeId), {
-    notFoundCode: ISSUE_CODES.STORE_NOT_FOUND,
-    notFoundMessage: `Store ${storeId} not found with the current API key.`,
-    notFoundFix: "Check the store ID and confirm the API key belongs to the account that owns it.",
-    notFoundContext: { storeId: String(storeId) }
-  });
+  const fetched = await probeFetch(
+    () => http.getResource(`/v1/stores/${storeId}`),
+    {
+      notFoundCode: ISSUE_CODES.STORE_NOT_FOUND,
+      notFoundMessage: `Store ${storeId} not found with the current API key.`,
+      notFoundFix: "Check the store ID and confirm the API key belongs to the account that owns it.",
+      notFoundContext: { storeId: String(storeId) }
+    }
+  );
   if (!fetched.ok) {
     return buildResult("store", mode, [fetched.issue], void 0, target);
   }
@@ -1496,7 +783,7 @@ var validateSubscriptionPlan = async (http, mode, options) => {
     id: String(options.variantId)
   };
   const fetched = await probeFetch(
-    () => getVariant(http, options.variantId),
+    () => http.getResource(`/v1/variants/${options.variantId}`),
     {
       notFoundCode: ISSUE_CODES.PLAN_VARIANT_NOT_FOUND,
       notFoundMessage: `Variant ${options.variantId} not found.`,
@@ -1516,10 +803,13 @@ var validateSubscriptionPlan = async (http, mode, options) => {
   const variant = fetched.resource;
   const attrs = variant.attributes;
   const issues = checkSubscriptionPlan(attrs, { variantId: options.variantId });
-  const productProbed = await probeFetch(() => getProduct(http, attrs.product_id), {
-    notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
-    notFoundMessage: `Product ${attrs.product_id} not found.`
-  });
+  const productProbed = await probeFetch(
+    () => http.getResource(`/v1/products/${attrs.product_id}`),
+    {
+      notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
+      notFoundMessage: `Product ${attrs.product_id} not found.`
+    }
+  );
   if (productProbed.ok) {
     const mismatch = checkStoreOwnership({
       expectedStoreId: options.storeId,
@@ -1658,7 +948,7 @@ var ACKNOWLEDGED_CHANGELOG_ENTRIES = [
   {
     date: "2025-06-11",
     summary: "Added payment_processor attribute to Subscription objects.",
-    handledBy: "Surfaced as SubscriptionAttributes.payment_processor in src/resources/subscriptions.ts."
+    handledBy: "Surfaced as SubscriptionAttributes.payment_processor in src/resources/attributes.ts."
   },
   {
     date: "2025-01-21",
@@ -1668,12 +958,12 @@ var ACKNOWLEDGED_CHANGELOG_ENTRIES = [
   {
     date: "2024-12-06",
     summary: "Added quantity parameter to OrderItem objects.",
-    handledBy: "OrderItemAttributes.quantity (src/resources/orderItems.ts)."
+    handledBy: "OrderItemAttributes.quantity (src/resources/attributes.ts)."
   },
   {
     date: "2024-09-10",
     summary: "Added fraudulent Order status.",
-    handledBy: "OrderAttributes.status union includes 'fraudulent' (src/resources/orders.ts)."
+    handledBy: "OrderAttributes.status union includes 'fraudulent' (src/resources/attributes.ts)."
   },
   {
     date: "2024-09-04",
@@ -1688,7 +978,7 @@ var ACKNOWLEDGED_CHANGELOG_ENTRIES = [
   {
     date: "2024-06-09",
     summary: "Added links property to Variant objects.",
-    handledBy: "VariantAttributes.links (src/resources/variants.ts)."
+    handledBy: "VariantAttributes.links (src/resources/attributes.ts)."
   },
   {
     date: "2024-05-20",
@@ -1708,7 +998,7 @@ var ACKNOWLEDGED_CHANGELOG_ENTRIES = [
   {
     date: "2024-02-20",
     summary: "Added urls.update_customer_portal to Subscription objects.",
-    handledBy: "SubscriptionUrls.update_customer_portal (src/resources/subscriptions.ts)."
+    handledBy: "SubscriptionUrls.update_customer_portal (src/resources/attributes.ts)."
   },
   {
     date: "2024-02-12",
@@ -1758,9 +1048,19 @@ var ACKNOWLEDGED_CHANGELOG_ENTRIES = [
 ];
 
 // src/validate/webhook.ts
+var sameWebhookUrl = (a, b) => {
+  return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
+};
+var normalizeWebhookUrl = (raw) => {
+  return raw.replace(/\/+$/, "").toLowerCase();
+};
 var validateWebhook = async (http, mode, options) => {
   const target = { label: options.url, url: options.url };
-  const fetched = await probeCollection(() => listWebhooksForStore(http, options.storeId));
+  const fetched = await probeCollection(
+    () => http.paginate("/v1/webhooks", {
+      "filter[store_id]": String(options.storeId)
+    })
+  );
   if (!fetched.ok) {
     return buildResult("webhook", mode, [fetched.issue], void 0, target);
   }
@@ -1945,46 +1245,6 @@ 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
-   * the caller knows the result fits in a single page.
-   */
-  async getCollection(path, query) {
-    const doc = await this.request({ path, query });
-    return doc.data;
-  }
   /**
    * Walk a JSON:API collection across every page and concatenate the
    * results. Lemon Squeezy returns 25 items per page by default; without
@@ -2178,81 +1438,24 @@ export {
   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,
-  getPrice,
-  getProduct,
-  getStore,
-  getSubscription,
-  getSubscriptionInvoice,
-  getSubscriptionItem,
-  getSubscriptionItemCurrentUsage,
-  getUsageRecord,
-  getVariant,
-  getWebhook,
   invokeOp,
   isOk,
   issue,
-  listAffiliatesForStore,
-  listCheckoutsForStore,
-  listCustomersForStore,
-  listDiscountRedemptionsForDiscount,
-  listDiscountsForStore,
-  listFilesForVariant,
-  listLicenseKeyInstancesForLicenseKey,
-  listLicenseKeysForStore,
-  listOrderItemsForOrder,
-  listOrdersForStore,
-  listPricesForVariant,
-  listProducts,
   listRegisteredResources,
   listRegisteredVerbs,
-  listStores,
-  listSubscriptionInvoicesForSubscription,
-  listSubscriptionItemsForSubscription,
-  listSubscriptionsForStore,
-  listUsageRecordsForSubscriptionItem,
-  listVariantsForProduct,
-  listWebhooksForStore,
   normalizeResourceName,
-  refundOrder,
-  refundSubscriptionInvoice,
   resolveActualMode,
   resolveConfig,
   resourceRegistry,
   sameWebhookUrl,
-  updateCustomer,
-  updateLicenseKey,
-  updateSubscription,
-  updateSubscriptionItem,
-  updateWebhook,
   validateConnection,
   validateDiscount,
   validateLicenseKey,