@zkp2p/pay-shared 5.0.0 → 7.0.0

package/dist/types.d.ts

@@ -1,6 +1,8 @@
+import type { PAYOUT_RAIL_CURRENCIES, PayoutCurrencyType, PayoutFiatValue, PayoutOracleCurrencyType } from './cashoutCurrencies.js';
 import type { PayCryptoTokenSymbol } from './crypto.js';
 import type { ProofMode } from './buyerTee.js';
 import type { OnboardingStepIdValue } from './onboarding.js';
+import type { SarSupportedFiatRail } from './rails.js';
 export declare const PaymentPlatform: {
     readonly VENMO: "venmo";
     readonly CASHAPP: "cashapp";
@@ -1043,8 +1045,21 @@ export declare const WebhookEventType: {
     readonly PAYMENT_CHARGEBACKED: "PAYMENT_CHARGEBACKED";
     readonly ORDER_PARTIALLY_CHARGEBACKED: "ORDER_PARTIALLY_CHARGEBACKED";
     readonly ORDER_CHARGEBACKED: "ORDER_CHARGEBACKED";
+    readonly PAYOUT_ORDER_CREATED: "PAYOUT_ORDER_CREATED";
+    readonly PAYOUT_ORDER_CANCELLED: "PAYOUT_ORDER_CANCELLED";
+    readonly PAYOUT_ORDER_PARTIALLY_FUNDED: "PAYOUT_ORDER_PARTIALLY_FUNDED";
+    readonly PAYOUT_ORDER_FUNDED: "PAYOUT_ORDER_FUNDED";
+    readonly PAYOUT_ORDER_MATCHED: "PAYOUT_ORDER_MATCHED";
+    readonly PAYOUT_ORDER_PARTIALLY_PAID: "PAYOUT_ORDER_PARTIALLY_PAID";
+    readonly PAYOUT_ORDER_SETTLED: "PAYOUT_ORDER_SETTLED";
+    readonly PAYOUT_ORDER_EXPIRED: "PAYOUT_ORDER_EXPIRED";
 };
 export type WebhookEventTypeValue = typeof WebhookEventType[keyof typeof WebhookEventType];
+/** Payout events carry a PayoutView, not the order envelope. */
+export declare const PAYOUT_WEBHOOK_EVENT_TYPES: readonly ["PAYOUT_ORDER_CREATED", "PAYOUT_ORDER_CANCELLED", "PAYOUT_ORDER_PARTIALLY_FUNDED", "PAYOUT_ORDER_FUNDED", "PAYOUT_ORDER_MATCHED", "PAYOUT_ORDER_PARTIALLY_PAID", "PAYOUT_ORDER_SETTLED", "PAYOUT_ORDER_EXPIRED"];
+export type PayoutWebhookEventTypeValue = typeof PAYOUT_WEBHOOK_EVENT_TYPES[number];
+export type OrderWebhookEventTypeValue = Exclude<WebhookEventTypeValue, PayoutWebhookEventTypeValue>;
+export declare function isPayoutWebhookEventType(type: string): type is PayoutWebhookEventTypeValue;
 export declare const WebhookDeliveryStatus: {
     readonly PENDING: "PENDING";
     readonly DELIVERED: "DELIVERED";
@@ -1077,9 +1092,9 @@ export type WebhookDelivery = {
     responseCode?: number | null;
     createdAt: string;
 };
-export type WebhookPayload = {
+export type OrderWebhookPayload = {
     id: string;
-    type: WebhookEventTypeValue;
+    type: OrderWebhookEventTypeValue;
     timestamp: string;
     data: {
         order: CheckoutOrder | null;
@@ -1101,6 +1116,47 @@ export type WebhookPayload = {
         amountChange?: OrderAmountChange;
     };
 };
+/** Bumped only on a breaking change to a payout payload. */
+export declare const PAYOUT_WEBHOOK_VERSION = 2;
+/** One buyer payment that left part of the payout unpaid; amounts are decimal USDC except fill.fiat. */
+export interface PayoutPartialPayment {
+    /** The payout's depositAmount: what buyers can pay in total. */
+    expectedAmount: string;
+    /** What buyers have paid so far, this fill included. */
+    paidAmount: string;
+    /** expectedAmount − paidAmount. */
+    remainingAmount: string;
+    fill: {
+        amount: string;
+        txHash: string;
+        /** Fiat paid at this fill's bound rate; null when the currency or rate is unknown. */
+        fiat: PayoutFiatValue | null;
+    };
+}
+export type PayoutWebhookEventData = {
+    readonly type: Exclude<PayoutWebhookEventTypeValue, typeof WebhookEventType.PAYOUT_ORDER_PARTIALLY_PAID>;
+    readonly data: PayoutView;
+} | {
+    readonly type: typeof WebhookEventType.PAYOUT_ORDER_PARTIALLY_PAID;
+    readonly data: PayoutView;
+    readonly partialPayment: PayoutPartialPayment;
+};
+export type PayoutWebhookPayload = {
+    id: string;
+    type: Exclude<PayoutWebhookEventTypeValue, typeof WebhookEventType.PAYOUT_ORDER_PARTIALLY_PAID>;
+    timestamp: string;
+    version: typeof PAYOUT_WEBHOOK_VERSION;
+    data: PayoutView;
+} | {
+    id: string;
+    type: typeof WebhookEventType.PAYOUT_ORDER_PARTIALLY_PAID;
+    timestamp: string;
+    version: typeof PAYOUT_WEBHOOK_VERSION;
+    data: PayoutView;
+    partialPayment: PayoutPartialPayment;
+};
+export type WebhookPayload = OrderWebhookPayload | PayoutWebhookPayload;
+export declare function isPayoutWebhook(payload: WebhookPayload): payload is PayoutWebhookPayload;
 export type CreateWebhookRequest = {
     url: string;
     events?: WebhookEventTypeValue[];
@@ -1201,4 +1257,646 @@ export type OwnershipTransferMasterMerchantPermissionType = typeof OwnershipTran
 export declare const OWNERSHIP_TRANSFER_MASTER_MERCHANT_PERMISSIONS: readonly OwnershipTransferMasterMerchantPermissionType[];
 /** "alice@example.com" → "a•••@example.com". The input is a validated, lowercased address. */
 export declare function maskOwnershipTransferEmail(email: string): string;
+export declare const PayoutStatus: {
+    readonly AWAITING_FUNDING: "AWAITING_FUNDING";
+    readonly FUNDED: "FUNDED";
+    readonly READY: "READY";
+    readonly LISTING: "LISTING";
+    readonly PAYING: "PAYING";
+    readonly SETTLED: "SETTLED";
+    readonly CANCELLED: "CANCELLED";
+    readonly EXPIRED: "EXPIRED";
+};
+export type PayoutStatusType = typeof PayoutStatus[keyof typeof PayoutStatus];
+export declare const PayoutFundingStatus: {
+    readonly AWAITING_FUNDING: "AWAITING_FUNDING";
+    readonly PARTIALLY_FUNDED: "PARTIALLY_FUNDED";
+    readonly FUNDED: "FUNDED";
+    readonly FUNDING_EXPIRED: "FUNDING_EXPIRED";
+};
+export type PayoutFundingStatusType = typeof PayoutFundingStatus[keyof typeof PayoutFundingStatus];
+export declare const PayoutCancelSource: {
+    readonly MERCHANT: "MERCHANT";
+    readonly PEER_APP: "PEER_APP";
+};
+export type PayoutCancelSourceType = typeof PayoutCancelSource[keyof typeof PayoutCancelSource];
+export declare const PayoutKind: {
+    readonly ESCROW: "ESCROW";
+    readonly CRYPTO: "CRYPTO";
+};
+export type PayoutKindType = typeof PayoutKind[keyof typeof PayoutKind];
+export declare const PayoutAttemptStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CLOSED: "CLOSED";
+    readonly SETTLED: "SETTLED";
+    readonly FAILED: "FAILED";
+};
+export type PayoutAttemptStatusType = typeof PayoutAttemptStatus[keyof typeof PayoutAttemptStatus];
+/** Fiat payout methods, in the order players see them: SAR rails, then buyer-proof rails. */
+export declare const PayoutFiatRail: {
+    readonly VENMO: "venmo";
+    readonly CASHAPP: "cashapp";
+    readonly PAYPAL: "paypal";
+    readonly ZELLE: "zelle";
+    readonly REVOLUT: "revolut";
+    readonly CHIME: "chime";
+};
+export type PayoutFiatRailType = typeof PayoutFiatRail[keyof typeof PayoutFiatRail];
+/** One rail per crypto payout network, with checkout's rail ids (any-coin spec "Cashout rails"); the player sees them as one "Crypto" option. */
+export declare const PayoutCryptoRail: {
+    readonly RELAY_1: "relay_1";
+    readonly RELAY_10: "relay_10";
+    readonly RELAY_56: "relay_56";
+    readonly RELAY_137: "relay_137";
+    readonly RELAY_480: "relay_480";
+    readonly RELAY_999: "relay_999";
+    readonly RELAY_5042: "relay_5042";
+    readonly RELAY_8453: "relay_8453";
+    readonly RELAY_42161: "relay_42161";
+    readonly RELAY_8253038: "relay_8253038";
+    readonly RELAY_728126428: "relay_728126428";
+    readonly RELAY_792703809: "relay_792703809";
+    /** ZEC on Zcash through NEAR Intents (Zcash spec "Catalog, route and address"); checkout's ZCASH_RAIL. */
+    readonly NEAR_INTENTS_133701: "near_intents_133701";
+};
+export type PayoutCryptoRailType = typeof PayoutCryptoRail[keyof typeof PayoutCryptoRail];
+/** Every payout rail, in rail order: fiat, then the crypto networks. */
+export declare const PayoutRail: {
+    readonly RELAY_1: "relay_1";
+    readonly RELAY_10: "relay_10";
+    readonly RELAY_56: "relay_56";
+    readonly RELAY_137: "relay_137";
+    readonly RELAY_480: "relay_480";
+    readonly RELAY_999: "relay_999";
+    readonly RELAY_5042: "relay_5042";
+    readonly RELAY_8453: "relay_8453";
+    readonly RELAY_42161: "relay_42161";
+    readonly RELAY_8253038: "relay_8253038";
+    readonly RELAY_728126428: "relay_728126428";
+    readonly RELAY_792703809: "relay_792703809";
+    /** ZEC on Zcash through NEAR Intents (Zcash spec "Catalog, route and address"); checkout's ZCASH_RAIL. */
+    readonly NEAR_INTENTS_133701: "near_intents_133701";
+    readonly VENMO: "venmo";
+    readonly CASHAPP: "cashapp";
+    readonly PAYPAL: "paypal";
+    readonly ZELLE: "zelle";
+    readonly REVOLUT: "revolut";
+    readonly CHIME: "chime";
+};
+export type PayoutRailType = PayoutFiatRailType | PayoutCryptoRailType;
+/** Fiat rails whose account the player connects so Peer can confirm buyer payments; derived from SAR_SUPPORTED_FIAT_RAILS. */
+export type PayoutSarRailType = Extract<PayoutFiatRailType, SarSupportedFiatRail>;
+/** Fiat rails with no connect step: the buyer proves the payment with the PeerAuth extension or the Peer app. */
+export type CashoutBuyerProofRailType = Exclude<PayoutFiatRailType, PayoutSarRailType>;
+export declare const PayoutProvider: {
+    readonly RELAY: "RELAY";
+    readonly NEAR_INTENTS: "NEAR_INTENTS";
+};
+export type PayoutProviderType = typeof PayoutProvider[keyof typeof PayoutProvider];
+export declare const CashoutPayoutBridgeStatus: {
+    readonly QUOTED: "QUOTED";
+    readonly NOT_SENT: "NOT_SENT";
+    readonly BRIDGING: "BRIDGING";
+    readonly DELIVERED: "DELIVERED";
+    readonly REFUNDED: "REFUNDED";
+};
+export type CashoutPayoutBridgeStatusType = typeof CashoutPayoutBridgeStatus[keyof typeof CashoutPayoutBridgeStatus];
+/** A crypto payout's coin, network and the player's address there. */
+export interface PayoutCryptoDestination {
+    chainId: number;
+    /** The shared catalog's address for the token on chainId. */
+    tokenAddress: string;
+    symbol: PayCryptoTokenSymbol;
+    decimals: number;
+    /** Canonical: EVM checksummed, bech32 lower-case, base58 as entered. */
+    address: string;
+}
+/** Body of the crypto payout-method, payout-quote and send-to-address requests. The rail names the network. */
+export interface CashoutPayoutDestinationRequest {
+    rail: PayoutCryptoRailType;
+    tokenAddress: string;
+    address: string;
+}
+/** A crypto payout method: the network's rail and where on it the player takes the payout. */
+export interface PayoutCryptoMethod {
+    rail: PayoutCryptoRailType;
+    destination: PayoutCryptoDestination;
+}
+/** POST /api/v1/cashout-checkout/:id/payout-quote. Not a promise. */
+export interface CashoutPayoutQuote {
+    destination: PayoutCryptoDestination;
+    /** Decimal USDC that would leave the player's wallet. */
+    usdcAmount: string;
+    /** Decimal destination token; equals usdcAmount for USDC on Base. */
+    estimatedAmount: string;
+    quotedAt: string;
+}
+/** The player's bridged payout, newest attempt first; never NOT_SENT. */
+export interface CashoutPayoutBridgeView {
+    provider: PayoutProviderType;
+    status: Exclude<CashoutPayoutBridgeStatusType, typeof CashoutPayoutBridgeStatus.NOT_SENT>;
+    destination: PayoutCryptoDestination;
+    usdcAmount: string;
+    /** The binding quote's output, decimal destination token. */
+    estimatedAmount: string;
+    deliveredAmount: string | null;
+    destinationTxHash: string | null;
+    /** Decimal USDC. */
+    refundedAmount: string | null;
+    refundTxHash: string | null;
+}
+export interface PayoutPartialFillView {
+    /** Fiat paid at this fill's bound rate; null when the currency or rate is unknown. */
+    fiat: PayoutFiatValue | null;
+    /** Decimal USDC this buyer paid. */
+    amount: string;
+    txHash: string;
+    paidAt: string;
+}
+/** Where a SETTLED payout's USDC ended up; decimal USDC, "0.00" for a part that did not happen. */
+export interface PayoutSettlementBreakdown {
+    /** Paid by buyers through the escrow, across every listing. */
+    buyerPaidAmount: string;
+    /** Fiat totals in first-paid order; null if any payment has an unknown currency or bound rate, [] if no buyer paid. */
+    buyerPaidFiat: PayoutFiatValue[] | null;
+    /** USDC that left the player's wallet for a crypto payout (direct or bridged) or a send-to-address remainder. */
+    sentAmount: string;
+    /** The player's recipient: EVM lower-case, Solana, Tron and Bitcoin canonical; never a deposit address. */
+    sentTo: string | null;
+    /** Left in, or returned to, the player's Peer wallet. */
+    returnedAmount: string;
+    /** Swept by the escrow as dust when it closed the deposit. */
+    dustAmount: string;
+    /** Σ refundLossUnits: USDC Relay kept on refunds; "0.00" when none. */
+    refundFeeAmount: string;
+}
+/** Merchant-facing payout. Never includes the Peer fee, the player's email, wallet or payee handle. */
+export interface PayoutView {
+    /** The chosen fiat payout currency; null for crypto or no selected method. */
+    payoutCurrency: PayoutCurrencyType | null;
+    payoutId: string;
+    merchantReference: string | null;
+    status: PayoutStatusType;
+    fundingStatus: PayoutFundingStatusType;
+    payout: {
+        amount: string;
+        chainId: number;
+        tokenAddress: string;
+        decimals: number;
+    };
+    merchantFee: {
+        bps: number;
+        amount: string;
+    };
+    funding: {
+        chainId: number;
+        tokenAddress: string;
+        decimals: number;
+        /** Quoted amount to send, decimal funding token. */
+        amount: string;
+        /** Sent before the deadline, decimal funding token. */
+        sentAmount: string;
+        /** amount − sentAmount, never below zero; decimal funding token. */
+        missingAmount: string;
+        /** Payout plus buffer: the USDC the quote delivers, decimal USDC. */
+        expectedAmount: string;
+        /** Reached the player's wallet on Base, decimal USDC. */
+        receivedAmount: string;
+        /** Null once the payout can no longer be funded. */
+        depositAddress: string | null;
+        /** Funding deadline; each on-time arrival moves it to at least the funding TTL (24 hours by default) after that check. */
+        quoteExpiresAt: string;
+    };
+    depositAmount: string | null;
+    /** What buyers have paid across every listing, partial fills included. */
+    paidAmount: string;
+    partialFills: PayoutPartialFillView[];
+    /** Only when status is SETTLED. */
+    settlement: PayoutSettlementBreakdown | null;
+    attempt: {
+        kind: PayoutKindType;
+        rail: string | null;
+        status: PayoutAttemptStatusType;
+    } | null;
+    /** Only when settled with a sent amount, including a send-to-address remainder. */
+    payoutTransfer: {
+        /** Where the player received it. */
+        chainId: number;
+        tokenAddress: string;
+        decimals: number;
+        address: string;
+        /** Delivered, decimal destination token. */
+        amount: string;
+        /** The delivering transaction on chainId. */
+        txHash: string;
+        /** The USDC transfer on Base; settlement.sentAmount is its amount. */
+        usdcTxHash: string;
+        /** The bridge provider (RELAY or NEAR_INTENTS) when bridged; null for USDC on Base, where txHash = usdcTxHash. */
+        provider: PayoutProviderType | null;
+    } | null;
+    cancelSource: PayoutCancelSourceType | null;
+    returnUrl: string | null;
+    expiresAt: string;
+    fundedAt: string | null;
+    settledAt: string | null;
+    cancelledAt: string | null;
+    createdAt: string;
+}
+export interface CreatePayoutRequest {
+    merchantReference?: string;
+    customerEmail: string;
+    payout: {
+        amount: string;
+        chainId: number;
+        tokenAddress: string;
+    };
+    funding: {
+        chainId: number;
+        tokenAddress: string;
+        refundAddress?: string;
+    };
+    returnUrl?: string;
+    /** Limits the payout to these rails; never widens the merchant's (any-coin spec "Cashout rails"). */
+    rails?: PayoutRailType[];
+}
+/** A replay with the same key and body returns the current checkout link, marked `idempotentReplay: true`. */
+export type CreatePayoutResponse = PayoutView & {
+    checkoutUrl: string;
+    idempotentReplay: boolean;
+};
+export interface ListPayoutsResponse {
+    items: PayoutView[];
+    page: number;
+    limit: number;
+    total: number;
+}
+/** A moment on a payout's dashboard timeline. */
+export declare const PayoutTimelineEventType: {
+    readonly CREATED: "CREATED";
+    readonly PARTIALLY_FUNDED: "PARTIALLY_FUNDED";
+    readonly FUNDED: "FUNDED";
+    readonly FUNDING_EXPIRED: "FUNDING_EXPIRED";
+    readonly SIGNED_IN: "SIGNED_IN";
+    readonly METHOD_READY: "METHOD_READY";
+    readonly LISTED: "LISTED";
+    readonly TRANSFER_SENT: "TRANSFER_SENT";
+    readonly MATCHED: "MATCHED";
+    /** A buyer paid part of the listing; the rest is listed again or left for the player. */
+    readonly PARTIALLY_PAID: "PARTIALLY_PAID";
+    /** Pay set the deposit's intent range to what is left, so another buyer can take it. */
+    readonly RELISTED: "RELISTED";
+    readonly BUYER_DROPPED: "BUYER_DROPPED";
+    readonly RECONNECT_NEEDED: "RECONNECT_NEEDED";
+    /** The listing came back to the player's wallet so they can pick another payout method. */
+    readonly LISTING_WITHDRAWN: "LISTING_WITHDRAWN";
+    readonly SETTLED: "SETTLED";
+    readonly CANCELLED: "CANCELLED";
+    readonly FUNDING_ISSUE: "FUNDING_ISSUE";
+    readonly PAYOUT_REFUNDED: "PAYOUT_REFUNDED";
+};
+export type PayoutTimelineEventTypeValue = typeof PayoutTimelineEventType[keyof typeof PayoutTimelineEventType];
+/** Largest merchant payout step, in whole USDC. The smallest is the API's CASHOUT_MIN_USDC (10 in production). */
+export declare const PAYOUT_STEP_MAX_USDC = 1000;
+/** Whole-USDC bounds for a merchant's payout step in this environment. */
+export interface PayoutStepRange {
+    min: number;
+    max: number;
+}
+/** A merchant's payout settings; the Peer fee is not the merchant's to see. */
+export interface PayoutSettings {
+    rails: PayoutRailType[];
+    /** Merchant fee in bps of the deposit, 0–1000. */
+    feeBps: number;
+    /** Whole USDC, within the environment's payout step range. */
+    payoutStepUsdc: number;
+    /** An https URL or a mailto: link; optional. Without it the player's checkout shows no contact line. */
+    supportUrl: string | null;
+}
+export declare const PayoutFundingIssueKind: {
+    readonly LATE_FUNDS: "LATE_FUNDS";
+    readonly OVERPAYMENT: "OVERPAYMENT";
+    readonly ROUTE_REFUND: "ROUTE_REFUND";
+};
+export type PayoutFundingIssueKindType = typeof PayoutFundingIssueKind[keyof typeof PayoutFundingIssueKind];
+export declare const PayoutFundingIssueResolution: {
+    readonly RETURNED: "RETURNED";
+    readonly CLAIMED: "CLAIMED";
+};
+export type PayoutFundingIssueResolutionType = typeof PayoutFundingIssueResolution[keyof typeof PayoutFundingIssueResolution];
+/** A funding token as offered to a merchant: `key` is "chainId:lowercaseAddress". */
+export interface PayoutFundingTokenOption {
+    key: string;
+    chainId: number;
+    address: string;
+    symbol: string;
+}
+/** GET /merchants/me/payout-settings: the saved settings plus what Peer currently allows. */
+export interface PayoutSettingsView extends PayoutSettings {
+    availableRails: PayoutRailType[];
+    availableFundingTokens: PayoutFundingTokenOption[];
+    payoutStepRange: PayoutStepRange;
+}
+/** Merchant-facing; never includes the admin's note or name. */
+export interface MerchantPayoutFundingIssue {
+    kind: PayoutFundingIssueKindType;
+    /** Decimal USDC; null for a route refund, which is paid back in the origin token. */
+    amountUsdc: string | null;
+    txHash: string | null;
+    detectedAt: string;
+    resolution: PayoutFundingIssueResolutionType | null;
+    resolutionTxHash: string | null;
+    resolvedAt: string | null;
+}
+export type PayoutMethodView = {
+    rail: PayoutFiatRailType;
+    handle: string;
+    currency: PayoutCurrencyType;
+} | PayoutCryptoMethod;
+/** The dashboard's payout: the API view plus what only the merchant's staff may see. */
+export interface MerchantPayoutView extends PayoutView {
+    /** The player's email as given at create, stored lower-cased. */
+    customerEmail: string;
+    payoutMethod: PayoutMethodView | null;
+    /** Null once the payout is final. */
+    checkoutUrl: string | null;
+}
+export interface PayoutTimelineEntry {
+    type: PayoutTimelineEventTypeValue;
+    text: string;
+    txHash: string | null;
+    /** The chain txHash is on; null when txHash isn't linked. */
+    txChainId: number | null;
+    occurredAt: string;
+}
+export interface PayoutWebhookDeliveryView {
+    eventType: string;
+    status: string;
+    attempts: number;
+    responseCode: number | null;
+    lastAttemptAt: string | null;
+    createdAt: string;
+}
+export interface MerchantPayoutDetail {
+    payout: MerchantPayoutView;
+    timeline: PayoutTimelineEntry[];
+    /** Not stored: what happens next from the current status, or null when final. */
+    nextStep: string | null;
+    webhooks: PayoutWebhookDeliveryView[];
+    fundingIssues: MerchantPayoutFundingIssue[];
+}
+/** The dashboard's create form result; a replay returns the same payout and its current link. */
+export type CreateMerchantPayoutResponse = MerchantPayoutView & {
+    idempotentReplay: boolean;
+};
+export interface ListMerchantPayoutsResponse {
+    items: MerchantPayoutView[];
+    page: number;
+    limit: number;
+    total: number;
+}
+export interface AdminCashoutSettings {
+    disabledRails: PayoutRailType[];
+    disabledFundingTokens: string[];
+    peerFeeRecipient: string;
+    supportedFundingTokens: PayoutFundingTokenOption[];
+    updatedAt: string;
+}
+export interface AdminCashoutMerchantConfig {
+    merchantId: string;
+    peerFeeBps: number;
+    payoutStepUsdc: number;
+    payoutStepRange: PayoutStepRange;
+    fundingTokens: string[];
+    /** Merchant cashout rails, edited by the merchant and Peer admins, in rail order. */
+    rails: PayoutRailType[];
+    /** Player support link; optional. */
+    supportUrl: string | null;
+    /** Merchant rails minus Peer's global disables and the fiat rails `DISABLED_RAILS` turns off, in rail order. */
+    effectiveRails: PayoutRailType[];
+    merchantFeeBps: number;
+    merchantFeeRecipient: string | null;
+}
+export interface AdminCashoutFundingIssue extends MerchantPayoutFundingIssue {
+    id: string;
+    cashoutId: string;
+    merchantId: string;
+    merchantName: string;
+    relayRequestId: string | null;
+    resolutionNote: string | null;
+    resolvedBy: string | null;
+}
+export interface AdminCashoutSupport {
+    fundingIssues: AdminCashoutFundingIssue[];
+}
+export interface AdminCashoutChange {
+    id: string;
+    merchantId: string | null;
+    cashoutFundingIssueId: string | null;
+    actor: string;
+    changes: Record<string, {
+        before: unknown;
+        after: unknown;
+    }>;
+    createdAt: string;
+}
+/** What the player can do next; drives every checkout button and every 409. */
+export declare const CashoutPlayerAction: {
+    readonly SET_METHOD: "SET_METHOD";
+    readonly CONNECT_RAIL: "CONNECT_RAIL";
+    readonly SKIP_CONNECT: "SKIP_CONNECT";
+    readonly CONFIRM: "CONFIRM";
+    readonly CHANGE_METHOD: "CHANGE_METHOD";
+    readonly SEND_TO_ADDRESS: "SEND_TO_ADDRESS";
+    readonly RELIST: "RELIST";
+};
+export type CashoutPlayerActionType = typeof CashoutPlayerAction[keyof typeof CashoutPlayerAction];
+/** What Pay is sending from the player's wallet. */
+export declare const CashoutSending: {
+    readonly LISTING: "LISTING";
+    readonly TRANSFER: "TRANSFER";
+    readonly WITHDRAW: "WITHDRAW";
+    readonly RELISTING: "RELISTING";
+};
+export type CashoutSendingType = typeof CashoutSending[keyof typeof CashoutSending];
+export declare const CashoutCredentialStatus: {
+    readonly ACTIVE: "active";
+    readonly INACTIVE: "inactive";
+    readonly MISSING: "missing";
+};
+export type CashoutCredentialStatusType = typeof CashoutCredentialStatus[keyof typeof CashoutCredentialStatus];
+export interface CashoutRailOption {
+    rail: PayoutRailType;
+    /** Smallest single buyer payment, USDC decimal; null for crypto rails. */
+    minAmount: string | null;
+    /** Largest single buyer payment, USDC decimal; null for crypto rails. */
+    maxAmount: string | null;
+}
+/** A SAR method supports seller-side confirmation; when connecting is skipped, each buyer proves payment. */
+export interface CashoutSarMethod {
+    currency: PayoutCurrencyType;
+    rail: PayoutSarRailType;
+    payeeHandle: string;
+    credentialStatus: CashoutCredentialStatusType;
+    /** The player chose to list without connecting this method. */
+    connectSkipped: boolean;
+    payeeHash: string;
+    /** The email of the PayPal account; null on every other rail. Only the player's own checkout sees it. */
+    paypalEmail: string | null;
+}
+/** A buyer-proof method has no connect step or credential; each buyer proves their payment. */
+export interface CashoutBuyerProofMethod {
+    currency: PayoutCurrencyType;
+    rail: CashoutBuyerProofRailType;
+    payeeHandle: string;
+    payeeHash: string;
+}
+/** GET /api/v1/cashout-checkout/:id (link token only). */
+export interface CashoutCheckoutSummary {
+    cashoutId: string;
+    merchant: {
+        name: string;
+        logoUrl: string | null;
+        supportUrl: string | null;
+        disableBranding: boolean;
+        checkoutTheme: MerchantCheckoutTheme | null;
+    };
+    email: string;
+    maskedEmail: string;
+    payoutAmount: string;
+    status: PayoutStatusType;
+    rails: CashoutRailOption[];
+    returnUrl: string | null;
+}
+/** Display only: an oracle read never gates a payout. */
+export interface CashoutFxRate {
+    currency: PayoutOracleCurrencyType;
+    rate: string;
+}
+export interface CashoutPayoutCurrencyOption {
+    currency: PayoutCurrencyType;
+    rails: PayoutFiatRailType[];
+    rate: CashoutFxRate | null;
+    estimate: PayoutFiatValue | null;
+}
+export interface CashoutFiatPricing {
+    currency: PayoutOracleCurrencyType;
+    rate: CashoutFxRate | null;
+    unpaid: PayoutFiatValue | null;
+    listed: PayoutFiatValue | null;
+}
+/** GET /api/v1/cashout-checkout/:id/state (link token + Peer app login). */
+export interface CashoutCheckoutState {
+    payoutCurrencies: CashoutPayoutCurrencyOption[];
+    fiatPricing: CashoutFiatPricing | null;
+    /** Exact fiat while PAYING; null when there is no buyer payment or no known currency and bound rate. */
+    buyerPayment: PayoutFiatValue | null;
+    cashoutId: string;
+    status: PayoutStatusType;
+    walletAddress: string;
+    depositAmount: string | null;
+    /** Live from the escrow deposit; null before listing and once the listing is closed. */
+    remainingAmount: string | null;
+    buyerPaymentActive: boolean;
+    method: CashoutSarMethod | CashoutBuyerProofMethod | PayoutCryptoMethod | null;
+    /** Prefill from this player's last cashout on an available rail; never a deposit address. */
+    lastPayoutTarget: PayoutMethodView | null;
+    attempt: {
+        attemptId: string;
+        status: PayoutAttemptStatusType;
+        depositId: string | null;
+    } | null;
+    signer: {
+        signerId: string;
+        policyId: string;
+        attached: boolean;
+    };
+    /** What Pay is sending from the player's wallet right now; null when nothing is in flight. */
+    sending: CashoutSendingType | null;
+    /**
+     * The newest send of the current attempt (or of the last closed attempt while the cashout is back in FUNDED/READY) failed; a failed relist counts only while the cashout is listed.
+     * Also true when a Venmo or PayPal listing's Peer Pay group send failed and its listing was withdrawn (the cashout is back in FUNDED/READY).
+     */
+    lastSendFailed: boolean;
+    /** Set when the Peer wallet no longer covers this cashout (newest first, like the wallet job): what it needs and what is left for it after the player's older cashouts, in decimal USDC. Nothing is offered then: the wallet job closes it. */
+    walletShortfall: {
+        requiredAmount: string;
+        availableAmount: string;
+    } | null;
+    /** PARTIALLY_FUNDED means the merchant still owes a top-up; receivedAmount is the USDC that reached the player's wallet. */
+    funding: {
+        status: PayoutFundingStatusType;
+        receivedAmount: string | null;
+    };
+    /** Who ended it: MERCHANT before funding, PEER_APP when the player moved the money in the Peer app. */
+    cancelSource: PayoutCancelSourceType | null;
+    merchantReference: string | null;
+    /** Once settled: the delivering transaction and its chain. */
+    settleTx: {
+        chainId: number;
+        txHash: string;
+    } | null;
+    /** The newest attempt's newest bridge unless it is NOT_SENT. */
+    payoutBridge: CashoutPayoutBridgeView | null;
+    /** While a buyer pays, when that buyer was matched (ISO time). */
+    buyerMatchedAt: string | null;
+    /** Set once a buyer paid part of the cashout; decimal USDC. totalAmount is depositAmount. */
+    partialPayment: {
+        /** Fiat totals in first-paid order; null if any payment has an unknown currency or bound rate, [] if no buyer paid. */
+        paidFiat: PayoutFiatValue[] | null;
+        paidAmount: string;
+        unpaidAmount: string;
+        totalAmount: string;
+        /** What the live listing's deposit holds (cashoutDepositRemainingUnits); null when nothing is listed. Relist, withdraw and send amounts. */
+        listedAmount: string | null;
+        /**
+         * The listed deposit still takes new buyers (EscrowV2 `acceptingIntents`). False when nothing is listed, and when a
+         * withdraw landed while a buyer held the deposit (a send-to-address or change-method exit, or a Peer-app withdraw): the
+         * escrow then takes no new buyer, so the rest is never relisted and only an exit moves it.
+         */
+        acceptingBuyers: boolean;
+    } | null;
+    /** Only when status is SETTLED. */
+    settlement: PayoutSettlementBreakdown | null;
+    actions: CashoutPlayerActionType[];
+}
+export type SetCashoutPayoutMethodRequest = {
+    rail: typeof PayoutRail.VENMO | typeof PayoutRail.CASHAPP;
+    payeeHandle: string;
+}
+/** The App Clip checks the connected PayPal account against this email. */
+ | {
+    rail: typeof PayoutRail.PAYPAL;
+    payeeHandle: string;
+    paypalEmail: string;
+    currency: (typeof PAYOUT_RAIL_CURRENCIES)['paypal'][number];
+}
+/** The multi-currency rail carries the player's selected payout currency. */
+ | {
+    rail: typeof PayoutRail.REVOLUT;
+    payeeHandle: string;
+    currency: (typeof PAYOUT_RAIL_CURRENCIES)['revolut'][number];
+} | {
+    rail: typeof PayoutRail.ZELLE | typeof PayoutRail.CHIME;
+    payeeHandle: string;
+} | CashoutPayoutDestinationRequest;
+/** POST /api/v1/cashout-checkout/:id/send-to-address. The checkout requires the network tick box before sending. */
+export type SendCashoutToAddressRequest = CashoutPayoutDestinationRequest;
+export interface CashoutActivityItem {
+    cashoutId: string;
+    /** Only the player passing linkAuth and loginAuth may see this link to open their cashout. */
+    checkoutUrl: string;
+    payoutAmount: string;
+    /** The chosen payout app, or null before the player picks one. */
+    payoutRail: PayoutRailType | null;
+    status: PayoutStatusType;
+    createdAt: string;
+}
+export interface ListCashoutActivityResponse {
+    /** Only the player passing linkAuth and loginAuth may see the full recipient email identifying this list. */
+    email: string;
+    items: CashoutActivityItem[];
+    page: number;
+    limit: number;
+    total: number;
+}
 export {};