@peable.to/contracts 0.3.0 → 1.0.0

package/dist/cjs/resources/connect/connectedAccounts.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectedAccountRoutes = exports.createConnectedAccountLinkParams = exports.refreshConnectedAccountParams = exports.listConnectedAccountsQuery = exports.createConnectedAccountParams = exports.connectedAccountSchema = exports.connectedAccountFaircoinSchema = void 0;
+const zod_1 = require("zod");
+const envelopes_1 = require("../../common/envelopes");
+const objects_1 = require("../../common/objects");
+const params_1 = require("../../common/params");
+const primitives_1 = require("../../common/primitives");
+const route_1 = require("../../route");
+const connect_1 = require("../../vocabulary/connect");
+const money_1 = require("../../vocabulary/money");
+const account_1 = require("./account");
+/**
+ * Connected accounts (`ca_…`) — a marketplace's sellers (ADR 0012).
+ *
+ * ## The provider's own ids are not here, and that is the contract
+ *
+ * ADR 0001 D3: a merchant integrates against Peable and never learns which
+ * acquirer sat behind their seller, because the day that changes should be a
+ * Peable deploy and not a merchant migration. No `acct_…`, no provider name —
+ * and no seller xpub (ADR 0012 D6): an account xpub reveals every address of
+ * that account, so a platform holding it would learn the seller's whole history
+ * and balance. Nothing a platform does needs it; each payment carries its own
+ * address.
+ */
+const capabilityStatus = zod_1.z.enum(connect_1.ACCOUNT_CAPABILITY_STATUSES);
+/** The FairCoin half of a seller's account. The seller's xpub is deliberately ABSENT (ADR 0012 D6). */
+exports.connectedAccountFaircoinSchema = (0, objects_1.defineComponent)('ConnectedAccountFaircoin', zod_1.z
+    .object({
+    network: primitives_1.network.describe('The chain the seller is paid on. Fixed when the half was opened.'),
+    status: zod_1.z
+        .enum(connect_1.CONNECTED_ACCOUNT_FAIRCOIN_STATUSES)
+        .describe('`pending`: the seller has not registered a key yet (an on-behalf payment is refused, `account_not_ready`). `active`: payments derive addresses from their key.'),
+    oxy_user_id: zod_1.z
+        .string()
+        .describe('The Oxy user who may register the key — and, once `active`, who did.'),
+    registered_at: primitives_1.unixSeconds
+        .nullable()
+        .describe('When the seller registered their key. `null` while `pending`.'),
+})
+    .strict());
+exports.connectedAccountSchema = (0, objects_1.defineObject)('connected_account', 'ConnectedAccount', zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    object: zod_1.z.literal('connected_account'),
+    livemode: primitives_1.livemode,
+    external_ref: zod_1.z
+        .string()
+        .describe("The merchant's OWN id for this seller — how they address it."),
+    rails: zod_1.z
+        .array(zod_1.z.enum(connect_1.CONNECTED_ACCOUNT_RAILS))
+        .describe('Which halves this account has. Never empty.'),
+    faircoin: exports.connectedAccountFaircoinSchema
+        .nullable()
+        .describe("The FairCoin half, or `null` when the platform never opened one. Readiness for FairCoin is `faircoin.status === 'active'`; `payable` is about the CARD half."),
+    country: zod_1.z
+        .string()
+        .nullable()
+        .describe('ISO 3166-1 alpha-2, upper-case. `null` on a FairCoin-only seller, which has no card half.'),
+    default_currency: zod_1.z.string().nullable(),
+    payable: zod_1.z
+        .boolean()
+        .describe('Whether this seller can receive a CARD settlement (a transfer) right now. A convenience: every field it is derived from is here too. Always `false` on a FairCoin-only seller.'),
+    payouts_enabled: zod_1.z.boolean(),
+    charges_enabled: zod_1.z.boolean(),
+    transfers_capability: capabilityStatus
+        .nullable()
+        .describe('`null`: never requested — a different fact from the provider declining it.'),
+    card_payments_capability: capabilityStatus.nullable(),
+    requirements: account_1.accountRequirementsSchema,
+    last_synced_at: primitives_1.unixSeconds.nullable(),
+    created: primitives_1.unixSeconds,
+    updated_at: primitives_1.unixSeconds,
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'ca_0193b8f2d4e1aa07c3b2',
+            object: 'connected_account',
+            livemode: false,
+            external_ref: 'seller_4821',
+            rails: ['card', 'faircoin'],
+            faircoin: {
+                network: 'mainnet',
+                status: 'active',
+                oxy_user_id: '665f1c0e9a1b2c3d4e5f6a7b',
+                registered_at: 1793751000,
+            },
+            country: 'DE',
+            default_currency: 'EUR',
+            payable: true,
+            payouts_enabled: true,
+            charges_enabled: true,
+            transfers_capability: 'active',
+            card_payments_capability: 'active',
+            requirements: {
+                currently_due: [],
+                eventually_due: [],
+                past_due: [],
+                pending_verification: [],
+                disabled_reason: null,
+            },
+            last_synced_at: 1793751060,
+            created: 1793750400,
+            updated_at: 1793751060,
+        },
+    ],
+});
+/** Bounded for the reason `external_ref` is: it is stored, and it is compared. */
+const OXY_USER_ID_MAX = 128;
+/**
+ * `POST /v1/connected_accounts`: open (or return) the account for one seller.
+ *
+ * Two halves, at least one: the CARD half (`country` + `business_type`, both or
+ * neither) and the FAIRCOIN half (`faircoin`). There is deliberately no `xpub`
+ * here: the key comes from the SELLER's own session, never from the platform
+ * (ADR 0012 D3).
+ */
+exports.createConnectedAccountParams = zod_1.z
+    .object({
+    // Bounded because it is a key: an unbounded string here is an unbounded
+    // index entry and an unbounded response field.
+    external_ref: zod_1.z
+        .string()
+        .min(1)
+        .max(255)
+        .describe('Your own id for the seller. Opening the same `external_ref` again answers that account (200).'),
+    country: zod_1.z
+        .string()
+        .length(2)
+        .optional()
+        .describe('The card half: ISO 3166-1 alpha-2 (case-insensitive). With `business_type`.'),
+    business_type: zod_1.z
+        .enum(connect_1.ACCOUNT_BUSINESS_TYPES)
+        .optional()
+        .describe('The card half: with `country`.'),
+    faircoin: zod_1.z
+        .object({
+        network: zod_1.z.enum(money_1.NETWORK_TYPES),
+        oxy_user_id: zod_1.z
+            .string()
+            .min(1)
+            .max(OXY_USER_ID_MAX)
+            .describe("The seller's Oxy user id — the only person who may register the key."),
+    })
+        .strict()
+        .optional()
+        .describe('The FairCoin half (ADR 0012 D2): the chain the seller is paid on, and who they are.'),
+})
+    .strict()
+    .refine((body) => (body.country === undefined) === (body.business_type === undefined), {
+    message: 'a card account needs both country and business_type, or neither',
+})
+    .refine((body) => body.country !== undefined || body.faircoin !== undefined, {
+    message: 'open at least one rail: country and business_type for cards, faircoin for FairCoin',
+});
+exports.listConnectedAccountsQuery = (0, params_1.listQuery)({});
+/** `POST /v1/connected_accounts/{accountId}/refresh` takes no parameters. */
+exports.refreshConnectedAccountParams = zod_1.z.object({}).strict();
+/** A seller's onboarding link. */
+exports.createConnectedAccountLinkParams = zod_1.z
+    .object({
+    refresh_url: zod_1.z.url().describe('Where the seller goes when the link has expired.'),
+    return_url: zod_1.z.url().describe('Where the seller returns when they leave the flow.'),
+    rail: zod_1.z
+        .enum(connect_1.CONNECTED_ACCOUNT_RAILS)
+        .optional()
+        .describe("Which half to onboard: `card` (the default) is the provider's hosted onboarding; `faircoin` is Peable's own page where the SELLER registers their watch-only key."),
+})
+    .strict();
+const accountIdParam = { accountId: 'The connected account (`ca_…`).' };
+exports.connectedAccountRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'createConnectedAccount',
+        method: 'post',
+        path: '/v1/connected_accounts',
+        tag: 'Connected accounts',
+        summary: 'Open a connected account',
+        description: 'Opens the account for one seller (201), or answers the one this `external_ref` already opened (200) — a provider account cannot be deleted, so a converged retry says so.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        body: exports.createConnectedAccountParams,
+        response: exports.connectedAccountSchema,
+        status: 201,
+        sdk: 'connectedAccounts.create',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listConnectedAccounts',
+        method: 'get',
+        path: '/v1/connected_accounts',
+        tag: 'Connected accounts',
+        summary: 'List connected accounts',
+        description: 'Every seller this merchant has onboarded, newest first.',
+        auth: 'service',
+        scope: 'payments:read',
+        query: exports.listConnectedAccountsQuery,
+        response: (0, envelopes_1.listOf)(exports.connectedAccountSchema),
+        sdk: 'connectedAccounts.list',
+        expandable: 'connected_account',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveConnectedAccountByRef',
+        method: 'get',
+        path: '/v1/connected_accounts/by_ref/{externalRef}',
+        tag: 'Connected accounts',
+        summary: 'Retrieve a connected account by your id',
+        description: 'By `external_ref`, the durable address you already hold — so a create whose answer never arrived is recoverable without a list scan.',
+        auth: 'service',
+        scope: 'payments:read',
+        params: { externalRef: 'Your own id for the seller.' },
+        query: params_1.expandOnlyQuery,
+        response: exports.connectedAccountSchema,
+        sdk: 'connectedAccounts.retrieveByRef',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveConnectedAccount',
+        method: 'get',
+        path: '/v1/connected_accounts/{accountId}',
+        tag: 'Connected accounts',
+        summary: 'Retrieve a connected account',
+        auth: 'service',
+        scope: 'payments:read',
+        params: accountIdParam,
+        query: params_1.expandOnlyQuery,
+        response: exports.connectedAccountSchema,
+        sdk: 'connectedAccounts.retrieve',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'refreshConnectedAccount',
+        method: 'post',
+        path: '/v1/connected_accounts/{accountId}/refresh',
+        tag: 'Connected accounts',
+        summary: 'Refresh a connected account',
+        description: 'Re-reads the account from the provider now. The sweep and the inbound event keep it fresh on their own; this is for a seller watching a screen.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        params: accountIdParam,
+        body: exports.refreshConnectedAccountParams,
+        response: exports.connectedAccountSchema,
+        sdk: 'connectedAccounts.refresh',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'createConnectedAccountLink',
+        method: 'post',
+        path: '/v1/connected_accounts/{accountId}/account_links',
+        tag: 'Connected accounts',
+        summary: "Create a seller's onboarding link",
+        description: 'Minted on demand and never stored: single-use and short-lived. A visit to `return_url` proves nothing about verification — read the account back.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        params: accountIdParam,
+        body: exports.createConnectedAccountLinkParams,
+        response: account_1.accountLinkSchema,
+        status: 201,
+        sdk: 'connectedAccounts.createAccountLink',
+    }),
+];

package/dist/cjs/resources/connect/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectRoutes = void 0;
+const account_1 = require("./account");
+const applicationFees_1 = require("./applicationFees");
+const balance_1 = require("./balance");
+const connectedAccounts_1 = require("./connectedAccounts");
+const onboarding_1 = require("./onboarding");
+const payouts_1 = require("./payouts");
+const reporting_1 = require("./reporting");
+const requestLogs_1 = require("./requestLogs");
+const transfers_1 = require("./transfers");
+__exportStar(require("./account"), exports);
+__exportStar(require("./applicationFees"), exports);
+__exportStar(require("./balance"), exports);
+__exportStar(require("./connectedAccounts"), exports);
+__exportStar(require("./onboarding"), exports);
+__exportStar(require("./payouts"), exports);
+__exportStar(require("./reporting"), exports);
+__exportStar(require("./requestLogs"), exports);
+__exportStar(require("./transfers"), exports);
+/**
+ * Connect and money (ADR 0012, ADR 0015): connected accounts and their
+ * onboarding, the merchant's account, balance, payouts, application fees,
+ * transfers, reporting and the request log.
+ */
+exports.connectRoutes = [
+    ...connectedAccounts_1.connectedAccountRoutes,
+    ...account_1.accountRoutes,
+    ...balance_1.balanceRoutes,
+    ...payouts_1.payoutRoutes,
+    ...applicationFees_1.applicationFeeRoutes,
+    ...onboarding_1.connectOnboardingRoutes,
+    ...transfers_1.transferRoutes,
+    ...reporting_1.reportingRoutes,
+    ...requestLogs_1.requestLogRoutes,
+];

package/dist/cjs/resources/connect/onboarding.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectOnboardingRoutes = exports.registerFaircoinKeyParams = exports.connectOnboardingCompleteSchema = exports.connectOnboardingSchema = void 0;
+const zod_1 = require("zod");
+const objects_1 = require("../../common/objects");
+const primitives_1 = require("../../common/primitives");
+const route_1 = require("../../route");
+const shared_1 = require("../checkout/shared");
+/**
+ * The SELLER-facing half of FairCoin connected accounts (ADR 0012 D3).
+ *
+ * A platform mints an onboarding link for a seller's account; the SELLER opens
+ * it signed in with Oxy and registers the watch-only key their FairCoin will be
+ * paid to. These routes are `auth: 'user'` — the seller's own session, never a
+ * service token — because the key that decides who receives a seller's money is
+ * accepted only from the seller. A platform cannot reach them at all, and the
+ * link token alone is not enough without the session it names.
+ */
+exports.connectOnboardingSchema = (0, objects_1.defineObject)('connect_onboarding', 'ConnectOnboarding', zod_1.z
+    .object({
+    object: zod_1.z.literal('connect_onboarding'),
+    account_id: zod_1.z.string().describe('The `ca_…` being onboarded.'),
+    // The platform's public display, as a payer would see it: never a
+    // webhook secret, never a key.
+    platform: shared_1.merchantDisplaySchema.describe("Who is asking: the PLATFORM's public display, as a payer would see it."),
+    network: primitives_1.network.describe('The chain the seller will be paid on. Their key must be for it.'),
+    expires_at: primitives_1.unixSeconds.describe('When this link stops working.'),
+    return_url: zod_1.z.string().describe('Where to send the seller once the key is registered.'),
+})
+    .strict());
+/** The answer to a successful registration. */
+exports.connectOnboardingCompleteSchema = (0, objects_1.defineComponent)('ConnectOnboardingComplete', zod_1.z
+    .object({
+    object: zod_1.z.literal('connect_onboarding'),
+    account_id: zod_1.z.string(),
+    status: zod_1.z.literal('active'),
+    return_url: zod_1.z.string(),
+})
+    .strict());
+/**
+ * An extended public key is 111 characters in base58check; the bound is a
+ * request-size guard with headroom, not a format check — the non-custody
+ * firewall (`assertWatchOnly`) is.
+ */
+const XPUB_MAX_LENGTH = 200;
+/** `POST /v1/connect/onboarding/{token}/faircoin` — the seller's watch-only ACCOUNT xpub. */
+exports.registerFaircoinKeyParams = zod_1.z
+    .object({
+    xpub: zod_1.z
+        .string()
+        .trim()
+        .min(1)
+        .max(XPUB_MAX_LENGTH)
+        .describe('A watch-only extended PUBLIC key. A private extended key is refused (`watch_only_violation`) and never stored.'),
+})
+    .strict();
+const tokenParam = { token: 'The onboarding link token (the last segment of its `url`).' };
+exports.connectOnboardingRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveConnectOnboarding',
+        method: 'get',
+        path: '/v1/connect/onboarding/{token}',
+        tag: 'Connect onboarding',
+        summary: 'Retrieve an onboarding link',
+        description: 'What the seller is being asked to do. Looking consumes nothing. An expired link answers 410 `link_expired` with the platform’s `refresh_url`.',
+        auth: 'user',
+        params: tokenParam,
+        response: exports.connectOnboardingSchema,
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'registerConnectOnboardingFaircoinKey',
+        method: 'post',
+        path: '/v1/connect/onboarding/{token}/faircoin',
+        tag: 'Connect onboarding',
+        summary: "Register the seller's FairCoin key",
+        description: 'The ONLY way a key reaches a connected account: runs the non-custody firewall, consumes the link and tells the platform (`connected_account.updated`), in one transaction. The key is immutable once registered and never appears on any response.',
+        auth: 'user',
+        params: tokenParam,
+        body: exports.registerFaircoinKeyParams,
+        response: exports.connectOnboardingCompleteSchema,
+    }),
+];

package/dist/cjs/resources/connect/payouts.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.payoutRoutes = exports.payoutReconciliationQuery = exports.cancelPayoutParams = exports.listPayoutsQuery = exports.createPayoutParams = exports.payoutReconciliationReportSchema = exports.payoutSchema = void 0;
+const zod_1 = require("zod");
+const envelopes_1 = require("../../common/envelopes");
+const objects_1 = require("../../common/objects");
+const params_1 = require("../../common/params");
+const primitives_1 = require("../../common/primitives");
+const route_1 = require("../../route");
+const connect_1 = require("../../vocabulary/connect");
+const money_1 = require("../../vocabulary/money");
+const balance_1 = require("./balance");
+/**
+ * Payouts (`po_…`) — the provider moving the merchant's balance to the
+ * merchant's bank (ADR 0015 §4). Executed by the provider, always; Orbit
+ * instructs (a manual payout) or mirrors (a scheduled one). The bank account
+ * itself stays at the provider and is never on this object.
+ */
+exports.payoutSchema = (0, objects_1.defineObject)('payout', 'Payout', zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    object: zod_1.z.literal('payout'),
+    livemode: primitives_1.livemode,
+    account: zod_1.z.string().describe('The account (`ca_…`) paid out.'),
+    amount: primitives_1.amount,
+    currency: zod_1.z.string().describe('Upper-case ISO 4217 code.'),
+    status: zod_1.z.enum(connect_1.PAYOUT_STATUSES),
+    arrival_date: primitives_1.unixSeconds
+        .nullable()
+        .describe('When the funds are expected in the bank, as the provider estimates.'),
+    automatic: zod_1.z
+        .boolean()
+        .describe("`true` when the provider's schedule created it, `false` for `POST /v1/payouts`."),
+    method: zod_1.z.enum(connect_1.PAYOUT_METHODS),
+    type: zod_1.z.enum(connect_1.PAYOUT_DESTINATION_TYPES),
+    description: zod_1.z.string().nullable(),
+    statement_descriptor: zod_1.z.string().nullable(),
+    failure_code: zod_1.z
+        .string()
+        .nullable()
+        .describe("The provider's failure code when `failed`; never its prose."),
+    balance_transaction: zod_1.z
+        .string()
+        .nullable()
+        .describe("The payout's own `txn_…` once ingested."),
+    metadata: primitives_1.metadata,
+    created: primitives_1.unixSeconds,
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'po_0193b8f31e2d4c5a9b60',
+            object: 'payout',
+            livemode: false,
+            account: 'ca_0193b8f2c1a87d3e9f4a',
+            amount: '150000',
+            currency: 'EUR',
+            status: 'in_transit',
+            arrival_date: 1793923200,
+            automatic: false,
+            method: 'standard',
+            type: 'bank_account',
+            description: 'November payout',
+            statement_descriptor: 'ROSEN PAYOUT',
+            failure_code: null,
+            balance_transaction: 'txn_0193b8f31f0a7e3d2c41',
+            metadata: {},
+            created: 1793750400,
+        },
+    ],
+});
+/**
+ * `GET /v1/reports/payout_reconciliation?payout=po_…` — the balance
+ * transactions one payout paid out, with their totals. A list page with the
+ * report's fields beside it.
+ */
+exports.payoutReconciliationReportSchema = (0, objects_1.defineComponent)('PayoutReconciliationReport', zod_1.z
+    .object({
+    object: zod_1.z.literal('list'),
+    data: zod_1.z.array(balance_1.balanceTransactionSchema),
+    has_more: zod_1.z.boolean(),
+    url: zod_1.z.string(),
+    payout: zod_1.z.string().describe('The payout (`po_…`) reconciled.'),
+    status: zod_1.z
+        .enum(connect_1.PAYOUT_RECONCILIATION_STATUSES)
+        .describe('`complete` once the payout is `paid` and its transactions were read from the provider; `pending` before — the set is not final and the totals may grow.'),
+    currency: zod_1.z.string(),
+    summary: zod_1.z
+        .object({
+        count: zod_1.z.number().int().nonnegative(),
+        amount: primitives_1.signedAmount,
+        fee: primitives_1.signedAmount,
+        net: primitives_1.signedAmount,
+    })
+        .strict()
+        .describe('Over EVERY transaction of the payout, not just this page.'),
+})
+    .strict());
+/** `POST /v1/payouts` — a payout instruction for an account on a manual schedule. */
+exports.createPayoutParams = zod_1.z
+    .object({
+    amount: zod_1.z
+        .string()
+        .refine(money_1.isBaseUnitString, 'amount must be a minor-unit integer string')
+        .refine((value) => value !== '0', 'amount must be positive'),
+    currency: zod_1.z.enum(money_1.CURRENCY_CODES),
+    description: zod_1.z.string().max(1000).optional(),
+    statement_descriptor: zod_1.z.string().min(1).max(22).optional(),
+    method: zod_1.z.enum(connect_1.PAYOUT_METHODS).optional().describe('Defaults to `standard`.'),
+    metadata: params_1.metadataCreateParam.optional(),
+})
+    .strict();
+exports.listPayoutsQuery = (0, params_1.listQuery)({ status: zod_1.z.enum(connect_1.PAYOUT_STATUSES).optional() });
+/** `POST /v1/payouts/{id}/cancel` takes no parameters. */
+exports.cancelPayoutParams = zod_1.z.object({}).strict();
+exports.payoutReconciliationQuery = (0, params_1.listQuery)({
+    payout: params_1.idParam.describe('The payout (`po_…`) to reconcile.'),
+});
+const payoutIdParam = { id: 'The payout (`po_…`).' };
+exports.payoutRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'listPayouts',
+        method: 'get',
+        path: '/v1/payouts',
+        tag: 'Payouts',
+        summary: 'List payouts',
+        auth: 'service',
+        scope: 'payments:read',
+        peableAccount: true,
+        query: exports.listPayoutsQuery,
+        response: (0, envelopes_1.listOf)(exports.payoutSchema),
+        sdk: 'payouts.list',
+        expandable: 'payout',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'createPayout',
+        method: 'post',
+        path: '/v1/payouts',
+        tag: 'Payouts',
+        summary: 'Create a payout',
+        description: 'An instruction to the provider, for an account on a `manual` payout schedule. The provider executes it; Orbit never moves the money itself.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        peableAccount: true,
+        body: exports.createPayoutParams,
+        response: exports.payoutSchema,
+        status: 201,
+        sdk: 'payouts.create',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrievePayout',
+        method: 'get',
+        path: '/v1/payouts/{id}',
+        tag: 'Payouts',
+        summary: 'Retrieve a payout',
+        auth: 'service',
+        scope: 'payments:read',
+        peableAccount: true,
+        params: payoutIdParam,
+        query: params_1.expandOnlyQuery,
+        response: exports.payoutSchema,
+        sdk: 'payouts.retrieve',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'cancelPayout',
+        method: 'post',
+        path: '/v1/payouts/{id}/cancel',
+        tag: 'Payouts',
+        summary: 'Cancel a payout',
+        description: 'Only a manual payout the provider still allows to be canceled.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        peableAccount: true,
+        params: payoutIdParam,
+        body: exports.cancelPayoutParams,
+        response: exports.payoutSchema,
+        sdk: 'payouts.cancel',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrievePayoutReconciliation',
+        method: 'get',
+        path: '/v1/reports/payout_reconciliation',
+        tag: 'Payouts',
+        summary: 'Reconcile a payout',
+        description: 'The balance transactions one payout paid out, a page at a time, with totals over all of them.',
+        auth: 'service',
+        scope: 'payments:read',
+        peableAccount: true,
+        query: exports.payoutReconciliationQuery,
+        response: exports.payoutReconciliationReportSchema,
+        sdk: 'reports.payoutReconciliation',
+        expandable: 'balance_transaction',
+    }),
+];