@peable.to/contracts 0.4.0 → 1.0.0

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

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportingRoutes = exports.downloadReportQuery = exports.listReportRunsQuery = exports.createReportRunParams = exports.reportRunSchema = exports.reportRunParametersSchema = exports.reportTypeSchema = void 0;
+const zod_1 = require("zod");
+const objects_1 = require("../../common/objects");
+const envelopes_1 = require("../../common/envelopes");
+const objects_2 = require("../../common/objects");
+const params_1 = require("../../common/params");
+const primitives_1 = require("../../common/primitives");
+const route_1 = require("../../route");
+const money_1 = require("../../vocabulary/money");
+const reporting_1 = require("../../vocabulary/reporting");
+/**
+ * Reporting (Stripe's `reporting.*`): a merchant asks for a report over an
+ * interval, Peable computes it in the background and stores the CSV as a
+ * `file_…` of purpose `finance_report_run` — or downloads the same CSV at once,
+ * streamed (`GET /v1/reporting/report_types/{id}/csv`). Both are ONE report:
+ * the same layout, the same columns, the same computation. The layouts are
+ * `REPORT_TYPE_LAYOUTS` in `@peable.to/shared-types/reporting`.
+ */
+const reportTypeId = zod_1.z.enum(reporting_1.REPORT_TYPE_IDS);
+/** `reporting.report_type` — what can be run, and over which interval data exists. */
+exports.reportTypeSchema = (0, objects_2.defineObject)('reporting.report_type', 'ReportType', zod_1.z
+    .object({
+    id: reportTypeId.describe('`payments.itemized.1`, …; the trailing number is the layout version.'),
+    object: zod_1.z.literal('reporting.report_type'),
+    livemode: primitives_1.livemode,
+    name: zod_1.z.string(),
+    version: zod_1.z
+        .number()
+        .int()
+        .describe("The column layout's version — the trailing number of the id."),
+    columns: zod_1.z
+        .array(zod_1.z.string())
+        .describe('Every column `parameters.columns` may name, in the order they are written.'),
+    default_columns: zod_1.z.array(zod_1.z.string()),
+    data_available_start: primitives_1.unixSeconds.describe('The earliest `interval_start` with data.'),
+    data_available_end: primitives_1.unixSeconds.describe('The latest `interval_end` a run may ask for: now — the data is live.'),
+    updated: primitives_1.unixSeconds.describe('When the layout last changed.'),
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'balance.summary.1',
+            object: 'reporting.report_type',
+            livemode: false,
+            name: 'Balance summary',
+            version: 1,
+            columns: [
+                'category',
+                'description',
+                'currency',
+                'net_amount',
+                'transaction_count',
+                'net_amount_decimal',
+            ],
+            default_columns: ['category', 'description', 'currency', 'net_amount'],
+            data_available_start: 1790000000,
+            data_available_end: 1793750400,
+            updated: 1793664000,
+        },
+    ],
+});
+/** What a run was asked to cover. */
+exports.reportRunParametersSchema = (0, objects_2.defineComponent)('ReportRunParameters', zod_1.z
+    .object({
+    interval_start: primitives_1.unixSeconds.describe('Inclusive.'),
+    interval_end: primitives_1.unixSeconds.describe('Exclusive.'),
+    columns: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe("The columns, in the layout's order; the report type's `default_columns` when absent."),
+    currency: primitives_1.currency.optional().describe('Only this currency.'),
+})
+    .strict());
+/** `reporting.report_run` (`frr_…`). */
+exports.reportRunSchema = (0, objects_2.defineObject)('reporting.report_run', 'ReportRun', zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    object: zod_1.z.literal('reporting.report_run'),
+    livemode: primitives_1.livemode,
+    created: primitives_1.unixSeconds,
+    report_type: reportTypeId,
+    parameters: exports.reportRunParametersSchema,
+    status: zod_1.z.enum(reporting_1.REPORT_RUN_STATUSES),
+    error: zod_1.z.string().nullable().describe('Why a `failed` run failed; `null` otherwise.'),
+    result: (0, objects_1.embedded)('file')
+        .nullable()
+        .describe('The CSV once `succeeded` — a File of purpose `finance_report_run` (`GET /v1/files/{id}/contents` reads it).'),
+    succeeded_at: primitives_1.unixSeconds.nullable(),
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'frr_0193b8f34d1e4a6b8c27',
+            object: 'reporting.report_run',
+            livemode: false,
+            created: 1793750400,
+            report_type: 'balance.summary.1',
+            parameters: { interval_start: 1790985600, interval_end: 1793577600 },
+            status: 'pending',
+            error: null,
+            result: null,
+            succeeded_at: null,
+        },
+    ],
+});
+const column = zod_1.z.string().min(1).max(64);
+/** `POST /v1/reporting/report_runs`. */
+exports.createReportRunParams = zod_1.z
+    .object({
+    report_type: reportTypeId,
+    parameters: zod_1.z
+        .object({
+        interval_start: params_1.unixSecondsParam.describe('Inclusive, Unix seconds.'),
+        interval_end: params_1.unixSecondsParam.describe('Exclusive, Unix seconds; after `interval_start` and not in the future.'),
+        columns: zod_1.z
+            .array(column)
+            .min(1)
+            .max(64)
+            .optional()
+            .describe("Columns of the report type's layout, each once."),
+        currency: zod_1.z.enum(money_1.CURRENCY_CODES).optional(),
+    })
+        .strict(),
+})
+    .strict();
+exports.listReportRunsQuery = (0, params_1.listQuery)({ report_type: reportTypeId.optional() });
+/**
+ * A download's query: a run's `parameters`, spelled as a query string
+ * (`columns[]=a&columns[]=b`, or one `columns=a`).
+ */
+exports.downloadReportQuery = zod_1.z
+    .object({
+    interval_start: (0, params_1.queryInteger)({ min: 0 }).describe('Inclusive, Unix seconds.'),
+    interval_end: (0, params_1.queryInteger)({ min: 0 }).describe('Exclusive, Unix seconds.'),
+    columns: (0, objects_2.describe)(zod_1.z
+        .union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())])
+        .transform((value) => (typeof value === 'string' ? [value] : value))
+        .pipe(zod_1.z.array(column).min(1).max(64)), {
+        description: "Columns of the report type's layout, each once.",
+        jsonSchema: {
+            type: 'array',
+            items: { type: 'string', minLength: 1, maxLength: 64 },
+            minItems: 1,
+            maxItems: 64,
+        },
+    }).optional(),
+    currency: zod_1.z.enum(money_1.CURRENCY_CODES).optional(),
+})
+    .strict();
+const reportTypeIdParam = { id: 'The report type (`payments.itemized.1`, …).' };
+exports.reportingRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'listReportTypes',
+        method: 'get',
+        path: '/v1/reporting/report_types',
+        tag: 'Reporting',
+        summary: 'List report types',
+        description: 'Every report Peable produces (a complete set), with the interval data exists for.',
+        auth: 'service',
+        scope: 'payments:read',
+        query: params_1.emptyQuery,
+        response: (0, envelopes_1.listOf)(exports.reportTypeSchema),
+        sdk: 'reporting.reportTypes.list',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveReportType',
+        method: 'get',
+        path: '/v1/reporting/report_types/{id}',
+        tag: 'Reporting',
+        summary: 'Retrieve a report type',
+        auth: 'service',
+        scope: 'payments:read',
+        params: reportTypeIdParam,
+        query: params_1.emptyQuery,
+        response: exports.reportTypeSchema,
+        sdk: 'reporting.reportTypes.retrieve',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'downloadReport',
+        method: 'get',
+        path: '/v1/reporting/report_types/{id}/csv',
+        tag: 'Reporting',
+        summary: 'Download a report',
+        description: 'The same report a run produces, with the same parameters, streamed at once as CSV instead of stored. Every refusal is the JSON error before the first byte; a read that fails afterwards aborts the response, so a truncated file never ends cleanly.',
+        auth: 'service',
+        scope: 'payments:read',
+        params: reportTypeIdParam,
+        query: exports.downloadReportQuery,
+        response: { kind: 'binary', contentType: 'text/csv' },
+        sdk: 'reporting.reportTypes.download',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'createReportRun',
+        method: 'post',
+        path: '/v1/reporting/report_runs',
+        tag: 'Reporting',
+        summary: 'Create a report run',
+        description: 'Answers `pending` at once; the CSV is produced in the background and announced with `reporting.report_run.succeeded` (or `.failed`).',
+        auth: 'service',
+        scope: 'payments:read',
+        idempotent: true,
+        body: exports.createReportRunParams,
+        response: exports.reportRunSchema,
+        sdk: 'reporting.reportRuns.create',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listReportRuns',
+        method: 'get',
+        path: '/v1/reporting/report_runs',
+        tag: 'Reporting',
+        summary: 'List report runs',
+        auth: 'service',
+        scope: 'payments:read',
+        query: exports.listReportRunsQuery,
+        response: (0, envelopes_1.listOf)(exports.reportRunSchema),
+        sdk: 'reporting.reportRuns.list',
+        expandable: 'reporting.report_run',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveReportRun',
+        method: 'get',
+        path: '/v1/reporting/report_runs/{id}',
+        tag: 'Reporting',
+        summary: 'Retrieve a report run',
+        auth: 'service',
+        scope: 'payments:read',
+        params: { id: 'The report run (`frr_…`).' },
+        query: params_1.expandOnlyQuery,
+        response: exports.reportRunSchema,
+        sdk: 'reporting.reportRuns.retrieve',
+        expandable: 'reporting.report_run',
+    }),
+];

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestLogRoutes = exports.streamRequestLogsQuery = exports.listRequestLogsQuery = exports.requestLogSchema = 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 reporting_1 = require("../../vocabulary/reporting");
+/**
+ * One merchant API request, as Peable recorded it (`req_…`) — the request log
+ * Orbit and `peable logs tail` read. Its `id` IS the `Request-Id` that request
+ * was answered with, so the id a merchant quotes to support and the log row
+ * are the same thing.
+ *
+ * Deliberately thin: method, path (no query string), status, duration and the
+ * `Idempotency-Key` it carried. No body, no headers, no query string, no caller
+ * address — a log a merchant can read is a log that must not hold what a
+ * request carried. Kept 30 days.
+ */
+exports.requestLogSchema = (0, objects_1.defineObject)('request_log', 'RequestLog', zod_1.z
+    .object({
+    id: zod_1.z.string().describe("The request's `Request-Id` (`req_…`)."),
+    object: zod_1.z.literal('request_log'),
+    livemode: primitives_1.livemode,
+    method: zod_1.z.enum(reporting_1.REQUEST_LOG_METHODS),
+    path: zod_1.z.string().describe('The path that was requested, without its query string.'),
+    status: zod_1.z.number().int().describe('The HTTP status it was answered with.'),
+    duration_ms: zod_1.z
+        .number()
+        .int()
+        .nonnegative()
+        .describe('How long the gateway took to answer, in milliseconds.'),
+    idempotency_key: zod_1.z
+        .string()
+        .nullable()
+        .describe('The `Idempotency-Key` the request carried, if it carried a valid one.'),
+    created: primitives_1.unixSeconds.describe('When it was answered.'),
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'req_0193b8f35e9c4f2a7b18',
+            object: 'request_log',
+            livemode: false,
+            method: 'POST',
+            path: '/v1/payment_intents',
+            status: 201,
+            duration_ms: 84,
+            idempotency_key: '5f1d3c2e-8a4b-4f6e-9d2c-1b7a0e3f4c5d',
+            created: 1793750400,
+        },
+    ],
+});
+/** `status=404` (one code) or `status=4xx` (a class). */
+const requestLogStatusFilter = zod_1.z
+    .union([(0, params_1.queryInteger)({ min: 100, max: 599 }), zod_1.z.enum(reporting_1.REQUEST_LOG_STATUS_CLASSES)])
+    .describe('One status code (`404`) or a class (`2xx`, `3xx`, `4xx`, `5xx`).');
+const requestLogFilters = {
+    status: requestLogStatusFilter.optional(),
+    method: zod_1.z.enum(reporting_1.REQUEST_LOG_METHODS).optional(),
+};
+exports.listRequestLogsQuery = (0, params_1.listQuery)(requestLogFilters);
+/** The live tail's filters: the list's, without paging. */
+exports.streamRequestLogsQuery = zod_1.z.object(requestLogFilters).strict();
+exports.requestLogRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'listRequestLogs',
+        method: 'get',
+        path: '/v1/request_logs',
+        tag: 'Request logs',
+        summary: 'List request logs',
+        description: 'Your API requests of the last 30 days, newest first, filtered by `status`, `method` and `created`.',
+        auth: 'service',
+        scope: 'payments:read',
+        query: exports.listRequestLogsQuery,
+        response: (0, envelopes_1.listOf)(exports.requestLogSchema),
+        sdk: 'requestLogs.list',
+        expandable: 'request_log',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'streamRequestLogs',
+        method: 'get',
+        path: '/v1/request_logs/stream',
+        tag: 'Request logs',
+        summary: 'Stream request logs',
+        description: 'Server-Sent Events: each request as it is answered (`event: request_log`), after a `ready` event. Reconnect with `Last-Event-ID` to resume without a gap. Test mode only; a stream ends after 15 minutes.',
+        auth: 'service',
+        scope: 'payments:read',
+        testModeOnly: true,
+        query: exports.streamRequestLogsQuery,
+        response: { kind: 'stream', event: exports.requestLogSchema },
+        sdk: 'requestLogs.stream',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveRequestLog',
+        method: 'get',
+        path: '/v1/request_logs/{id}',
+        tag: 'Request logs',
+        summary: 'Retrieve a request log',
+        description: 'By `Request-Id`; 404 once older than 30 days.',
+        auth: 'service',
+        scope: 'payments:read',
+        params: { id: 'The `Request-Id` (`req_…`).' },
+        query: params_1.expandOnlyQuery,
+        response: exports.requestLogSchema,
+        sdk: 'requestLogs.retrieve',
+    }),
+];

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

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferRoutes = exports.listPaymentIntentTransfersQuery = exports.listTransfersQuery = exports.reverseTransferParams = exports.createTransferParams = exports.transferWithReversalSchema = exports.transferReversalSchema = exports.transferSchema = 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");
+/**
+ * Transfers (`tr_…`) — a marketplace settling one seller out of a funded
+ * payment — and their reversals.
+ *
+ * The amounts come from the merchant and are recorded, never computed: Peable
+ * does not know what a marketplace fee is. The provider's own transfer id never
+ * crosses (ADR 0001 D3).
+ */
+exports.transferSchema = (0, objects_1.defineObject)('transfer', 'Transfer', zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    object: zod_1.z.literal('transfer'),
+    livemode: primitives_1.livemode,
+    external_ref: zod_1.z
+        .string()
+        .describe("The merchant's OWN id for what this settles. Their idempotency."),
+    connected_account: (0, objects_1.expandable)('connected_account', "The seller's `ca_…` — never their account id at the provider — or the ConnectedAccount with `expand[]=connected_account`."),
+    payment_intent: (0, objects_1.expandable)('payment_intent', 'The `pi_…` this settlement was funded by, or the PaymentIntent with `expand[]=payment_intent`.'),
+    amount: primitives_1.amount,
+    currency: zod_1.z.string(),
+    amount_reversed: primitives_1.amount.describe("CUMULATIVE, in the units of `amount` — the provider's own total, never a sum of the reversals."),
+    status: zod_1.z.enum(connect_1.TRANSFER_STATUSES),
+    failure_message: zod_1.z.string().nullable(),
+    created: primitives_1.unixSeconds,
+    updated_at: primitives_1.unixSeconds,
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'tr_0193b8f33c5a4b7e9d02',
+            object: 'transfer',
+            livemode: false,
+            external_ref: 'order_6735_seller_4821',
+            connected_account: 'ca_0193b8f2d4e1aa07c3b2',
+            payment_intent: 'pi_0193b8f2e8a14f6c9d31',
+            amount: '1700',
+            currency: 'EUR',
+            amount_reversed: '0',
+            status: 'paid',
+            failure_message: null,
+            created: 1793750400,
+            updated_at: 1793750402,
+        },
+    ],
+});
+/**
+ * One reversal operation. It exists as an object because an AMOUNT IS NOT AN
+ * IDENTITY: two reversals of one settlement for the same amount are two
+ * operations, and a caller needs to tell which one a response is about.
+ */
+exports.transferReversalSchema = (0, objects_1.defineObject)('transfer_reversal', 'TransferReversal', zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    object: zod_1.z.literal('transfer_reversal'),
+    livemode: primitives_1.livemode,
+    external_ref: zod_1.z.string().describe("The merchant's own id for this reversal."),
+    amount: primitives_1.amount,
+    currency: zod_1.z.string(),
+    status: zod_1.z.enum(connect_1.TRANSFER_REVERSAL_STATUSES),
+    failure_message: zod_1.z.string().nullable(),
+    created: primitives_1.unixSeconds,
+})
+    .strict());
+/** What `POST /v1/transfers/{transferId}/reversals` answers: the transfer, and the leg. */
+exports.transferWithReversalSchema = (0, objects_1.defineComponent)('TransferWithReversal', exports.transferSchema.extend({ reversal: exports.transferReversalSchema }).strict());
+/**
+ * A canonical base-unit integer string, validated with the SAME predicate the
+ * database CHECK is rendered from. A `z.number()` here would be a silent
+ * precision ceiling on a money value.
+ */
+const transferAmount = zod_1.z
+    .string()
+    .refine(money_1.isBaseUnitString, "amount must be a canonical integer string in the currency's smallest unit")
+    // `'0'` passes the predicate above, and a zero transfer is not a transfer:
+    // it would consume the merchant's `external_ref`, so the REAL settlement of
+    // that order could never be created afterwards.
+    .refine((value) => value !== '0', 'a transfer of 0 is not a transfer');
+/**
+ * `POST /v1/transfers`: settle one seller out of a funded payment. The seller
+ * by exactly one of its two addresses; the currency is the payment's, never the
+ * request's (a transfer in another currency is an FX conversion nothing here
+ * performs).
+ */
+exports.createTransferParams = zod_1.z
+    .object({
+    payment_intent: zod_1.z.string().min(1).describe('The `pi_…` this settles out of.'),
+    connected_account: zod_1.z.string().min(1).optional().describe("The seller's `ca_…`."),
+    connected_account_ref: zod_1.z
+        .string()
+        .min(1)
+        .max(255)
+        .optional()
+        .describe('Or your own id for the seller (its `external_ref`).'),
+    external_ref: zod_1.z
+        .string()
+        .min(1)
+        .max(255)
+        .describe('Your own id for what this settles — the idempotency: the same ref answers the stored settlement (200), a different payment or amount under it is a 409.'),
+    amount: transferAmount,
+})
+    .strict()
+    .refine((body) => Boolean(body.connected_account) !== Boolean(body.connected_account_ref), {
+    message: 'name the seller by exactly one of connected_account or connected_account_ref',
+});
+exports.reverseTransferParams = zod_1.z
+    .object({
+    amount: transferAmount,
+    // Required, and durable. It used to be satisfiable by the
+    // `Idempotency-Key` header instead; that header is now the generic 24-hour
+    // retry layer (ADR 0014 D3), which the SDK fills with a fresh uuid per call
+    // — accepting it here would hand every un-referenced reversal a random
+    // identity, and an application's own retry a second reversal.
+    external_ref: zod_1.z
+        .string()
+        .min(1)
+        .max(255)
+        .describe('Your own id for THIS reversal — required and durable: two reversals for the same amount are two operations.'),
+})
+    .strict();
+exports.listTransfersQuery = (0, params_1.listQuery)({
+    payment_intent: params_1.idParam.optional().describe('Only the settlements of this payment (`pi_…`).'),
+    connected_account: params_1.idParam.optional().describe('Only the settlements to this seller (`ca_…`).'),
+});
+/** The per-payment list: the payment is in the path. */
+exports.listPaymentIntentTransfersQuery = (0, params_1.listQuery)({});
+const transferIdParam = { transferId: 'The transfer (`tr_…`).' };
+exports.transferRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'createTransfer',
+        method: 'post',
+        path: '/v1/transfers',
+        tag: 'Transfers',
+        summary: 'Create a transfer',
+        description: 'Settles one seller out of a funded payment (201). An order already settled answers the stored settlement (200): a merchant retrying after a timeout needs to know whether they just paid a seller twice.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        body: exports.createTransferParams,
+        response: exports.transferSchema,
+        status: 201,
+        sdk: 'transfers.create',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'createTransferReversal',
+        method: 'post',
+        path: '/v1/transfers/{transferId}/reversals',
+        tag: 'Transfers',
+        summary: 'Reverse a transfer',
+        description: 'Takes some or all of a settlement back (201), or answers the reversal this `external_ref` already made (200).',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        params: transferIdParam,
+        body: exports.reverseTransferParams,
+        response: exports.transferWithReversalSchema,
+        status: 201,
+        sdk: 'transfers.reverse',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listTransferReversals',
+        method: 'get',
+        path: '/v1/transfers/{transferId}/reversals',
+        tag: 'Transfers',
+        summary: "List a transfer's reversals",
+        description: 'Newest first. A complete set (`has_more: false`): a settlement can only be reversed down to zero.',
+        auth: 'service',
+        scope: 'payments:read',
+        params: transferIdParam,
+        query: params_1.expandOnlyQuery,
+        response: (0, envelopes_1.listOf)(exports.transferReversalSchema),
+        sdk: 'transfers.listReversals',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listTransfers',
+        method: 'get',
+        path: '/v1/transfers',
+        tag: 'Transfers',
+        summary: 'List transfers',
+        description: 'Newest first, narrowed by `payment_intent` and/or `connected_account`.',
+        auth: 'service',
+        scope: 'payments:read',
+        query: exports.listTransfersQuery,
+        response: (0, envelopes_1.listOf)(exports.transferSchema),
+        sdk: 'transfers.list',
+        expandable: 'transfer',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveTransfer',
+        method: 'get',
+        path: '/v1/transfers/{transferId}',
+        tag: 'Transfers',
+        summary: 'Retrieve a transfer',
+        auth: 'service',
+        scope: 'payments:read',
+        params: transferIdParam,
+        query: params_1.expandOnlyQuery,
+        response: exports.transferSchema,
+        sdk: 'transfers.retrieve',
+        expandable: 'transfer',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listPaymentIntentTransfers',
+        method: 'get',
+        path: '/v1/payment_intents/{intentId}/transfers',
+        tag: 'Transfers',
+        summary: "List a payment's transfers",
+        description: 'What one payment settled, newest first. The reconciliation read.',
+        auth: 'service',
+        scope: 'payments:read',
+        params: { intentId: 'The payment intent (`pi_…`).' },
+        query: exports.listPaymentIntentTransfersQuery,
+        response: (0, envelopes_1.listOf)(exports.transferSchema),
+        sdk: 'transfers.listForPaymentIntent',
+        expandable: 'transfer',
+    }),
+];