@peable.to/contracts 0.4.0 → 1.0.0

package/dist/esm/common/envelopes.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { ERROR_CODES, ERROR_DOCS_BASE_URL, ERROR_TYPES } from '../vocabulary/errors.js';
+import { contractRegistry, resolveObject } from './objects.js';
+/**
+ * The envelopes every resource shares (ADR 0014 D1): the list, the search
+ * result, the deleted tombstone and the error.
+ */
+/**
+ * One page of a list, newest first. `url` is the path that was listed, so a
+ * page carries enough to fetch the next one without the caller remembering
+ * where it came from.
+ */
+export function listOf(item) {
+    return z
+        .object({
+        object: z.literal('list'),
+        data: z.array(item),
+        has_more: z
+            .boolean()
+            .describe('Whether another page exists in the direction this one was read.'),
+        url: z.string().describe('The path that was listed.'),
+    })
+        .strict();
+}
+/**
+ * One page of a search. Pages FORWARD only, by an opaque `next_page` token
+ * passed back as `page`, bound to the query it came from.
+ */
+export function searchResultOf(item) {
+    return z
+        .object({
+        object: z.literal('search_result'),
+        data: z.array(item),
+        has_more: z.boolean(),
+        next_page: z
+            .string()
+            .nullable()
+            .describe('Pass as `page` for the next page; `null` on the last one.'),
+        url: z.string().describe('The path that was searched.'),
+        total_count: z
+            .number()
+            .int()
+            .nonnegative()
+            .optional()
+            .describe('Present only when asked for with `expand[]=total_count`.'),
+    })
+        .strict();
+}
+/** A deleted object, as its `DELETE` answers: `{id, object, deleted: true}`. */
+export function deletedOf(object) {
+    return z.object({ id: z.string(), object: z.literal(object), deleted: z.literal(true) }).strict();
+}
+/** The error object inside every non-2xx answer. */
+export const apiErrorSchema = z
+    .object({
+    type: z.enum(ERROR_TYPES).describe('The broad class a caller branches on first.'),
+    // A string rather than the closed `ERROR_CODES`: a `card_error` carries the
+    // provider's decline code (`insufficient_funds`, `expired_card`, …), which
+    // Peable passes through. Every code Peable itself answers with is an
+    // `ErrorCode` (the backend's `sendError` takes nothing else).
+    code: z
+        .string()
+        .optional()
+        .describe(`The machine-readable reason (one of ${String(ERROR_CODES.length)} documented at ${ERROR_DOCS_BASE_URL}, or a card network's decline code on a \`card_error\`).`),
+    decline_code: z
+        .string()
+        .optional()
+        .describe("A card issuer's decline reason, on a `card_error`."),
+    param: z
+        .string()
+        .optional()
+        .describe('The offending request field, in bracket notation (`metadata[order_id]`).'),
+    message: z.string().describe('A human-readable message, for a developer.'),
+    doc_url: z.url().optional().describe('The documentation of `code`.'),
+    request_id: z.string().nullable().describe('The `Request-Id` of this response, for support.'),
+    payment_intent: z
+        .lazy(() => resolveObject('payment_intent'))
+        .optional()
+        .describe('On a `card_error` from a confirm or an invoice payment: the PaymentIntent, as it now is.'),
+    invoice: z
+        .lazy(() => resolveObject('invoice'))
+        .optional()
+        .describe('On a failed invoice payment: the invoice, as it now is.'),
+    refresh_url: z
+        .url()
+        .optional()
+        .describe('On an expired onboarding link: where the seller gets a fresh one.'),
+})
+    .strict();
+/** `{ error: {...} }` — every non-2xx answer. */
+export const errorEnvelopeSchema = z.object({ error: apiErrorSchema }).strict();
+contractRegistry.add(errorEnvelopeSchema, {
+    id: 'Error',
+    description: 'Every non-2xx answer. The HTTP status and `error.type` identify the failure.',
+});

package/dist/esm/common/objects.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+/** The one registry every contract schema's metadata lives in. */
+export const contractRegistry = z.registry();
+const objectSchemas = new Map();
+/**
+ * Register a wire object: its `object` value (the key references use) and its
+ * component name. Returns the schema so a definition reads as one expression.
+ */
+export function defineObject(type, id, schema, meta = {}) {
+    if (objectSchemas.has(type))
+        throw new Error(`object type '${type}' is defined twice`);
+    objectSchemas.set(type, schema);
+    contractRegistry.add(schema, { id, ...meta });
+    return schema;
+}
+/**
+ * Register a named schema that is not an expandable object — a tombstone, a
+ * shared sub-object, a polymorphic payload — as `#/components/schemas/<id>`.
+ */
+export function defineComponent(id, schema, meta = {}) {
+    contractRegistry.add(schema, { id, ...meta });
+    return schema;
+}
+/** The registered schema of `type`, or `undefined`. */
+export function objectSchema(type) {
+    return objectSchemas.get(type);
+}
+/**
+ * The registered schema of `type`. Resolved lazily (a reference is declared
+ * before the module defining its target has loaded), and loud when nothing
+ * registers it: a reference to an unknown object is a contract bug.
+ */
+export function resolveObject(type) {
+    const schema = objectSchemas.get(type);
+    if (!schema)
+        throw new Error(`no wire object is registered as '${type}'`);
+    return schema;
+}
+/** Every registered object type, in registration order. */
+export function objectTypes() {
+    return [...objectSchemas.keys()];
+}
+/**
+ * A reference `expand[]` can replace: the id (`cus_…`) or, expanded, the
+ * object. The naming rule (`lib/expand.ts` in the backend): an expandable
+ * reference is spelled WITHOUT `_id`, and a field without `_id` that is not
+ * expandable is a bug.
+ */
+export function expandable(type, description) {
+    const resolved = z.lazy(() => resolveObject(type));
+    const union = z.union([z.string(), resolved]);
+    contractRegistry.add(union, {
+        'x-peable-expandable': type,
+        ...(description === undefined ? {} : { description }),
+    });
+    return union;
+}
+/**
+ * A field that always carries the FULL object `type` names (never an id): a
+ * subscription item's `price`, a payer view's `payment_intent`, a report run's
+ * result `file`. Validated against the registered schema and typed through
+ * {@link Ref}, so {@link Expand} resolves it to that object's wire type.
+ */
+export function embedded(type, description) {
+    const schema = z.lazy(() => resolveObject(type));
+    return (description === undefined
+        ? schema
+        : schema.describe(description));
+}
+/** Attach OpenAPI metadata to a schema without changing its type. */
+export function describe(schema, meta) {
+    contractRegistry.add(schema, { ...contractRegistry.get(schema), ...meta });
+    return schema;
+}

package/dist/esm/common/params.js

@@ -0,0 +1,203 @@
+import { z } from 'zod';
+import { LIST_LIMIT_DEFAULT, LIST_LIMIT_MAX, SEARCH_QUERY_MAX_LENGTH } from '../vocabulary/lists.js';
+import { contractRegistry } from './objects.js';
+/**
+ * Request-side building blocks (ADR 0014 D1).
+ *
+ * A request schema has two sides and both matter:
+ *
+ * - its INPUT (`z.input`) is the wire — what a caller sends, what the SDK's
+ *   parameter types are, and what the OpenAPI document describes;
+ * - its OUTPUT (`z.output`) is what a backend handler receives once parsed —
+ *   a query integer as a `number`, `expand` always an array, a metadata update
+ *   as a `{ set, unset }` patch.
+ *
+ * So the transforms live HERE, beside the shape, and the backend never
+ * re-parses what a contract already decided.
+ */
+/** Attach the JSON Schema a node is documented with when its input side is not the wire's spelling. */
+function documentedAs(schema, jsonSchema) {
+    contractRegistry.add(schema, { ...contractRegistry.get(schema), jsonSchema });
+    return schema;
+}
+/**
+ * An integer in a query string. Arrives as a string from a URL, as a number
+ * from a typed caller; both are the same request.
+ */
+export function queryInteger(bounds = {}) {
+    let target = z.number().int();
+    if (bounds.min !== undefined)
+        target = target.min(bounds.min);
+    if (bounds.max !== undefined)
+        target = target.max(bounds.max);
+    return documentedAs(z.union([z.number(), z.string()]).transform(Number).pipe(target), {
+        type: 'integer',
+        ...(bounds.min === undefined ? {} : { minimum: bounds.min }),
+        ...(bounds.max === undefined ? {} : { maximum: bounds.max }),
+    });
+}
+/** `true` / `false` in a query string (or a real boolean from a typed caller). */
+export const queryBoolean = documentedAs(z.union([z.boolean(), z.enum(['true', 'false'])]).transform((v) => v === true || v === 'true'), { type: 'boolean' });
+/** The latest representable instant (9999-12-31T23:59:59Z), the bound of every Unix-seconds parameter. */
+export const MAX_UNIX_SECONDS = 253402300799;
+/** Unix seconds in a body. */
+export const unixSecondsParam = z.number().int().min(0).max(MAX_UNIX_SECONDS);
+/** Unix seconds in a query string. */
+export const queryUnixSeconds = queryInteger({ min: 0, max: MAX_UNIX_SECONDS });
+/**
+ * `created=X` (exactly that second) or `created[gt|gte|lt|lte]=X`. The bare
+ * form is normalized to the range `[X, X]` so the repository reads one shape.
+ */
+export const rangeParam = documentedAs(z.union([
+    queryUnixSeconds.transform((x) => ({ gte: x, lte: x })),
+    z
+        .object({
+        gt: queryUnixSeconds.optional(),
+        gte: queryUnixSeconds.optional(),
+        lt: queryUnixSeconds.optional(),
+        lte: queryUnixSeconds.optional(),
+    })
+        .strict()
+        .transform((range) => range),
+]), {
+    description: 'Unix seconds: exactly one second, or a range with `gt`, `gte`, `lt`, `lte`.',
+    oneOf: [
+        { type: 'integer', minimum: 0 },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                gt: { type: 'integer', minimum: 0 },
+                gte: { type: 'integer', minimum: 0 },
+                lt: { type: 'integer', minimum: 0 },
+                lte: { type: 'integer', minimum: 0 },
+            },
+        },
+    ],
+});
+/**
+ * `expand[]=a&expand[]=b` arrives as an array; `expand=a` as a string. Both
+ * mean the same request. Dot paths, at most four levels; on a list every path
+ * starts with `data.`.
+ */
+export const expandParam = documentedAs(z
+    .union([z.string(), z.array(z.string())])
+    .transform((value) => (typeof value === 'string' ? [value] : value))
+    .pipe(z.array(z.string().min(1).max(200)).max(20)), {
+    type: 'array',
+    items: { type: 'string', maxLength: 200 },
+    maxItems: 20,
+    description: 'Dot paths of references to replace with the objects they name (at most four levels; `data.`-prefixed on a list).',
+});
+/** The public id of a cursor. Bounded so a cursor is never an unbounded index probe. */
+export const cursorParam = z.string().min(1).max(255);
+/** An object id in a body or query. */
+export const idParam = z.string().min(1).max(255);
+/** The list limit: 1–100, default 10. */
+export const limitParam = documentedAs(z
+    .union([z.number(), z.string()])
+    .transform(Number)
+    .pipe(z.number().int().min(1).max(LIST_LIMIT_MAX))
+    .optional()
+    .transform((value) => value ?? LIST_LIMIT_DEFAULT), { type: 'integer', minimum: 1, maximum: LIST_LIMIT_MAX, default: LIST_LIMIT_DEFAULT });
+/** The parameters every list accepts. */
+export const listShape = {
+    limit: limitParam,
+    starting_after: cursorParam
+        .optional()
+        .describe('The id of the LAST object of the previous page: the next page is older.'),
+    ending_before: cursorParam
+        .optional()
+        .describe('The id of the FIRST object of the current page: the page returned is newer.'),
+    created: rangeParam.optional(),
+    expand: expandParam.optional(),
+};
+function refuseBothCursors(query, ctx) {
+    if (query.starting_after !== undefined && query.ending_before !== undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['ending_before'],
+            message: 'starting_after and ending_before are mutually exclusive',
+        });
+    }
+}
+/**
+ * A list query: the shared parameters plus the route's own filters.
+ *
+ * `.strict()`: an unknown parameter is a 400 naming it, never silently ignored
+ * — `?stauts=settled` answering every intent is a filter the caller believes
+ * they applied.
+ */
+export function listQuery(filters) {
+    return z
+        .object({ ...listShape, ...filters })
+        .strict()
+        .superRefine((query, ctx) => refuseBothCursors(query, ctx));
+}
+/** A retrieve's query: `expand[]` and nothing else unless the route says so. */
+export function retrieveQuery(extra) {
+    return z.object({ expand: expandParam.optional(), ...extra }).strict();
+}
+/** The query of a route that takes `expand[]` only. */
+export const expandOnlyQuery = retrieveQuery({});
+/** The query of a route that takes no parameters at all. */
+export const emptyQuery = z.object({}).strict();
+/** The parameters every `GET /v1/<objects>/search` accepts. */
+export const searchShape = {
+    query: z
+        .string({ error: 'query is required' })
+        .min(1, 'query is required')
+        .max(SEARCH_QUERY_MAX_LENGTH, `a query is at most ${String(SEARCH_QUERY_MAX_LENGTH)} characters`)
+        .describe('Stripe\'s search query language: `email:"jenny@example.com"`, `amount>1000 AND currency:"EUR"`, `metadata[\'order_id\']:\'6735\'`, `name~"shirt"`, `-status:"canceled"`, `customer:null`.'),
+    limit: limitParam,
+    page: z
+        .string()
+        .min(1)
+        .max(512)
+        .optional()
+        .describe('The `next_page` of the previous page, with the SAME query.'),
+    expand: expandParam.optional(),
+};
+/** A search query. */
+export const searchQuery = z.object(searchShape).strict();
+export const METADATA_MAX_KEYS = 50;
+export const METADATA_KEY_MAX = 40;
+export const METADATA_VALUE_MAX = 500;
+const metadataKey = z
+    .string()
+    .min(1, 'metadata keys cannot be empty')
+    .max(METADATA_KEY_MAX, `metadata keys are at most ${METADATA_KEY_MAX} characters`)
+    // A key is quoted back in bracket notation (`metadata[order_id]`) in every
+    // error's `param`; a key containing brackets would make that ambiguous.
+    .refine((key) => !/[[\]]/.test(key), 'metadata keys cannot contain square brackets');
+const metadataValue = z
+    .string()
+    .max(METADATA_VALUE_MAX, `metadata values are at most ${METADATA_VALUE_MAX} characters`);
+const metadataBag = z
+    .record(metadataKey, metadataValue)
+    .refine((bag) => Object.keys(bag).length <= METADATA_MAX_KEYS, `metadata holds at most ${METADATA_MAX_KEYS} keys`)
+    .describe('At most 50 keys; keys ≤ 40 characters, values ≤ 500.');
+/**
+ * The bag a create stores. Empty values are dropped: there is nothing to unset
+ * yet.
+ */
+export const metadataCreateParam = metadataBag.transform((bag) => Object.fromEntries(Object.entries(bag).filter(([, value]) => value !== '')));
+/**
+ * The patch an update applies: named keys are set, a key sent as `""` is
+ * removed, keys not named are kept. The 50-key limit is then judged on the
+ * merged result, which only the database can see.
+ */
+export const metadataUpdateParam = metadataBag
+    .transform((bag) => ({
+    set: Object.fromEntries(Object.entries(bag).filter(([, value]) => value !== '')),
+    unset: Object.entries(bag)
+        .filter(([, value]) => value === '')
+        .map(([key]) => key),
+}))
+    .describe('A patch: named keys are set, a key sent as `""` is removed, others are kept.');
+/** The answer when the MERGED bag would exceed the key limit. */
+export const METADATA_LIMIT_MESSAGE = `metadata holds at most ${METADATA_MAX_KEYS} keys`;
+/** `""` clears a field on an update, Stripe's rule. */
+export const clearable = (schema) => z.union([schema, z.literal('')]);
+/** Bounded text. */
+export const text = (max) => z.string().max(max);

package/dist/esm/common/primitives.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { BASE_UNIT_PATTERN, CURRENCY_CODES, FIAT_CURRENCY_CODES, NETWORK_TYPES, SIGNED_BASE_UNIT_PATTERN, } from '../vocabulary/money.js';
+/**
+ * The house style's primitives (ADR 0014 D1), as RESPONSE schemas: what the
+ * gateway emits. Request-side building blocks (coercing query integers,
+ * `expand[]`, metadata patches) are in `params.ts`.
+ */
+/** Every instant on the wire: integer Unix seconds. */
+export const unixSeconds = z.number().int().nonnegative().describe('Unix seconds.');
+/** A base-unit amount: an integer string in the currency's smallest unit (a FAIR amount does not fit a JS number). */
+export const amount = z
+    .string()
+    .regex(BASE_UNIT_PATTERN)
+    .describe('Base units of `currency`, as an integer string (cents for EUR, m⊜ for FAIR).');
+/** A signed base-unit amount (a customer balance, a balance transaction's net). */
+export const signedAmount = z
+    .string()
+    .regex(SIGNED_BASE_UNIT_PATTERN)
+    .describe('Signed base units of `currency`, as an integer string.');
+/** An uppercase ISO 4217 code, or `FAIR`. */
+export const currency = z.enum(CURRENCY_CODES).describe('Uppercase ISO 4217 code, or `FAIR`.');
+/** A currency the card rail can denominate in. */
+export const fiatCurrency = z.enum(FIAT_CURRENCY_CODES);
+/** The FairCoin network. */
+export const network = z.enum(NETWORK_TYPES);
+/** Whether the object exists in live mode (`false`: test mode). */
+export const livemode = z.boolean().describe('`true` in live mode, `false` in test mode.');
+/** The merchant's own key/value bag, as returned. */
+export const metadata = z
+    .record(z.string(), z.string())
+    .describe('Your own key/value pairs: at most 50 keys, keys ≤ 40 characters, values ≤ 500.');
+/** A nullable string — the shape of every optional text field on a response. */
+export const nullableString = z.string().nullable();
+/** A literal `object` discriminator. */
+export const objectName = (name) => z.literal(name);

package/dist/esm/contributions.js

@@ -0,0 +1,5 @@
+// `@peable.to/contracts/contributions` — the contribution schemas and FAIR
+// amount helpers, without the rest of the API's schemas: the hosted checkout
+// and Orbit import this subpath at runtime. The contracts themselves live in
+// `resources/checkout/contributions.ts`, beside the other checkout routes.
+export { contributionAmountSchema, contributionCollectionListSchema, contributionCollectionSchema, contributionDetailsSchema, contributionLinkSchema, contributionListSchema, contributionMintSchema, contributionOperationKeySchema, contributionPageQuerySchema, contributionPatchSchema, contributionScopeQuerySchema, createContributionSchema, decimalContributionAmount, formatContributionAmount, } from './resources/checkout/contributions.js';

package/dist/esm/index.js

@@ -1,134 +1,26 @@
-import { z } from 'zod';
-export const contributionAmountSchema = z
-    .string()
-    .regex(/^[1-9][0-9]{0,15}$/)
-    .refine((v) => /^[1-9][0-9]{0,15}$/.test(v) && BigInt(v) <= 9007199254740991n, 'Enter a positive FairCoin base-unit amount within the supported range');
-/** Every instant on the wire is integer Unix seconds (ADR 0014 D1). */
-const unixSecondsSchema = z.number().int().nonnegative();
-export const contributionDetailsSchema = z
-    .object({
-    organization_id: z.string().min(1).max(200),
-    purpose: z.string().trim().min(1).max(500),
-    amount_mode: z.enum(['fixed', 'free']),
-    expires_at: unixSecondsSchema.nullable(),
-})
-    .strict();
-export const createContributionSchema = z
-    .object({
-    purpose: contributionDetailsSchema.shape.purpose,
-    amount_mode: contributionDetailsSchema.shape.amount_mode,
-    amount: contributionAmountSchema.optional(),
-    currency: z.literal('FAIR'),
-    expires_at: unixSecondsSchema.nullable().optional(),
-})
-    .strict()
-    .refine((v) => (v.amount_mode === 'free' ? v.amount === undefined : v.amount !== undefined), 'Fixed contributions require an amount; free contributions omit it');
-export const contributionLinkSchema = z
-    .object({
-    id: z.string(),
-    object: z.literal('payment_link'),
-    amount: z.string(),
-    currency: z.literal('FAIR'),
-    network: z.enum(['mainnet', 'testnet']),
-    active: z.boolean(),
-    url: z.url(),
-    contribution: contributionDetailsSchema,
-    created: unixSecondsSchema,
-})
-    .strict();
-/**
- * The one list envelope (ADR 0014 D1): `url` is the path that was listed.
- */
-function listSchema(item) {
-    return z
-        .object({
-        object: z.literal('list'),
-        data: z.array(item),
-        has_more: z.boolean(),
-        url: z.string(),
-    })
-        .strict();
-}
-export const contributionListSchema = listSchema(contributionLinkSchema);
-export const contributionCollectionSchema = z
-    .object({
-    id: z.string(),
-    object: z.literal('payment_intent'),
-    amount: z.string(),
-    currency: z.literal('FAIR'),
-    status: z.string(),
-    created: unixSecondsSchema,
-    refund_capability: z.literal('unsupported_non_custodial'),
-    refunds: z.array(z
-        .object({
-        id: z.string(),
-        object: z.literal('refund'),
-        amount: z.string(),
-        status: z.string(),
-        created: unixSecondsSchema,
-    })
-        .strict()),
-})
-    .strict();
-export const contributionCollectionListSchema = listSchema(contributionCollectionSchema);
-const unixSecondsQuery = z.coerce.number().int().nonnegative();
-/**
- * The list parameters every list accepts (ADR 0014 D1), newest first:
- *
- * - `limit` 1–100, default 10;
- * - `starting_after` — the id of the last object of the previous page — or
- *   `ending_before` — the id of the first object of the current one, which
- *   pages backwards and still answers newest first. Never both;
- * - `created` (one second) or `created[gt|gte|lt|lte]`, Unix seconds.
- *
- * Cursors are resolved by the gateway inside the caller's scope; one naming
- * anything else is a 400 with `param` naming the cursor.
- */
-export const listQueryShape = {
-    limit: z.coerce.number().int().min(1).max(100).default(10),
-    starting_after: z.string().min(1).max(255).optional(),
-    ending_before: z.string().min(1).max(255).optional(),
-    created: z
-        .union([
-        unixSecondsQuery.transform((x) => ({ gte: x, lte: x })),
-        z
-            .object({
-            gt: unixSecondsQuery.optional(),
-            gte: unixSecondsQuery.optional(),
-            lt: unixSecondsQuery.optional(),
-            lte: unixSecondsQuery.optional(),
-        })
-            .strict(),
-    ])
-        .optional(),
-};
-/**
- * Paging a contribution list: the list parameters (`link_…` cursors for links,
- * `pi_…` for collections) plus the environment the Test/Live toggle selects.
- */
-export const contributionPageQuerySchema = z
-    .object({
-    ...listQueryShape,
-    environment: z.enum(['development', 'staging', 'production']),
-})
-    .strict()
-    .refine((query) => query.starting_after === undefined || query.ending_before === undefined, {
-    message: 'starting_after and ending_before are mutually exclusive',
-    path: ['ending_before'],
-});
-export const contributionMintSchema = z
-    .object({ amount: contributionAmountSchema.optional() })
-    .strict();
-export const contributionOperationKeySchema = z.string().uuid();
-export const contributionPatchSchema = z.object({ active: z.boolean() }).strict();
-export function decimalContributionAmount(value) {
-    if (!/^(0|[1-9][0-9]{0,7})(\.[0-9]{1,8})?$/.test(value))
-        throw new Error('Enter a FAIR amount with at most eight decimals');
-    const [whole = '0', fraction = ''] = value.split('.');
-    return contributionAmountSchema.parse((BigInt(whole) * 100000000n + BigInt(fraction.padEnd(8, '0'))).toString());
-}
-export function formatContributionAmount(value) {
-    const units = BigInt(value);
-    const fraction = (units % 100000000n).toString().padStart(8, '0').replace(/0+$/, '');
-    return (units / 100000000n).toString() + (fraction ? `.${fraction}` : '');
-}
+// @peable.to/contracts — the Peable wire, declared once (ADR 0014 D5).
+//
+// Every public route's request and response schema is a Zod schema here. The
+// backend validates with these exact objects, the OpenAPI document
+// (`@peable.to/contracts/openapi`) is generated from them, `@peable.to/shared-types`
+// re-exports their inferred types, and `@peable.to/sdk`'s resource methods are
+// generated from the route list.
+//
+// Importing this root constructs every schema. A bundle that only needs the
+// closed value sets imports `@peable.to/contracts/vocabulary`.
+export * from './common/address.js';
+export * from './common/envelopes.js';
+export * from './common/objects.js';
+export * from './common/params.js';
+export * from './common/primitives.js';
+export * from './route.js';
+export * from './routes.js';
+export * from './vocabulary/index.js';
+export * from './resources/core/index.js';
+export * from './resources/payments/index.js';
+export * from './resources/checkout/index.js';
+export * from './resources/catalog/index.js';
+export * from './resources/billingEngine/index.js';
+export * from './resources/connect/index.js';
+export * from './resources/tax/index.js';
+export * from './resources/events/index.js';