fresh-squeezy 0.1.13 → 0.1.15

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/main.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { Command } from "commander";
 import dotenv from "dotenv";
 
@@ -9,7 +9,7 @@ import dotenv from "dotenv";
 import { existsSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { dirname, resolve } from "path";
-async function runAugmentCommand(options = {}) {
+var runAugmentCommand = async (options = {}) => {
   const cwd = options.cwd ?? process.cwd();
   const outPath = resolve(cwd, options.out ?? "lemonsqueezy.augment.d.ts");
   try {
@@ -37,8 +37,8 @@ async function runAugmentCommand(options = {}) {
 `);
     return 2;
   }
-}
-async function detectFlavour(cwd, force) {
+};
+var detectFlavour = async (cwd, force) => {
   if (force) return "generic";
   const pkgPath = resolve(cwd, "package.json");
   if (!existsSync(pkgPath)) return "generic";
@@ -50,8 +50,8 @@ async function detectFlavour(cwd, force) {
     ...pkg.peerDependencies ?? {}
   };
   return "@lemonsqueezy/lemonsqueezy.js" in deps ? "with-sdk" : "generic";
-}
-function renderAugmentationFile(flavour) {
+};
+var renderAugmentationFile = (flavour) => {
   const header = `/**
  * Generated by \`fresh-squeezy types:augment\` \u2014 re-run after upgrading
  * fresh-squeezy to refresh the field set.
@@ -215,7 +215,7 @@ export type {
  * }
  */
 `;
-}
+};
 
 // src/core/errors.ts
 var FreshSqueezyError = class _FreshSqueezyError extends Error {
@@ -239,7 +239,7 @@ var ENV_KEYS = {
   storeId: "LEMON_SQUEEZY_STORE_ID",
   mode: "LEMON_SQUEEZY_MODE"
 };
-function resolveConfig(input2 = {}) {
+var resolveConfig = (input2 = {}) => {
   const apiKey = input2.apiKey ?? process.env[ENV_KEYS.apiKey];
   if (!apiKey) {
     throw new FreshSqueezyError({
@@ -256,14 +256,14 @@ function resolveConfig(input2 = {}) {
     baseUrl: input2.baseUrl ?? DEFAULT_BASE_URL,
     fetch: input2.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 {
@@ -309,6 +309,37 @@ var HttpClient = class {
     const doc = await this.request({ path: path4 });
     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(path4, body) {
+    const doc = await this.request({ method: "POST", path: path4, 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(path4, body) {
+    const doc = await this.request({ method: "PATCH", path: path4, 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(path4) {
+    await this.request({ method: "DELETE", path: path4 });
+  }
   /**
    * Fetch a single page of a JSON:API collection. Most callers want
    * `paginate()` instead — this method is kept for one-shot lookups where
@@ -356,48 +387,913 @@ 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 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" });
-}
+};
+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 = {
@@ -436,16 +1332,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),
@@ -455,10 +1351,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, {
@@ -485,8 +1381,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,
@@ -495,15 +1391,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;
@@ -521,10 +1417,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 () => {
@@ -577,15 +1473,10 @@ async function validateConnection(http, mode) {
     );
   }
   return buildResult("connection", mode, issues, summary);
-}
-
-// 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,
@@ -606,8 +1497,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,
@@ -696,15 +1587,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,
@@ -725,8 +1611,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,
@@ -780,25 +1666,10 @@ function checkLicenseKey(attrs, options) {
     );
   }
   return issues;
-}
-
-// src/resources/products.ts
-async function getProduct(http, productId) {
-  return http.getResource(`/v1/products/${productId}`);
-}
-
-// 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,
@@ -844,8 +1715,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({
@@ -881,10 +1752,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,
@@ -903,11 +1774,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),
@@ -953,8 +1824,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(
@@ -1038,22 +1909,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/support/manifest.ts
 var RECOMMENDED_WEBHOOK_EVENTS = [
@@ -1075,7 +1939,7 @@ var OPTIONAL_WEBHOOK_EVENTS = [
 ];
 
 // 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) {
@@ -1135,7 +1999,7 @@ async function validateWebhook(http, mode, options) {
     id: match.id,
     url: match.attributes.url
   });
-}
+};
 
 // src/validate/doctor.ts
 var DEFAULT_VALIDATORS = {
@@ -1147,7 +2011,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);
@@ -1213,8 +2077,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");
@@ -1226,23 +2090,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 values2 = /* @__PURE__ */ new Set();
   if (single !== void 0) values2.add(single);
   for (const value of many ?? []) {
     if (value !== void 0) values2.add(value);
   }
   return Array.from(values2);
-}
-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),
@@ -1265,12 +2130,109 @@ function createFreshSqueezy(config = {}) {
       licenseKeyIds: options?.licenseKeyIds,
       variantId: options?.variantId,
       variantIds: options?.variantIds
-    })
+    }),
+    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/cli/errors.ts
-function renderCliError(message, hints = []) {
+var renderCliError = (message, hints = []) => {
   const lines = [`fresh-squeezy: ${message}`];
   if (hints.length > 0) {
     lines.push("", "Try:");
@@ -1280,8 +2242,8 @@ function renderCliError(message, hints = []) {
   }
   return `${lines.join("\n")}
 `;
-}
-function getDoctorHints(err) {
+};
+var getDoctorHints = (err) => {
   if (!isFreshSqueezyError(err)) return [];
   if (err.code === "MISSING_API_KEY") {
     return ["fresh-squeezy init", `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`];
@@ -1293,8 +2255,8 @@ function getDoctorHints(err) {
     return ["Check that the API key belongs to an account with a Lemon Squeezy store."];
   }
   return [];
-}
-function getValidateHints(err, target) {
+};
+var getValidateHints = (err, target) => {
   if (!isFreshSqueezyError(err)) return [];
   if (err.code === "MISSING_API_KEY") {
     return ["fresh-squeezy init", `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`];
@@ -1309,8 +2271,8 @@ function getValidateHints(err, target) {
     return getMissingArgHints(target);
   }
   return [];
-}
-function getMissingArgHints(target) {
+};
+var getMissingArgHints = (target) => {
   if (target === "connection") {
     return ["fresh-squeezy validate connection"];
   }
@@ -1336,14 +2298,14 @@ function getMissingArgHints(target) {
     return ["fresh-squeezy validate license-key --store-ids 12 --license-key-id 123"];
   }
   return ["fresh-squeezy validate subscription-plan --store-ids 12 --variant-id 123"];
-}
-function isFreshSqueezyError(err) {
+};
+var isFreshSqueezyError = (err) => {
   return err instanceof FreshSqueezyError;
-}
+};
 
 // src/cli/render.ts
 import chalk from "chalk";
-function renderResult(result) {
+var renderResult = (result) => {
   const lines = [];
   const badge = result.ok ? chalk.green("PASS") : chalk.red("FAIL");
   const mode = chalk.dim(`[${result.mode}]`);
@@ -1357,15 +2319,15 @@ function renderResult(result) {
     }
   }
   return lines.join("\n");
-}
-function renderTarget(target) {
+};
+var renderTarget = (target) => {
   if (!target) return "";
   const parts = [target.label];
   if (target.id) parts.push(`id ${target.id}`);
   if (target.url && target.url !== target.label) parts.push(target.url);
   return parts.join(" - ");
-}
-function renderReport(report) {
+};
+var renderReport = (report) => {
   const header = report.ok ? chalk.green.bold("fresh-squeezy doctor: OK") : chalk.red.bold("fresh-squeezy doctor: FAILED");
   const failed = report.results.filter((result) => !result.ok).length;
   const summary = failed === 0 ? chalk.dim(`${report.results.length} checks passed`) : chalk.dim(`${failed}/${report.results.length} checks failed`);
@@ -1374,11 +2336,11 @@ function renderReport(report) {
 ${summary}
 
 ${body}`;
-}
-function renderIssueLine(issue2) {
+};
+var renderIssueLine = (issue2) => {
   const label = issue2.severity === "error" ? chalk.red("\u2717 error") : issue2.severity === "warning" ? chalk.yellow("! warn ") : chalk.blue("i info ");
   return `${label} ${chalk.gray(`[${issue2.code}]`)} ${issue2.message}`;
-}
+};
 
 // src/cli/prompts.ts
 import path from "path";
@@ -1392,7 +2354,7 @@ var EMPTY_INIT_RESOURCE_CHOICES = {
   licenseKeys: { choices: [] },
   subscriptionPlans: { choices: [] }
 };
-async function discoverInitResourceChoices(client, storeId, targets) {
+var discoverInitResourceChoices = async (client, storeId, targets) => {
   const choices = {
     products: { choices: [] },
     webhooks: { choices: [] },
@@ -1439,8 +2401,8 @@ async function discoverInitResourceChoices(client, storeId, targets) {
     }
   }
   return choices;
-}
-async function discoverSubscriptionPlans(client, products) {
+};
+var discoverSubscriptionPlans = async (client, products) => {
   const discovered = [];
   for (const product of products) {
     const result = await discover(
@@ -1458,8 +2420,8 @@ async function discoverSubscriptionPlans(client, products) {
     }
   }
   return { choices: discovered };
-}
-async function paginate(client, path4, query) {
+};
+var paginate = async (client, path4, query) => {
   const all = [];
   let pageNumber = Number(query?.["page[number]"] ?? 1);
   while (true) {
@@ -1472,45 +2434,45 @@ async function paginate(client, path4, query) {
     if (lastPage === void 0 || pageNumber >= lastPage) return all;
     pageNumber += 1;
   }
-}
-async function discover(load) {
+};
+var discover = async (load) => {
   try {
     return { ok: true, value: await load() };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
-}
-function toProductChoice(product) {
+};
+var toProductChoice = (product) => {
   return {
     value: product.id,
     label: `${product.attributes.name} (${product.attributes.status}) - id ${product.id}`
   };
-}
-function toWebhookChoice(webhook) {
+};
+var toWebhookChoice = (webhook) => {
   return {
     value: webhook.attributes.url,
     label: `${webhook.attributes.url} - id ${webhook.id}`
   };
-}
-function toDiscountChoice(discount) {
+};
+var toDiscountChoice = (discount) => {
   return {
     value: discount.id,
     label: `${discount.attributes.name} (${discount.attributes.code}) - id ${discount.id}`
   };
-}
-function toLicenseKeyChoice(licenseKey) {
+};
+var toLicenseKeyChoice = (licenseKey) => {
   return {
     value: licenseKey.id,
     label: `${licenseKey.attributes.key_short} (${licenseKey.attributes.status}) - id ${licenseKey.id}`
   };
-}
-function toSubscriptionPlanChoice(variant, productName) {
+};
+var toSubscriptionPlanChoice = (variant, productName) => {
   const interval = variant.attributes.interval ? `${variant.attributes.interval_count ?? 1}/${variant.attributes.interval}` : "no interval";
   return {
     value: variant.id,
     label: `${productName} / ${variant.attributes.name} (${interval}) - id ${variant.id}`
   };
-}
+};
 
 // src/cli/prompts.ts
 var PROMPT_THEME = {
@@ -1519,7 +2481,7 @@ var PROMPT_THEME = {
     done: "\u2713"
   }
 };
-async function pickLauncherAction() {
+var pickLauncherAction = async () => {
   return select({
     message: "What do you want to do?",
     theme: PROMPT_THEME,
@@ -1542,8 +2504,8 @@ async function pickLauncherAction() {
       }
     ]
   });
-}
-async function askForApiKey() {
+};
+var askForApiKey = async () => {
   const apiKey = await password({
     message: "Paste your Lemon Squeezy API key:",
     mask: false,
@@ -1551,8 +2513,8 @@ async function askForApiKey() {
     validate: (value) => value.trim().length > 0 ? true : "API key is required."
   });
   return { apiKey: apiKey.trim() };
-}
-async function pickStore(choices) {
+};
+var pickStore = async (choices) => {
   return select({
     message: "Pick a store to validate against:",
     theme: PROMPT_THEME,
@@ -1561,8 +2523,8 @@ async function pickStore(choices) {
       value: entry.id
     }))
   });
-}
-async function pickStores(choices) {
+};
+var pickStores = async (choices) => {
   return checkbox({
     message: "Pick one or more stores (space to toggle, enter to confirm):",
     theme: PROMPT_THEME,
@@ -1573,8 +2535,8 @@ async function pickStores(choices) {
     })),
     validate: (selected) => selected.length > 0 ? true : "Pick at least one store."
   });
-}
-async function selectDoctorTargets() {
+};
+var selectDoctorTargets = async () => {
   return checkbox({
     message: "Add resource checks to this doctor run?",
     theme: PROMPT_THEME,
@@ -1586,8 +2548,8 @@ async function selectDoctorTargets() {
       { name: "Subscription plan", value: "subscription-plan" }
     ]
   });
-}
-async function askForDoctorTargetValues(targets, choices = EMPTY_INIT_RESOURCE_CHOICES) {
+};
+var askForDoctorTargetValues = async (targets, choices = EMPTY_INIT_RESOURCE_CHOICES) => {
   if (targets.length === 0) return {};
   const answers = {};
   const manualQuestions = [];
@@ -1665,22 +2627,29 @@ async function askForDoctorTargetValues(targets, choices = EMPTY_INIT_RESOURCE_C
     licenseKeyIds: cleanList(answers.licenseKeyIds),
     variantIds: cleanList(answers.variantIds)
   };
-}
-async function confirmLiveModeRun() {
+};
+var confirmLiveModeRun = async () => {
   return confirm({
     message: "This is a live-mode key. Continue with live checks?",
     default: false,
     theme: PROMPT_THEME
   });
-}
-async function confirmWriteEnvFile(filePath) {
+};
+var confirmWriteEnvFile = async (filePath) => {
   return confirm({
     message: `Write these values to ${formatPromptPath(filePath)}?`,
     default: true,
     theme: PROMPT_THEME
   });
-}
-async function resolveTargetValue(input2) {
+};
+var confirmResourceOp = async (message) => {
+  return confirm({
+    message,
+    default: false,
+    theme: PROMPT_THEME
+  });
+};
+var resolveTargetValue = async (input2) => {
   if (input2.group.choices.length === 0) {
     input2.manualQuestions.push({
       field: input2.field,
@@ -1709,8 +2678,8 @@ async function resolveTargetValue(input2) {
       validate: input2.validate
     });
   }
-}
-async function askEmptyTargetAction(message) {
+};
+var askEmptyTargetAction = async (message) => {
   return select({
     message,
     theme: PROMPT_THEME,
@@ -1719,18 +2688,18 @@ async function askEmptyTargetAction(message) {
       { name: "Skip this check", value: "skip" }
     ]
   });
-}
-function required(label) {
+};
+var required = (label) => {
   return (value) => value.trim().length > 0 ? true : `${label} is required.`;
-}
-function optional(label) {
+};
+var optional = (label) => {
   return (value) => {
     const trimmed = value.trim();
     if (trimmed.length === 0) return true;
     return required(label)(trimmed);
   };
-}
-function validateWebhookUrl(value) {
+};
+var validateWebhookUrl = (value) => {
   const trimmed = value.trim();
   if (trimmed.length === 0) return "Webhook URL is required.";
   try {
@@ -1739,32 +2708,32 @@ function validateWebhookUrl(value) {
   } catch {
     return "Enter a valid webhook URL.";
   }
-}
-function optionalWebhookUrls(value) {
+};
+var optionalWebhookUrls = (value) => {
   const values2 = splitManualValues(value);
   if (values2.length === 0) return true;
   return values2.every((entry) => validateWebhookUrl(entry) === true) ? true : "Enter valid webhook URLs.";
-}
-function cleanList(value) {
+};
+var cleanList = (value) => {
   const values2 = Array.isArray(value) ? value : splitManualValues(value);
   const cleanValues = Array.from(new Set(values2.map((entry) => entry.trim()).filter(Boolean)));
   return cleanValues.length > 0 ? cleanValues : void 0;
-}
-function splitManualValues(value) {
+};
+var splitManualValues = (value) => {
   return (value ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
-}
-function formatPromptPath(filePath) {
+};
+var formatPromptPath = (filePath) => {
   const relative = path.relative(process.cwd(), filePath);
   if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) return relative;
   return path.basename(filePath);
-}
-function isPromptCancel(error) {
+};
+var isPromptCancel = (error) => {
   if (!(error instanceof Error)) return false;
   return error.name === "ExitPromptError" || error.message.includes("User force closed");
-}
+};
 
 // src/cli/resolveStores.ts
-async function resolveStores(client, input2) {
+var resolveStores = async (client, input2) => {
   if (input2.storeIds && input2.storeIds.length > 0) {
     return { storeIds: dedupe(input2.storeIds), skipped: false };
   }
@@ -1809,8 +2778,8 @@ async function resolveStores(client, input2) {
     });
   }
   return { storeIds: picked, skipped: false };
-}
-async function fetchReachableStoreIds(client) {
+};
+var fetchReachableStoreIds = async (client) => {
   const connection = await client.validateConnection();
   if (!connection.ok) {
     const authIssue = connection.issues.find((entry) => entry.code === "AUTH_FAILED");
@@ -1822,10 +2791,10 @@ async function fetchReachableStoreIds(client) {
     }
   }
   return connection.resource?.storeIds ?? [];
-}
-function dedupe(values2) {
+};
+var dedupe = (values2) => {
   return Array.from(new Set(values2.map((value) => value.trim()).filter(Boolean)));
-}
+};
 
 // src/cli/commands/doctor.ts
 var ALL_RESOURCE_TARGETS = [
@@ -1835,7 +2804,7 @@ var ALL_RESOURCE_TARGETS = [
   "license-key",
   "subscription-plan"
 ];
-async function runDoctorCommand(options) {
+var runDoctorCommand = async (options) => {
   try {
     const client = createFreshSqueezy({ mode: options.mode });
     const resolved = await resolveStores(client, {
@@ -1874,8 +2843,8 @@ async function runDoctorCommand(options) {
     writeFatal(err, options.json ?? false);
     return 2;
   }
-}
-async function resolveDoctorTargets(client, storeId, options) {
+};
+var resolveDoctorTargets = async (client, storeId, options) => {
   const explicit = {
     productIds: one(options.productId),
     webhookUrls: one(options.webhookUrl),
@@ -1899,8 +2868,8 @@ async function resolveDoctorTargets(client, storeId, options) {
     licenseKeyIds: mergeValues(explicit.licenseKeyIds, values(discovered.licenseKeys)),
     variantIds: mergeValues(explicit.variantIds, values(discovered.subscriptionPlans))
   };
-}
-function formatDiscoveryCounts(choices) {
+};
+var formatDiscoveryCounts = (choices) => {
   return [
     countLabel("products", choices.products.choices.length),
     countLabel("webhooks", choices.webhooks.choices.length),
@@ -1908,11 +2877,11 @@ function formatDiscoveryCounts(choices) {
     countLabel("license keys", choices.licenseKeys.choices.length),
     countLabel("subscription plans", choices.subscriptionPlans.choices.length)
   ].join(", ");
-}
-function countLabel(label, count) {
+};
+var countLabel = (label, count) => {
   return `${label} ${count}`;
-}
-function reportDiscoveryErrors(choices) {
+};
+var reportDiscoveryErrors = (choices) => {
   const errors = [
     choices.products.error && `products: ${choices.products.error}`,
     choices.webhooks.error && `webhooks: ${choices.webhooks.error}`,
@@ -1924,23 +2893,23 @@ function reportDiscoveryErrors(choices) {
     process.stderr.write(`fresh-squeezy: discovery skipped ${error}
 `);
   }
-}
-function values(group) {
+};
+var values = (group) => {
   return group.choices.length > 0 ? group.choices.map((choice) => choice.value) : void 0;
-}
-function one(value) {
+};
+var one = (value) => {
   return value ? [value] : void 0;
-}
-function mergeValues(explicit, discovered) {
+};
+var mergeValues = (explicit, discovered) => {
   const merged = Array.from(/* @__PURE__ */ new Set([...explicit ?? [], ...discovered ?? []]));
   return merged.length > 0 ? merged : void 0;
-}
-function hasExplicitResourceSelection(options) {
+};
+var hasExplicitResourceSelection = (options) => {
   return Boolean(
     options.productId || options.webhookUrl || options.discountId || options.licenseKeyId || options.variantId
   );
-}
-async function runConnectionOnly(client, options) {
+};
+var runConnectionOnly = async (client, options) => {
   const connection = await client.validateConnection();
   const report = {
     ok: connection.ok,
@@ -1959,8 +2928,8 @@ async function runConnectionOnly(client, options) {
 `);
   }
   return connection.ok ? 0 : 1;
-}
-function writeFatal(err, asJson) {
+};
+var writeFatal = (err, asJson) => {
   if (asJson) {
     const payload = err instanceof FreshSqueezyError ? { ok: false, error: { code: err.code, message: err.message, status: err.status ?? null } } : {
       ok: false,
@@ -1972,7 +2941,7 @@ function writeFatal(err, asJson) {
   }
   const message = err instanceof Error ? err.message : String(err);
   process.stderr.write(renderCliError(message, getDoctorHints(err)));
-}
+};
 
 // src/cli/commands/init.ts
 import fs from "fs/promises";
@@ -1983,24 +2952,24 @@ import chalk3 from "chalk";
 import chalk2 from "chalk";
 var brand = chalk2.green.bold("fresh-squeezy");
 var divider = chalk2.dim("\u2022");
-function renderBrandHeader(title, subtitle) {
+var renderBrandHeader = (title, subtitle) => {
   const lines = [`${brand} ${divider} ${chalk2.bold(title)}`];
   if (subtitle) lines.push(chalk2.dim(subtitle));
   lines.push("");
   return lines.join("\n");
-}
-function renderStep(index, total, title, detail) {
+};
+var renderStep = (index, total, title, detail) => {
   const suffix = detail ? ` ${chalk2.dim(detail)}` : "";
   const prefix = index > 1 ? "\n" : "";
   return `${prefix}${chalk2.yellow("\u25CF")} ${chalk2.dim(`${index}/${total}`)} ${chalk2.bold(title)}${suffix}
 `;
-}
-function renderDetected(label, value, source) {
+};
+var renderDetected = (label, value, source) => {
   const suffix = source ? ` ${chalk2.dim(`from ${source}`)}` : "";
   return `  ${chalk2.green("\u2713")} ${chalk2.bold(label)} ${value}${suffix}
 `;
-}
-function renderCommandExamples() {
+};
+var renderCommandExamples = () => {
   return [
     renderBrandHeader("Command examples", "Direct commands stay stable for scripts and CI."),
     `${chalk2.bold("Guided setup")}`,
@@ -2018,14 +2987,14 @@ function renderCommandExamples() {
     "  fresh-squeezy doctor --all-stores --json",
     ""
   ].join("\n");
-}
-function renderCancelMessage() {
+};
+var renderCancelMessage = () => {
   return `${chalk2.dim("fresh-squeezy cancelled.")}
 `;
-}
+};
 
 // src/cli/commands/init.ts
-async function runInitCommand(options = {}) {
+var runInitCommand = async (options = {}) => {
   try {
     return await runInitFlow(options);
   } catch (err) {
@@ -2035,8 +3004,8 @@ async function runInitCommand(options = {}) {
     }
     throw err;
   }
-}
-async function runInitFlow(options) {
+};
+var runInitFlow = async (options) => {
   if (options.isInteractive === false) {
     process.stderr.write(
       renderCliError("`fresh-squeezy init` requires an interactive terminal.", [
@@ -2113,8 +3082,8 @@ Running doctor (${checkNames.join(", ")})...
   process.stdout.write(`${renderReport(report)}
 `);
   return report.ok ? 0 : 1;
-}
-async function resolveStoreSelection(pickable) {
+};
+var resolveStoreSelection = async (pickable) => {
   if (pickable.length === 1) {
     const store = pickable[0];
     if (!store) throw new Error("Expected one reachable store.");
@@ -2124,8 +3093,8 @@ async function resolveStoreSelection(pickable) {
     return store.id;
   }
   return pickStore(pickable);
-}
-async function discoverChoices(client, storeId, selectedTargets) {
+};
+var discoverChoices = async (client, storeId, selectedTargets) => {
   if (selectedTargets.length === 0)
     return {
       products: { choices: [] },
@@ -2135,8 +3104,8 @@ async function discoverChoices(client, storeId, selectedTargets) {
       subscriptionPlans: { choices: [] }
     };
   return discoverInitResourceChoices(client, storeId, selectedTargets);
-}
-async function resolveApiKey() {
+};
+var resolveApiKey = async () => {
   const envApiKey = process.env[ENV_KEYS.apiKey]?.trim();
   if (envApiKey) {
     process.stdout.write(chalk3.dim(`Using ${ENV_KEYS.apiKey} from environment.
@@ -2145,8 +3114,8 @@ async function resolveApiKey() {
   }
   const answers = await askForApiKey();
   return answers.apiKey;
-}
-async function createDetectedClient(apiKey) {
+};
+var createDetectedClient = async (apiKey) => {
   const envMode = parseEnvMode();
   const initialMode = envMode ?? "test";
   let client = createFreshSqueezy({ apiKey, mode: initialMode });
@@ -2174,8 +3143,8 @@ async function createDetectedClient(apiKey) {
   }
   process.stdout.write(chalk3.dim("Could not auto-detect key mode; using test mode.\n"));
   return { client, mode: initialMode, connection };
-}
-function parseEnvMode() {
+};
+var parseEnvMode = () => {
   const value = process.env[ENV_KEYS.mode]?.trim();
   if (value === "test" || value === "live") return value;
   if (value) {
@@ -2185,8 +3154,8 @@ function parseEnvMode() {
     );
   }
   return void 0;
-}
-function getDoctorCheckNames(targets) {
+};
+var getDoctorCheckNames = (targets) => {
   const names = ["connection", "store"];
   pushCheckName(names, "product", targets.productIds);
   pushCheckName(names, "webhook", targets.webhookUrls);
@@ -2194,12 +3163,12 @@ function getDoctorCheckNames(targets) {
   pushCheckName(names, "licenseKey", targets.licenseKeyIds);
   pushCheckName(names, "subscriptionPlan", targets.variantIds);
   return names;
-}
-function pushCheckName(names, name, values2) {
+};
+var pushCheckName = (names, name, values2) => {
   if (!values2 || values2.length === 0) return;
   names.push(values2.length === 1 ? name : `${name} x${values2.length}`);
-}
-function renderSetupSummary(input2) {
+};
+var renderSetupSummary = (input2) => {
   return [
     renderStep(5, 5, "Ready to verify", "review before writing env"),
     `  ${chalk3.dim("mode")}   ${input2.mode}`,
@@ -2208,8 +3177,8 @@ function renderSetupSummary(input2) {
     `  ${chalk3.dim("env")}    ${input2.envPath}`,
     ""
   ].join("\n");
-}
-async function writeEnvFile(envPath, values2) {
+};
+var writeEnvFile = async (envPath, values2) => {
   const updates = /* @__PURE__ */ new Map([
     [ENV_KEYS.apiKey, values2.apiKey],
     [ENV_KEYS.storeId, values2.storeId],
@@ -2236,8 +3205,8 @@ async function writeEnvFile(envPath, values2) {
   await fs.mkdir(path2.dirname(envPath), { recursive: true });
   await fs.writeFile(envPath, `${next.join("\n").replace(/\n*$/, "")}
 `, { encoding: "utf8" });
-}
-async function readEnvFile(envPath) {
+};
+var readEnvFile = async (envPath) => {
   try {
     return await fs.readFile(envPath, "utf8");
   } catch (err) {
@@ -2246,8 +3215,8 @@ async function readEnvFile(envPath) {
     }
     throw err;
   }
-}
-function renderDiscoverySummary(choices, selectedTargets) {
+};
+var renderDiscoverySummary = (choices, selectedTargets) => {
   if (selectedTargets.length === 0) return chalk3.dim("  No optional resource checks selected.\n");
   const groups = [
     ["product", "Products", choices.products],
@@ -2269,7 +3238,7 @@ function renderDiscoverySummary(choices, selectedTargets) {
   }
   return `${lines.join("\n")}
 `;
-}
+};
 
 // src/cli/commands/launcher.ts
 import chalk4 from "chalk";
@@ -2279,7 +3248,7 @@ import { spawn } from "child_process";
 import fs2 from "fs/promises";
 import path3 from "path";
 var PACKAGE_NAME = "fresh-squeezy";
-async function ensureFreshSqueezyDevDependency(options = {}) {
+var ensureFreshSqueezyDevDependency = async (options = {}) => {
   if (options.skipInstall) {
     return { status: "skipped" };
   }
@@ -2307,8 +3276,8 @@ async function ensureFreshSqueezyDevDependency(options = {}) {
     throw new Error(`${command.join(" ")} failed with exit code ${code}`);
   }
   return { status: "installed", projectDir, packageJsonPath, packageManager, command };
-}
-async function findPackageJson(cwd) {
+};
+var findPackageJson = async (cwd) => {
   let current = path3.resolve(cwd);
   while (true) {
     const candidate = path3.join(current, "package.json");
@@ -2317,34 +3286,34 @@ async function findPackageJson(cwd) {
     if (parent === current) return void 0;
     current = parent;
   }
-}
-async function readPackageJson(packageJsonPath) {
+};
+var readPackageJson = async (packageJsonPath) => {
   const raw = await fs2.readFile(packageJsonPath, "utf8");
   return JSON.parse(raw);
-}
-async function detectPackageManager(projectDir) {
+};
+var detectPackageManager = async (projectDir) => {
   if (await pathExists(path3.join(projectDir, "pnpm-lock.yaml"))) return "pnpm";
   if (await pathExists(path3.join(projectDir, "yarn.lock"))) return "yarn";
   if (await pathExists(path3.join(projectDir, "bun.lock")) || await pathExists(path3.join(projectDir, "bun.lockb"))) {
     return "bun";
   }
   return "npm";
-}
-function hasFreshSqueezy(manifest) {
+};
+var hasFreshSqueezy = (manifest) => {
   return [
     manifest.dependencies,
     manifest.devDependencies,
     manifest.optionalDependencies,
     manifest.peerDependencies
   ].some((section) => section?.[PACKAGE_NAME] !== void 0);
-}
-function buildInstallCommand(packageManager, packageSpec) {
+};
+var buildInstallCommand = (packageManager, packageSpec) => {
   if (packageManager === "pnpm") return ["pnpm", "add", "-D", packageSpec];
   if (packageManager === "yarn") return ["yarn", "add", "-D", packageSpec];
   if (packageManager === "bun") return ["bun", "add", "-d", packageSpec];
   return ["npm", "install", "--save-dev", packageSpec];
-}
-function runPackageCommand(command, args, options) {
+};
+var runPackageCommand = (command, args, options) => {
   return new Promise((resolve2, reject) => {
     const child = spawn(command, args, {
       cwd: options.cwd,
@@ -2354,18 +3323,18 @@ function runPackageCommand(command, args, options) {
     child.on("error", reject);
     child.on("close", (code) => resolve2(code ?? 1));
   });
-}
-async function pathExists(filePath) {
+};
+var pathExists = async (filePath) => {
   try {
     await fs2.access(filePath);
     return true;
   } catch {
     return false;
   }
-}
+};
 
 // src/cli/commands/launcher.ts
-async function runLauncherCommand(options) {
+var runLauncherCommand = async (options) => {
   if (!options.isInteractive) return 2;
   try {
     process.stdout.write(
@@ -2396,8 +3365,8 @@ async function runLauncherCommand(options) {
     process.stderr.write(renderCommandExamples());
     return 1;
   }
-}
-async function routeLauncherAction(action) {
+};
+var routeLauncherAction = async (action) => {
   switch (action) {
     case "init":
       return startGuidedSetup();
@@ -2409,14 +3378,14 @@ async function routeLauncherAction(action) {
     case "exit":
       return 0;
   }
-}
-function startGuidedSetup() {
+};
+var startGuidedSetup = () => {
   process.stdout.write(
     renderStep(2, 2, "Guided setup", "detect credentials, stores, and resources")
   );
   return runInitCommand({ isInteractive: true });
-}
-function renderProjectInstallResult(result) {
+};
+var renderProjectInstallResult = (result) => {
   if (result.status === "installed") {
     return renderDetected(
       "Dev dependency",
@@ -2434,10 +3403,150 @@ function renderProjectInstallResult(result) {
     return chalk4.dim("  Skipped dev dependency install (--no-install).\n");
   }
   return chalk4.yellow("  No package.json found; running without installing a dev dependency.\n");
-}
+};
+
+// src/cli/commands/resourceOps.ts
+import { readFileSync } from "fs";
+var runResourceOpCommand = async (options) => {
+  if (options.listCatalog) {
+    writeCatalog(options.json ?? false);
+    return 0;
+  }
+  const spec = findResourceVerb(options.resource, options.verb);
+  if (!spec) {
+    process.stderr.write(
+      renderCliError(`Unknown or unsupported op: ${options.verb} ${options.resource}`, [
+        "fresh-squeezy ops --list",
+        "fresh-squeezy get product --id 1",
+        "fresh-squeezy list webhook --store-ids 1"
+      ])
+    );
+    return 2;
+  }
+  try {
+    const body = readBody(options);
+    if (spec.body === "required" && body === void 0) {
+      throw new FreshSqueezyError({
+        code: "MISSING_ARG",
+        message: "This op requires a JSON body (--body, --body-file, or stdin)."
+      });
+    }
+    const client = createFreshSqueezy({ mode: options.mode });
+    const allowed = await assertWriteSafety(spec, client.mode, options);
+    if (!allowed) return 2;
+    const config = resolveConfig({ mode: options.mode });
+    const http = new HttpClient(config);
+    const data = await invokeOp(http, options.resource, options.verb, {
+      id: options.id,
+      storeId: options.storeIds?.[0],
+      parentId: options.parentId,
+      body
+    });
+    const payload = {
+      ok: true,
+      mode: client.mode,
+      resource: spec.resource,
+      verb: spec.verb,
+      docs: `https://docs.lemonsqueezy.com/api/${spec.docsPath}`,
+      data: data ?? null
+    };
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    } else {
+      process.stdout.write(
+        `${spec.verb} ${spec.resource} \u2014 ok (mode=${client.mode})
+${JSON.stringify(data ?? null, null, 2)}
+`
+      );
+    }
+    return 0;
+  } catch (err) {
+    writeFatal2(err, options.json ?? false);
+    return 2;
+  }
+};
+var writeCatalog = (asJson) => {
+  if (asJson) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          resources: listRegisteredResources(),
+          ops: resourceRegistry
+        },
+        null,
+        2
+      )}
+`
+    );
+    return;
+  }
+  process.stdout.write("Docs-backed ops (Lemon Squeezy official API only):\n\n");
+  for (const entry of resourceRegistry) {
+    const flags = [
+      entry.destructive ? "destructive" : void 0,
+      entry.body && entry.body !== "none" ? `body=${entry.body}` : void 0
+    ].filter(Boolean).join(", ");
+    process.stdout.write(
+      `  ${entry.verb.padEnd(18)} ${entry.resource.padEnd(22)} ${entry.docsPath}${flags ? `  (${flags})` : ""}
+`
+    );
+  }
+  process.stdout.write(
+    "\nCatalog resources (product, variant, price, file, store, \u2026) are read-only in the API.\n"
+  );
+};
+var assertWriteSafety = async (spec, mode, options) => {
+  const isWrite = spec.verb !== "get" && spec.verb !== "list" && spec.verb !== "current-usage";
+  if (!isWrite) return true;
+  const needsGate = Boolean(spec.destructive) || mode === "live";
+  if (!needsGate) return true;
+  if (options.yes) return true;
+  if (options.isInteractive) {
+    return confirmResourceOp(
+      mode === "live" ? `LIVE mode: allow ${spec.verb} ${spec.resource}?` : `Confirm ${spec.verb} ${spec.resource}?`
+    );
+  }
+  process.stderr.write(
+    renderCliError(
+      `${spec.verb} ${spec.resource} requires --yes in non-interactive ${mode} mode${spec.destructive ? " (destructive op)" : ""}`,
+      [
+        `fresh-squeezy ${spec.verb} ${spec.resource} --yes \u2026`,
+        "Use test mode for safer experimentation: --mode test"
+      ]
+    )
+  );
+  return false;
+};
+var readBody = (options) => {
+  if (options.bodyFile) {
+    const text = readFileSync(options.bodyFile, "utf8");
+    return JSON.parse(text);
+  }
+  if (options.body !== void 0) {
+    return JSON.parse(options.body);
+  }
+  if (!process.stdin.isTTY && !options.isInteractive) {
+  }
+  return void 0;
+};
+var writeFatal2 = (err, json) => {
+  if (json) {
+    const code = err instanceof FreshSqueezyError ? err.code : "FATAL";
+    const message2 = err instanceof Error ? err.message : String(err);
+    const status = err instanceof FreshSqueezyError ? err.status : void 0;
+    process.stderr.write(
+      `${JSON.stringify({ ok: false, error: { code, message: message2, status } }, null, 2)}
+`
+    );
+    return;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(renderCliError(message, ["fresh-squeezy ops --list"]));
+};
 
 // src/cli/commands/validate.ts
-async function runValidateCommand(target, options) {
+var runValidateCommand = async (target, options) => {
   try {
     const client = createFreshSqueezy({ mode: options.mode });
     if (target === "connection") {
@@ -2473,8 +3582,8 @@ async function runValidateCommand(target, options) {
     process.stderr.write(renderCliError(message, getValidateHints(err, target)));
     return 2;
   }
-}
-async function resolveStoresForTarget(client, target, options) {
+};
+var resolveStoresForTarget = async (client, target, options) => {
   const resolved = await resolveStores(client, {
     storeIds: options.storeIds,
     allStores: options.allStores,
@@ -2487,8 +3596,8 @@ async function resolveStoresForTarget(client, target, options) {
     });
   }
   return resolved.storeIds;
-}
-async function runPerStore(client, target, storeIds, options) {
+};
+var runPerStore = async (client, target, storeIds, options) => {
   if (target === "store") {
     return Promise.all(storeIds.map((id) => client.validateStore(id)));
   }
@@ -2497,16 +3606,16 @@ async function runPerStore(client, target, storeIds, options) {
     return Promise.all(storeIds.map((storeId) => client.validateWebhook({ storeId, url })));
   }
   return [];
-}
-async function runProduct(client, options) {
+};
+var runProduct = async (client, options) => {
   const productId = required2(options.productId, "--product-id is required for `validate product`.");
   const expected = options.storeIds?.[0];
   return client.validateProduct({
     productId,
     expectedStoreId: expected
   });
-}
-async function runDiscount(client, options) {
+};
+var runDiscount = async (client, options) => {
   const discountId = required2(
     options.discountId,
     "--discount-id is required for `validate discount`."
@@ -2516,8 +3625,8 @@ async function runDiscount(client, options) {
     "--store-ids is required for `validate discount`."
   );
   return client.validateDiscount({ storeId, discountId });
-}
-async function runLicenseKey(client, options) {
+};
+var runLicenseKey = async (client, options) => {
   const licenseKeyId = required2(
     options.licenseKeyId,
     "--license-key-id is required for `validate license-key`."
@@ -2527,8 +3636,8 @@ async function runLicenseKey(client, options) {
     "--store-ids is required for `validate license-key`."
   );
   return client.validateLicenseKey({ storeId, licenseKeyId });
-}
-async function runSubscriptionPlan(client, options) {
+};
+var runSubscriptionPlan = async (client, options) => {
   const variantId = required2(
     options.variantId,
     "--variant-id is required for `validate subscription-plan`."
@@ -2538,8 +3647,8 @@ async function runSubscriptionPlan(client, options) {
     "--store-ids is required for `validate subscription-plan`."
   );
   return client.validateSubscriptionPlan({ storeId, variantId });
-}
-function emit(result, options) {
+};
+var emit = (result, options) => {
   if (options.json) {
     process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
@@ -2548,29 +3657,79 @@ function emit(result, options) {
 `);
   }
   return result.ok ? 0 : 1;
-}
-function required2(value, message) {
+};
+var required2 = (value, message) => {
   if (value === void 0 || value === null || value === "") {
     throw new FreshSqueezyError({ code: "MISSING_ARG", message });
   }
   return value;
-}
+};
 
 // src/cli/main.ts
 dotenv.config();
+var parseMode = (value) => {
+  if (value === "test" || value === "live") return value;
+  throw new Error(`Mode must be "test" or "live", got "${value}"`);
+};
+var parseCsv = (value) => {
+  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+};
+var readPackageVersion = () => {
+  const candidates = [
+    new URL("../package.json", import.meta.url),
+    new URL("../../package.json", import.meta.url)
+  ];
+  for (const candidate of candidates) {
+    try {
+      const payload = JSON.parse(readFileSync2(candidate, "utf8"));
+      if (typeof payload.version === "string") return payload.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+};
 var isInteractive = Boolean(process.stdin.isTTY);
 var packageVersion = readPackageVersion();
+var runValidate = async (target, opts) => {
+  const code = await runValidateCommand(target, {
+    mode: opts.mode,
+    storeIds: opts.storeIds,
+    allStores: Boolean(opts.allStores),
+    productId: opts.productId,
+    webhookUrl: opts.webhookUrl,
+    discountId: opts.discountId,
+    licenseKeyId: opts.licenseKeyId,
+    variantId: opts.variantId,
+    json: Boolean(opts.json),
+    isInteractive
+  });
+  process.exit(code);
+};
 var program = new Command();
-program.name("fresh-squeezy").description("Lemon Squeezy integration doctor for billing teams").version(packageVersion).option("--no-install", "Skip adding fresh-squeezy to devDependencies before guided setup").showSuggestionAfterError().showHelpAfterError("\nRun `fresh-squeezy --help` for examples.");
+program.name("fresh-squeezy").description(
+  "Dual-mode Lemon Squeezy CLI: doctor/validate pre-flight + docs-backed resource ops (get/list/create/\u2026)"
+).version(packageVersion).option("--no-install", "Skip adding fresh-squeezy to devDependencies before guided setup").showSuggestionAfterError().showHelpAfterError("\nRun `fresh-squeezy --help` for examples.");
 program.addHelpText(
   "after",
   `
-Start:
+Start (doctor setup):
   fresh-squeezy              add as a dev dependency, then run guided setup
   fresh-squeezy --no-install run guided setup without editing package.json
   fresh-squeezy doctor --all-stores --all-resources
   fresh-squeezy validate webhook --store-ids 12 --webhook-url https://app.example.com/api/webhooks/lemon-squeezy
 
+Ops (docs-backed Lemon Squeezy API only \u2014 products/variants are read-only):
+  fresh-squeezy ops --list
+  fresh-squeezy get product --id 42 --json
+  fresh-squeezy list webhook --store-ids 12
+  fresh-squeezy create webhook --body-file webhook.json --yes
+  fresh-squeezy cancel subscription --id 9 --yes
+  fresh-squeezy refund order --id 100 --yes
+  fresh-squeezy generate-invoice order --id 100 --yes
+
+Safety: delete/cancel/refund always need --yes (or TTY confirm); live-mode writes need --yes too.
+Bodies are JSON:API documents via --body or --body-file (not flat flags).
+
 Store selection:
   Use --store-ids 12,34 for explicit stores, --all-stores for automation, or run in a TTY to pick stores interactively.
 `
@@ -2659,46 +3818,55 @@ types.command("augment").description(
   const code = await runAugmentCommand({ out: opts.out, force: Boolean(opts.force) });
   process.exit(code);
 });
+program.command("ops").description("List docs-backed resource ops (Lemon Squeezy official API matrix)").option("--list", "Print the full verb matrix", true).option("--json", "Emit machine-readable JSON").action(async (opts) => {
+  const code = await runResourceOpCommand({
+    resource: "",
+    verb: "get",
+    listCatalog: true,
+    json: Boolean(opts.json)
+  });
+  process.exit(code);
+});
+var OP_VERBS = [
+  "get",
+  "list",
+  "create",
+  "update",
+  "delete",
+  "cancel",
+  "refund",
+  "generate-invoice",
+  "current-usage"
+];
+for (const verb of OP_VERBS) {
+  program.command(`${verb} <resource>`).description(`Docs-backed ${verb} for a Lemon Squeezy resource`).option("-m, --mode <mode>", "test or live", parseMode).option("--id <id>", "Resource id").option(
+    "--store-ids <ids>",
+    "Comma-separated store IDs (first used for list filters)",
+    parseCsv
+  ).option(
+    "--parent-id <id>",
+    "Parent resource id for nested lists (product, order, subscription, \u2026)"
+  ).option("--body <json>", "JSON:API body string").option("--body-file <path>", "Path to JSON:API body file").option("--yes", "Skip confirm; required for live writes and destructive ops when non-TTY").option("--json", "Emit machine-readable JSON").action(async (resource, opts) => {
+    const code = await runResourceOpCommand({
+      verb,
+      resource,
+      mode: opts.mode,
+      id: opts.id,
+      storeIds: opts.storeIds,
+      parentId: opts.parentId,
+      body: opts.body,
+      bodyFile: opts.bodyFile,
+      yes: Boolean(opts.yes),
+      json: Boolean(opts.json),
+      isInteractive
+    });
+    process.exit(code);
+  });
+}
 program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
   const hints = message.includes("Mode must be") ? ["fresh-squeezy doctor --mode test", "fresh-squeezy doctor --mode live"] : ["fresh-squeezy --help"];
   process.stderr.write(renderCliError(message, hints));
   process.exit(2);
 });
-function parseMode(value) {
-  if (value === "test" || value === "live") return value;
-  throw new Error(`Mode must be "test" or "live", got "${value}"`);
-}
-function parseCsv(value) {
-  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-}
-function readPackageVersion() {
-  const candidates = [
-    new URL("../package.json", import.meta.url),
-    new URL("../../package.json", import.meta.url)
-  ];
-  for (const candidate of candidates) {
-    try {
-      const payload = JSON.parse(readFileSync(candidate, "utf8"));
-      if (typeof payload.version === "string") return payload.version;
-    } catch {
-    }
-  }
-  return "0.0.0";
-}
-async function runValidate(target, opts) {
-  const code = await runValidateCommand(target, {
-    mode: opts.mode,
-    storeIds: opts.storeIds,
-    allStores: Boolean(opts.allStores),
-    productId: opts.productId,
-    webhookUrl: opts.webhookUrl,
-    discountId: opts.discountId,
-    licenseKeyId: opts.licenseKeyId,
-    variantId: opts.variantId,
-    json: Boolean(opts.json),
-    isInteractive
-  });
-  process.exit(code);
-}
 //# sourceMappingURL=cli.js.map