@umituz/web-payment 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 umituz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,350 @@
-# Temporary Holding Version
+# @umituz/web-payment
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Universal web payment and subscription billing engine with multi-provider architecture (Polar.sh, Stripe, etc.), an HTTP adapter, a turnkey billing portal, and React bindings.
+
+The SDK is split into an **adapter-agnostic core** (`BillingAdapter` contract, payment models, calculation primitives)
+and a **React presentation layer** (`BillingProvider`, `useBilling`).
+The HTTP adapter binds the contract to your own API; any payment backend can
+be plugged in by implementing the same interface.
+
+## Features
+
+- Multi-provider architecture with adapter-agnostic core (`BillingAdapter`, `PaymentServerClient`)
+- Polar.sh client & webhook verification (`PolarBillingClient`, `verifyPolarWebhook`)
+- Extensible for Stripe and future payment gateways
+- HTTP adapter for your own REST backend (`createHttpAdapter`)
+- Common checkout utilities (`buildCheckoutMetadata`, `readCheckoutMetadata`, `formatReceiptNumber`)
+- Polar.sh product catalog (`getProducts`, `getProductById`, `getAllProducts`)
+- React provider + hooks (`BillingProvider`, `useBilling`, `useProducts`)
+- Ready-made UI: pricing table, checkout button, status badge, billing
+  history, customer portal link, cancel flow — all localizable
+- Turnkey billing portal page (`TurnkeyBillingPage`)
+- Strongly-typed domain models, abortable I/O
+
+## Installation
+
+```bash
+npm install @umituz/web-payment
+```
+
+Peers are **optional** — install only what you use:
+
+| You use… | Also install | Runtime requirement |
+|---|---|---|
+| `…/core` | — | Any JS runtime (zero deps) |
+| `…/products` | — | `fetch` (browsers, Node ≥ 18, workers) |
+| `…/react` | `react` (≥ 18) | React DOM or React Native Web |
+| root (`@umituz/web-polar-payment`) | `react` if you use the React parts | Node ≥ 18 (`engines`) |
+
+`react-dom` is **not** required. The package is fully tree-shakeable
+(`sideEffects: false`, ESM + CJS + `.d.ts` via tsup).
+
+## Subpath entries
+
+Each surface pulls in only its own dependencies — importing `/react`
+never loads server code, importing `/core` loads nothing at all:
+
+```ts
+// Pure domain — types, enums, mappers, the BillingAdapter contract
+import { BILLING_CYCLE, parseBillingCycle, mapProduct } from '@umituz/web-polar-payment/core';
+
+// Polar.sh product catalog over a pluggable HttpClient
+import { ProductRepository, FetchHttpClient } from '@umituz/web-polar-payment/products';
+
+// React layer: provider, hooks, components, theme tokens
+import { BillingProvider, PricingTable } from '@umituz/web-polar-payment/react';
+
+// Server-side Polar.sh operations: checkout sessions, customer portal,
+// subscription management, webhook signature verification (server only!)
+import { BillingClient, verifyWebhook } from '@umituz/web-polar-payment/server';
+
+// Browser BillingAdapter over your own REST endpoints
+import { createHttpAdapter } from '@umituz/web-polar-payment/http';
+
+// Turnkey billing portal page over any adapter
+import { TurnkeyBillingPage } from '@umituz/web-polar-payment/portal';
+
+// Root entry = everything above (backwards-compatible import paths)
+import { useBilling } from '@umituz/web-polar-payment';
+```
+
+## Usage
+
+### 1. Wrap the app
+
+```tsx
+import { BillingProvider, createHttpAdapter } from '@umituz/web-polar-payment';
+
+const adapter = createHttpAdapter({
+  baseUrl: '/api/billing',
+  getUserId: () => session.organizationId,
+});
+
+function App({ userId, children }) {
+  return (
+    <BillingProvider adapter={adapter} userId={userId}>
+      {children}
+    </BillingProvider>
+  );
+}
+```
+
+### 2. Read subscription state
+
+```tsx
+import { useBilling } from '@umituz/web-polar-payment';
+
+function PlanBadge() {
+  const { status, loading } = useBilling();
+  if (loading) return null;
+  return <span>{status.plan}</span>;
+}
+```
+
+### 3. Start a checkout
+
+```tsx
+import { useBilling } from '@umituz/web-polar-payment';
+
+function UpgradeButton({ productId }) {
+  const { startCheckout } = useBilling();
+  return (
+    <button onClick={() => startCheckout({ productId, billingCycle: 'monthly' })}>
+      Upgrade
+    </button>
+  );
+}
+```
+
+### 4. Sync after a checkout redirect
+
+```tsx
+import { useEffect } from 'react';
+import { useBilling } from '@umituz/web-polar-payment';
+
+function CheckoutReturn() {
+  const { syncSubscription } = useBilling();
+  useEffect(() => {
+    void syncSubscription();
+  }, [syncSubscription]);
+  return null;
+}
+```
+
+### 5. Pricing table — the secure pattern
+
+Fetch products **on your server** and pass them down; no access token ever
+reaches the browser bundle:
+
+```tsx
+// server.ts
+import { getAllProducts } from '@umituz/web-polar-payment/products';
+
+const products = await getAllProducts(
+  { apiToken: process.env.POLAR_OAT_TOKEN! }, // server-side secret
+  { isRecurring: true },
+);
+
+// PricingPage.tsx
+<PricingTable products={products} ctaLabel="Subscribe" />
+```
+
+> ⚠️ OAT tokens grant full account access — never ship them to a public
+> browser bundle. The `apiToken` prop on `PricingTable` exists for local
+> development only.
+
+### 6. Localize any component
+
+Every component takes an optional `labels` subset and `locale`:
+
+```tsx
+<SubscriptionStatusBadge
+  loading={false}
+  status={status}
+  locale="de-DE"
+  labels={{ statuses: { active: 'Aktiv' }, endsPrefix: 'endet' }}
+/>
+```
+
+### 7. Own REST backend — `./server` + `./http`
+
+When the backend is your own API worker (any runtime with `fetch`), split the
+work with the two transport entry points:
+
+```ts
+// api/billing.ts — server side
+import {
+  BillingClient,
+  verifyWebhook,
+  parseWebhookEvent,
+  asCheckoutCompleted,
+  asSubscriptionChanged,
+  asOrderPaid,
+} from '@umituz/web-polar-payment/server';
+
+const billing = new BillingClient({
+  apiToken: env.POLAR_ACCESS_TOKEN!,     // OAT token, server only
+  sandbox: env.POLAR_SANDBOX === 'true', // sandbox-api.polar.sh
+});
+
+// Checkout: POST /v1/checkouts with `products: [id]` — metadata is copied
+// onto the order/subscription. Never collect card data yourself: redirect
+// the browser to `checkout.url` (Polar-hosted, PCI scope stays SAQ-A).
+const checkout = await billing.createCheckout({
+  productId,
+  successUrl: `${appUrl}/billing/return?checkout_id={CHECKOUT_ID}`,
+  externalCustomerId: user.id, // links your user to the Polar customer
+  metadata: { organizationId: user.orgId },
+});
+
+// Dynamic amount (bookings, pay-what-you-want floors): an ad-hoc fixed
+// price is created on the checkout session, catalog product stays intact
+const bookingCheckout = await billing.createCheckout({
+  productId: bookingProductId,
+  amountCents: 2500,
+  currency: 'usd',
+  allowDiscountCodes: false,
+  metadata: { bookingId },
+});
+
+// One-time products (digital goods): POST /v1/products with a fixed price
+const product = await billing.createProduct({
+  name: 'Ultralight Gear Course',
+  amountCents: 7900, // smallest currency unit
+  metadata: { creatorId },
+});
+
+// Managed billing portal (payment methods, invoices, cancellation)
+const { url } = await billing.createPortalSession(customerId, appUrl);
+
+// Cancel at period end (reversible) vs revoke (immediate)
+await billing.updateSubscription(subscriptionId, { cancelAtPeriodEnd: true });
+
+// Webhooks: Standard Webhooks spec — verify the RAW body, before JSON.parse
+const raw = await request.text();
+if (!(await verifyWebhook(raw, request.headers, env.POLAR_WEBHOOK_SECRET))) {
+  return new Response('invalid signature', { status: 401 });
+}
+// Then parse the (still raw) body into a typed event view
+const event = parseWebhookEvent(raw);
+const sale = event && asCheckoutCompleted(event);        // checkout.completed
+const change = event && asSubscriptionChanged(event);    // subscription.* lifecycle
+const paid = event && asOrderPaid(event);                // order.paid (renewals)
+```
+
+The browser side binds the same `BillingAdapter` contract to six endpoints under
+one base path — implement them on your worker to match:
+
+```ts
+// app/billing.ts — browser side
+import { createHttpAdapter } from '@umituz/web-polar-payment/http';
+
+const adapter = createHttpAdapter({
+  baseUrl: '/api/billing',
+  getUserId: () => session.organizationId, // used when a call has no id
+});
+
+//   GET  /status?userId=    POST /checkout { productId, billingCycle?, ... }
+//   POST /sync { checkoutId? }              GET  /history?userId=
+//   POST /cancel { reason? }                GET  /portal?userId=
+```
+
+Failures return a `{ "error": string | { "message": string } }` envelope with
+a non-2xx status; the adapter surfaces it as `Error("detail (HTTP status)")`.
+
+### 8. Turnkey billing page — `./portal` over any adapter
+
+`TurnkeyBillingPage` composes the whole portal (plan comparison, subscription
+tabs, invoices, hosted-portal payment methods) over a `BillingAdapter`. The
+host binds the adapter and the server-fetched catalog; everything else —
+data loading, checkout redirects, cancellation — is wired inside:
+
+```tsx
+import { TurnkeyBillingPage } from '@umituz/web-polar-payment/portal';
+import { createHttpAdapter } from '@umituz/web-polar-payment/http';
+
+// products: fetched from your server (metadata.planId tags plan keys)
+<TurnkeyBillingPage
+  adapter={createHttpAdapter({ baseUrl: '/api/billing', getUserId: () => orgId })}
+  products={products}
+  config={{ brandName: 'Acme', supportEmail: 'billing@acme.dev' }}
+/>
+```
+
+Prefer composing yourself? `createPortalClient({ adapter, products })`
+returns the portal's `BillingApiClient` seam (plus `selectPlan` /
+`openPortal`) for direct use with `useBilling`.
+
+## Error handling
+
+Server-side failures throw `BillingApiError` with the HTTP `status` and the
+raw `body` attached — check with `isBillingApiError(error)`. Browser-side
+adapter failures surface as plain `Error` values carrying the endpoint's
+`{ "error": ... }` envelope detail and the HTTP status.
+
+## Architecture
+
+```
+src/
+├── core.ts / products.ts / react.tsx   # subpath entries (+ server, http, portal)
+├── domain/                       # Pure types + interfaces (no I/O)
+│   ├── entities/                 #   Subscription, Checkout, Order, ...
+│   ├── enums/                    #   SubscriptionStatus, BillingCycle, ...
+│   ├── interfaces/               #   BillingAdapter contract
+│   ├── utils/                    #   minor-unit money math
+│   └── mappers/                  #   snake_case DTO → camelCase domain
+├── infrastructure/               # Transport, repositories, utilities
+│   ├── http/                     #   HttpClient (Strategy, AbortSignal-aware)
+│   ├── query/                    #   QueryBuilder (Builder)
+│   ├── pagination/               #   PageIterator (Iterator)
+│   ├── services/                 #   ProductRepository, BillingClient,
+│   │   └── http/                 #   createHttpAdapter (six-endpoint contract)
+│   ├── constants/                #   SUBSCRIPTION_STATUS, API base URL
+│   └── utils/                    #   validation, security, type-guards
+└── presentation/                 # React layer
+    ├── context/                  #   BillingContext (race-safe refresh)
+    ├── hooks/                    #   useBilling, useProducts
+    ├── navigation/               #   NavigationStrategy
+    ├── portal/                   #   Turnkey billing portal (page + client)
+    ├── theme/                    #   VisualTokens (self-contained)
+    └── components/               #   Provider + UI components
+```
+
+### Patterns in use
+
+- **Adapter** — `BillingAdapter` interface, HTTP implementation
+- **Repository** — one repository per business operation
+- **Strategy** — `HttpClient` (swap `fetch` for tests), `NavigationStrategy`
+- **Builder** — `QueryBuilder` for URL search params
+- **Iterator** — `PageIterator` for paginated Polar.sh lists
+- **Error as a value** — `BillingApiError` carries status + raw body
+
+### Design decisions
+
+- **Dependency direction points inward.** `presentation` and
+  `infrastructure` depend on `domain`; `domain` depends on nothing. This is
+  what lets each subpath ship with only its own dependencies.
+- **VisualTokens are self-contained** rather than depending on a shared
+  design-system package: a billing SDK must be droppable into any app
+  without dragging a UI framework along. Override styles via `labels`,
+  `locale`, and component composition instead.
+- **Localization via prop injection, not an i18n framework** — `labels`
+  objects with English defaults keep the runtime dependency-free while
+  still allowing full translation.
+- **Optimistic-free state**: `BillingProvider` serializes refreshes behind a
+  generation counter; a slow earlier response can never overwrite a newer
+  one.
+
+## Development
+
+```bash
+npm run typecheck   # tsc --noEmit
+npm run lint        # eslint (flat config)
+npm test            # vitest — 170 tests (domain, infra, presentation)
+npm run build       # tsup — CJS + ESM + d.ts for every subpath entry
+npm pack --dry-run  # inspect the publishable tarball
+```
+
+## License
+
+MIT

package/dist/billing-adapter.interface-CDkeeowZ.d.mts

@@ -0,0 +1,94 @@
+import { b as BillingCycle } from './billing-cycle.enum--hJRYlgP.mjs';
+
+declare const SUBSCRIPTION_STATUS: {
+    readonly ACTIVE: "active";
+    readonly CANCELED: "canceled";
+    readonly REVOKED: "revoked";
+    readonly TRIALING: "trialing";
+    readonly PAST_DUE: "past_due";
+    readonly INCOMPLETE: "incomplete";
+    readonly INCOMPLETE_EXPIRED: "incomplete_expired";
+    readonly UNPAID: "unpaid";
+    readonly NONE: "none";
+};
+declare const SUBSCRIPTION_STATUS_VALUES: readonly ["active", "canceled", "revoked", "trialing", "past_due", "incomplete", "incomplete_expired", "unpaid", "none"];
+type SubscriptionStatusValue = (typeof SUBSCRIPTION_STATUS_VALUES)[number];
+declare function isKnownSubscriptionStatus(value: unknown): value is SubscriptionStatusValue;
+
+declare const CANCELLATION_REASON: Readonly<{
+    readonly TOO_EXPENSIVE: "too_expensive";
+    readonly MISSING_FEATURES: "missing_features";
+    readonly SWITCHED_SERVICE: "switched_service";
+    readonly UNUSED: "unused";
+    readonly CUSTOMER_SERVICE: "customer_service";
+    readonly LOW_QUALITY: "low_quality";
+    readonly TOO_COMPLEX: "too_complex";
+    readonly OTHER: "other";
+}>;
+declare const CANCELLATION_REASON_VALUES: readonly ["too_expensive", "missing_features", "switched_service", "unused", "customer_service", "low_quality", "too_complex", "other"];
+type CancellationReason = (typeof CANCELLATION_REASON_VALUES)[number];
+interface CancelResult {
+    success: boolean;
+    endsAt?: string;
+}
+
+interface SubscriptionStatus {
+    plan: string;
+    subscriptionId?: string;
+    subscriptionStatus: SubscriptionStatusValue;
+    cancelAtPeriodEnd?: boolean;
+    currentPeriodEnd?: string;
+    billingCycle?: BillingCycle;
+    providerCustomerId?: string;
+}
+declare const FREE_SUBSCRIPTION_STATUS: SubscriptionStatus;
+declare function isActiveSubscription(status: SubscriptionStatus): boolean;
+
+interface CheckoutParams {
+    productId?: string;
+    productKey?: string;
+    itemId?: string;
+    couponCode?: string;
+    planKey?: string;
+    billingCycle?: BillingCycle;
+    successUrl?: string;
+    userId?: string;
+    customerEmail?: string;
+    seats?: number;
+    metadata?: Record<string, string | number | boolean>;
+}
+interface CheckoutResult {
+    url: string;
+    id: string;
+}
+
+interface OrderItem {
+    id: string;
+    createdAt: string;
+    amount: number;
+    currency: string;
+    status: string;
+    paid: boolean;
+    productName?: string;
+    itemType?: string;
+    itemId?: string;
+    amountUsd?: number;
+    receiptNumber?: string;
+    invoiceUrl?: string;
+}
+
+interface SyncResult {
+    synced: boolean;
+    plan?: string;
+}
+
+interface BillingAdapter {
+    getStatus(userId: string): Promise<SubscriptionStatus>;
+    createCheckout(params: CheckoutParams): Promise<CheckoutResult>;
+    syncSubscription(userId: string, checkoutId?: string): Promise<SyncResult>;
+    getBillingHistory(userId: string): Promise<OrderItem[]>;
+    cancelSubscription(reason?: CancellationReason): Promise<CancelResult>;
+    getPortalUrl(userId: string): Promise<string>;
+}
+
+export { type BillingAdapter as B, CANCELLATION_REASON as C, FREE_SUBSCRIPTION_STATUS as F, type OrderItem as O, SUBSCRIPTION_STATUS as S, CANCELLATION_REASON_VALUES as a, type CancelResult as b, type CancellationReason as c, type CheckoutParams as d, type CheckoutResult as e, SUBSCRIPTION_STATUS_VALUES as f, type SubscriptionStatus as g, type SubscriptionStatusValue as h, type SyncResult as i, isActiveSubscription as j, isKnownSubscriptionStatus as k };

package/dist/billing-adapter.interface-m7yE50I0.d.ts

@@ -0,0 +1,94 @@
+import { b as BillingCycle } from './billing-cycle.enum--hJRYlgP.js';
+
+declare const SUBSCRIPTION_STATUS: {
+    readonly ACTIVE: "active";
+    readonly CANCELED: "canceled";
+    readonly REVOKED: "revoked";
+    readonly TRIALING: "trialing";
+    readonly PAST_DUE: "past_due";
+    readonly INCOMPLETE: "incomplete";
+    readonly INCOMPLETE_EXPIRED: "incomplete_expired";
+    readonly UNPAID: "unpaid";
+    readonly NONE: "none";
+};
+declare const SUBSCRIPTION_STATUS_VALUES: readonly ["active", "canceled", "revoked", "trialing", "past_due", "incomplete", "incomplete_expired", "unpaid", "none"];
+type SubscriptionStatusValue = (typeof SUBSCRIPTION_STATUS_VALUES)[number];
+declare function isKnownSubscriptionStatus(value: unknown): value is SubscriptionStatusValue;
+
+declare const CANCELLATION_REASON: Readonly<{
+    readonly TOO_EXPENSIVE: "too_expensive";
+    readonly MISSING_FEATURES: "missing_features";
+    readonly SWITCHED_SERVICE: "switched_service";
+    readonly UNUSED: "unused";
+    readonly CUSTOMER_SERVICE: "customer_service";
+    readonly LOW_QUALITY: "low_quality";
+    readonly TOO_COMPLEX: "too_complex";
+    readonly OTHER: "other";
+}>;
+declare const CANCELLATION_REASON_VALUES: readonly ["too_expensive", "missing_features", "switched_service", "unused", "customer_service", "low_quality", "too_complex", "other"];
+type CancellationReason = (typeof CANCELLATION_REASON_VALUES)[number];
+interface CancelResult {
+    success: boolean;
+    endsAt?: string;
+}
+
+interface SubscriptionStatus {
+    plan: string;
+    subscriptionId?: string;
+    subscriptionStatus: SubscriptionStatusValue;
+    cancelAtPeriodEnd?: boolean;
+    currentPeriodEnd?: string;
+    billingCycle?: BillingCycle;
+    providerCustomerId?: string;
+}
+declare const FREE_SUBSCRIPTION_STATUS: SubscriptionStatus;
+declare function isActiveSubscription(status: SubscriptionStatus): boolean;
+
+interface CheckoutParams {
+    productId?: string;
+    productKey?: string;
+    itemId?: string;
+    couponCode?: string;
+    planKey?: string;
+    billingCycle?: BillingCycle;
+    successUrl?: string;
+    userId?: string;
+    customerEmail?: string;
+    seats?: number;
+    metadata?: Record<string, string | number | boolean>;
+}
+interface CheckoutResult {
+    url: string;
+    id: string;
+}
+
+interface OrderItem {
+    id: string;
+    createdAt: string;
+    amount: number;
+    currency: string;
+    status: string;
+    paid: boolean;
+    productName?: string;
+    itemType?: string;
+    itemId?: string;
+    amountUsd?: number;
+    receiptNumber?: string;
+    invoiceUrl?: string;
+}
+
+interface SyncResult {
+    synced: boolean;
+    plan?: string;
+}
+
+interface BillingAdapter {
+    getStatus(userId: string): Promise<SubscriptionStatus>;
+    createCheckout(params: CheckoutParams): Promise<CheckoutResult>;
+    syncSubscription(userId: string, checkoutId?: string): Promise<SyncResult>;
+    getBillingHistory(userId: string): Promise<OrderItem[]>;
+    cancelSubscription(reason?: CancellationReason): Promise<CancelResult>;
+    getPortalUrl(userId: string): Promise<string>;
+}
+
+export { type BillingAdapter as B, CANCELLATION_REASON as C, FREE_SUBSCRIPTION_STATUS as F, type OrderItem as O, SUBSCRIPTION_STATUS as S, CANCELLATION_REASON_VALUES as a, type CancelResult as b, type CancellationReason as c, type CheckoutParams as d, type CheckoutResult as e, SUBSCRIPTION_STATUS_VALUES as f, type SubscriptionStatus as g, type SubscriptionStatusValue as h, type SyncResult as i, isActiveSubscription as j, isKnownSubscriptionStatus as k };

package/dist/billing-cycle.enum--hJRYlgP.d.mts

@@ -0,0 +1,10 @@
+declare const BILLING_CYCLE: Readonly<{
+    readonly MONTHLY: "monthly";
+    readonly YEARLY: "yearly";
+}>;
+declare const BILLING_CYCLE_VALUES: readonly ["monthly", "yearly"];
+type BillingCycle = (typeof BILLING_CYCLE_VALUES)[number];
+declare function isKnownBillingCycle(value: unknown): value is BillingCycle;
+declare function parseBillingCycle(value: unknown): BillingCycle | null;
+
+export { BILLING_CYCLE as B, BILLING_CYCLE_VALUES as a, type BillingCycle as b, isKnownBillingCycle as i, parseBillingCycle as p };

package/dist/billing-cycle.enum--hJRYlgP.d.ts

@@ -0,0 +1,10 @@
+declare const BILLING_CYCLE: Readonly<{
+    readonly MONTHLY: "monthly";
+    readonly YEARLY: "yearly";
+}>;
+declare const BILLING_CYCLE_VALUES: readonly ["monthly", "yearly"];
+type BillingCycle = (typeof BILLING_CYCLE_VALUES)[number];
+declare function isKnownBillingCycle(value: unknown): value is BillingCycle;
+declare function parseBillingCycle(value: unknown): BillingCycle | null;
+
+export { BILLING_CYCLE as B, BILLING_CYCLE_VALUES as a, type BillingCycle as b, isKnownBillingCycle as i, parseBillingCycle as p };

package/dist/billing-env-D4YjvA3M.d.mts

@@ -0,0 +1,8 @@
+declare const CHECKOUT_ID_PARAM = "checkout_id";
+declare const CHECKOUT_ID_PLACEHOLDER = "{CHECKOUT_ID}";
+type ProductIdMap = Map<string, string>;
+declare function parseProductIds(raw: string | undefined): ProductIdMap;
+declare function productIdOf(ids: ProductIdMap, productKey: string): string | null;
+declare function successUrlWithCheckoutId(origin: string, returnPath: string): string;
+
+export { CHECKOUT_ID_PARAM as C, type ProductIdMap as P, CHECKOUT_ID_PLACEHOLDER as a, productIdOf as b, parseProductIds as p, successUrlWithCheckoutId as s };

package/dist/billing-env-D4YjvA3M.d.ts

@@ -0,0 +1,8 @@
+declare const CHECKOUT_ID_PARAM = "checkout_id";
+declare const CHECKOUT_ID_PLACEHOLDER = "{CHECKOUT_ID}";
+type ProductIdMap = Map<string, string>;
+declare function parseProductIds(raw: string | undefined): ProductIdMap;
+declare function productIdOf(ids: ProductIdMap, productKey: string): string | null;
+declare function successUrlWithCheckoutId(origin: string, returnPath: string): string;
+
+export { CHECKOUT_ID_PARAM as C, type ProductIdMap as P, CHECKOUT_ID_PLACEHOLDER as a, productIdOf as b, parseProductIds as p, successUrlWithCheckoutId as s };

package/dist/checkout-metadata-D7Wp_DAD.d.mts

@@ -0,0 +1,27 @@
+declare const PAYMENT_PROVIDER: {
+    readonly POLAR: "polar";
+    readonly STRIPE: "stripe";
+};
+declare const PAYMENT_PROVIDER_VALUES: ("polar" | "stripe")[];
+type PaymentProvider = (typeof PAYMENT_PROVIDER)[keyof typeof PAYMENT_PROVIDER];
+declare function isKnownPaymentProvider(value: unknown): value is PaymentProvider;
+
+declare function formatReceiptNumber(id: string, prefix?: string): string;
+
+interface CheckoutOrderMetadata {
+    userId: string;
+    itemType: string;
+    itemId: string;
+    couponCode?: string;
+}
+interface BuildCheckoutMetadataInput {
+    userId: string;
+    itemType: string;
+    itemId: string;
+    couponCode?: string;
+    extra?: Record<string, string>;
+}
+declare function buildCheckoutMetadata(input: BuildCheckoutMetadataInput): Record<string, string>;
+declare function readCheckoutMetadata(metadata: Record<string, unknown> | undefined, allowedItemTypes: readonly string[]): CheckoutOrderMetadata | null;
+
+export { type BuildCheckoutMetadataInput as B, type CheckoutOrderMetadata as C, PAYMENT_PROVIDER as P, PAYMENT_PROVIDER_VALUES as a, type PaymentProvider as b, buildCheckoutMetadata as c, formatReceiptNumber as f, isKnownPaymentProvider as i, readCheckoutMetadata as r };

package/dist/checkout-metadata-D7Wp_DAD.d.ts

@@ -0,0 +1,27 @@
+declare const PAYMENT_PROVIDER: {
+    readonly POLAR: "polar";
+    readonly STRIPE: "stripe";
+};
+declare const PAYMENT_PROVIDER_VALUES: ("polar" | "stripe")[];
+type PaymentProvider = (typeof PAYMENT_PROVIDER)[keyof typeof PAYMENT_PROVIDER];
+declare function isKnownPaymentProvider(value: unknown): value is PaymentProvider;
+
+declare function formatReceiptNumber(id: string, prefix?: string): string;
+
+interface CheckoutOrderMetadata {
+    userId: string;
+    itemType: string;
+    itemId: string;
+    couponCode?: string;
+}
+interface BuildCheckoutMetadataInput {
+    userId: string;
+    itemType: string;
+    itemId: string;
+    couponCode?: string;
+    extra?: Record<string, string>;
+}
+declare function buildCheckoutMetadata(input: BuildCheckoutMetadataInput): Record<string, string>;
+declare function readCheckoutMetadata(metadata: Record<string, unknown> | undefined, allowedItemTypes: readonly string[]): CheckoutOrderMetadata | null;
+
+export { type BuildCheckoutMetadataInput as B, type CheckoutOrderMetadata as C, PAYMENT_PROVIDER as P, PAYMENT_PROVIDER_VALUES as a, type PaymentProvider as b, buildCheckoutMetadata as c, formatReceiptNumber as f, isKnownPaymentProvider as i, readCheckoutMetadata as r };