@sweepconsole/node 0.0.0-stage → 0.1.0

package/dist/client.js

@@ -0,0 +1,433 @@
+import { errorFrom, SweepError } from "./errors.js";
+// The API is its own origin, not a path under the website. www.sweepconsole.xyz
+// is the Vercel-hosted front end and answers every path with the app shell, so
+// pointing a client there yields a 200 full of HTML — see `parse` below, which
+// exists because that mistake is otherwise diagnosed by JSON.parse.
+const DEFAULT_BASE_URL = "https://api.sweepconsole.xyz";
+/**
+ * Refuse to carry a secret key over plaintext.
+ *
+ * Every request sends `Authorization: Bearer <your key>`. An http baseUrl —
+ * from a typo, a copied tunnel URL, or an environment variable someone else
+ * can set — puts that key on the wire in clear, where it buys the ability to
+ * charge this merchant's payers. Loopback is exempt because that is where
+ * people legitimately run the API while developing.
+ */
+function checkedBaseUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error(`Sweep: baseUrl is not a URL: ${JSON.stringify(raw)}`);
+    }
+    const host = url.hostname.toLowerCase();
+    const loopback = host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || host.endsWith(".localhost");
+    if (url.protocol !== "https:" && !loopback) {
+        throw new Error(`Sweep: baseUrl must be https — ${url.protocol}//${url.host} would send your API key in clear. ` +
+            `Only localhost may use http.`);
+    }
+    return raw.replace(/\/+$/, "");
+}
+export class Sweep {
+    mandates;
+    charges;
+    /** Hosted plans: start a checkout for a plan you made in the portal. */
+    checkout;
+    /** Hosted plans: read and cancel what checkout created. */
+    subscriptions;
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    maxRetries;
+    constructor(apiKey, options = {}) {
+        if (!apiKey) {
+            throw new Error("Sweep: an API key is required. Create one in the portal under API Keys, " +
+                "and read it from the environment — never commit it.");
+        }
+        if (apiKey.startsWith("live_")) {
+            // Better here than as a 403 three calls later.
+            throw new Error("Sweep: live API keys are not issued yet. Use your test_ key.");
+        }
+        this.apiKey = apiKey;
+        this.baseUrl = checkedBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL);
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.mandates = new Mandates(this);
+        this.charges = new Charges(this);
+        this.checkout = { sessions: new Sessions(this) };
+        this.subscriptions = new Subscriptions(this);
+    }
+    /**
+     * A 200 that is not JSON almost always means `baseUrl` is pointing at the web
+     * app rather than the API — a single-page app answers every path with its
+     * index.html, so the request "succeeds" and then dies in JSON.parse with
+     * `Unexpected token '<'`. Say that, rather than letting the parser say it.
+     */
+    async parse(res) {
+        const text = await res.text();
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const looksLikeHtml = /^\s*<(!doctype|html)/i.test(text);
+            throw new SweepError(looksLikeHtml
+                ? `Expected JSON from ${res.url} but got an HTML page. This usually means baseUrl points at the ` +
+                    `website rather than the API — check the API base URL in your Sweep portal.`
+                : `Expected JSON from ${res.url} but got ${res.headers.get("content-type") ?? "an unknown type"}.`, { code: "invalid_response", status: res.status });
+        }
+    }
+    /** @internal */
+    async request(method, path, opts = {}) {
+        const url = new URL(this.baseUrl + path);
+        for (const [k, v] of Object.entries(opts.query ?? {})) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        }
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            "User-Agent": "sweepconsole-node/0.1.0",
+        };
+        if (opts.body !== undefined)
+            headers["Content-Type"] = "application/json";
+        if (opts.idempotencyKey)
+            headers["Idempotency-Key"] = opts.idempotencyKey;
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            if (attempt > 0)
+                await sleep(250 * 2 ** (attempt - 1));
+            try {
+                const res = await fetch(url, {
+                    method,
+                    headers,
+                    body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
+                    signal: AbortSignal.timeout(this.timeoutMs),
+                });
+                if (res.ok)
+                    return (await this.parse(res));
+                // 5xx and 429 may succeed on a retry; a 4xx is a decision, not a blip.
+                if ((res.status >= 500 || res.status === 429) && attempt < this.maxRetries) {
+                    lastError = errorFrom(res.status, await safeJson(res));
+                    continue;
+                }
+                throw errorFrom(res.status, await safeJson(res));
+            }
+            catch (e) {
+                if (e instanceof SweepError)
+                    throw e;
+                // Network-level: DNS, connection reset, timeout.
+                lastError = e;
+                if (attempt >= this.maxRetries) {
+                    throw new SweepError(`Could not reach the Sweep API: ${e instanceof Error ? e.message : String(e)}`, { code: "network_error", status: 0 });
+                }
+            }
+        }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
+}
+class Mandates {
+    sweep;
+    constructor(sweep) {
+        this.sweep = sweep;
+    }
+    /**
+     * Create a pending mandate and get back the URL to send the payer to.
+     *
+     * Nothing is authorized yet. The mandate becomes chargeable when the payer
+     * signs and `mandate.authorized` fires — start your billing clock on that
+     * webhook, not on the redirect, which they can close.
+     */
+    async create(params) {
+        return toMandate(await this.sweep.request("POST", "/v1/mandates", {
+            body: {
+                external_ref: params.externalRef,
+                email: params.email,
+                max_amount: params.maxAmount,
+                interval: params.interval,
+                chains: params.chains,
+                expires_at: params.expiresAt.toISOString(),
+                return_url: params.returnUrl,
+                metadata: params.metadata,
+            },
+        }));
+    }
+    async retrieve(id) {
+        return toMandate(await this.sweep.request("GET", `/v1/mandates/${encodeURIComponent(id)}`));
+    }
+    async list(params = {}) {
+        const body = await this.sweep.request("GET", "/v1/mandates", {
+            query: { status: params.status, limit: params.limit },
+        });
+        return rows(body).map(toMandate);
+    }
+    /**
+     * Stop honouring a mandate. Idempotent, and fires `mandate.revoked`.
+     *
+     * This is a decision recorded on our side, not a cryptographic one: the
+     * grants stay signed on chain, because only the payer's wallet can disable
+     * them. We stop redeeming them.
+     */
+    async revoke(id) {
+        return toMandate(await this.sweep.request("DELETE", `/v1/mandates/${encodeURIComponent(id)}`));
+    }
+}
+class Charges {
+    sweep;
+    constructor(sweep) {
+        this.sweep = sweep;
+    }
+    /**
+     * Collect one pull against a mandate.
+     *
+     * Answers 202, never 200: the charge row exists immediately, the money
+     * arrives seconds to minutes later. Learn the outcome from
+     * `charge.succeeded` / `charge.failed`, or by polling `retrieve`.
+     *
+     * `idempotencyKey` is required by this signature rather than by a runtime
+     * 400. Use a natural key — an invoice id, or `${userId}:${period}` — so that
+     * a retry after a timeout cannot collect twice.
+     */
+    async create(params, opts) {
+        if (!opts?.idempotencyKey?.trim()) {
+            throw new Error("Sweep: charges.create needs an idempotencyKey. Use a natural one — an invoice id, " +
+                "or `${userId}:${period}` — so a retry collects once rather than twice.");
+        }
+        return toCharge(await this.sweep.request("POST", "/v1/charges", {
+            idempotencyKey: opts.idempotencyKey.trim(),
+            body: {
+                mandate: typeof params.mandate === "string" ? params.mandate : params.mandate.id,
+                amount: params.amount,
+                description: params.description,
+                metadata: params.metadata,
+            },
+        }));
+    }
+    async retrieve(id) {
+        return toCharge(await this.sweep.request("GET", `/v1/charges/${encodeURIComponent(id)}`));
+    }
+    async list(params = {}) {
+        const body = await this.sweep.request("GET", "/v1/charges", {
+            query: { mandate: params.mandate, status: params.status, limit: params.limit },
+        });
+        return rows(body).map(toCharge);
+    }
+}
+// ─── wire → typed ─────────────────────────────────────────────────────────────
+function rows(body) {
+    if (Array.isArray(body))
+        return body;
+    const d = body?.data;
+    return Array.isArray(d) ? d : [];
+}
+function date(v) {
+    return new Date(String(v));
+}
+function maybeDate(v) {
+    return v == null ? null : new Date(String(v));
+}
+function toMandate(raw) {
+    return {
+        id: raw.id,
+        mode: "external",
+        status: raw.status,
+        externalRef: raw.external_ref,
+        email: raw.email ?? null,
+        verifiedEmail: raw.verified_email ?? null,
+        walletAddress: raw.wallet_address ?? null,
+        maxAmount: raw.max_amount,
+        currency: "USDC",
+        interval: raw.interval,
+        periodDuration: raw.period_duration,
+        chains: raw.chains ?? [],
+        testMode: !!raw.test_mode,
+        expiresAt: date(raw.expires_at),
+        authorizationUrl: raw.authorization_url ?? null,
+        authorizationUrlExpiresAt: date(raw.authorization_url_expires_at),
+        authorizedAt: maybeDate(raw.authorized_at),
+        revokedAt: maybeDate(raw.revoked_at),
+        metadata: raw.metadata ?? null,
+        createdAt: date(raw.created_at),
+    };
+}
+function toCharge(raw) {
+    return {
+        id: raw.id,
+        mandate: raw.mandate,
+        status: raw.status,
+        amount: raw.amount,
+        currency: raw.currency ?? "USDC",
+        description: raw.description ?? null,
+        externalRef: raw.external_ref,
+        metadata: raw.metadata ?? null,
+        testMode: !!raw.test_mode,
+        sourceChain: raw.source_chain ?? null,
+        settlementChain: raw.settlement_chain ?? null,
+        txHash: raw.tx_hash ?? null,
+        failureReason: raw.failure_reason ?? null,
+        createdAt: date(raw.created_at),
+        settledAt: maybeDate(raw.settled_at),
+    };
+}
+function safeJson(res) {
+    return res.json().catch(() => null);
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/* ── Hosted plans ──────────────────────────────────────────────────────────── */
+function toSession(raw) {
+    const plan = raw["plan"];
+    return {
+        id: raw["session_id"],
+        url: raw["checkout_url"],
+        status: raw["status"],
+        ...(raw["session_token"] ? { sessionToken: raw["session_token"] } : {}),
+        plan: {
+            name: plan["name"],
+            amount: plan["amount"],
+            currency: "USDC",
+            interval: plan["interval"],
+        },
+        expiresAt: new Date(raw["expires_at"]),
+    };
+}
+function toRetrievedSession(raw) {
+    const plan = raw["plan"];
+    return {
+        id: raw["id"],
+        status: raw["status"],
+        externalRef: raw["external_ref"],
+        successUrl: raw["success_url"],
+        cancelUrl: raw["cancel_url"],
+        metadata: raw["metadata"] ?? null,
+        testMode: !!raw["test_mode"],
+        plan: {
+            name: plan["name"],
+            amount: plan["amount"],
+            currency: "USDC",
+            interval: plan["interval"],
+        },
+        subscriptionId: raw["subscription_id"] ?? null,
+        expiresAt: new Date(raw["expires_at"]),
+        createdAt: new Date(raw["created_at"]),
+    };
+}
+function toSubscription(raw) {
+    const plan = raw["plan"];
+    const date = (v) => (v ? new Date(v) : null);
+    return {
+        id: raw["id"],
+        externalRef: raw["external_ref"],
+        status: raw["status"],
+        walletAddress: raw["wallet_address"] ?? null,
+        activationMethod: raw["activation_method"],
+        testMode: !!raw["test_mode"],
+        plan: {
+            id: plan["id"],
+            name: plan["name"],
+            amount: plan["amount"],
+            currency: "USDC",
+            interval: plan["interval"],
+        },
+        txHash: raw["tx_hash"] ?? null,
+        currentPeriodStart: new Date(raw["current_period_start"]),
+        currentPeriodEnd: new Date(raw["current_period_end"]),
+        trialStart: date(raw["trial_start"]),
+        trialEnd: date(raw["trial_end"]),
+        cancelledAt: date(raw["cancelled_at"]),
+        createdAt: new Date(raw["created_at"]),
+        updatedAt: new Date(raw["updated_at"]),
+    };
+}
+class Sessions {
+    sweep;
+    constructor(sweep) {
+        this.sweep = sweep;
+    }
+    /**
+     * Start a hosted checkout and get the URL to send the payer to.
+     *
+     * This is the server half of a "Subscribe with USDC" button: call it from
+     * your own endpoint, where `externalRef` comes from your session rather than
+     * from the page, and return `url` for the browser to follow.
+     */
+    async create(params) {
+        return toSession(await this.sweep.request("POST", "/v1/checkout/sessions", {
+            body: {
+                plan_id: params.plan,
+                external_ref: params.externalRef,
+                success_url: params.successUrl,
+                cancel_url: params.cancelUrl,
+                ...(params.metadata && { metadata: params.metadata }),
+            },
+        }));
+    }
+    /**
+     * Read a session back. `subscriptionId` is set once checkout completed.
+     *
+     * Do not treat this as the signal to grant access: a payer who closed the tab
+     * leaves a session you will poll forever. Act on subscription.created.
+     */
+    async retrieve(id) {
+        return toRetrievedSession(await this.sweep.request("GET", `/v1/checkout/sessions/${encodeURIComponent(id)}`));
+    }
+    /** Close an open session early, so its link stops working. */
+    async expire(id) {
+        return this.sweep.request("POST", `/v1/checkout/sessions/${encodeURIComponent(id)}/expire`);
+    }
+}
+class Subscriptions {
+    sweep;
+    constructor(sweep) {
+        this.sweep = sweep;
+    }
+    async retrieve(id) {
+        return toSubscription(await this.sweep.request("GET", `/v1/subscriptions/${encodeURIComponent(id)}`));
+    }
+    /**
+     * The live subscription for one of YOUR user ids, or null.
+     *
+     * Only active, trialing and past_due count as live. Use it to answer "is
+     * this person a subscriber right now" on a page load, not as a substitute
+     * for handling the webhooks — polling this per request is a round trip you
+     * do not need when subscription.created already told you.
+     */
+    async status(externalRef) {
+        try {
+            return toSubscription(await this.sweep.request("GET", "/v1/subscriptions/status", {
+                query: { external_ref: externalRef },
+            }));
+        }
+        catch (e) {
+            // The endpoint 404s when nothing is live, which is an answer rather than
+            // a fault — every caller would otherwise write this same try/catch.
+            if (e instanceof SweepError && e.status === 404)
+                return null;
+            throw e;
+        }
+    }
+    async list(params = {}) {
+        const body = await this.sweep.request("GET", "/v1/subscriptions", {
+            query: {
+                status: params.status,
+                plan_id: params.plan,
+                external_ref: params.externalRef,
+                limit: params.limit,
+            },
+        });
+        const rows = Array.isArray(body) ? body : body.data ?? [];
+        return rows.map((r) => toSubscription(r));
+    }
+    /**
+     * Stop a subscription. No further charges are attempted.
+     *
+     * It also revokes the renewal delegations behind it, so this is not merely a
+     * status flag. No money moves: nothing was ever held, so there is nothing to
+     * return — see the note on refunds in the README.
+     */
+    async cancel(id, opts = {}) {
+        return toSubscription(await this.sweep.request("POST", `/v1/subscriptions/${encodeURIComponent(id)}/cancel`, {
+            body: opts.reason ? { cancel_reason: opts.reason } : {},
+        }));
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,79 @@
+export declare class SweepError extends Error {
+    /** The API's machine-readable code, e.g. `period_cap_exceeded`. */
+    readonly code: string;
+    readonly status: number;
+    /** Present on a 5xx. Quote it to support; it locates the failure in our logs. */
+    readonly reference?: string;
+    /** Per-field messages from a 422. */
+    readonly details?: Record<string, string>;
+    /** The id of whatever conflicted. Set on `mandate_exists`. */
+    readonly mandateId?: string;
+    /** Set on `mandate_exists` when the existing mandate is still pending. */
+    readonly authorizationUrl?: string;
+    constructor(message: string, opts: {
+        code: string;
+        status: number;
+        reference?: string;
+        details?: Record<string, string>;
+        mandateId?: string;
+        authorizationUrl?: string;
+    });
+}
+/** 403 — the account has not been granted the rail. Ask in portal → Payment rail. */
+export declare class RailNotEnabled extends SweepError {
+}
+/** 404 — no mandate with that id on this account. */
+export declare class MandateNotFound extends SweepError {
+}
+/** 409 — the payer withdrew it. Stop charging; a new mandate needs a new signature. */
+export declare class MandateRevoked extends SweepError {
+}
+/** 409 — never authorized, or no longer active. */
+export declare class MandateNotActive extends SweepError {
+}
+/**
+ * 409 — this `externalRef` already has a live mandate at your merchant.
+ *
+ * Two live mandates for one payer are two independent delegations with
+ * independent period enforcers, so their ceilings add up and both can be
+ * charged. `mandateId` names the one already standing. If it is still pending,
+ * `authorizationUrl` is the link to resend — do that instead of creating a
+ * second. To replace an active one, revoke it first.
+ */
+export declare class MandateExists extends SweepError {
+}
+/** 422 — this single charge is larger than the mandate's `maxAmount`. */
+export declare class AmountOverCap extends SweepError {
+}
+/**
+ * 422 — it fits under `maxAmount` but not under what is left this period.
+ * The message names what is committed, what remains, and when the period resets.
+ */
+export declare class PeriodCapExceeded extends SweepError {
+}
+/** 400 — no `Idempotency-Key`. The client always sends one, so this means a bug here. */
+export declare class IdempotencyKeyRequired extends SweepError {
+}
+/** 422 — that key was already used with a different body. A new charge needs a new key. */
+export declare class IdempotencyKeyReused extends SweepError {
+}
+/** 409 — a charge with this key is still in flight. Retry shortly, same key. */
+export declare class IdempotencyKeyInFlight extends SweepError {
+}
+/** 409 — two charges against one mandate committed at the same instant. Retry, same key. */
+export declare class ChargeConflict extends SweepError {
+}
+/** The signature on an incoming webhook did not verify. Do not trust the body. */
+export declare class WebhookSignatureError extends Error {
+    constructor(message: string);
+}
+export declare function errorFrom(status: number, body: {
+    error?: {
+        message?: string;
+        code?: string;
+        reference?: string;
+        details?: Record<string, string>;
+        mandate_id?: string;
+        authorization_url?: string;
+    };
+} | null): SweepError;

package/dist/errors.js

@@ -0,0 +1,104 @@
+// One class per refusal the rail can hand back, because `catch (e)` on a rail
+// that moves money should be able to ask "which of these is it" without parsing
+// a string. Every one of these is a documented, expected outcome — not a bug.
+export class SweepError extends Error {
+    /** The API's machine-readable code, e.g. `period_cap_exceeded`. */
+    code;
+    status;
+    /** Present on a 5xx. Quote it to support; it locates the failure in our logs. */
+    reference;
+    /** Per-field messages from a 422. */
+    details;
+    /** The id of whatever conflicted. Set on `mandate_exists`. */
+    mandateId;
+    /** Set on `mandate_exists` when the existing mandate is still pending. */
+    authorizationUrl;
+    constructor(message, opts) {
+        super(message);
+        this.name = new.target.name;
+        this.code = opts.code;
+        this.status = opts.status;
+        this.reference = opts.reference;
+        this.details = opts.details;
+        this.mandateId = opts.mandateId;
+        this.authorizationUrl = opts.authorizationUrl;
+    }
+}
+/** 403 — the account has not been granted the rail. Ask in portal → Payment rail. */
+export class RailNotEnabled extends SweepError {
+}
+/** 404 — no mandate with that id on this account. */
+export class MandateNotFound extends SweepError {
+}
+/** 409 — the payer withdrew it. Stop charging; a new mandate needs a new signature. */
+export class MandateRevoked extends SweepError {
+}
+/** 409 — never authorized, or no longer active. */
+export class MandateNotActive extends SweepError {
+}
+/**
+ * 409 — this `externalRef` already has a live mandate at your merchant.
+ *
+ * Two live mandates for one payer are two independent delegations with
+ * independent period enforcers, so their ceilings add up and both can be
+ * charged. `mandateId` names the one already standing. If it is still pending,
+ * `authorizationUrl` is the link to resend — do that instead of creating a
+ * second. To replace an active one, revoke it first.
+ */
+export class MandateExists extends SweepError {
+}
+/** 422 — this single charge is larger than the mandate's `maxAmount`. */
+export class AmountOverCap extends SweepError {
+}
+/**
+ * 422 — it fits under `maxAmount` but not under what is left this period.
+ * The message names what is committed, what remains, and when the period resets.
+ */
+export class PeriodCapExceeded extends SweepError {
+}
+/** 400 — no `Idempotency-Key`. The client always sends one, so this means a bug here. */
+export class IdempotencyKeyRequired extends SweepError {
+}
+/** 422 — that key was already used with a different body. A new charge needs a new key. */
+export class IdempotencyKeyReused extends SweepError {
+}
+/** 409 — a charge with this key is still in flight. Retry shortly, same key. */
+export class IdempotencyKeyInFlight extends SweepError {
+}
+/** 409 — two charges against one mandate committed at the same instant. Retry, same key. */
+export class ChargeConflict extends SweepError {
+}
+/** The signature on an incoming webhook did not verify. Do not trust the body. */
+export class WebhookSignatureError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WebhookSignatureError";
+    }
+}
+const BY_CODE = {
+    rail_not_enabled: RailNotEnabled,
+    not_found: MandateNotFound,
+    mandate_revoked: MandateRevoked,
+    mandate_not_active: MandateNotActive,
+    mandate_exists: MandateExists,
+    amount_over_cap: AmountOverCap,
+    period_cap_exceeded: PeriodCapExceeded,
+    idempotency_key_required: IdempotencyKeyRequired,
+    idempotency_key_reused: IdempotencyKeyReused,
+    idempotency_key_in_flight: IdempotencyKeyInFlight,
+    charge_conflict: ChargeConflict,
+};
+export function errorFrom(status, body) {
+    const e = body?.error;
+    const code = e?.code ?? "error";
+    const Cls = BY_CODE[code] ?? SweepError;
+    const message = e?.message ?? `Sweep API error (${status})`;
+    return new Cls(message, {
+        code,
+        status,
+        reference: e?.reference,
+        details: e?.details,
+        mandateId: e?.mandate_id,
+        authorizationUrl: e?.authorization_url,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @sweepconsole/node — charge a USDC wallet from your own app.
+ *
+ * The whole integration is four calls:
+ *
+ *   import { Sweep, usdc } from "@sweepconsole/node";
+ *   const sweep = new Sweep(process.env.SWEEP_API_KEY!);
+ *
+ *   // 1 — when a user subscribes
+ *   const mandate = await sweep.mandates.create({
+ *     externalRef: user.id,
+ *     email: user.email,
+ *     maxAmount: usdc("15.00"),          // the CEILING, not the price
+ *     interval: "monthly",
+ *     chains: ["base", "arbitrum", "optimism"],
+ *     expiresAt: new Date("2027-01-01"),
+ *   });
+ *
+ *   // 2 — send them to sign it
+ *   res.redirect(mandate.authorizationUrl!);
+ *
+ *   // 3 — react to what happens (mount with express.raw)
+ *   app.post("/webhooks/sweep", express.raw({ type: "application/json" }),
+ *     sweep.webhooks.express(process.env.SWEEP_WEBHOOK_SECRET!, {
+ *       "mandate.authorized": (e) => db.users.activate(e.externalRef),
+ *       "charge.succeeded":   (e) => db.users.extend(e.externalRef),
+ *     }));
+ *
+ *   // 4 — charge on your own clock
+ *   await sweep.charges.create(
+ *     { mandate: user.sweepMandate, amount: usdc("9.00"), description: "Pro — September" },
+ *     { idempotencyKey: `${user.id}:2027-01` },
+ *   );
+ *
+ * Sweep owns no schedule. Your app decides when to charge; this moves the money
+ * and enforces the ceiling the payer signed.
+ */
+import { Sweep as SweepClient, type SweepOptions } from "./client.js";
+import { construct, expressHandler, verify } from "./webhooks.js";
+export { usdc, format } from "./money.js";
+export type { SweepOptions } from "./client.js";
+export type { Chain, Charge, ChargeStatus, CheckoutSession, CreateChargeParams, CreateMandateParams, CreateSessionParams, FailureCode, Interval, Mandate, MandateStatus, RetrievedSession, Subscription, SubscriptionStatus, Usdc, WebhookEvent, WebhookEventType, WebhookPayloads, TypedWebhookEvent, } from "./types.js";
+export type { ConstructOptions } from "./webhooks.js";
+export { AmountOverCap, ChargeConflict, IdempotencyKeyInFlight, IdempotencyKeyRequired, IdempotencyKeyReused, MandateExists, MandateNotActive, MandateNotFound, MandateRevoked, PeriodCapExceeded, RailNotEnabled, SweepError, WebhookSignatureError, } from "./errors.js";
+export declare class Sweep extends SweepClient {
+    readonly webhooks: {
+        verify: typeof verify;
+        construct: typeof construct;
+        express: typeof expressHandler;
+    };
+    constructor(apiKey: string, options?: SweepOptions);
+}
+export default Sweep;