@peable.to/contracts 0.4.0 → 1.1.0

package/dist/cjs/common/address.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emailParam = exports.shippingParams = exports.addressParams = exports.shippingSchema = exports.addressSchema = void 0;
+exports.toAddress = toAddress;
+exports.toShipping = toShipping;
+const zod_1 = require("zod");
+const objects_1 = require("./objects");
+/**
+ * Stripe's address and shipping shapes — as returned (every field present,
+ * `null` when not given) and as a request carries them (every field optional).
+ * Shared by every object that holds one: intents, customers, payment methods,
+ * checkout sessions.
+ */
+exports.addressSchema = zod_1.z
+    .object({
+    line1: zod_1.z.string().nullable(),
+    line2: zod_1.z.string().nullable(),
+    city: zod_1.z.string().nullable(),
+    state: zod_1.z.string().nullable(),
+    postal_code: zod_1.z.string().nullable(),
+    country: zod_1.z.string().nullable().describe('ISO 3166-1 alpha-2.'),
+})
+    .strict();
+objects_1.contractRegistry.add(exports.addressSchema, { id: 'Address' });
+exports.shippingSchema = zod_1.z
+    .object({
+    name: zod_1.z.string(),
+    phone: zod_1.z.string().nullable(),
+    address: exports.addressSchema,
+    carrier: zod_1.z.string().nullable(),
+    tracking_number: zod_1.z.string().nullable(),
+})
+    .strict();
+objects_1.contractRegistry.add(exports.shippingSchema, { id: 'Shipping' });
+const line = zod_1.z.string().max(500);
+/** An address as a request carries it: every field optional. */
+exports.addressParams = zod_1.z
+    .object({
+    line1: line.optional(),
+    line2: line.optional(),
+    city: line.optional(),
+    state: line.optional(),
+    postal_code: zod_1.z.string().max(40).optional(),
+    country: zod_1.z
+        .string()
+        .regex(/^[A-Z]{2}$/, 'country must be an ISO 3166-1 alpha-2 code')
+        .optional(),
+})
+    .strict();
+/** Shipping as a request carries it: only `name` and `address` are required. */
+exports.shippingParams = zod_1.z
+    .object({
+    name: zod_1.z.string().min(1).max(500),
+    phone: zod_1.z.string().max(40).optional(),
+    address: exports.addressParams,
+    carrier: zod_1.z.string().max(200).optional(),
+    tracking_number: zod_1.z.string().max(200).optional(),
+})
+    .strict();
+exports.emailParam = zod_1.z.email().max(512);
+/** A request address in the stored (and wire) shape: every field present. */
+function toAddress(input) {
+    return {
+        line1: input.line1 ?? null,
+        line2: input.line2 ?? null,
+        city: input.city ?? null,
+        state: input.state ?? null,
+        postal_code: input.postal_code ?? null,
+        country: input.country ?? null,
+    };
+}
+/** Request shipping in the stored (and wire) shape. */
+function toShipping(input) {
+    return {
+        name: input.name,
+        phone: input.phone ?? null,
+        address: toAddress(input.address),
+        carrier: input.carrier ?? null,
+        tracking_number: input.tracking_number ?? null,
+    };
+}

package/dist/cjs/common/envelopes.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorEnvelopeSchema = exports.apiErrorSchema = void 0;
+exports.listOf = listOf;
+exports.searchResultOf = searchResultOf;
+exports.deletedOf = deletedOf;
+const zod_1 = require("zod");
+const errors_1 = require("../vocabulary/errors");
+const objects_1 = require("./objects");
+/**
+ * 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.
+ */
+function listOf(item) {
+    return zod_1.z
+        .object({
+        object: zod_1.z.literal('list'),
+        data: zod_1.z.array(item),
+        has_more: zod_1.z
+            .boolean()
+            .describe('Whether another page exists in the direction this one was read.'),
+        url: zod_1.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.
+ */
+function searchResultOf(item) {
+    return zod_1.z
+        .object({
+        object: zod_1.z.literal('search_result'),
+        data: zod_1.z.array(item),
+        has_more: zod_1.z.boolean(),
+        next_page: zod_1.z
+            .string()
+            .nullable()
+            .describe('Pass as `page` for the next page; `null` on the last one.'),
+        url: zod_1.z.string().describe('The path that was searched.'),
+        total_count: zod_1.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}`. */
+function deletedOf(object) {
+    return zod_1.z.object({ id: zod_1.z.string(), object: zod_1.z.literal(object), deleted: zod_1.z.literal(true) }).strict();
+}
+/** The error object inside every non-2xx answer. */
+exports.apiErrorSchema = zod_1.z
+    .object({
+    type: zod_1.z.enum(errors_1.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: zod_1.z
+        .string()
+        .optional()
+        .describe(`The machine-readable reason (one of ${String(errors_1.ERROR_CODES.length)} documented at ${errors_1.ERROR_DOCS_BASE_URL}, or a card network's decline code on a \`card_error\`).`),
+    decline_code: zod_1.z
+        .string()
+        .optional()
+        .describe("A card issuer's decline reason, on a `card_error`."),
+    param: zod_1.z
+        .string()
+        .optional()
+        .describe('The offending request field, in bracket notation (`metadata[order_id]`).'),
+    message: zod_1.z.string().describe('A human-readable message, for a developer.'),
+    doc_url: zod_1.z.url().optional().describe('The documentation of `code`.'),
+    request_id: zod_1.z.string().nullable().describe('The `Request-Id` of this response, for support.'),
+    payment_intent: zod_1.z
+        .lazy(() => (0, objects_1.resolveObject)('payment_intent'))
+        .optional()
+        .describe('On a `card_error` from a confirm or an invoice payment: the PaymentIntent, as it now is.'),
+    invoice: zod_1.z
+        .lazy(() => (0, objects_1.resolveObject)('invoice'))
+        .optional()
+        .describe('On a failed invoice payment: the invoice, as it now is.'),
+    refresh_url: zod_1.z
+        .url()
+        .optional()
+        .describe('On an expired onboarding link: where the seller gets a fresh one.'),
+})
+    .strict();
+/** `{ error: {...} }` — every non-2xx answer. */
+exports.errorEnvelopeSchema = zod_1.z.object({ error: exports.apiErrorSchema }).strict();
+objects_1.contractRegistry.add(exports.errorEnvelopeSchema, {
+    id: 'Error',
+    description: 'Every non-2xx answer. The HTTP status and `error.type` identify the failure.',
+});

package/dist/cjs/common/objects.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractRegistry = void 0;
+exports.defineObject = defineObject;
+exports.defineComponent = defineComponent;
+exports.objectSchema = objectSchema;
+exports.resolveObject = resolveObject;
+exports.objectTypes = objectTypes;
+exports.expandable = expandable;
+exports.embedded = embedded;
+exports.describe = describe;
+const zod_1 = require("zod");
+/** The one registry every contract schema's metadata lives in. */
+exports.contractRegistry = zod_1.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.
+ */
+function defineObject(type, id, schema, meta = {}) {
+    if (objectSchemas.has(type))
+        throw new Error(`object type '${type}' is defined twice`);
+    objectSchemas.set(type, schema);
+    exports.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>`.
+ */
+function defineComponent(id, schema, meta = {}) {
+    exports.contractRegistry.add(schema, { id, ...meta });
+    return schema;
+}
+/** The registered schema of `type`, or `undefined`. */
+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.
+ */
+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. */
+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.
+ */
+function expandable(type, description) {
+    const resolved = zod_1.z.lazy(() => resolveObject(type));
+    const union = zod_1.z.union([zod_1.z.string(), resolved]);
+    exports.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.
+ */
+function embedded(type, description) {
+    const schema = zod_1.z.lazy(() => resolveObject(type));
+    return (description === undefined
+        ? schema
+        : schema.describe(description));
+}
+/** Attach OpenAPI metadata to a schema without changing its type. */
+function describe(schema, meta) {
+    exports.contractRegistry.add(schema, { ...exports.contractRegistry.get(schema), ...meta });
+    return schema;
+}

package/dist/cjs/common/params.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.text = exports.clearable = exports.METADATA_LIMIT_MESSAGE = exports.metadataUpdateParam = exports.metadataCreateParam = exports.METADATA_VALUE_MAX = exports.METADATA_KEY_MAX = exports.METADATA_MAX_KEYS = exports.searchQuery = exports.searchShape = exports.emptyQuery = exports.expandOnlyQuery = exports.listShape = exports.limitParam = exports.idParam = exports.cursorParam = exports.expandParam = exports.rangeParam = exports.queryUnixSeconds = exports.unixSecondsParam = exports.MAX_UNIX_SECONDS = exports.queryBoolean = void 0;
+exports.queryInteger = queryInteger;
+exports.listQuery = listQuery;
+exports.retrieveQuery = retrieveQuery;
+const zod_1 = require("zod");
+const lists_1 = require("../vocabulary/lists");
+const objects_1 = require("./objects");
+/**
+ * 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) {
+    objects_1.contractRegistry.add(schema, { ...objects_1.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.
+ */
+function queryInteger(bounds = {}) {
+    let target = zod_1.z.number().int();
+    if (bounds.min !== undefined)
+        target = target.min(bounds.min);
+    if (bounds.max !== undefined)
+        target = target.max(bounds.max);
+    return documentedAs(zod_1.z.union([zod_1.z.number(), zod_1.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). */
+exports.queryBoolean = documentedAs(zod_1.z.union([zod_1.z.boolean(), zod_1.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. */
+exports.MAX_UNIX_SECONDS = 253402300799;
+/** Unix seconds in a body. */
+exports.unixSecondsParam = zod_1.z.number().int().min(0).max(exports.MAX_UNIX_SECONDS);
+/** Unix seconds in a query string. */
+exports.queryUnixSeconds = queryInteger({ min: 0, max: exports.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.
+ */
+exports.rangeParam = documentedAs(zod_1.z.union([
+    exports.queryUnixSeconds.transform((x) => ({ gte: x, lte: x })),
+    zod_1.z
+        .object({
+        gt: exports.queryUnixSeconds.optional(),
+        gte: exports.queryUnixSeconds.optional(),
+        lt: exports.queryUnixSeconds.optional(),
+        lte: exports.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.`.
+ */
+exports.expandParam = documentedAs(zod_1.z
+    .union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())])
+    .transform((value) => (typeof value === 'string' ? [value] : value))
+    .pipe(zod_1.z.array(zod_1.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. */
+exports.cursorParam = zod_1.z.string().min(1).max(255);
+/** An object id in a body or query. */
+exports.idParam = zod_1.z.string().min(1).max(255);
+/** The list limit: 1–100, default 10. */
+exports.limitParam = documentedAs(zod_1.z
+    .union([zod_1.z.number(), zod_1.z.string()])
+    .transform(Number)
+    .pipe(zod_1.z.number().int().min(1).max(lists_1.LIST_LIMIT_MAX))
+    .optional()
+    .transform((value) => value ?? lists_1.LIST_LIMIT_DEFAULT), { type: 'integer', minimum: 1, maximum: lists_1.LIST_LIMIT_MAX, default: lists_1.LIST_LIMIT_DEFAULT });
+/** The parameters every list accepts. */
+exports.listShape = {
+    limit: exports.limitParam,
+    starting_after: exports.cursorParam
+        .optional()
+        .describe('The id of the LAST object of the previous page: the next page is older.'),
+    ending_before: exports.cursorParam
+        .optional()
+        .describe('The id of the FIRST object of the current page: the page returned is newer.'),
+    created: exports.rangeParam.optional(),
+    expand: exports.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.
+ */
+function listQuery(filters) {
+    return zod_1.z
+        .object({ ...exports.listShape, ...filters })
+        .strict()
+        .superRefine((query, ctx) => refuseBothCursors(query, ctx));
+}
+/** A retrieve's query: `expand[]` and nothing else unless the route says so. */
+function retrieveQuery(extra) {
+    return zod_1.z.object({ expand: exports.expandParam.optional(), ...extra }).strict();
+}
+/** The query of a route that takes `expand[]` only. */
+exports.expandOnlyQuery = retrieveQuery({});
+/** The query of a route that takes no parameters at all. */
+exports.emptyQuery = zod_1.z.object({}).strict();
+/** The parameters every `GET /v1/<objects>/search` accepts. */
+exports.searchShape = {
+    query: zod_1.z
+        .string({ error: 'query is required' })
+        .min(1, 'query is required')
+        .max(lists_1.SEARCH_QUERY_MAX_LENGTH, `a query is at most ${String(lists_1.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: exports.limitParam,
+    page: zod_1.z
+        .string()
+        .min(1)
+        .max(512)
+        .optional()
+        .describe('The `next_page` of the previous page, with the SAME query.'),
+    expand: exports.expandParam.optional(),
+};
+/** A search query. */
+exports.searchQuery = zod_1.z.object(exports.searchShape).strict();
+exports.METADATA_MAX_KEYS = 50;
+exports.METADATA_KEY_MAX = 40;
+exports.METADATA_VALUE_MAX = 500;
+const metadataKey = zod_1.z
+    .string()
+    .min(1, 'metadata keys cannot be empty')
+    .max(exports.METADATA_KEY_MAX, `metadata keys are at most ${exports.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 = zod_1.z
+    .string()
+    .max(exports.METADATA_VALUE_MAX, `metadata values are at most ${exports.METADATA_VALUE_MAX} characters`);
+const metadataBag = zod_1.z
+    .record(metadataKey, metadataValue)
+    .refine((bag) => Object.keys(bag).length <= exports.METADATA_MAX_KEYS, `metadata holds at most ${exports.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.
+ */
+exports.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.
+ */
+exports.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. */
+exports.METADATA_LIMIT_MESSAGE = `metadata holds at most ${exports.METADATA_MAX_KEYS} keys`;
+/** `""` clears a field on an update, Stripe's rule. */
+const clearable = (schema) => zod_1.z.union([schema, zod_1.z.literal('')]);
+exports.clearable = clearable;
+/** Bounded text. */
+const text = (max) => zod_1.z.string().max(max);
+exports.text = text;

package/dist/cjs/common/primitives.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectName = exports.nullableString = exports.metadata = exports.livemode = exports.network = exports.fiatCurrency = exports.currency = exports.signedAmount = exports.amount = exports.unixSeconds = void 0;
+const zod_1 = require("zod");
+const money_1 = require("../vocabulary/money");
+/**
+ * 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. */
+exports.unixSeconds = zod_1.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). */
+exports.amount = zod_1.z
+    .string()
+    .regex(money_1.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). */
+exports.signedAmount = zod_1.z
+    .string()
+    .regex(money_1.SIGNED_BASE_UNIT_PATTERN)
+    .describe('Signed base units of `currency`, as an integer string.');
+/** An uppercase ISO 4217 code, or `FAIR`. */
+exports.currency = zod_1.z.enum(money_1.CURRENCY_CODES).describe('Uppercase ISO 4217 code, or `FAIR`.');
+/** A currency the card rail can denominate in. */
+exports.fiatCurrency = zod_1.z.enum(money_1.FIAT_CURRENCY_CODES);
+/** The FairCoin network. */
+exports.network = zod_1.z.enum(money_1.NETWORK_TYPES);
+/** Whether the object exists in live mode (`false`: test mode). */
+exports.livemode = zod_1.z.boolean().describe('`true` in live mode, `false` in test mode.');
+/** The merchant's own key/value bag, as returned. */
+exports.metadata = zod_1.z
+    .record(zod_1.z.string(), zod_1.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. */
+exports.nullableString = zod_1.z.string().nullable();
+/** A literal `object` discriminator. */
+const objectName = (name) => zod_1.z.literal(name);
+exports.objectName = objectName;

package/dist/cjs/contributions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatContributionAmount = exports.decimalContributionAmount = exports.createContributionSchema = exports.contributionScopeQuerySchema = exports.contributionPatchSchema = exports.contributionPageQuerySchema = exports.contributionOperationKeySchema = exports.contributionMintSchema = exports.contributionListSchema = exports.contributionLinkSchema = exports.contributionDetailsSchema = exports.contributionCollectionSchema = exports.contributionCollectionListSchema = exports.contributionAmountSchema = void 0;
+// `@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.
+var contributions_1 = require("./resources/checkout/contributions");
+Object.defineProperty(exports, "contributionAmountSchema", { enumerable: true, get: function () { return contributions_1.contributionAmountSchema; } });
+Object.defineProperty(exports, "contributionCollectionListSchema", { enumerable: true, get: function () { return contributions_1.contributionCollectionListSchema; } });
+Object.defineProperty(exports, "contributionCollectionSchema", { enumerable: true, get: function () { return contributions_1.contributionCollectionSchema; } });
+Object.defineProperty(exports, "contributionDetailsSchema", { enumerable: true, get: function () { return contributions_1.contributionDetailsSchema; } });
+Object.defineProperty(exports, "contributionLinkSchema", { enumerable: true, get: function () { return contributions_1.contributionLinkSchema; } });
+Object.defineProperty(exports, "contributionListSchema", { enumerable: true, get: function () { return contributions_1.contributionListSchema; } });
+Object.defineProperty(exports, "contributionMintSchema", { enumerable: true, get: function () { return contributions_1.contributionMintSchema; } });
+Object.defineProperty(exports, "contributionOperationKeySchema", { enumerable: true, get: function () { return contributions_1.contributionOperationKeySchema; } });
+Object.defineProperty(exports, "contributionPageQuerySchema", { enumerable: true, get: function () { return contributions_1.contributionPageQuerySchema; } });
+Object.defineProperty(exports, "contributionPatchSchema", { enumerable: true, get: function () { return contributions_1.contributionPatchSchema; } });
+Object.defineProperty(exports, "contributionScopeQuerySchema", { enumerable: true, get: function () { return contributions_1.contributionScopeQuerySchema; } });
+Object.defineProperty(exports, "createContributionSchema", { enumerable: true, get: function () { return contributions_1.createContributionSchema; } });
+Object.defineProperty(exports, "decimalContributionAmount", { enumerable: true, get: function () { return contributions_1.decimalContributionAmount; } });
+Object.defineProperty(exports, "formatContributionAmount", { enumerable: true, get: function () { return contributions_1.formatContributionAmount; } });