@peable.to/contracts 0.0.0-stage → 0.2.0

package/dist/cjs/index.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contributionPatchSchema = exports.contributionOperationKeySchema = exports.contributionMintSchema = exports.contributionPageQuerySchema = exports.contributionCollectionListSchema = exports.contributionCollectionSchema = exports.contributionListSchema = exports.contributionLinkSchema = exports.createContributionSchema = exports.contributionDetailsSchema = exports.contributionAmountSchema = void 0;
+exports.decimalContributionAmount = decimalContributionAmount;
+exports.formatContributionAmount = formatContributionAmount;
+const zod_1 = require("zod");
+exports.contributionAmountSchema = zod_1.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');
+exports.contributionDetailsSchema = zod_1.z
+    .object({
+    organizationId: zod_1.z.string().min(1).max(200),
+    purpose: zod_1.z.string().trim().min(1).max(500),
+    amountMode: zod_1.z.enum(['fixed', 'free']),
+    expiresAt: zod_1.z.iso.datetime().nullable(),
+})
+    .strict();
+exports.createContributionSchema = zod_1.z
+    .object({
+    purpose: exports.contributionDetailsSchema.shape.purpose,
+    amountMode: exports.contributionDetailsSchema.shape.amountMode,
+    amount: exports.contributionAmountSchema.optional(),
+    currency: zod_1.z.literal('FAIR'),
+    expiresAt: zod_1.z.iso.datetime().nullable().optional(),
+})
+    .strict()
+    .refine((v) => (v.amountMode === 'free' ? v.amount === undefined : v.amount !== undefined), 'Fixed contributions require an amount; free contributions omit it');
+exports.contributionLinkSchema = zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    amount: zod_1.z.string(),
+    currency: zod_1.z.literal('FAIR'),
+    network: zod_1.z.enum(['mainnet', 'testnet']),
+    active: zod_1.z.boolean(),
+    url: zod_1.z.url(),
+    contribution: exports.contributionDetailsSchema,
+    createdAt: zod_1.z.iso.datetime(),
+})
+    .strict();
+exports.contributionListSchema = zod_1.z
+    .object({ items: zod_1.z.array(exports.contributionLinkSchema), nextCursor: zod_1.z.string().nullable() })
+    .strict();
+exports.contributionCollectionSchema = zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    amount: zod_1.z.string(),
+    currency: zod_1.z.literal('FAIR'),
+    status: zod_1.z.string(),
+    createdAt: zod_1.z.iso.datetime(),
+    refundCapability: zod_1.z.literal('unsupported_non_custodial'),
+    refunds: zod_1.z.array(zod_1.z
+        .object({
+        id: zod_1.z.string(),
+        amount: zod_1.z.string(),
+        status: zod_1.z.string(),
+        createdAt: zod_1.z.iso.datetime(),
+    })
+        .strict()),
+})
+    .strict();
+exports.contributionCollectionListSchema = zod_1.z
+    .object({ items: zod_1.z.array(exports.contributionCollectionSchema), nextCursor: zod_1.z.string().nullable() })
+    .strict();
+exports.contributionPageQuerySchema = zod_1.z
+    .object({
+    limit: zod_1.z.coerce.number().int().min(1).max(100).default(20),
+    cursor: zod_1.z.string().max(1000).optional(),
+    environment: zod_1.z.enum(['development', 'staging', 'production']),
+})
+    .strict();
+exports.contributionMintSchema = zod_1.z
+    .object({ amount: exports.contributionAmountSchema.optional() })
+    .strict();
+exports.contributionOperationKeySchema = zod_1.z.string().uuid();
+exports.contributionPatchSchema = zod_1.z.object({ active: zod_1.z.boolean() }).strict();
+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 exports.contributionAmountSchema.parse((BigInt(whole) * 100000000n + BigInt(fraction.padEnd(8, '0'))).toString());
+}
+function formatContributionAmount(value) {
+    const units = BigInt(value);
+    const fraction = (units % 100000000n).toString().padStart(8, '0').replace(/0+$/, '');
+    return (units / 100000000n).toString() + (fraction ? `.${fraction}` : '');
+}

package/dist/cjs/openapi.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contributionRoutes = void 0;
+exports.contributionOpenApi = contributionOpenApi;
+const zod_1 = require("zod");
+const index_1 = require("./index");
+const path = '/v1/organizations/{organizationId}/applications/{applicationId}/contributions';
+exports.contributionRoutes = [
+    {
+        method: 'post',
+        path,
+        operationId: 'createContribution',
+        body: index_1.createContributionSchema,
+        response: index_1.contributionLinkSchema,
+        status: 201,
+    },
+    {
+        method: 'get',
+        path,
+        operationId: 'listContributions',
+        response: index_1.contributionListSchema,
+        status: 200,
+    },
+    {
+        method: 'patch',
+        path: `${path}/{id}`,
+        operationId: 'setContributionActive',
+        body: index_1.contributionPatchSchema,
+        response: index_1.contributionLinkSchema,
+        status: 200,
+    },
+    {
+        method: 'get',
+        path: `${path}/{id}/collections`,
+        operationId: 'listContributionCollections',
+        response: index_1.contributionCollectionListSchema,
+        status: 200,
+    },
+];
+function contributionOpenApi() {
+    var _a;
+    const paths = {};
+    for (const route of exports.contributionRoutes) {
+        paths[_a = route.path] ?? (paths[_a] = {});
+        const parameters = [...route.path.matchAll(/\{([^}]+)\}/g)].map((match) => ({
+            in: 'path',
+            name: match[1],
+            required: true,
+            schema: { type: 'string' },
+        }));
+        parameters.push({
+            in: 'query',
+            name: 'environment',
+            required: true,
+            schema: { type: 'string', enum: ['development', 'staging', 'production'] },
+        });
+        if (route.method === 'get')
+            parameters.push({
+                in: 'query',
+                name: 'limit',
+                schema: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
+            }, { in: 'query', name: 'cursor', schema: { type: 'string' } });
+        if (route.method === 'post')
+            parameters.push({
+                in: 'header',
+                name: 'Idempotency-Key',
+                required: true,
+                schema: { type: 'string', format: 'uuid' },
+            });
+        paths[route.path][route.method] = {
+            operationId: route.operationId,
+            security: [{ oxySession: [] }],
+            parameters,
+            ...('body' in route
+                ? {
+                    requestBody: {
+                        required: true,
+                        content: { 'application/json': { schema: zod_1.z.toJSONSchema(route.body) } },
+                    },
+                }
+                : {}),
+            responses: {
+                [route.status]: {
+                    description: 'Success',
+                    content: { 'application/json': { schema: zod_1.z.toJSONSchema(route.response) } },
+                },
+                default: {
+                    description: 'Peable error envelope; HTTP status identifies failure',
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                required: ['error'],
+                                properties: {
+                                    error: {
+                                        type: 'object',
+                                        required: ['type', 'message'],
+                                        properties: { type: { type: 'string' }, message: { type: 'string' } },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    return {
+        openapi: '3.1.0',
+        info: {
+            title: 'Peable organization contributions',
+            version: '0.1.0',
+            description: 'One-off links. Human Oxy session for management; existing /v1/payment_links/{id}/public and /payment_intent remain anonymous. Fixed/free amounts use FAIR base units (8 decimals); the registered merchant determines the network. Refunds cannot be created by the watch-only gateway. No recurring billing.',
+        },
+        servers: [{ url: 'https://api.peable.to' }],
+        components: { securitySchemes: { oxySession: { type: 'http', scheme: 'bearer' } } },
+        paths,
+    };
+}

package/dist/esm/index.js

@@ -0,0 +1,82 @@
+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');
+export const contributionDetailsSchema = z
+    .object({
+    organizationId: z.string().min(1).max(200),
+    purpose: z.string().trim().min(1).max(500),
+    amountMode: z.enum(['fixed', 'free']),
+    expiresAt: z.iso.datetime().nullable(),
+})
+    .strict();
+export const createContributionSchema = z
+    .object({
+    purpose: contributionDetailsSchema.shape.purpose,
+    amountMode: contributionDetailsSchema.shape.amountMode,
+    amount: contributionAmountSchema.optional(),
+    currency: z.literal('FAIR'),
+    expiresAt: z.iso.datetime().nullable().optional(),
+})
+    .strict()
+    .refine((v) => (v.amountMode === 'free' ? v.amount === undefined : v.amount !== undefined), 'Fixed contributions require an amount; free contributions omit it');
+export const contributionLinkSchema = z
+    .object({
+    id: z.string(),
+    amount: z.string(),
+    currency: z.literal('FAIR'),
+    network: z.enum(['mainnet', 'testnet']),
+    active: z.boolean(),
+    url: z.url(),
+    contribution: contributionDetailsSchema,
+    createdAt: z.iso.datetime(),
+})
+    .strict();
+export const contributionListSchema = z
+    .object({ items: z.array(contributionLinkSchema), nextCursor: z.string().nullable() })
+    .strict();
+export const contributionCollectionSchema = z
+    .object({
+    id: z.string(),
+    amount: z.string(),
+    currency: z.literal('FAIR'),
+    status: z.string(),
+    createdAt: z.iso.datetime(),
+    refundCapability: z.literal('unsupported_non_custodial'),
+    refunds: z.array(z
+        .object({
+        id: z.string(),
+        amount: z.string(),
+        status: z.string(),
+        createdAt: z.iso.datetime(),
+    })
+        .strict()),
+})
+    .strict();
+export const contributionCollectionListSchema = z
+    .object({ items: z.array(contributionCollectionSchema), nextCursor: z.string().nullable() })
+    .strict();
+export const contributionPageQuerySchema = z
+    .object({
+    limit: z.coerce.number().int().min(1).max(100).default(20),
+    cursor: z.string().max(1000).optional(),
+    environment: z.enum(['development', 'staging', 'production']),
+})
+    .strict();
+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}` : '');
+}

package/dist/esm/openapi.js

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+import { createContributionSchema, contributionLinkSchema, contributionListSchema, contributionCollectionListSchema, contributionPatchSchema, } from './index.js';
+const path = '/v1/organizations/{organizationId}/applications/{applicationId}/contributions';
+export const contributionRoutes = [
+    {
+        method: 'post',
+        path,
+        operationId: 'createContribution',
+        body: createContributionSchema,
+        response: contributionLinkSchema,
+        status: 201,
+    },
+    {
+        method: 'get',
+        path,
+        operationId: 'listContributions',
+        response: contributionListSchema,
+        status: 200,
+    },
+    {
+        method: 'patch',
+        path: `${path}/{id}`,
+        operationId: 'setContributionActive',
+        body: contributionPatchSchema,
+        response: contributionLinkSchema,
+        status: 200,
+    },
+    {
+        method: 'get',
+        path: `${path}/{id}/collections`,
+        operationId: 'listContributionCollections',
+        response: contributionCollectionListSchema,
+        status: 200,
+    },
+];
+export function contributionOpenApi() {
+    var _a;
+    const paths = {};
+    for (const route of contributionRoutes) {
+        paths[_a = route.path] ?? (paths[_a] = {});
+        const parameters = [...route.path.matchAll(/\{([^}]+)\}/g)].map((match) => ({
+            in: 'path',
+            name: match[1],
+            required: true,
+            schema: { type: 'string' },
+        }));
+        parameters.push({
+            in: 'query',
+            name: 'environment',
+            required: true,
+            schema: { type: 'string', enum: ['development', 'staging', 'production'] },
+        });
+        if (route.method === 'get')
+            parameters.push({
+                in: 'query',
+                name: 'limit',
+                schema: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
+            }, { in: 'query', name: 'cursor', schema: { type: 'string' } });
+        if (route.method === 'post')
+            parameters.push({
+                in: 'header',
+                name: 'Idempotency-Key',
+                required: true,
+                schema: { type: 'string', format: 'uuid' },
+            });
+        paths[route.path][route.method] = {
+            operationId: route.operationId,
+            security: [{ oxySession: [] }],
+            parameters,
+            ...('body' in route
+                ? {
+                    requestBody: {
+                        required: true,
+                        content: { 'application/json': { schema: z.toJSONSchema(route.body) } },
+                    },
+                }
+                : {}),
+            responses: {
+                [route.status]: {
+                    description: 'Success',
+                    content: { 'application/json': { schema: z.toJSONSchema(route.response) } },
+                },
+                default: {
+                    description: 'Peable error envelope; HTTP status identifies failure',
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                required: ['error'],
+                                properties: {
+                                    error: {
+                                        type: 'object',
+                                        required: ['type', 'message'],
+                                        properties: { type: { type: 'string' }, message: { type: 'string' } },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    return {
+        openapi: '3.1.0',
+        info: {
+            title: 'Peable organization contributions',
+            version: '0.1.0',
+            description: 'One-off links. Human Oxy session for management; existing /v1/payment_links/{id}/public and /payment_intent remain anonymous. Fixed/free amounts use FAIR base units (8 decimals); the registered merchant determines the network. Refunds cannot be created by the watch-only gateway. No recurring billing.',
+        },
+        servers: [{ url: 'https://api.peable.to' }],
+        components: { securitySchemes: { oxySession: { type: 'http', scheme: 'bearer' } } },
+        paths,
+    };
+}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/types/index.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+export declare const contributionAmountSchema: z.ZodString;
+export declare const contributionDetailsSchema: z.ZodObject<{
+    organizationId: z.ZodString;
+    purpose: z.ZodString;
+    amountMode: z.ZodEnum<{
+        fixed: "fixed";
+        free: "free";
+    }>;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type ContributionDetails = z.infer<typeof contributionDetailsSchema>;
+export declare const createContributionSchema: z.ZodObject<{
+    purpose: z.ZodString;
+    amountMode: z.ZodEnum<{
+        fixed: "fixed";
+        free: "free";
+    }>;
+    amount: z.ZodOptional<z.ZodString>;
+    currency: z.ZodLiteral<"FAIR">;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+}, z.core.$strict>;
+export type CreateContribution = z.infer<typeof createContributionSchema>;
+export declare const contributionLinkSchema: z.ZodObject<{
+    id: z.ZodString;
+    amount: z.ZodString;
+    currency: z.ZodLiteral<"FAIR">;
+    network: z.ZodEnum<{
+        mainnet: "mainnet";
+        testnet: "testnet";
+    }>;
+    active: z.ZodBoolean;
+    url: z.ZodURL;
+    contribution: z.ZodObject<{
+        organizationId: z.ZodString;
+        purpose: z.ZodString;
+        amountMode: z.ZodEnum<{
+            fixed: "fixed";
+            free: "free";
+        }>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type ContributionLink = z.infer<typeof contributionLinkSchema>;
+export declare const contributionListSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodString;
+        currency: z.ZodLiteral<"FAIR">;
+        network: z.ZodEnum<{
+            mainnet: "mainnet";
+            testnet: "testnet";
+        }>;
+        active: z.ZodBoolean;
+        url: z.ZodURL;
+        contribution: z.ZodObject<{
+            organizationId: z.ZodString;
+            purpose: z.ZodString;
+            amountMode: z.ZodEnum<{
+                fixed: "fixed";
+                free: "free";
+            }>;
+            expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const contributionCollectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    amount: z.ZodString;
+    currency: z.ZodLiteral<"FAIR">;
+    status: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    refundCapability: z.ZodLiteral<"unsupported_non_custodial">;
+    refunds: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const contributionCollectionListSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodString;
+        currency: z.ZodLiteral<"FAIR">;
+        status: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        refundCapability: z.ZodLiteral<"unsupported_non_custodial">;
+        refunds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            amount: z.ZodString;
+            status: z.ZodString;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const contributionPageQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    environment: z.ZodEnum<{
+        development: "development";
+        staging: "staging";
+        production: "production";
+    }>;
+}, z.core.$strict>;
+export declare const contributionMintSchema: z.ZodObject<{
+    amount: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const contributionOperationKeySchema: z.ZodString;
+export declare const contributionPatchSchema: z.ZodObject<{
+    active: z.ZodBoolean;
+}, z.core.$strict>;
+export declare function decimalContributionAmount(value: string): string;
+export declare function formatContributionAmount(value: string): string;
+export type ContributionCollectionList = z.infer<typeof contributionCollectionListSchema>;

package/dist/types/openapi.d.ts

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+export declare const contributionRoutes: readonly [{
+    readonly method: "post";
+    readonly path: "/v1/organizations/{organizationId}/applications/{applicationId}/contributions";
+    readonly operationId: "createContribution";
+    readonly body: z.ZodObject<{
+        purpose: z.ZodString;
+        amountMode: z.ZodEnum<{
+            fixed: "fixed";
+            free: "free";
+        }>;
+        amount: z.ZodOptional<z.ZodString>;
+        currency: z.ZodLiteral<"FAIR">;
+        expiresAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    }, z.core.$strict>;
+    readonly response: z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodString;
+        currency: z.ZodLiteral<"FAIR">;
+        network: z.ZodEnum<{
+            mainnet: "mainnet";
+            testnet: "testnet";
+        }>;
+        active: z.ZodBoolean;
+        url: z.ZodURL;
+        contribution: z.ZodObject<{
+            organizationId: z.ZodString;
+            purpose: z.ZodString;
+            amountMode: z.ZodEnum<{
+                fixed: "fixed";
+                free: "free";
+            }>;
+            expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    readonly status: 201;
+}, {
+    readonly method: "get";
+    readonly path: "/v1/organizations/{organizationId}/applications/{applicationId}/contributions";
+    readonly operationId: "listContributions";
+    readonly response: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            amount: z.ZodString;
+            currency: z.ZodLiteral<"FAIR">;
+            network: z.ZodEnum<{
+                mainnet: "mainnet";
+                testnet: "testnet";
+            }>;
+            active: z.ZodBoolean;
+            url: z.ZodURL;
+            contribution: z.ZodObject<{
+                organizationId: z.ZodString;
+                purpose: z.ZodString;
+                amountMode: z.ZodEnum<{
+                    fixed: "fixed";
+                    free: "free";
+                }>;
+                expiresAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        nextCursor: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    readonly status: 200;
+}, {
+    readonly method: "patch";
+    readonly path: "/v1/organizations/{organizationId}/applications/{applicationId}/contributions/{id}";
+    readonly operationId: "setContributionActive";
+    readonly body: z.ZodObject<{
+        active: z.ZodBoolean;
+    }, z.core.$strict>;
+    readonly response: z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodString;
+        currency: z.ZodLiteral<"FAIR">;
+        network: z.ZodEnum<{
+            mainnet: "mainnet";
+            testnet: "testnet";
+        }>;
+        active: z.ZodBoolean;
+        url: z.ZodURL;
+        contribution: z.ZodObject<{
+            organizationId: z.ZodString;
+            purpose: z.ZodString;
+            amountMode: z.ZodEnum<{
+                fixed: "fixed";
+                free: "free";
+            }>;
+            expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    readonly status: 200;
+}, {
+    readonly method: "get";
+    readonly path: "/v1/organizations/{organizationId}/applications/{applicationId}/contributions/{id}/collections";
+    readonly operationId: "listContributionCollections";
+    readonly response: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            amount: z.ZodString;
+            currency: z.ZodLiteral<"FAIR">;
+            status: z.ZodString;
+            createdAt: z.ZodISODateTime;
+            refundCapability: z.ZodLiteral<"unsupported_non_custodial">;
+            refunds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                amount: z.ZodString;
+                status: z.ZodString;
+                createdAt: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        nextCursor: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    readonly status: 200;
+}];
+export declare function contributionOpenApi(): {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    components: {
+        securitySchemes: {
+            oxySession: {
+                type: string;
+                scheme: string;
+            };
+        };
+    };
+    paths: Record<string, Record<string, unknown>>;
+};

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@peable.to/contracts",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Validated Peable contribution-link contracts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "source": "src/index.ts",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "exports": {
+    ".": {
+      "react-native": "./dist/esm/index.js",
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "default": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json",
+    "./openapi": {
+      "import": {
+        "types": "./dist/types/openapi.d.ts",
+        "default": "./dist/esm/openapi.js"
+      },
+      "require": {
+        "types": "./dist/types/openapi.d.ts",
+        "default": "./dist/cjs/openapi.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "peable",
+    "gateway",
+    "payments",
+    "types"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OxyHQ/Peable.git",
+    "directory": "packages/contracts"
+  },
+  "author": "Peable",
+  "license": "MIT",
+  "homepage": "https://peable.to",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "bun run build:cjs && bun run build:esm && bun run build:types",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json && node scripts/fix-esm-imports.mjs",
+    "build:types": "tsc -p tsconfig.types.json",
+    "clean": "rm -rf dist",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run clean && bun run typecheck && bun run test && bun run build"
+  },
+  "devDependencies": {
+    "typescript": "~5.9.2",
+    "@types/node": "^20.0.0",
+    "@types/bun": "latest"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.