@peable.to/contracts 0.4.0 → 1.0.0

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

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { listOf } from '../../common/envelopes.js';
+import { defineObject } from '../../common/objects.js';
+import { emptyQuery, expandOnlyQuery, idParam, listQuery } from '../../common/params.js';
+import { amount, livemode, unixSeconds } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+/**
+ * Application fees (`fee_…`, ADR 0015 §3) — Orbit's fee on one payment, taken
+ * by the provider from the merchant's account when the charge succeeded.
+ * Created from the provider's own record, never computed after the fact, and
+ * refunded through `POST /v1/refunds` with `refund_application_fee`.
+ */
+/** A refund of an application fee (`fr_…`). */
+export const feeRefundSchema = defineObject('fee_refund', 'FeeRefund', z
+    .object({
+    id: z.string(),
+    object: z.literal('fee_refund'),
+    amount,
+    currency: z.string(),
+    fee: z.string().describe('The `fee_…` it refunds.'),
+    created: unixSeconds,
+})
+    .strict());
+export const applicationFeeSchema = defineObject('application_fee', 'ApplicationFee', z
+    .object({
+    id: z.string(),
+    object: z.literal('application_fee'),
+    livemode,
+    account: z.string().describe('The account (`ca_…`) the fee was taken from.'),
+    amount,
+    amount_refunded: amount,
+    currency: z.string(),
+    charge: z
+        .string()
+        .nullable()
+        .describe('The `ch_…` it was taken on, when Orbit holds the charge.'),
+    payment_intent: z.string().describe('The `pi_…` it was taken on.'),
+    refunded: z.boolean().describe('Refunded in full.'),
+    refunds: listOf(feeRefundSchema).describe('Every refund of the fee: a complete set.'),
+    created: unixSeconds,
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'fee_0193b8f32b7f4d0e8a15',
+            object: 'application_fee',
+            livemode: false,
+            account: 'ca_0193b8f2c1a87d3e9f4a',
+            amount: '60',
+            amount_refunded: '0',
+            currency: 'EUR',
+            charge: 'ch_0193b8f2f7c94b1d8e02',
+            payment_intent: 'pi_0193b8f2e8a14f6c9d31',
+            refunded: false,
+            refunds: {
+                object: 'list',
+                data: [],
+                has_more: false,
+                url: '/v1/application_fees/fee_0193b8f32b7f4d0e8a15/refunds',
+            },
+            created: 1793750400,
+        },
+    ],
+});
+export const listApplicationFeesQuery = listQuery({
+    payment_intent: idParam.optional().describe('Only the fee taken on this payment (`pi_…`).'),
+});
+const feeIdParam = { id: 'The application fee (`fee_…`).' };
+export const applicationFeeRoutes = [
+    defineRoute({
+        operationId: 'listApplicationFees',
+        method: 'get',
+        path: '/v1/application_fees',
+        tag: 'Application fees',
+        summary: 'List application fees',
+        auth: 'service',
+        scope: 'payments:read',
+        query: listApplicationFeesQuery,
+        response: listOf(applicationFeeSchema),
+        sdk: 'applicationFees.list',
+        expandable: 'application_fee',
+    }),
+    defineRoute({
+        operationId: 'retrieveApplicationFee',
+        method: 'get',
+        path: '/v1/application_fees/{id}',
+        tag: 'Application fees',
+        summary: 'Retrieve an application fee',
+        auth: 'service',
+        scope: 'payments:read',
+        params: feeIdParam,
+        query: expandOnlyQuery,
+        response: applicationFeeSchema,
+        sdk: 'applicationFees.retrieve',
+    }),
+    defineRoute({
+        operationId: 'listApplicationFeeRefunds',
+        method: 'get',
+        path: '/v1/application_fees/{id}/refunds',
+        tag: 'Application fees',
+        summary: "List an application fee's refunds",
+        description: 'A complete set (`has_more: false`): one refund per partial refund of the payment.',
+        auth: 'service',
+        scope: 'payments:read',
+        params: feeIdParam,
+        query: emptyQuery,
+        response: listOf(feeRefundSchema),
+        sdk: 'applicationFees.listRefunds',
+    }),
+];

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

@@ -0,0 +1,209 @@
+import { z } from 'zod';
+import { listOf } from '../../common/envelopes.js';
+import { defineComponent, defineObject } from '../../common/objects.js';
+import { expandOnlyQuery, idParam, listQuery } from '../../common/params.js';
+import { livemode, signedAmount, unixSeconds } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { BALANCE_TRANSACTION_FEE_TYPES, BALANCE_TRANSACTION_STATUSES, BALANCE_TRANSACTION_TYPES, RECONCILIATION_MISMATCH_KINDS, } from '../../vocabulary/connect.js';
+/**
+ * Balance and balance transactions (ADR 0015 §3–§5).
+ *
+ * MIRRORS, every one of them. The money is in the merchant's own provider
+ * account; Orbit's double-entry ledger is fed by the provider's own balance
+ * transactions and payouts for that account and reconciled against them daily.
+ * Nothing here is computed by Orbit: a figure the provider has not given is
+ * `null` with a status, never `0`.
+ *
+ * Every amount is a canonical integer STRING in the currency's smallest unit
+ * that MAY be negative (`"-1500"`): a refund or a payout takes money out of a
+ * balance.
+ */
+/** A currency as the provider reports it: upper-case ISO 4217, or `FAIR`. */
+const ledgerCurrency = z.string().describe('Upper-case ISO 4217 code, or `FAIR`.');
+/** One currency's figure in a balance. */
+export const balanceAmountSchema = defineComponent('BalanceAmount', z.object({ amount: signedAmount, currency: ledgerCurrency }).strict());
+/**
+ * `GET /v1/balance` — read from the ledger, per currency. A merchant without a
+ * fiat account has NO balance and is told so (404 `account_missing`), never
+ * shown zeros.
+ */
+export const balanceSchema = defineObject('balance', 'Balance', z
+    .object({
+    object: z.literal('balance'),
+    livemode,
+    available: z
+        .array(balanceAmountSchema)
+        .describe('Payable now: the provider has made these funds available.'),
+    pending: z.array(balanceAmountSchema).describe('Not yet available at the provider.'),
+    informational: z
+        .array(balanceAmountSchema)
+        .describe("FairCoin received straight into the merchant's own wallet (ADR 0015 §5): recorded for the books only. Orbit never held it, so it is never payable."),
+    account: z
+        .string()
+        .nullable()
+        .describe('The account (`ca_…`) this balance mirrors; `null` for an Oxy first-party merchant.'),
+})
+    .strict(), {
+    examples: [
+        {
+            object: 'balance',
+            livemode: false,
+            available: [{ amount: '184250', currency: 'EUR' }],
+            pending: [{ amount: '12900', currency: 'EUR' }],
+            informational: [{ amount: '250000000', currency: 'FAIR' }],
+            account: 'ca_0193b8f2c1a87d3e9f4a',
+        },
+    ],
+});
+/** One component of a transaction's fee. */
+export const balanceTransactionFeeDetailSchema = defineComponent('BalanceTransactionFeeDetail', z
+    .object({
+    amount: signedAmount,
+    currency: ledgerCurrency,
+    type: z.enum(BALANCE_TRANSACTION_FEE_TYPES),
+})
+    .strict());
+export const balanceTransactionSchema = defineObject('balance_transaction', 'BalanceTransaction', z
+    .object({
+    id: z.string().describe('`txn_…`'),
+    object: z.literal('balance_transaction'),
+    livemode,
+    amount: signedAmount.describe('Gross, signed.'),
+    fee: signedAmount
+        .nullable()
+        .describe('What was taken, or `null` when the source gave no figure (never `0` for unknown).'),
+    net: signedAmount
+        .nullable()
+        .describe('`amount - fee`, as the provider reports it, or `null` with `fee`.'),
+    currency: ledgerCurrency,
+    type: z.enum(BALANCE_TRANSACTION_TYPES),
+    reporting_category: z
+        .string()
+        .describe('A coarser grouping for reports (`charge`, `refund`, `payout`, `fee`, …).'),
+    status: z.enum(BALANCE_TRANSACTION_STATUSES),
+    available_on: unixSeconds
+        .nullable()
+        .describe('When the funds became (or become) available; `null` for an informational entry.'),
+    created: unixSeconds.describe('When it happened at its source.'),
+    description: z.string().nullable(),
+    exchange_rate: z.number().nullable(),
+    fee_details: z.array(balanceTransactionFeeDetailSchema),
+    source: z
+        .string()
+        .nullable()
+        .describe("The Orbit object that caused it (`ch_…`, `re_…`, `po_…`, `fee_…`, `tr_…`, `pi_…`), or `null` when the provider's source is not an object Orbit holds."),
+    payout: z
+        .string()
+        .nullable()
+        .describe('The payout (`po_…`) that paid this transaction out, once known.'),
+    account: z
+        .string()
+        .nullable()
+        .describe('The account (`ca_…`) whose balance it moved; `null` for a first-party merchant.'),
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'txn_0193b8f30a6c4e21b7d9',
+            object: 'balance_transaction',
+            livemode: false,
+            amount: '2000',
+            fee: '88',
+            net: '1912',
+            currency: 'EUR',
+            type: 'charge',
+            reporting_category: 'charge',
+            status: 'available',
+            available_on: 1794355200,
+            created: 1793750400,
+            description: 'Order 6735',
+            exchange_rate: null,
+            fee_details: [{ amount: '88', currency: 'EUR', type: 'processing_fee' }],
+            source: 'ch_0193b8f2f7c94b1d8e02',
+            payout: null,
+            account: 'ca_0193b8f2c1a87d3e9f4a',
+        },
+    ],
+});
+/**
+ * What the daily reconciliation found disagreeing with the provider (Orbit's
+ * dashboard reads them). Never auto-corrected.
+ */
+export const reconciliationMismatchSchema = defineObject('reconciliation_mismatch', 'ReconciliationMismatch', z
+    .object({
+    id: z.string(),
+    object: z.literal('reconciliation_mismatch'),
+    livemode,
+    account: z.string().nullable(),
+    kind: z.enum(RECONCILIATION_MISMATCH_KINDS),
+    object_id: z
+        .string()
+        .nullable()
+        .describe('The Orbit object concerned (`txn_…`, `po_…`), when Orbit holds one.'),
+    expected: z.record(z.string(), z.unknown()).nullable().describe('What the provider says.'),
+    actual: z.record(z.string(), z.unknown()).nullable().describe('What the ledger holds.'),
+    detected_at: unixSeconds,
+    last_seen_at: unixSeconds,
+    resolved_at: unixSeconds
+        .nullable()
+        .describe('Set when a later run no longer sees the difference.'),
+})
+    .strict());
+export const listBalanceTransactionsQuery = listQuery({
+    type: z.enum(BALANCE_TRANSACTION_TYPES).optional(),
+    payout: idParam.optional().describe('`po_…`: only the transactions that payout paid out.'),
+    source: idParam.optional().describe('An Orbit object id the transaction was caused by.'),
+    currency: z
+        .string()
+        .regex(/^[A-Za-z]{3,4}$/)
+        .optional()
+        .describe('Case-insensitive.'),
+});
+/** Reconciliation findings, as Orbit's dashboard lists them (not a public route). */
+export const listReconciliationMismatchesQuery = listQuery({
+    open: z.enum(['true', 'false']).optional().describe('`true`: only unresolved findings.'),
+});
+export const balanceRoutes = [
+    defineRoute({
+        operationId: 'retrieveBalance',
+        method: 'get',
+        path: '/v1/balance',
+        tag: 'Balance',
+        summary: 'Retrieve the balance',
+        auth: 'service',
+        scope: 'payments:read',
+        peableAccount: true,
+        query: expandOnlyQuery,
+        response: balanceSchema,
+        sdk: 'balance.retrieve',
+    }),
+    defineRoute({
+        operationId: 'listBalanceTransactions',
+        method: 'get',
+        path: '/v1/balance_transactions',
+        tag: 'Balance transactions',
+        summary: 'List balance transactions',
+        description: 'Newest first, filtered by `type`, `payout`, `source`, `currency` and `created`.',
+        auth: 'service',
+        scope: 'payments:read',
+        peableAccount: true,
+        query: listBalanceTransactionsQuery,
+        response: listOf(balanceTransactionSchema),
+        sdk: 'balanceTransactions.list',
+        expandable: 'balance_transaction',
+    }),
+    defineRoute({
+        operationId: 'retrieveBalanceTransaction',
+        method: 'get',
+        path: '/v1/balance_transactions/{id}',
+        tag: 'Balance transactions',
+        summary: 'Retrieve a balance transaction',
+        auth: 'service',
+        scope: 'payments:read',
+        peableAccount: true,
+        params: { id: 'The balance transaction (`txn_…`).' },
+        query: expandOnlyQuery,
+        response: balanceTransactionSchema,
+        sdk: 'balanceTransactions.retrieve',
+    }),
+];

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

@@ -0,0 +1,257 @@
+import { z } from 'zod';
+import { listOf } from '../../common/envelopes.js';
+import { defineComponent, defineObject } from '../../common/objects.js';
+import { expandOnlyQuery, listQuery } from '../../common/params.js';
+import { livemode, network, unixSeconds } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { ACCOUNT_BUSINESS_TYPES, ACCOUNT_CAPABILITY_STATUSES, CONNECTED_ACCOUNT_FAIRCOIN_STATUSES, CONNECTED_ACCOUNT_RAILS, } from '../../vocabulary/connect.js';
+import { NETWORK_TYPES } from '../../vocabulary/money.js';
+import { accountLinkSchema, accountRequirementsSchema } from './account.js';
+/**
+ * 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 = z.enum(ACCOUNT_CAPABILITY_STATUSES);
+/** The FairCoin half of a seller's account. The seller's xpub is deliberately ABSENT (ADR 0012 D6). */
+export const connectedAccountFaircoinSchema = defineComponent('ConnectedAccountFaircoin', z
+    .object({
+    network: network.describe('The chain the seller is paid on. Fixed when the half was opened.'),
+    status: z
+        .enum(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: z
+        .string()
+        .describe('The Oxy user who may register the key — and, once `active`, who did.'),
+    registered_at: unixSeconds
+        .nullable()
+        .describe('When the seller registered their key. `null` while `pending`.'),
+})
+    .strict());
+export const connectedAccountSchema = defineObject('connected_account', 'ConnectedAccount', z
+    .object({
+    id: z.string(),
+    object: z.literal('connected_account'),
+    livemode,
+    external_ref: z
+        .string()
+        .describe("The merchant's OWN id for this seller — how they address it."),
+    rails: z
+        .array(z.enum(CONNECTED_ACCOUNT_RAILS))
+        .describe('Which halves this account has. Never empty.'),
+    faircoin: 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: z
+        .string()
+        .nullable()
+        .describe('ISO 3166-1 alpha-2, upper-case. `null` on a FairCoin-only seller, which has no card half.'),
+    default_currency: z.string().nullable(),
+    payable: 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: z.boolean(),
+    charges_enabled: z.boolean(),
+    transfers_capability: capabilityStatus
+        .nullable()
+        .describe('`null`: never requested — a different fact from the provider declining it.'),
+    card_payments_capability: capabilityStatus.nullable(),
+    requirements: accountRequirementsSchema,
+    last_synced_at: unixSeconds.nullable(),
+    created: unixSeconds,
+    updated_at: 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).
+ */
+export const createConnectedAccountParams = z
+    .object({
+    // Bounded because it is a key: an unbounded string here is an unbounded
+    // index entry and an unbounded response field.
+    external_ref: z
+        .string()
+        .min(1)
+        .max(255)
+        .describe('Your own id for the seller. Opening the same `external_ref` again answers that account (200).'),
+    country: z
+        .string()
+        .length(2)
+        .optional()
+        .describe('The card half: ISO 3166-1 alpha-2 (case-insensitive). With `business_type`.'),
+    business_type: z
+        .enum(ACCOUNT_BUSINESS_TYPES)
+        .optional()
+        .describe('The card half: with `country`.'),
+    faircoin: z
+        .object({
+        network: z.enum(NETWORK_TYPES),
+        oxy_user_id: 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',
+});
+export const listConnectedAccountsQuery = listQuery({});
+/** `POST /v1/connected_accounts/{accountId}/refresh` takes no parameters. */
+export const refreshConnectedAccountParams = z.object({}).strict();
+/** A seller's onboarding link. */
+export const createConnectedAccountLinkParams = z
+    .object({
+    refresh_url: z.url().describe('Where the seller goes when the link has expired.'),
+    return_url: z.url().describe('Where the seller returns when they leave the flow.'),
+    rail: z
+        .enum(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_…`).' };
+export const connectedAccountRoutes = [
+    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: createConnectedAccountParams,
+        response: connectedAccountSchema,
+        status: 201,
+        sdk: 'connectedAccounts.create',
+    }),
+    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: listConnectedAccountsQuery,
+        response: listOf(connectedAccountSchema),
+        sdk: 'connectedAccounts.list',
+        expandable: 'connected_account',
+    }),
+    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: expandOnlyQuery,
+        response: connectedAccountSchema,
+        sdk: 'connectedAccounts.retrieveByRef',
+    }),
+    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: expandOnlyQuery,
+        response: connectedAccountSchema,
+        sdk: 'connectedAccounts.retrieve',
+    }),
+    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: refreshConnectedAccountParams,
+        response: connectedAccountSchema,
+        sdk: 'connectedAccounts.refresh',
+    }),
+    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: createConnectedAccountLinkParams,
+        response: accountLinkSchema,
+        status: 201,
+        sdk: 'connectedAccounts.createAccountLink',
+    }),
+];

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

@@ -0,0 +1,34 @@
+import { accountRoutes } from './account.js';
+import { applicationFeeRoutes } from './applicationFees.js';
+import { balanceRoutes } from './balance.js';
+import { connectedAccountRoutes } from './connectedAccounts.js';
+import { connectOnboardingRoutes } from './onboarding.js';
+import { payoutRoutes } from './payouts.js';
+import { reportingRoutes } from './reporting.js';
+import { requestLogRoutes } from './requestLogs.js';
+import { transferRoutes } from './transfers.js';
+export * from './account.js';
+export * from './applicationFees.js';
+export * from './balance.js';
+export * from './connectedAccounts.js';
+export * from './onboarding.js';
+export * from './payouts.js';
+export * from './reporting.js';
+export * from './requestLogs.js';
+export * from './transfers.js';
+/**
+ * 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.
+ */
+export const connectRoutes = [
+    ...connectedAccountRoutes,
+    ...accountRoutes,
+    ...balanceRoutes,
+    ...payoutRoutes,
+    ...applicationFeeRoutes,
+    ...connectOnboardingRoutes,
+    ...transferRoutes,
+    ...reportingRoutes,
+    ...requestLogRoutes,
+];