@lunora/payment 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/{constantTimeEqual-CfY0jYcL.mjs → constantTimeEqual-BQjoW85H.mjs}

@@ -1,4 +1,4 @@
-import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+import { LunoraPaymentError } from './LunoraPaymentError-BeQlhkZj.mjs';
 
 const encoder = new TextEncoder();
 const toHex = (buffer) => [...new Uint8Array(buffer)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -25,42 +25,6 @@ const hmacSha256Hex = async (secret, payload) => {
   const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
   return toHex(signature);
 };
-const parseStripeSignatureHeader = (header) => {
-  let timestamp = Number.NaN;
-  const signatures = [];
-  for (const part of header.split(",")) {
-    const index = part.indexOf("=");
-    if (index === -1) {
-      continue;
-    }
-    const scheme = part.slice(0, index).trim();
-    const value = part.slice(index + 1).trim();
-    if (scheme === "t") {
-      timestamp = Number(value);
-    } else if (scheme === "v1") {
-      signatures.push(value);
-    }
-  }
-  return { signatures, timestamp };
-};
-const verifyStripeSignature = async (input) => {
-  if (!input.secret) {
-    throw new LunoraPaymentError("CONFIG_INVALID", "webhook secret not configured");
-  }
-  const toleranceSeconds = input.toleranceSeconds ?? 300;
-  const nowMs = input.now ?? Date.now();
-  const { signatures, timestamp } = parseStripeSignatureHeader(input.signatureHeader);
-  if (!Number.isFinite(timestamp) || signatures.length === 0) {
-    throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "malformed signature header");
-  }
-  if (Math.abs(Math.floor(nowMs / 1e3) - timestamp) > toleranceSeconds) {
-    throw new LunoraPaymentError("WEBHOOK_TIMESTAMP_INVALID", "signature timestamp outside tolerance");
-  }
-  const expected = await hmacSha256Hex(input.secret, `${String(timestamp)}.${input.payload}`);
-  if (!signatures.some((candidate) => constantTimeEqual(candidate, expected))) {
-    throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "no matching signature");
-  }
-};
 const verifyStandardWebhook = async (input) => {
   if (!input.secret) {
     throw new LunoraPaymentError("CONFIG_INVALID", "webhook secret not configured");
@@ -91,5 +55,17 @@ const verifyStandardWebhook = async (input) => {
     throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "no matching signature");
   }
 };
+const verifyCreemSignature = async (input) => {
+  if (!input.secret) {
+    throw new LunoraPaymentError("CONFIG_INVALID", "webhook secret not configured");
+  }
+  if (!input.signature) {
+    throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "missing creem-signature header");
+  }
+  const expected = await hmacSha256Hex(input.secret, input.payload);
+  if (!constantTimeEqual(input.signature, expected)) {
+    throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "no matching signature");
+  }
+};
 
-export { constantTimeEqual, hmacSha256Hex, parseStripeSignatureHeader, verifyStandardWebhook, verifyStripeSignature };
+export { constantTimeEqual, hmacSha256Hex, verifyCreemSignature, verifyStandardWebhook };

package/dist/packem_shared/{createAdapterRegistry-BuDHFCBc.mjs → createAdapterRegistry-Ds7bx_TK.mjs}

@@ -1,4 +1,4 @@
-import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+import { LunoraPaymentError } from './LunoraPaymentError-BeQlhkZj.mjs';
 
 const createAdapterRegistry = (adapters) => {
   const byId = /* @__PURE__ */ new Map();

package/dist/packem_shared/{createDatabasePaymentStore-bYB_HUE6.mjs → createDatabasePaymentStore-C0NUCj1H.mjs}

@@ -1,4 +1,4 @@
-import { money } from './addMoney-bCcs1nyw.mjs';
+import { money } from './addMoney-jSh_7TfF.mjs';
 
 const readString = (row, key) => typeof row[key] === "string" ? row[key] : "";
 const readOptionalString = (row, key) => typeof row[key] === "string" ? row[key] : void 0;

package/dist/packem_shared/{createPayment-BccfPGyw.mjs → createPayment-DzX-ji34.mjs}

@@ -1,10 +1,12 @@
+import { toErrorBody } from '@lunora/errors';
 import { usagePeriodStart, resolveEntitlements, featureNames, hasActivePrice } from './entitlementsForReference-CzZGXPoZ.mjs';
-import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+import { LunoraPaymentError } from './LunoraPaymentError-BeQlhkZj.mjs';
 import idempotencyKey from './idempotencyKey-BFzDCA7g.mjs';
 import { n as notifyObserver } from './observability-CvhJ205g.mjs';
-import applyWebhookAction from './applyWebhookAction-DpAqf3Lw.mjs';
+import applyWebhookAction from './applyWebhookAction-CLAx4svt.mjs';
+
+const jsonResponse = (body, status = 200, headers) => Response.json(body, { headers: { "content-type": "application/json", ...headers }, status });
 
-const jsonResponse = (body, status) => Response.json(body, { headers: { "content-type": "application/json" }, status });
 const stripReferenceId = (metadata) => metadata && "referenceId" in metadata ? Object.fromEntries(Object.entries(metadata).filter(([key]) => key !== "referenceId")) : metadata;
 const createPayment = (options) => {
   const { adapter, store } = options;
@@ -31,7 +33,7 @@ const createPayment = (options) => {
       if (existing) {
         customerId = existing.id;
       } else {
-        const customer = await adapter.getOrCreateCustomer({ referenceId: input.referenceId });
+        const customer = await adapter.getOrCreateCustomer({ email: input.email, referenceId: input.referenceId });
         customerId = customer.id;
         await store.upsertCustomer(customer);
       }
@@ -78,6 +80,12 @@ const createPayment = (options) => {
     },
     check: async (input) => {
       await ensureAuthorized(input.referenceId);
+      if (input.featureId === void 0 && input.priceId === void 0) {
+        throw new LunoraPaymentError("CONFIG_INVALID", "check() requires a featureId or priceId");
+      }
+      if (adapter.checkEntitlement) {
+        return adapter.checkEntitlement(input);
+      }
       const subscriptions = await store.listSubscriptionsByReference(input.referenceId);
       if (input.priceId !== void 0) {
         return { allowed: hasActivePrice(subscriptions, input.priceId), unlimited: false };
@@ -107,7 +115,8 @@ const createPayment = (options) => {
         action = await adapter.parseWebhook({ headers: request.headers, payload });
       } catch (error) {
         if (error instanceof LunoraPaymentError) {
-          return jsonResponse({ error: error.message }, error.status);
+          const { body, status } = toErrorBody(error);
+          return jsonResponse({ error: body.message }, status);
         }
         return jsonResponse({ error: "webhook error" }, 400);
       }
@@ -116,6 +125,9 @@ const createPayment = (options) => {
     },
     listBalances: async (referenceId) => {
       await ensureAuthorized(referenceId);
+      if (adapter.getBalances) {
+        return adapter.getBalances(referenceId);
+      }
       if (!options.entitlements) {
         throw new LunoraPaymentError("CONFIG_INVALID", "listBalances() requires `entitlements` to be configured");
       }

package/dist/packem_shared/json-DhcPm8EO.mjs

@@ -0,0 +1,11 @@
+const asRecord = (value) => typeof value === "object" && value !== null ? value : {};
+const readString = (object, key) => typeof object[key] === "string" ? object[key] : void 0;
+const readNumber = (object, key) => typeof object[key] === "number" ? object[key] : void 0;
+const readBoolean = (object, key) => typeof object[key] === "boolean" ? object[key] : void 0;
+const referenceFromMetadata = (object) => readString(asRecord(object.metadata), "referenceId");
+const parseTimestamp = (value) => {
+  const parsed = typeof value === "string" ? Date.parse(value) : Number.NaN;
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+
+export { asRecord as a, readNumber as b, readBoolean as c, referenceFromMetadata as d, parseTimestamp as p, readString as r };

package/dist/packem_shared/{lunoraDatabaseToPaymentDatabase-RlKX3Kcd.mjs → lunoraDatabaseToPaymentDatabase-CL2vdAXq.mjs}

@@ -1,5 +1,5 @@
-import { createPayment } from './createPayment-BccfPGyw.mjs';
-import { createDatabasePaymentStore } from './createDatabasePaymentStore-bYB_HUE6.mjs';
+import { createPayment } from './createPayment-DzX-ji34.mjs';
+import { createDatabasePaymentStore } from './createDatabasePaymentStore-C0NUCj1H.mjs';
 
 const lunoraDatabaseToPaymentDatabase = (database) => {
   return {

package/dist/packem_shared/not-supported-C0onRyia.mjs

@@ -0,0 +1,7 @@
+import { LunoraPaymentError } from './LunoraPaymentError-BeQlhkZj.mjs';
+
+const makeNotSupported = (label) => (operation) => {
+  throw new LunoraPaymentError("PROVIDER_ERROR", `${label} does not support ${operation}`);
+};
+
+export { makeNotSupported as m };

package/dist/packem_shared/{reconcile-CI1ukJF9.mjs → reconcile-Dtn_ErbJ.mjs}

@@ -1,4 +1,4 @@
-import { compareMoney } from './addMoney-bCcs1nyw.mjs';
+import { compareMoney } from './addMoney-jSh_7TfF.mjs';
 import { n as notifyObserver } from './observability-CvhJ205g.mjs';
 
 const sameCurrencyAmount = (a, b) => a.currency === b.currency && compareMoney(a, b) === 0;

package/dist/packem_shared/subscription-event-CwEsWRCK.mjs

@@ -0,0 +1,17 @@
+const stateToEventType = (state) => {
+  if (state === "canceled") {
+    return "subscription.canceled";
+  }
+  if (state === "past_due") {
+    return "subscription.past_due";
+  }
+  if (state === "paused") {
+    return "subscription.paused";
+  }
+  if (state === "active" || state === "trialing") {
+    return "subscription.active";
+  }
+  return "subscription.updated";
+};
+
+export { stateToEventType as s };

package/dist/providers/autumn-features.d.mts

@@ -0,0 +1,94 @@
+/** A per-seat / per-workspace sub-customer with its own feature balances. */
+interface AutumnEntity {
+  readonly featureId?: string;
+  readonly id: string;
+  readonly name?: string;
+  /** The raw provider record, for fields this facade does not normalize. */
+  readonly raw: Record<string, unknown>;
+}
+interface CreateEntityInput {
+  /** The feature the entity consumes a seat/allowance of (e.g. `"seats"`). */
+  readonly featureId: string;
+  /** Caller-chosen stable id — Autumn requires an entity id on create. */
+  readonly id: string;
+  readonly name?: string;
+}
+/** One point in a usage-events aggregation. */
+interface UsageEventPoint {
+  readonly count: number;
+  readonly period?: string;
+  readonly raw: Record<string, unknown>;
+}
+interface EventsListInput {
+  /** Feature(s) to report on. */
+  readonly featureId: ReadonlyArray<string> | string;
+}
+interface EventsAggregateInput extends EventsListInput {
+  /** Time window to aggregate over (aggregate only — `list` ignores it, so it isn't accepted there). */
+  readonly range?: "7d" | "24h" | "30d" | "90d" | "last_cycle";
+}
+/** A prepaid feature quantity purchased at checkout (e.g. buy 5 seats up front). */
+interface PrepaidOption {
+  readonly featureId: string;
+  readonly quantity: number;
+}
+/** Autumn-native checkout — richer than the generic `createCheckout` (trials, prepaid, entities, rewards). */
+interface AutumnCheckoutInput {
+  /** Scope the checkout to a specific entity (seat/workspace) rather than the top-level customer. */
+  readonly entityId?: string;
+  /**
+  * Autumn applies a plan's configured free trial automatically. Pass `false` to opt out of that
+  * trial for this checkout; leave unset (or `true`) to keep the plan default.
+  */
+  readonly freeTrial?: boolean;
+  /** Prepaid feature quantities to purchase up front. */
+  readonly options?: ReadonlyArray<PrepaidOption>;
+  /** The plan to attach (Autumn's plan id — the successor to the classic "product" id). */
+  readonly planId: string;
+  /** An Autumn reward id to apply as a discount. */
+  readonly reward?: string;
+  readonly successUrl?: string;
+}
+/** The subset of the Autumn SDK surface the native facade calls. A real `Autumn` instance satisfies it. */
+interface AutumnFeaturesClientLike {
+  readonly billing: unknown;
+  readonly entities: unknown;
+  readonly events: unknown;
+  readonly plans: unknown;
+  readonly referrals: unknown;
+}
+interface AutumnFeaturesOptions {
+  readonly client: AutumnFeaturesClientLike;
+}
+/** The Autumn-native feature facade returned by {@link createAutumnFeatures}. */
+interface AutumnFeatures {
+  readonly checkout: (referenceId: string, input: AutumnCheckoutInput) => Promise<{
+    raw: Record<string, unknown>;
+    url: string;
+  }>;
+  readonly entities: {
+    readonly create: (referenceId: string, input: CreateEntityInput) => Promise<AutumnEntity>;
+    readonly delete: (referenceId: string, entityId: string) => Promise<void>;
+    readonly get: (referenceId: string, entityId: string) => Promise<AutumnEntity>;
+  };
+  readonly events: {
+    readonly aggregate: (referenceId: string, input: EventsAggregateInput) => Promise<UsageEventPoint[]>;
+    readonly list: (referenceId: string, input: EventsListInput) => Promise<UsageEventPoint[]>;
+  };
+  readonly plans: {
+    readonly list: () => Promise<Record<string, unknown>[]>;
+  };
+  readonly referrals: {
+    readonly createCode: (referenceId: string, programId: string) => Promise<{
+      code: string;
+      raw: Record<string, unknown>;
+    }>;
+    readonly redeemCode: (referenceId: string, code: string) => Promise<Record<string, unknown>>;
+  };
+}
+/**
+* Build the Autumn-native feature facade over an injected client. Companion to `createAutumnAdapter`;
+* share the same underlying `autumn-js` `Autumn` client between them.
+*/
+declare const createAutumnFeatures: (options: AutumnFeaturesOptions) => AutumnFeatures;
+export { type AutumnCheckoutInput, type AutumnEntity, type AutumnFeatures, type AutumnFeaturesClientLike, type AutumnFeaturesOptions, type CreateEntityInput, type EventsAggregateInput, type EventsListInput, type PrepaidOption, type UsageEventPoint, createAutumnFeatures };

package/dist/providers/autumn-features.d.ts

@@ -0,0 +1,94 @@
+/** A per-seat / per-workspace sub-customer with its own feature balances. */
+interface AutumnEntity {
+  readonly featureId?: string;
+  readonly id: string;
+  readonly name?: string;
+  /** The raw provider record, for fields this facade does not normalize. */
+  readonly raw: Record<string, unknown>;
+}
+interface CreateEntityInput {
+  /** The feature the entity consumes a seat/allowance of (e.g. `"seats"`). */
+  readonly featureId: string;
+  /** Caller-chosen stable id — Autumn requires an entity id on create. */
+  readonly id: string;
+  readonly name?: string;
+}
+/** One point in a usage-events aggregation. */
+interface UsageEventPoint {
+  readonly count: number;
+  readonly period?: string;
+  readonly raw: Record<string, unknown>;
+}
+interface EventsListInput {
+  /** Feature(s) to report on. */
+  readonly featureId: ReadonlyArray<string> | string;
+}
+interface EventsAggregateInput extends EventsListInput {
+  /** Time window to aggregate over (aggregate only — `list` ignores it, so it isn't accepted there). */
+  readonly range?: "7d" | "24h" | "30d" | "90d" | "last_cycle";
+}
+/** A prepaid feature quantity purchased at checkout (e.g. buy 5 seats up front). */
+interface PrepaidOption {
+  readonly featureId: string;
+  readonly quantity: number;
+}
+/** Autumn-native checkout — richer than the generic `createCheckout` (trials, prepaid, entities, rewards). */
+interface AutumnCheckoutInput {
+  /** Scope the checkout to a specific entity (seat/workspace) rather than the top-level customer. */
+  readonly entityId?: string;
+  /**
+  * Autumn applies a plan's configured free trial automatically. Pass `false` to opt out of that
+  * trial for this checkout; leave unset (or `true`) to keep the plan default.
+  */
+  readonly freeTrial?: boolean;
+  /** Prepaid feature quantities to purchase up front. */
+  readonly options?: ReadonlyArray<PrepaidOption>;
+  /** The plan to attach (Autumn's plan id — the successor to the classic "product" id). */
+  readonly planId: string;
+  /** An Autumn reward id to apply as a discount. */
+  readonly reward?: string;
+  readonly successUrl?: string;
+}
+/** The subset of the Autumn SDK surface the native facade calls. A real `Autumn` instance satisfies it. */
+interface AutumnFeaturesClientLike {
+  readonly billing: unknown;
+  readonly entities: unknown;
+  readonly events: unknown;
+  readonly plans: unknown;
+  readonly referrals: unknown;
+}
+interface AutumnFeaturesOptions {
+  readonly client: AutumnFeaturesClientLike;
+}
+/** The Autumn-native feature facade returned by {@link createAutumnFeatures}. */
+interface AutumnFeatures {
+  readonly checkout: (referenceId: string, input: AutumnCheckoutInput) => Promise<{
+    raw: Record<string, unknown>;
+    url: string;
+  }>;
+  readonly entities: {
+    readonly create: (referenceId: string, input: CreateEntityInput) => Promise<AutumnEntity>;
+    readonly delete: (referenceId: string, entityId: string) => Promise<void>;
+    readonly get: (referenceId: string, entityId: string) => Promise<AutumnEntity>;
+  };
+  readonly events: {
+    readonly aggregate: (referenceId: string, input: EventsAggregateInput) => Promise<UsageEventPoint[]>;
+    readonly list: (referenceId: string, input: EventsListInput) => Promise<UsageEventPoint[]>;
+  };
+  readonly plans: {
+    readonly list: () => Promise<Record<string, unknown>[]>;
+  };
+  readonly referrals: {
+    readonly createCode: (referenceId: string, programId: string) => Promise<{
+      code: string;
+      raw: Record<string, unknown>;
+    }>;
+    readonly redeemCode: (referenceId: string, code: string) => Promise<Record<string, unknown>>;
+  };
+}
+/**
+* Build the Autumn-native feature facade over an injected client. Companion to `createAutumnAdapter`;
+* share the same underlying `autumn-js` `Autumn` client between them.
+*/
+declare const createAutumnFeatures: (options: AutumnFeaturesOptions) => AutumnFeatures;
+export { type AutumnCheckoutInput, type AutumnEntity, type AutumnFeatures, type AutumnFeaturesClientLike, type AutumnFeaturesOptions, type CreateEntityInput, type EventsAggregateInput, type EventsListInput, type PrepaidOption, type UsageEventPoint, createAutumnFeatures };

package/dist/providers/autumn-features.mjs

@@ -0,0 +1,95 @@
+import { a as asRecord, r as readString, b as readNumber } from '../packem_shared/json-DhcPm8EO.mjs';
+
+const toFeatureId = (featureId) => typeof featureId === "string" ? featureId : [...featureId];
+const entityFrom = (record) => {
+  return {
+    featureId: readString(record, "featureId") ?? readString(record, "feature_id"),
+    id: readString(record, "id") ?? "",
+    name: readString(record, "name"),
+    raw: record
+  };
+};
+const pointsFrom = (result) => {
+  const list = result.list ?? result.data ?? result.events;
+  const rows = Array.isArray(list) ? list : [];
+  return rows.map((entry) => {
+    const record = asRecord(entry);
+    return { count: readNumber(record, "count") ?? readNumber(record, "value") ?? 0, period: readString(record, "period"), raw: record };
+  });
+};
+const createAutumnFeatures = (options) => {
+  const client = options.client;
+  return {
+    /**
+     * Native Autumn checkout — supports opting out of a plan's free trial, prepaid feature
+     * quantities, entity scoping, and reward codes. Returns the hosted checkout URL (empty when
+     * Autumn applied the change directly without a payment step).
+     */
+    checkout: async (referenceId, input) => {
+      const result = asRecord(
+        await client.billing.attach({
+          customerId: referenceId,
+          // Autumn applies the plan's configured trial by default; `null` opts this checkout out.
+          // eslint-disable-next-line unicorn/no-null -- the SDK's customize.freeTrial requires null (not undefined) to disable
+          ...input.freeTrial === false ? { customize: { freeTrial: null } } : {},
+          discounts: input.reward ? [{ rewardId: input.reward }] : void 0,
+          entityId: input.entityId,
+          featureQuantities: input.options?.map((option) => {
+            return { featureId: option.featureId, quantity: option.quantity };
+          }),
+          planId: input.planId,
+          successUrl: input.successUrl
+        })
+      );
+      const url = readString(result, "paymentUrl") ?? readString(result, "checkoutUrl") ?? readString(result, "url") ?? "";
+      return { raw: result, url };
+    },
+    entities: {
+      /** Create a per-seat / per-workspace sub-customer under a reference. */
+      create: async (referenceId, input) => {
+        const created = await client.entities.create({ customerId: referenceId, entityId: input.id, featureId: input.featureId, name: input.name });
+        return entityFrom(asRecord(created));
+      },
+      /** Remove an entity — frees its seat/allowance. */
+      delete: async (referenceId, entityId) => {
+        await client.entities.delete({ customerId: referenceId, entityId });
+      },
+      /** Fetch one entity and its balances. */
+      get: async (referenceId, entityId) => {
+        const entity = await client.entities.get({ customerId: referenceId, entityId });
+        return entityFrom(asRecord(entity));
+      }
+    },
+    events: {
+      /** Bucketed usage aggregation for a reference's feature(s) over a range. */
+      aggregate: async (referenceId, input) => {
+        const result = await client.events.aggregate({ customerId: referenceId, featureId: toFeatureId(input.featureId), range: input.range });
+        return pointsFrom(asRecord(result));
+      },
+      /** Raw usage events for a reference's feature(s). */
+      list: async (referenceId, input) => {
+        const result = await client.events.list({ customerId: referenceId, featureId: toFeatureId(input.featureId) });
+        return pointsFrom(asRecord(result));
+      }
+    },
+    plans: {
+      /** The configured plan catalog. */
+      list: async () => {
+        const result = asRecord(await client.plans.list());
+        const list = result.list ?? result.data ?? result.plans;
+        return Array.isArray(list) ? list.map((entry) => asRecord(entry)) : [];
+      }
+    },
+    referrals: {
+      /** Mint (or fetch) a referral code for a reference in a referral program. */
+      createCode: async (referenceId, programId) => {
+        const result = asRecord(await client.referrals.createCode({ customerId: referenceId, programId }));
+        return { code: readString(result, "code") ?? "", raw: result };
+      },
+      /** Redeem a referral code on behalf of a reference. */
+      redeemCode: async (referenceId, code) => asRecord(await client.referrals.redeemCode({ code, customerId: referenceId }))
+    }
+  };
+};
+
+export { createAutumnFeatures };

package/dist/providers/autumn.d.mts

@@ -0,0 +1,19 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-iFA55DzU.mjs";
+/**
+* The `autumn-js` SDK surface the adapter uses, as a structural type — a real `Autumn` instance
+* satisfies it without a cast. Resources/methods are `unknown` (the adapter re-types the client as
+* the real `Autumn` internally); this keeps the SDK's full type out of the published declarations.
+*/
+interface AutumnClientLike {
+  readonly billing: unknown;
+  readonly check: unknown;
+  readonly customers: unknown;
+  readonly track: unknown;
+}
+interface AutumnAdapterOptions {
+  readonly client: AutumnClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+declare const createAutumnAdapter: (options: AutumnAdapterOptions) => PaymentAdapter;
+export { type AutumnAdapterOptions, type AutumnClientLike, createAutumnAdapter };

package/dist/providers/autumn.d.ts

@@ -0,0 +1,19 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-iFA55DzU.js";
+/**
+* The `autumn-js` SDK surface the adapter uses, as a structural type — a real `Autumn` instance
+* satisfies it without a cast. Resources/methods are `unknown` (the adapter re-types the client as
+* the real `Autumn` internally); this keeps the SDK's full type out of the published declarations.
+*/
+interface AutumnClientLike {
+  readonly billing: unknown;
+  readonly check: unknown;
+  readonly customers: unknown;
+  readonly track: unknown;
+}
+interface AutumnAdapterOptions {
+  readonly client: AutumnClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+declare const createAutumnAdapter: (options: AutumnAdapterOptions) => PaymentAdapter;
+export { type AutumnAdapterOptions, type AutumnClientLike, createAutumnAdapter };