@peable.to/contracts 0.3.0 → 1.0.0

package/dist/esm/resources/checkout/shared.js

@@ -0,0 +1,363 @@
+import { z } from 'zod';
+import { PAYMENT_INTENT_RAILS } from '../../vocabulary/payments.js';
+import { addressSchema } from '../../common/address.js';
+import { defineComponent, defineObject, expandable } from '../../common/objects.js';
+import { amount, currency } from '../../common/primitives.js';
+import { CHECKOUT_BILLING_ADDRESS_COLLECTIONS, CHECKOUT_CUSTOM_FIELD_TYPES, CHECKOUT_LIMITS, CHECKOUT_LOCALES, CHECKOUT_SESSION_ID_TEMPLATE, CHECKOUT_TAX_ID_TYPES, } from '../../vocabulary/checkout.js';
+import { BRANDING_BORDER_STYLES, BRANDING_FONTS } from '../../vocabulary/merchants.js';
+import { BASE_UNIT_PATTERN } from '../../vocabulary/money.js';
+/**
+ * What Checkout Sessions and Payment Links share: the `item` a line renders
+ * as, the collection options (address, phone, tax id, terms, custom fields),
+ * the payer-facing merchant and branding, and the request halves of those.
+ * One shape rule is written once, so a link and a session refuse the same
+ * mistake with the same `param`.
+ */
+// ---------------------------------------------------------------------------
+// Response side
+// ---------------------------------------------------------------------------
+/** The payment rail: FairCoin on chain, or a card (and the methods riding on it). */
+export const railSchema = z.enum(PAYMENT_INTENT_RAILS);
+export const checkoutAdjustableQuantitySchema = defineComponent('CheckoutAdjustableQuantity', z
+    .object({
+    enabled: z.boolean(),
+    minimum: z.number().int().nullable().describe('Default 0 when enabled.'),
+    maximum: z.number().int().nullable().describe('Default 99 when enabled.'),
+})
+    .strict());
+/** One line of a session or link — Stripe's `item`. */
+export const checkoutLineItemSchema = defineObject('item', 'CheckoutLineItem', z
+    .object({
+    id: z.string(),
+    object: z.literal('item'),
+    description: z.string().describe("The product's name, or the inline `product_data.name`."),
+    price: expandable('price', 'The catalog price (`price_…`, or the Price with `expand[]=data.price`); `null` for an inline `price_data` line, which is a snapshot on the line and never a stored price.').nullable(),
+    product: expandable('product', 'The catalog product (`prod_…`, expandable); `null` for `product_data`.').nullable(),
+    images: z
+        .array(z.string())
+        .describe("Images to show beside the line (the product's, or `product_data.images`)."),
+    quantity: z.number().int(),
+    adjustable_quantity: checkoutAdjustableQuantitySchema.nullable(),
+    currency,
+    unit_amount: amount
+        .nullable()
+        .describe('The per-unit amount for a per-unit price; `null` for a tiered one.'),
+    amount_subtotal: amount.describe('Before discount and tax.'),
+    amount_discount: amount,
+    amount_tax: amount,
+    amount_total: amount.describe('`amount_subtotal - amount_discount + amount_tax` (exclusive tax only).'),
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'li_0193b8f2c1a87d3e9f4a',
+            object: 'item',
+            description: 'Pro plan',
+            price: 'price_0193b8f2c1a87d3e9f4b',
+            product: 'prod_0193b8f2c1a87d3e9f4c',
+            images: [],
+            quantity: 1,
+            adjustable_quantity: null,
+            currency: 'EUR',
+            unit_amount: '1999',
+            amount_subtotal: '1999',
+            amount_discount: '0',
+            amount_tax: '0',
+            amount_total: '1999',
+        },
+    ],
+});
+export const checkoutTaxIdSchema = defineComponent('CheckoutTaxId', z.object({ type: z.enum(CHECKOUT_TAX_ID_TYPES), value: z.string() }).strict());
+/** What the payer told checkout about themselves — Stripe's `customer_details`. */
+export const checkoutCustomerDetailsSchema = defineComponent('CheckoutCustomerDetails', z
+    .object({
+    email: z.string().nullable(),
+    name: z.string().nullable(),
+    phone: z.string().nullable(),
+    address: addressSchema.nullable(),
+    tax_ids: z.array(checkoutTaxIdSchema),
+})
+    .strict());
+export const checkoutShippingDetailsSchema = defineComponent('CheckoutShippingDetails', z.object({ name: z.string(), address: addressSchema }).strict());
+export const checkoutCustomFieldLabelSchema = z
+    .object({ type: z.literal('custom'), custom: z.string() })
+    .strict();
+export const checkoutCustomFieldDropdownOptionSchema = z
+    .object({ label: z.string(), value: z.string() })
+    .strict();
+const customFieldBounds = z
+    .object({
+    minimum_length: z.number().int().nullable(),
+    maximum_length: z.number().int().nullable(),
+    value: z.string().nullable().describe('What the payer entered.'),
+})
+    .strict();
+/** A merchant-defined field the payer fills in; `value`s are what they entered. */
+export const checkoutCustomFieldSchema = defineComponent('CheckoutCustomField', z
+    .object({
+    key: z.string(),
+    label: checkoutCustomFieldLabelSchema,
+    type: z.enum(CHECKOUT_CUSTOM_FIELD_TYPES),
+    optional: z.boolean(),
+    dropdown: z
+        .object({
+        options: z.array(checkoutCustomFieldDropdownOptionSchema),
+        value: z.string().nullable(),
+    })
+        .strict()
+        .nullable(),
+    text: customFieldBounds.nullable(),
+    numeric: customFieldBounds.nullable(),
+})
+    .strict());
+export const checkoutDiscountSchema = defineComponent('CheckoutDiscount', z
+    .object({
+    coupon: z.string().describe('The coupon applied (merchant-chosen id or `coupon_…`).'),
+    promotion_code: z
+        .string()
+        .nullable()
+        .describe('The promotion code it was redeemed through (`promo_…`), or `null`.'),
+})
+    .strict());
+export const checkoutTotalDetailsSchema = defineComponent('CheckoutTotalDetails', z.object({ amount_discount: amount, amount_tax: amount, amount_shipping: amount }).strict());
+/**
+ * `automatic_tax` — Peable Tax (ADR 0011). `requires_location_inputs` until
+ * the payer gave an address Peable Tax can locate them with; `failed` when the
+ * sale is covered and could not be priced (checkout refuses to proceed: tax
+ * fails CLOSED, never zero).
+ */
+export const checkoutAutomaticTaxSchema = defineComponent('CheckoutAutomaticTax', z
+    .object({
+    enabled: z.boolean(),
+    status: z.enum(['complete', 'requires_location_inputs', 'failed']).nullable(),
+})
+    .strict());
+export const checkoutConsentCollectionSchema = z
+    .object({ terms_of_service: z.enum(['none', 'required']) })
+    .strict();
+export const checkoutConsentSchema = z
+    .object({ terms_of_service: z.literal('accepted').nullable() })
+    .strict();
+/** The collection options, as a session or link reports them. */
+export const collectionResponseFields = {
+    billing_address_collection: z.enum(CHECKOUT_BILLING_ADDRESS_COLLECTIONS),
+    shipping_address_collection: z
+        .object({ allowed_countries: z.array(z.string()) })
+        .strict()
+        .nullable(),
+    phone_number_collection: z.object({ enabled: z.boolean() }).strict(),
+    tax_id_collection: z.object({ enabled: z.boolean() }).strict(),
+    custom_fields: z.array(checkoutCustomFieldSchema),
+    consent_collection: checkoutConsentCollectionSchema.nullable(),
+};
+/** The public, secret-free merchant identity a payer surface renders. */
+export const merchantDisplaySchema = defineComponent('MerchantDisplay', z
+    .object({
+    name: z.string().describe("The merchant's display name, or a neutral fallback when unset."),
+    avatar_url: z
+        .string()
+        .nullable()
+        .describe('Resolved server-side; `null` when the merchant has no avatar.'),
+    logo_url: z
+        .string()
+        .nullable()
+        .describe("The merchant's `business_logo`, resolved; `null` when unset or not served."),
+    description: z.string().nullable(),
+})
+    .strict());
+/**
+ * Branding as a payer surface renders it: every field resolved (defaults
+ * filled in), the logo and icon as URLs the gateway built through Oxy's media
+ * chokepoint — a withheld file is `null`, never a broken image.
+ */
+export const checkoutBrandingSchema = defineComponent('CheckoutBranding', z
+    .object({
+    icon_url: z.string().nullable(),
+    logo_url: z.string().nullable(),
+    primary_color: z.string(),
+    accent_color: z.string(),
+    font: z.enum(BRANDING_FONTS),
+    border_style: z.enum(BRANDING_BORDER_STYLES),
+})
+    .strict());
+// ---------------------------------------------------------------------------
+// Request side
+// ---------------------------------------------------------------------------
+export const checkoutIdParam = z.string().min(1).max(255);
+export const countryCodeParam = z
+    .string()
+    .regex(/^[A-Z]{2}$/, 'must be an ISO 3166-1 alpha-2 country code');
+/** A base-unit amount in a request. */
+export const amountParam = z
+    .string()
+    .regex(BASE_UNIT_PATTERN, 'must be a non-negative integer string in the smallest currency unit');
+/**
+ * A redirect target. `https` only, except `http://localhost` for development —
+ * a payer is sent there after paying, so an `http` URL elsewhere would leak the
+ * session id in the clear. `{CHECKOUT_SESSION_ID}` may appear anywhere.
+ */
+export const redirectUrlParam = z
+    .string()
+    .max(2048)
+    .refine((value) => {
+    const probe = value.split(CHECKOUT_SESSION_ID_TEMPLATE).join('cs_template');
+    try {
+        const url = new URL(probe);
+        return (url.protocol === 'https:' ||
+            (url.protocol === 'http:' && (url.hostname === 'localhost' || url.hostname === '127.0.0.1')));
+    }
+    catch {
+        return false;
+    }
+}, 'must be an https URL (http only on localhost)')
+    .describe('`https` (or `http://localhost`); may carry `{CHECKOUT_SESSION_ID}`.');
+/** `auto` follows the payer's browser: parsed as `null`. */
+export const localeParam = z
+    .enum([...CHECKOUT_LOCALES, 'auto'])
+    .transform((value) => (value === 'auto' ? null : value))
+    .describe("`auto` follows the payer's browser.");
+export const checkoutEmailParam = z.string().trim().max(254).email('must be an email address');
+const customFieldParam = z
+    .object({
+    key: z
+        .string()
+        .regex(new RegExp(`^[A-Za-z0-9_]{1,${CHECKOUT_LIMITS.customFieldKeyMax}}$`), 'a key is letters, digits and underscores'),
+    label: z
+        .object({
+        type: z.literal('custom'),
+        custom: z.string().trim().min(1).max(CHECKOUT_LIMITS.customFieldLabelMax),
+    })
+        .strict(),
+    type: z.enum(CHECKOUT_CUSTOM_FIELD_TYPES),
+    optional: z.boolean().optional(),
+    dropdown: z
+        .object({
+        options: z
+            .array(z
+            .object({
+            label: z.string().trim().min(1).max(CHECKOUT_LIMITS.dropdownOptionLabelMax),
+            value: z
+                .string()
+                .regex(new RegExp(`^[A-Za-z0-9]{1,${CHECKOUT_LIMITS.dropdownOptionValueMax}}$`), 'an option value is letters and digits'),
+        })
+            .strict())
+            .min(1)
+            .max(CHECKOUT_LIMITS.dropdownOptionsMax),
+    })
+        .strict()
+        .optional(),
+    text: z
+        .object({
+        minimum_length: z.number().int().min(1).max(CHECKOUT_LIMITS.customFieldTextMax).optional(),
+        maximum_length: z.number().int().min(1).max(CHECKOUT_LIMITS.customFieldTextMax).optional(),
+    })
+        .strict()
+        .optional(),
+    numeric: z
+        .object({
+        minimum_length: z.number().int().min(1).max(CHECKOUT_LIMITS.customFieldTextMax).optional(),
+        maximum_length: z.number().int().min(1).max(CHECKOUT_LIMITS.customFieldTextMax).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .superRefine((field, ctx) => {
+    const issue = (path, message) => ctx.addIssue({ code: 'custom', path, message });
+    if (field.type === 'dropdown' && !field.dropdown) {
+        issue(['dropdown'], 'a dropdown field needs dropdown.options');
+    }
+    if (field.type !== 'dropdown' && field.dropdown) {
+        issue(['dropdown'], 'dropdown is only for a dropdown field');
+    }
+    if (field.type !== 'text' && field.text)
+        issue(['text'], 'text is only for a text field');
+    if (field.type !== 'numeric' && field.numeric) {
+        issue(['numeric'], 'numeric is only for a numeric field');
+    }
+    const bounds = field.text ?? field.numeric;
+    if (bounds?.minimum_length !== undefined &&
+        bounds.maximum_length !== undefined &&
+        bounds.minimum_length > bounds.maximum_length) {
+        issue([field.type, 'minimum_length'], 'minimum_length cannot exceed maximum_length');
+    }
+    if (field.dropdown) {
+        const values = field.dropdown.options.map((option) => option.value);
+        if (new Set(values).size !== values.length) {
+            issue(['dropdown', 'options'], 'option values must be unique');
+        }
+    }
+});
+/** At most three, keys unique. */
+export const customFieldsParam = z
+    .array(customFieldParam)
+    .max(CHECKOUT_LIMITS.customFieldsMax)
+    .superRefine((fields, ctx) => {
+    const keys = fields.map((field) => field.key);
+    if (new Set(keys).size !== keys.length) {
+        ctx.addIssue({ code: 'custom', message: 'custom field keys must be unique' });
+    }
+});
+/** The collection options, as a request names them — shared by sessions and links. */
+export const collectionParams = {
+    billing_address_collection: z.enum(CHECKOUT_BILLING_ADDRESS_COLLECTIONS).optional(),
+    shipping_address_collection: z
+        .object({
+        allowed_countries: z.array(countryCodeParam).min(1).max(CHECKOUT_LIMITS.shippingCountriesMax),
+    })
+        .strict()
+        .optional(),
+    phone_number_collection: z.object({ enabled: z.boolean() }).strict().optional(),
+    tax_id_collection: z.object({ enabled: z.boolean() }).strict().optional(),
+    consent_collection: z
+        .object({ terms_of_service: z.enum(['none', 'required']).optional() })
+        .strict()
+        .optional(),
+    custom_fields: customFieldsParam.optional(),
+};
+export const adjustableQuantityParam = z
+    .object({
+    enabled: z.boolean(),
+    minimum: z.number().int().min(0).max(CHECKOUT_LIMITS.quantityMax).optional(),
+    maximum: z.number().int().min(1).max(CHECKOUT_LIMITS.quantityMax).optional(),
+})
+    .strict();
+export const quantityParam = z.number().int().min(1).max(CHECKOUT_LIMITS.quantityMax);
+/** Stripe's defaults: 0–99 when enabled. */
+export function adjustableBoundsOf(adjustable) {
+    if (!adjustable?.enabled)
+        return null;
+    return { minimum: adjustable.minimum ?? 0, maximum: adjustable.maximum ?? 99 };
+}
+/** The refusals of a line's `quantity` against its `adjustable_quantity`. */
+export function adjustableIssues(quantity, adjustable, ctx) {
+    if (!adjustable)
+        return;
+    if (!adjustable.enabled) {
+        if (adjustable.minimum !== undefined || adjustable.maximum !== undefined) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['adjustable_quantity', 'enabled'],
+                message: 'minimum and maximum need adjustable_quantity.enabled',
+            });
+        }
+        return;
+    }
+    const bounds = adjustableBoundsOf(adjustable);
+    if (!bounds)
+        return;
+    if (bounds.minimum > bounds.maximum) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['adjustable_quantity', 'minimum'],
+            message: 'minimum cannot exceed maximum',
+        });
+    }
+    else if (quantity < bounds.minimum || quantity > bounds.maximum) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['quantity'],
+            message: `quantity must be between ${bounds.minimum} and ${bounds.maximum}`,
+        });
+    }
+}

package/dist/esm/resources/connect/account.js

@@ -0,0 +1,329 @@
+import { z } from 'zod';
+import { defineComponent, defineObject } from '../../common/objects.js';
+import { expandOnlyQuery } from '../../common/params.js';
+import { livemode, unixSeconds } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { ACCOUNT_BUSINESS_TYPES, ACCOUNT_CAPABILITY_STATUSES, ACCOUNT_LINK_TYPES, ACCOUNT_TYPES, PAYOUT_INTERVALS, PAYOUT_WEEKLY_ANCHORS, } from '../../vocabulary/connect.js';
+/**
+ * The merchant's fiat account (ADR 0015 §1) — `GET /v1/account`.
+ *
+ * Orbit's funds never reach a Peable bank account: a merchant that takes fiat
+ * has its OWN provider account, opened and onboarded through Peable, and this
+ * object mirrors it. Everything here is what the provider last reported; the
+ * provider is the authority and Orbit never decides readiness itself. The
+ * provider's own `acct_…` never crosses (ADR 0016 D2).
+ *
+ * A marketplace's sellers (`/v1/connected_accounts`) are provider accounts too,
+ * and a platform reads one of them in this same shape by sending
+ * `Peable-Account: ca_…` to `GET /v1/account`.
+ */
+const capabilityStatus = z.enum(ACCOUNT_CAPABILITY_STATUSES);
+/**
+ * What the provider is waiting on. Requirement IDENTIFIERS only
+ * (`individual.verification.document`), never their values: the gateway
+ * records that a document is owed and never learns what it says.
+ */
+export const accountRequirementsSchema = defineComponent('AccountRequirements', z
+    .object({
+    currently_due: z.array(z.string()),
+    eventually_due: z.array(z.string()),
+    past_due: z.array(z.string()),
+    pending_verification: z
+        .array(z.string())
+        .describe('Submitted and being checked — nothing for the merchant to do.'),
+    disabled_reason: z
+        .string()
+        .nullable()
+        .describe("Why charges or payouts are disabled, in the provider's own code, or `null`."),
+})
+    .strict());
+export const accountBusinessProfileSchema = defineComponent('AccountBusinessProfile', z
+    .object({
+    name: z.string().nullable(),
+    url: z.string().nullable(),
+    support_email: z.string().nullable(),
+    support_url: z.string().nullable(),
+    product_description: z.string().nullable(),
+    mcc: z.string().nullable().describe('Merchant category code.'),
+})
+    .strict());
+/**
+ * When the provider pays the balance out. `manual` means only an explicit
+ * `POST /v1/payouts` does — the provider still executes it; Orbit never moves
+ * the money itself (ADR 0015 §4).
+ */
+export const accountPayoutScheduleSchema = defineComponent('AccountPayoutSchedule', z
+    .object({
+    interval: z.enum(PAYOUT_INTERVALS),
+    delay_days: z
+        .number()
+        .int()
+        .nullable()
+        .describe('Days between a payment and its funds becoming payable; `null` when not reported.'),
+    weekly_anchor: z.enum(PAYOUT_WEEKLY_ANCHORS).nullable().describe('`weekly` only.'),
+    monthly_anchor: z
+        .number()
+        .int()
+        .nullable()
+        .describe('`monthly` only: the day of the month, 1–31.'),
+})
+    .strict());
+export const accountSettingsSchema = defineComponent('AccountSettings', z
+    .object({
+    payouts: z
+        .object({
+        schedule: accountPayoutScheduleSchema.nullable(),
+        statement_descriptor: z
+            .string()
+            .nullable()
+            .describe("What the merchant's bank statement shows for a payout."),
+    })
+        .strict(),
+    payments: z
+        .object({
+        statement_descriptor: z
+            .string()
+            .nullable()
+            .describe("What a cardholder's statement shows — the merchant is the merchant of record."),
+    })
+        .strict(),
+    branding: z
+        .object({
+        primary_color: z.string().nullable(),
+        secondary_color: z.string().nullable(),
+    })
+        .strict(),
+})
+    .strict());
+export const accountSchema = defineObject('account', 'Account', z
+    .object({
+    id: z.string().describe('`ca_…` — the same id space as a marketplace seller.'),
+    object: z.literal('account'),
+    livemode,
+    type: z.enum(ACCOUNT_TYPES),
+    country: z.string().describe('ISO 3166-1 alpha-2. Fixed at the provider once created.'),
+    default_currency: z.string().nullable(),
+    business_profile: accountBusinessProfileSchema,
+    capabilities: z
+        .object({
+        card_payments: capabilityStatus.nullable(),
+        transfers: capabilityStatus.nullable(),
+    })
+        .strict()
+        .describe('`null`: never requested — a different fact from the provider declining it.'),
+    requirements: accountRequirementsSchema,
+    charges_enabled: z
+        .boolean()
+        .describe('Whether the account can take payments as merchant of record (`on_behalf_of`).'),
+    payouts_enabled: z
+        .boolean()
+        .describe("Whether the provider will pay this account's balance out."),
+    settings: accountSettingsSchema,
+    last_synced_at: unixSeconds
+        .nullable()
+        .describe('The last provider read; `null` before the first one completed.'),
+    created: unixSeconds,
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'ca_0193b8f2c1a87d3e9f4a',
+            object: 'account',
+            livemode: false,
+            type: 'merchant',
+            country: 'ES',
+            default_currency: 'EUR',
+            business_profile: {
+                name: 'Rosen Ceramics',
+                url: 'https://rosen.example',
+                support_email: 'help@rosen.example',
+                support_url: null,
+                product_description: 'Handmade tableware',
+                mcc: '5719',
+            },
+            capabilities: { card_payments: 'active', transfers: 'active' },
+            requirements: {
+                currently_due: [],
+                eventually_due: [],
+                past_due: [],
+                pending_verification: [],
+                disabled_reason: null,
+            },
+            charges_enabled: true,
+            payouts_enabled: true,
+            settings: {
+                payouts: {
+                    schedule: {
+                        interval: 'weekly',
+                        delay_days: 7,
+                        weekly_anchor: 'friday',
+                        monthly_anchor: null,
+                    },
+                    statement_descriptor: 'ROSEN CERAMICS',
+                },
+                payments: { statement_descriptor: 'ROSEN CERAMICS' },
+                branding: { primary_color: '#1f2937', secondary_color: null },
+            },
+            last_synced_at: 1793750460,
+            created: 1793750400,
+        },
+    ],
+});
+/**
+ * A hosted onboarding link — the merchant's own account's
+ * (`POST /v1/account_links`) or a seller's
+ * (`POST /v1/connected_accounts/{accountId}/account_links`). Single-use and
+ * short-lived: mint one when the person is about to open it, never store it.
+ */
+export const accountLinkSchema = defineObject('account_link', 'AccountLink', z
+    .object({
+    object: z.literal('account_link'),
+    livemode,
+    url: z.string().describe('Where to send the person. Single use.'),
+    expires_at: unixSeconds.describe('When the link stops working (minutes, not days).'),
+})
+    .strict(), {
+    examples: [
+        {
+            object: 'account_link',
+            livemode: false,
+            url: 'https://connect.peable.to/onboarding/Zk3s9v…',
+            expires_at: 1793750700,
+        },
+    ],
+});
+/** A statement descriptor: what a bank or card statement shows. */
+const statementDescriptor = z
+    .string()
+    .min(5)
+    .max(22)
+    .regex(/^[^<>\\'"*]*$/, 'a statement descriptor may not contain < > \\ \' " *');
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/);
+/**
+ * `POST /v1/account`: the account's settings, written to the provider and read
+ * back. `country` + `business_type` OPEN the account the first time (when the
+ * merchant has none) and are refused afterwards — a provider account's country
+ * cannot change.
+ */
+export const updateAccountParams = z
+    .object({
+    country: z.string().length(2).optional(),
+    business_type: z.enum(ACCOUNT_BUSINESS_TYPES).optional(),
+    business_profile: z
+        .object({
+        name: z.string().min(1).max(200).optional(),
+        url: z.url().max(2048).optional(),
+        support_email: z.email().max(320).optional(),
+        support_url: z.url().max(2048).optional(),
+        product_description: z.string().max(1000).optional(),
+        mcc: z
+            .string()
+            .regex(/^[0-9]{4}$/)
+            .optional(),
+    })
+        .strict()
+        .optional(),
+    settings: z
+        .object({
+        payouts: z
+            .object({
+            schedule: z
+                .object({
+                interval: z.enum(PAYOUT_INTERVALS),
+                delay_days: z.number().int().min(1).max(365).optional(),
+                weekly_anchor: z.enum(PAYOUT_WEEKLY_ANCHORS).optional(),
+                monthly_anchor: z.number().int().min(1).max(31).optional(),
+            })
+                .strict()
+                .superRefine((schedule, ctx) => {
+                if (schedule.weekly_anchor !== undefined && schedule.interval !== 'weekly') {
+                    ctx.addIssue({
+                        code: 'custom',
+                        path: ['weekly_anchor'],
+                        message: 'weekly_anchor is for a weekly schedule',
+                    });
+                }
+                if (schedule.monthly_anchor !== undefined && schedule.interval !== 'monthly') {
+                    ctx.addIssue({
+                        code: 'custom',
+                        path: ['monthly_anchor'],
+                        message: 'monthly_anchor is for a monthly schedule',
+                    });
+                }
+            })
+                .optional(),
+            statement_descriptor: statementDescriptor.optional(),
+        })
+            .strict()
+            .optional(),
+        payments: z
+            .object({ statement_descriptor: statementDescriptor.optional() })
+            .strict()
+            .optional(),
+        branding: z
+            .object({
+            primary_color: hexColor.optional(),
+            secondary_color: hexColor.optional(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+/** `POST /v1/account_links`: hosted onboarding (or an update of what was submitted). */
+export const createAccountLinkParams = z
+    .object({
+    refresh_url: z.url().describe('Where the person goes when the link has expired.'),
+    return_url: z.url().describe('Where the person returns when they leave the flow.'),
+    type: z.enum(ACCOUNT_LINK_TYPES).optional().describe('Defaults to `account_onboarding`.'),
+})
+    .strict();
+export const accountRoutes = [
+    defineRoute({
+        operationId: 'retrieveAccount',
+        method: 'get',
+        path: '/v1/account',
+        tag: 'Account',
+        summary: 'Retrieve the account',
+        description: "The merchant's own fiat account, or with `Peable-Account: ca_…` one of a platform's sellers. A merchant without one is told so (404 `account_missing`).",
+        auth: 'service',
+        scope: 'payments:read',
+        peableAccount: true,
+        query: expandOnlyQuery,
+        response: accountSchema,
+        sdk: 'account.retrieve',
+    }),
+    defineRoute({
+        operationId: 'updateAccount',
+        method: 'post',
+        path: '/v1/account',
+        tag: 'Account',
+        summary: 'Open or update the account',
+        description: 'The first call, with `country` and `business_type`, opens the account (201); every later one writes its settings to the provider and answers the account read back (200).',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        peableAccount: true,
+        body: updateAccountParams,
+        response: accountSchema,
+        sdk: 'account.update',
+    }),
+    defineRoute({
+        operationId: 'createAccountLink',
+        method: 'post',
+        path: '/v1/account_links',
+        tag: 'Account links',
+        summary: 'Create an account link',
+        description: "Hosted onboarding for the merchant's own account (or, with `Peable-Account`, a seller's card account), minted on demand.",
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        peableAccount: true,
+        body: createAccountLinkParams,
+        response: accountLinkSchema,
+        status: 201,
+        sdk: 'accountLinks.create',
+    }),
+];