@peable.to/sdk 0.1.1

package/dist/esm/core/serviceToken.js

@@ -0,0 +1,78 @@
+// Mints a short-lived Oxy service token from an `ApplicationCredential`
+// (`{publicKey, secret}`) by presenting it to oxy-api's `POST
+// /auth/service-token` — the exact mechanism `oxyClient.serviceAuth()`
+// validates at the Gateway. Caches the token until near expiry and re-mints
+// reactively when `RestClient` sees a 401 (see `client.ts`).
+import { resolveConfig } from './config.js';
+import { errorFromResponse, PeableApiError } from './errors.js';
+/** Path (relative to `oxyApiUrl`) of oxy-api's service-token mint endpoint. */
+const SERVICE_TOKEN_PATH = '/auth/service-token';
+/** Refresh proactively this long before the minted token's actual expiry. */
+const REFRESH_MARGIN_MS = 60000;
+function isServiceTokenMintEnvelope(body) {
+    if (typeof body !== 'object' || body === null || !('data' in body))
+        return false;
+    const { data } = body;
+    if (typeof data !== 'object' || data === null)
+        return false;
+    const candidate = data;
+    return typeof candidate.token === 'string' && typeof candidate.expiresIn === 'number';
+}
+async function readJsonBody(response) {
+    const text = await response.text();
+    if (text.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createServiceTokenProvider(cfg, deps = {}) {
+    const resolved = resolveConfig(cfg);
+    const fetchImpl = deps.fetch ?? fetch;
+    let cachedToken = null;
+    let cachedExpiresAt = 0;
+    let inflight = null;
+    async function mint() {
+        let response;
+        try {
+            response = await fetchImpl(`${resolved.oxyApiUrl}${SERVICE_TOKEN_PATH}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ apiKey: resolved.publicKey, apiSecret: resolved.secret }),
+            });
+        }
+        catch (cause) {
+            throw new PeableApiError(`Failed to reach ${resolved.oxyApiUrl} to mint an Peable service token: ${cause instanceof Error ? cause.message : String(cause)}`);
+        }
+        const body = await readJsonBody(response);
+        if (!response.ok) {
+            throw errorFromResponse(response.status, body);
+        }
+        if (!isServiceTokenMintEnvelope(body)) {
+            throw new PeableApiError('Peable: the service-token mint response was missing `data.token`/`data.expiresIn`');
+        }
+        cachedToken = body.data.token;
+        cachedExpiresAt = Date.now() + body.data.expiresIn * 1000;
+        return cachedToken;
+    }
+    return {
+        async getToken() {
+            if (cachedToken !== null && Date.now() < cachedExpiresAt - REFRESH_MARGIN_MS) {
+                return cachedToken;
+            }
+            if (inflight === null) {
+                inflight = mint().finally(() => {
+                    inflight = null;
+                });
+            }
+            return inflight;
+        },
+        invalidate() {
+            cachedToken = null;
+            cachedExpiresAt = 0;
+        },
+    };
+}

package/dist/esm/index.js

@@ -0,0 +1,28 @@
+// Server entry (`@peable.to/sdk`) — the merchant-authed SDK. Configured with a
+// confidential `ApplicationCredential` (`{publicKey, secret}`); mints and
+// caches an Oxy service token, and exposes Stripe-ergonomics resource
+// namespaces over the Gateway REST contract.
+//
+// Deliberately never imports `socket.io-client` or `./browser/*` — the
+// server bundle stays lean and holds no browser-only code.
+import { resolveConfig } from './core/config.js';
+import { createServiceTokenProvider } from './core/serviceToken.js';
+import { createRestClient } from './core/client.js';
+import { PaymentIntentsResource } from './resources/paymentIntents.js';
+import { PaymentLinksResource } from './resources/paymentLinks.js';
+import { CheckoutResource } from './resources/checkoutSessions.js';
+import { WebhooksResource } from './resources/webhooks.js';
+export class Peable {
+    constructor(config) {
+        const resolved = resolveConfig(config);
+        const tokenProvider = createServiceTokenProvider(config);
+        const client = createRestClient({ baseURL: resolved.baseURL }, tokenProvider);
+        this.paymentIntents = new PaymentIntentsResource(client);
+        this.paymentLinks = new PaymentLinksResource(client);
+        this.checkout = new CheckoutResource(client);
+        this.webhooks = new WebhooksResource();
+    }
+}
+export { DEFAULT_GATEWAY_BASE_URL, DEFAULT_OXY_API_URL } from './core/config.js';
+export { PeableError, PeableAuthenticationError, PeableInvalidRequestError, PeablePermissionError, PeableApiError, PeableSignatureVerificationError, } from './core/errors.js';
+export { WEBHOOK_SIGNATURE_HEADER } from './resources/webhooks.js';

package/dist/esm/resources/checkoutSessions.js

@@ -0,0 +1,21 @@
+export class CheckoutSessionsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    create(params) {
+        return this.client.request('POST', '/v1/checkout_sessions', {
+            body: params,
+        });
+    }
+    retrieve(id) {
+        return this.client.request('GET', `/v1/checkout_sessions/${encodeURIComponent(id)}`);
+    }
+}
+/** `peable.checkout.sessions.*` — a thin namespace wrapper so the public API
+ * reads `peable.checkout.sessions.create(...)` (Stripe Checkout Session
+ * parity), leaving room for future `peable.checkout.*` resources. */
+export class CheckoutResource {
+    constructor(client) {
+        this.sessions = new CheckoutSessionsResource(client);
+    }
+}

package/dist/esm/resources/paymentIntents.js

@@ -0,0 +1,26 @@
+export class PaymentIntentsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    create(params, options) {
+        return this.client.request('POST', '/v1/payment_intents', {
+            body: params,
+            idempotencyKey: options.idempotencyKey,
+        });
+    }
+    retrieve(id) {
+        return this.client.request('GET', `/v1/payment_intents/${encodeURIComponent(id)}`);
+    }
+    list(params = {}) {
+        return this.client.request('GET', '/v1/payment_intents', {
+            query: {
+                status: params.status,
+                limit: params.limit,
+                starting_after: params.starting_after,
+            },
+        });
+    }
+    reject(id) {
+        return this.client.request('POST', `/v1/payment_intents/${encodeURIComponent(id)}/reject`);
+    }
+}

package/dist/esm/resources/paymentLinks.js

@@ -0,0 +1,19 @@
+export class PaymentLinksResource {
+    constructor(client) {
+        this.client = client;
+    }
+    create(params) {
+        return this.client.request('POST', '/v1/payment_links', { body: params });
+    }
+    retrieve(id) {
+        return this.client.request('GET', `/v1/payment_links/${encodeURIComponent(id)}`);
+    }
+    list(params = {}) {
+        return this.client.request('GET', '/v1/payment_links', {
+            query: { limit: params.limit, starting_after: params.starting_after },
+        });
+    }
+    update(id, params) {
+        return this.client.request('PATCH', `/v1/payment_links/${encodeURIComponent(id)}`, { body: params });
+    }
+}

package/dist/esm/resources/webhooks.js

@@ -0,0 +1,61 @@
+import { verifyWebhook } from '@peable.to/shared-types';
+import { PeableSignatureVerificationError } from '../core/errors.js';
+/** Header the Gateway's `webhookDispatcher.deliver` signs with (`Peable-Signature`). */
+export const WEBHOOK_SIGNATURE_HEADER = 'Peable-Signature';
+/** Default replay-tolerance window, matching the backend's own tests/usage. */
+const DEFAULT_TOLERANCE_SEC = 300;
+const WEBHOOK_EVENT_TYPES = [
+    'payment_intent.confirming',
+    'payment_intent.settled',
+    'payment_intent.failed',
+    'payment_intent.rejected',
+    'payment_intent.expired',
+];
+/**
+ * Structural guard for the parsed payload — the signature already proves the
+ * bytes were produced by `signWebhook` on the SAME secret, but a caller could
+ * still pass an unrelated (validly HMAC'd under a shared secret) JSON blob;
+ * this keeps `constructEvent`'s return type honest rather than a blind cast.
+ */
+function isWebhookEventShape(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return (typeof candidate.id === 'string' &&
+        candidate.object === 'event' &&
+        typeof candidate.type === 'string' &&
+        WEBHOOK_EVENT_TYPES.includes(candidate.type) &&
+        typeof candidate.created === 'string' &&
+        typeof candidate.data === 'object' &&
+        candidate.data !== null &&
+        'object' in candidate.data);
+}
+export class WebhooksResource {
+    /**
+     * Verify a webhook delivery and parse it into a typed `WebhookEvent`.
+     * Verifies via the SAME `verifyWebhook` the Gateway signs with
+     * (`@peable.to/shared-types`) so the algorithm can never drift between the two
+     * sides. Throws `PeableSignatureVerificationError` on a bad/stale/tampered
+     * signature or a malformed payload — never returns a partially-trusted
+     * event.
+     */
+    constructEvent(rawBody, signatureHeader, endpointSecret, opts = {}) {
+        const toleranceSec = opts.toleranceSec ?? DEFAULT_TOLERANCE_SEC;
+        const nowSec = Math.floor(Date.now() / 1000);
+        const verified = verifyWebhook(endpointSecret, rawBody, signatureHeader, toleranceSec, nowSec);
+        if (!verified) {
+            throw new PeableSignatureVerificationError('Webhook signature verification failed — the payload, signature header, or secret do not match, or the timestamp is stale.');
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(rawBody);
+        }
+        catch {
+            throw new PeableSignatureVerificationError('Webhook signature verified, but the payload is not valid JSON');
+        }
+        if (!isWebhookEventShape(parsed)) {
+            throw new PeableSignatureVerificationError('Webhook signature verified, but the payload does not match the expected event shape');
+        }
+        return parsed;
+    }
+}

package/dist/types/browser/mount.d.ts

@@ -0,0 +1,80 @@
+import type { PaymentIntent } from '@peable.to/shared-types';
+import { PeableError } from '../core/errors';
+/**
+ * Derive and validate the payment intent id for `mount()`. When `intentId` is
+ * omitted, the id IS the prefix of `clientSecret` before `_secret_`
+ * (`clientSecretFor` in `packages/backend/src/lib/ids.ts` mints
+ * `${id}_secret_<hex>`, so `clientSecret.split('_secret_')[0]` recovers it).
+ * Either way the result must look like a real Gateway-minted id AND
+ * `clientSecret` must actually belong to it — a malformed or mismatched pair
+ * is a caller integration bug, and `mount()` must never render a button
+ * wired to a bogus id.
+ */
+export declare function deriveIntentId(clientSecret: string, intentId?: string): string;
+export interface PayDeepLinkParams {
+    intentId: string;
+    clientSecret: string;
+    address: string;
+    /** Base-unit integer string (m⊜) — `PaymentIntent['amount']`'s own shape. */
+    amount: string;
+    network: PaymentIntent['network'];
+}
+/**
+ * Build an `peable://pay?...` deep link. Param names AND percent-encoding
+ * must match the wallet's parser byte-for-byte
+ * (`packages/frontend/src/pay/payment-request.ts`'s `parseQuery`, which
+ * splits on `&` then `=` and `decodeURIComponent`s each side raw) —
+ * deliberately built by hand with `encodeURIComponent` rather than
+ * `URLSearchParams`, whose `application/x-www-form-urlencoded` encoding
+ * (e.g. space → `+`) is a different scheme than plain `decodeURIComponent`
+ * expects on the other end.
+ */
+export declare function buildPayDeepLink(params: PayDeepLinkParams): string;
+export declare function isMobileUserAgent(userAgent: string): boolean;
+export interface PeableCheckoutEventMap {
+    settled: PaymentIntent;
+    confirming: PaymentIntent;
+    failed: PaymentIntent;
+    error: PeableError;
+}
+type CheckoutEventName = keyof PeableCheckoutEventMap;
+type CheckoutEventHandler<K extends CheckoutEventName> = (payload: PeableCheckoutEventMap[K]) => void;
+interface CheckoutEmitter {
+    on<K extends CheckoutEventName>(event: K, handler: CheckoutEventHandler<K>): void;
+    emit<K extends CheckoutEventName>(event: K, payload: PeableCheckoutEventMap[K]): void;
+    removeAll(): void;
+}
+/**
+ * A minimal typed pub/sub. The public `on`/`emit` are fully type-checked per
+ * event; the internal `Map` necessarily erases each handler's specific
+ * payload type (it stores handlers for every event key in one collection),
+ * so the single cast at the storage boundary is intentional, not a type-safety
+ * hole — nothing outside this function ever sees the erased type.
+ */
+export declare function createEmitter(): CheckoutEmitter;
+export interface PeableCheckoutMountOptions {
+    /** The payment intent's `client_secret` — the payer's proof of possession. */
+    clientSecret: string;
+    /** Payment intent id. Derived from `clientSecret` when omitted — see {@link deriveIntentId}. */
+    intentId?: string;
+    /** Gateway base URL, forwarded to {@link createPeableCheckout}. Default `https://api.peable.to`. */
+    gatewayUrl?: string;
+}
+export interface PeableCheckoutInstance {
+    on<K extends CheckoutEventName>(event: K, handler: CheckoutEventHandler<K>): void;
+    /** Unsubscribes from realtime updates and removes the button from the DOM. */
+    destroy(): void;
+}
+/**
+ * Render the "Pay with Peable" button into `target` and start tracking the
+ * payment intent. Returns synchronously — before any network call resolves —
+ * so a caller's `.on(...)` registrations (called immediately after `mount()`
+ * returns, in the same synchronous tick) are always in place before the
+ * first `settled`/`confirming`/`failed`/`error` event can fire on the
+ * following microtask.
+ */
+declare function mount(target: string | Element, opts: PeableCheckoutMountOptions): PeableCheckoutInstance;
+export declare const PeableCheckout: {
+    mount: typeof mount;
+};
+export {};

package/dist/types/browser/payerClient.d.ts

@@ -0,0 +1,23 @@
+import type { PaymentIntent } from '@peable.to/shared-types';
+export interface PeableCheckoutClient {
+    /**
+     * `GET /v1/payment_intents/:id` — the initial REST snapshot. Sends
+     * `clientSecret` via the `X-Peable-Client-Secret` header, never a query
+     * param, so the capability token never lands in server/CDN access logs.
+     */
+    getPaymentIntent(id: string, clientSecret: string): Promise<PaymentIntent>;
+    /** Realtime status stream over the Gateway's socket contract, filtered to this intent. */
+    subscribe(id: string, clientSecret: string, onUpdate: (intent: PaymentIntent) => void): Promise<{
+        unsubscribe(): void;
+    }>;
+    /** `POST /v1/payment_intents/:id/submit_tx` — report a broadcast txid. */
+    submitTx(id: string, clientSecret: string, txid: string): Promise<PaymentIntent>;
+}
+export interface CreatePeableCheckoutOptions {
+    /** Gateway base URL. Default `https://api.peable.to`. */
+    gatewayUrl?: string;
+}
+/**
+ * Factory for the payer-side client core.
+ */
+export declare function createPeableCheckout(opts?: CreatePeableCheckoutOptions): PeableCheckoutClient;

package/dist/types/checkout.d.ts

@@ -0,0 +1,2 @@
+export { createPeableCheckout, type CreatePeableCheckoutOptions, type PeableCheckoutClient, } from './browser/payerClient';
+export { PeableCheckout, type PeableCheckoutMountOptions, type PeableCheckoutInstance, type PeableCheckoutEventMap, } from './browser/mount';

package/dist/types/core/client.d.ts

@@ -0,0 +1,17 @@
+import type { ServiceTokenProvider } from './serviceToken';
+export interface RestClientRequestOptions {
+    body?: unknown;
+    query?: Record<string, string | number | undefined>;
+    idempotencyKey?: string;
+    headers?: Record<string, string>;
+}
+export interface RestClient {
+    request<T>(method: string, path: string, opts?: RestClientRequestOptions): Promise<T>;
+}
+export interface RestClientConfig {
+    /** Gateway base URL, already stripped of a trailing slash. */
+    baseURL: string;
+}
+export declare function createRestClient(config: RestClientConfig, tokenProvider: ServiceTokenProvider, deps?: {
+    fetch?: typeof fetch;
+}): RestClient;

package/dist/types/core/config.d.ts

@@ -0,0 +1,30 @@
+/** Default Gateway host (`api.peable.to`) — the SDK never sends a `livemode`
+ * flag; the credential's `environment` rides in the minted service JWT and
+ * the Gateway resolves test/live from it. */
+export declare const DEFAULT_GATEWAY_BASE_URL = "https://api.peable.to";
+/** Default oxy-api host used to mint the short-lived service token. */
+export declare const DEFAULT_OXY_API_URL = "https://api.oxy.so";
+export interface PeableConfig {
+    /** ApplicationCredential publicKey (e.g. `oxy_dk_...`). */
+    publicKey: string;
+    /** ApplicationCredential plaintext secret. */
+    secret: string;
+    /** Gateway base URL. Default `https://api.peable.to`. */
+    baseURL?: string;
+    /** oxy-api host used to mint the service token. Default `https://api.oxy.so`. */
+    oxyApiUrl?: string;
+}
+/** `PeableConfig` with every optional field defaulted and normalized. */
+export interface ResolvedPeableConfig {
+    publicKey: string;
+    secret: string;
+    baseURL: string;
+    oxyApiUrl: string;
+}
+/**
+ * Validate and normalize an `PeableConfig`. Throws a plain `Error` for a
+ * missing `publicKey`/`secret` — a programmer error caught at construction
+ * time, not an API-response failure, so it deliberately does not go through
+ * the `PeableError` hierarchy (which models mapped HTTP responses).
+ */
+export declare function resolveConfig(config: PeableConfig): ResolvedPeableConfig;

package/dist/types/core/errors.d.ts

@@ -0,0 +1,54 @@
+export type PeableErrorType = 'authentication_error' | 'invalid_request_error' | 'permission_error' | 'api_error' | 'signature_verification_error';
+export interface PeableErrorDetails {
+    /** The HTTP status code that produced this error, when applicable. */
+    statusCode?: number;
+    /**
+     * The raw upstream discriminator: `error.type` from the Gateway's own
+     * `{ error: { type, message } }` envelope, or the flat `error` code string
+     * from `@oxyhq/core`'s auth middleware (`{ error: 'INVALID_TOKEN', ... }`)
+     * — see `errorFromResponse`'s doc comment for why both shapes exist.
+     */
+    code?: string;
+}
+export declare class PeableError extends Error {
+    readonly type: PeableErrorType;
+    readonly statusCode?: number;
+    readonly code?: string;
+    constructor(type: PeableErrorType, message: string, details?: PeableErrorDetails);
+}
+export declare class PeableAuthenticationError extends PeableError {
+    constructor(message: string, details?: PeableErrorDetails);
+}
+export declare class PeableInvalidRequestError extends PeableError {
+    constructor(message: string, details?: PeableErrorDetails);
+}
+export declare class PeablePermissionError extends PeableError {
+    constructor(message: string, details?: PeableErrorDetails);
+}
+export declare class PeableApiError extends PeableError {
+    constructor(message: string, details?: PeableErrorDetails);
+}
+/** Thrown by `webhooks.constructEvent` on a bad/stale/tampered signature. */
+export declare class PeableSignatureVerificationError extends PeableError {
+    constructor(message: string);
+}
+/**
+ * Map an HTTP status + parsed JSON body into a typed `PeableError`.
+ *
+ * The Oxy ecosystem returns TWO distinct error envelopes depending on WHERE a
+ * request was rejected:
+ * - The Gateway's own route handlers use the Stripe-style nested envelope
+ *   `{ error: { type, message } }` (`lib/http.ts`'s `sendError`).
+ * - `@oxyhq/core`'s Express auth middleware (`oxyClient.serviceAuth()` /
+ *   `requireScope()` — rejecting a missing/expired/insufficiently-scoped
+ *   service token BEFORE a route handler ever runs) and oxy-api's own
+ *   `ApiError.toJSON()` use a FLAT envelope: `{ error: <CODE_STRING>,
+ *   message, code? }`.
+ *
+ * A caller of this SDK hits the flat shape on every auth failure (expired
+ * token, missing scope, bad credentials at mint time), so the HTTP status
+ * code — not `error.type` — is the primary classifier here; the raw
+ * upstream `type`/`code` string is still attached to the resulting error
+ * (`.code`) for callers who want it.
+ */
+export declare function errorFromResponse(status: number, body: unknown): PeableError;

package/dist/types/core/serviceToken.d.ts

@@ -0,0 +1,11 @@
+import { type PeableConfig } from './config';
+export interface ServiceTokenProvider {
+    /** Mints once, caches until near expiry, re-mints on expiry/401. */
+    getToken(): Promise<string>;
+    /** Drop the cached token so the next `getToken()` re-mints. Called by
+     * `RestClient` after a Gateway request comes back 401. */
+    invalidate(): void;
+}
+export declare function createServiceTokenProvider(cfg: PeableConfig, deps?: {
+    fetch?: typeof fetch;
+}): ServiceTokenProvider;

package/dist/types/index.d.ts

@@ -0,0 +1,22 @@
+import { type PeableConfig } from './core/config';
+import { PaymentIntentsResource } from './resources/paymentIntents';
+import { PaymentLinksResource } from './resources/paymentLinks';
+import { CheckoutResource } from './resources/checkoutSessions';
+import { WebhooksResource } from './resources/webhooks';
+export declare class Peable {
+    readonly paymentIntents: PaymentIntentsResource;
+    readonly paymentLinks: PaymentLinksResource;
+    readonly checkout: CheckoutResource;
+    readonly webhooks: WebhooksResource;
+    constructor(config: PeableConfig);
+}
+export type { PeableConfig, ResolvedPeableConfig } from './core/config';
+export { DEFAULT_GATEWAY_BASE_URL, DEFAULT_OXY_API_URL } from './core/config';
+export { PeableError, PeableAuthenticationError, PeableInvalidRequestError, PeablePermissionError, PeableApiError, PeableSignatureVerificationError, } from './core/errors';
+export type { PeableErrorType, PeableErrorDetails } from './core/errors';
+export type { RestClient, RestClientRequestOptions } from './core/client';
+export type { ServiceTokenProvider } from './core/serviceToken';
+export type { CreatePaymentIntentOptions, PaymentIntentListParams, PaymentIntentList, } from './resources/paymentIntents';
+export type { PaymentLinkListParams, PaymentLinkList, UpdatePaymentLinkParams, } from './resources/paymentLinks';
+export { WEBHOOK_SIGNATURE_HEADER } from './resources/webhooks';
+export type { ConstructEventOptions } from './resources/webhooks';

package/dist/types/resources/checkoutSessions.d.ts

@@ -0,0 +1,15 @@
+import type { CheckoutSession, CreateCheckoutSessionParams } from '@peable.to/shared-types';
+import type { RestClient } from '../core/client';
+export declare class CheckoutSessionsResource {
+    private readonly client;
+    constructor(client: RestClient);
+    create(params: CreateCheckoutSessionParams): Promise<CheckoutSession>;
+    retrieve(id: string): Promise<CheckoutSession>;
+}
+/** `peable.checkout.sessions.*` — a thin namespace wrapper so the public API
+ * reads `peable.checkout.sessions.create(...)` (Stripe Checkout Session
+ * parity), leaving room for future `peable.checkout.*` resources. */
+export declare class CheckoutResource {
+    readonly sessions: CheckoutSessionsResource;
+    constructor(client: RestClient);
+}

package/dist/types/resources/paymentIntents.d.ts

@@ -0,0 +1,29 @@
+import type { CreatePaymentIntentParams, PaymentIntent, PaymentIntentStatus } from '@peable.to/shared-types';
+import type { RestClient } from '../core/client';
+export interface PaymentIntentListParams {
+    status?: PaymentIntentStatus;
+    limit?: number;
+    starting_after?: string;
+}
+export interface PaymentIntentList {
+    object: 'list';
+    data: PaymentIntent[];
+    has_more: boolean;
+}
+export interface CreatePaymentIntentOptions {
+    /**
+     * Required — the Gateway mandates the `Idempotency-Key` header on
+     * `POST /v1/payment_intents` (`paymentIntents.ts`'s `idempotencyKey`
+     * check). Making this a required option (not optional) means a caller
+     * cannot forget it.
+     */
+    idempotencyKey: string;
+}
+export declare class PaymentIntentsResource {
+    private readonly client;
+    constructor(client: RestClient);
+    create(params: CreatePaymentIntentParams, options: CreatePaymentIntentOptions): Promise<PaymentIntent>;
+    retrieve(id: string): Promise<PaymentIntent>;
+    list(params?: PaymentIntentListParams): Promise<PaymentIntentList>;
+    reject(id: string): Promise<PaymentIntent>;
+}

package/dist/types/resources/paymentLinks.d.ts

@@ -0,0 +1,29 @@
+import type { CreatePaymentLinkParams, PaymentLink } from '@peable.to/shared-types';
+import type { RestClient } from '../core/client';
+export interface PaymentLinkListParams {
+    limit?: number;
+    starting_after?: string;
+}
+export interface PaymentLinkList {
+    object: 'list';
+    data: PaymentLink[];
+    has_more: boolean;
+}
+/**
+ * Fields mutable after a link is created. `amount`/`network` are
+ * deliberately absent — a link's price is immutable once shared (the
+ * Gateway's `PATCH /v1/payment_links/:id` whitelist enforces the same).
+ */
+export interface UpdatePaymentLinkParams {
+    active?: boolean;
+    metadata?: Record<string, string>;
+    successUrl?: string;
+}
+export declare class PaymentLinksResource {
+    private readonly client;
+    constructor(client: RestClient);
+    create(params: CreatePaymentLinkParams): Promise<PaymentLink>;
+    retrieve(id: string): Promise<PaymentLink>;
+    list(params?: PaymentLinkListParams): Promise<PaymentLinkList>;
+    update(id: string, params: UpdatePaymentLinkParams): Promise<PaymentLink>;
+}

package/dist/types/resources/webhooks.d.ts

@@ -0,0 +1,18 @@
+import { type WebhookEvent } from '@peable.to/shared-types';
+/** Header the Gateway's `webhookDispatcher.deliver` signs with (`Peable-Signature`). */
+export declare const WEBHOOK_SIGNATURE_HEADER = "Peable-Signature";
+export interface ConstructEventOptions {
+    /** Max allowed drift (seconds) between the signed timestamp and now. */
+    toleranceSec?: number;
+}
+export declare class WebhooksResource {
+    /**
+     * Verify a webhook delivery and parse it into a typed `WebhookEvent`.
+     * Verifies via the SAME `verifyWebhook` the Gateway signs with
+     * (`@peable.to/shared-types`) so the algorithm can never drift between the two
+     * sides. Throws `PeableSignatureVerificationError` on a bad/stale/tampered
+     * signature or a malformed payload — never returns a partially-trusted
+     * event.
+     */
+    constructEvent(rawBody: string, signatureHeader: string, endpointSecret: string, opts?: ConstructEventOptions): WebhookEvent;
+}