@zkp2p/pay-shared 4.0.1 → 6.0.0

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 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";
@@ -62,6 +63,7 @@ export type CheckoutMethodType = typeof CheckoutMethod[keyof typeof CheckoutMeth
 export declare const FeePayer: {
     readonly MERCHANT: "MERCHANT";
     readonly PAYEE: "PAYEE";
+    readonly SPLIT: "SPLIT";
 };
 export type FeePayerType = typeof FeePayer[keyof typeof FeePayer];
 export declare const MerchantPaymentFlowMode: {
@@ -147,11 +149,95 @@ export type SettlementReferralFeeEntry = {
     recipient: string;
     feeUsdc: string;
 };
+/** FIXED orders carry an amount from creation; OPEN orders get one when the buyer starts a payment. */
+export declare const OrderAmountMode: {
+    readonly FIXED: "FIXED";
+    readonly OPEN: "OPEN";
+};
+export type OrderAmountModeType = typeof OrderAmountMode[keyof typeof OrderAmountMode];
+/**
+ * Why the buyer can no longer change an open order's amount. Precedence when several apply:
+ * PAID, then PAYMENT_MAY_SETTLE, then PAYMENT_IN_PROGRESS.
+ */
+export declare const AmountLockReason: {
+    /** Only CREATED non-Zcash payments lock the amount; cancelling them unlocks it. */
+    readonly PAYMENT_IN_PROGRESS: "PAYMENT_IN_PROGRESS";
+    /** An EXPIRED payment, a locking Zcash payment or a reopenable FAILED Relay payment can still settle; cancelling cannot unlock it. */
+    readonly PAYMENT_MAY_SETTLE: "PAYMENT_MAY_SETTLE";
+    /** A SETTLED payment exists. */
+    readonly PAID: "PAID";
+};
+export type AmountLockReasonType = typeof AmountLockReason[keyof typeof AmountLockReason];
+export declare const OpenAmountErrorCode: {
+    readonly OPEN_AMOUNT_INVALID: "OPEN_AMOUNT_INVALID";
+    readonly OPEN_AMOUNT_DISABLED: "OPEN_AMOUNT_DISABLED";
+    readonly AMOUNT_REQUIRED: "AMOUNT_REQUIRED";
+    readonly AMOUNT_NOT_ALLOWED: "AMOUNT_NOT_ALLOWED";
+    readonly AMOUNT_OUT_OF_RANGE: "AMOUNT_OUT_OF_RANGE";
+    readonly AMOUNT_LOCKED: "AMOUNT_LOCKED";
+    readonly AMOUNT_CONFLICT: "AMOUNT_CONFLICT";
+    readonly RESIZE_NOT_SUPPORTED: "RESIZE_NOT_SUPPORTED";
+};
+export type OpenAmountErrorCodeType = typeof OpenAmountErrorCode[keyof typeof OpenAmountErrorCode];
+/** Merchant request shape. Amounts are positive decimals in `currency` with at most 2 decimals. */
+export type OpenAmountInput = {
+    currency: string;
+    minAmount?: string;
+    maxAmount?: string;
+    presets?: string[];
+};
+/** Stored + API shape (normalized: upper-case currency, 2-dp decimal strings, presets sorted asc, unique). */
+export type OpenAmountConfig = {
+    currency: string;
+    minAmount: string | null;
+    maxAmount: string | null;
+    presets: string[];
+};
+/** The buyer's saved amount and the currency they typed it in (the checkout's selected currency, which may differ from `openAmount.currency`). */
+export type OpenAmountSavedInput = {
+    amount: string;
+    currency: string;
+};
+/**
+ * Platform-quotes `openAmountDisplay` (amendment 2026-10-05): an unlocked open order's range and
+ * presets in the request's `fiatCurrency`. In the order's own currency the merchant's values are
+ * exact, cents kept; in any other currency they are whole units (minimum rounded up, maximum down,
+ * presets half-up and clamped into the range). The bounds and `currencyPerOrderUnit` are null, and
+ * `presets` is empty, when an exchange rate is unavailable.
+ */
+export type OpenAmountDisplay = {
+    currency: string;
+    effectiveMin: string | null;
+    effectiveMax: string | null;
+    presets: string[];
+    /** Units of `currency` one unit of `openAmount.currency` buys at the rates used, as a decimal string; null when unavailable. */
+    currencyPerOrderUnit: string | null;
+};
+/** Hosted (checkout) only. */
+export type HostedOpenAmount = OpenAmountConfig & {
+    /** In `currency`, 2 dp, rounded UP. Null while locked, once FULFILLED or CANCELLED, or when the live rate is unavailable. */
+    effectiveMin: string | null;
+    /** In `currency`, 2 dp, rounded DOWN. Null while locked, once FULFILLED or CANCELLED, or when the live rate is unavailable. */
+    effectiveMax: string | null;
+    /** The buyer's saved amount in the currency they typed it in, or null before the first payment start. */
+    savedInput: OpenAmountSavedInput | null;
+};
+/** `ORDER_AMOUNT_SET` webhook detail. */
+export type OrderAmountChange = {
+    previousAmountUsdc: string | null;
+    newAmountUsdc: string;
+    /** The amount the buyer typed, in the currency they typed it in (the checkout's selected currency). */
+    fiat: OpenAmountSavedInput;
+    amountVersion: number;
+};
 type CreateOrderRequestBase = {
+    idempotencyKey?: string;
     destinationAddress?: string;
     destinationToken?: string;
     destinationChainId?: number;
     feePayer?: FeePayerType;
+    /** SPLIT buyer share of total fees, in basis points (0–10000, steps of 1000). */
+    buyerFeeShareBps?: number;
     enabledRails?: string[];
     dynamicOrdersEnabled?: boolean;
     successUrl?: string | null;
@@ -162,13 +248,21 @@ type CreateOrderRequestWithUsdc = CreateOrderRequestBase & {
     requestedUsdcAmount: string;
     requestedFiatAmount?: never;
     requestedFiatCurrency?: never;
+    openAmount?: never;
 };
 type CreateOrderRequestWithFiat = CreateOrderRequestBase & {
     requestedUsdcAmount?: never;
     requestedFiatAmount: string;
     requestedFiatCurrency: string;
+    openAmount?: never;
 };
-export type CreateOrderRequest = CreateOrderRequestWithUsdc | CreateOrderRequestWithFiat;
+type CreateOrderRequestWithOpenAmount = CreateOrderRequestBase & {
+    requestedUsdcAmount?: never;
+    requestedFiatAmount?: never;
+    requestedFiatCurrency?: never;
+    openAmount: OpenAmountInput;
+};
+export type CreateOrderRequest = CreateOrderRequestWithUsdc | CreateOrderRequestWithFiat | CreateOrderRequestWithOpenAmount;
 export type CheckoutRequest = CreateOrderRequest;
 export type MerchantCheckoutTheme = {
     presetName?: 'default' | 'dark' | 'light' | 'custom';
@@ -196,7 +290,7 @@ export type CheckoutMerchant = {
     /** Whether the merchant has been verified by ZKP2P. */
     verified: boolean;
 };
-export type CheckoutOrder = {
+type CheckoutOrderBase = {
     id: string;
     merchantId: string;
     status: CheckoutOrderStatusType;
@@ -208,12 +302,18 @@ export type CheckoutOrder = {
     refundTransactionHash: string | null;
     refundMetadata: unknown | null;
     inPersonCheckout: boolean;
-    requestedUsdcAmount: string;
-    remainingUsdcAmount: string;
+    /**
+     * USDC the customer would be charged for the current outstanding balance if they
+     * paid by Apple Pay, grossed up by the merchant's Apple Pay fee when the payer
+     * owes it. Hosted aggregates only; null when Apple Pay is disabled or pricing
+     * cannot be resolved. Checkout hides Apple Pay when it is above the 2,500 USDC cap.
+     */
+    applePayChargeUsdcAmount?: string | null;
     destinationAddress: string;
     destinationToken: string;
     destinationChainId: string;
     feePayer: FeePayerType;
+    buyerFeeShareBps: number;
     enabledRails: string[];
     successUrl: string | null;
     cancelUrl: string | null;
@@ -231,7 +331,34 @@ export type CheckoutOrder = {
     createdAt: string;
     updatedAt: string | null;
 };
+export type FixedAmountCheckoutOrder = CheckoutOrderBase & {
+    amountMode: typeof OrderAmountMode.FIXED;
+    requestedUsdcAmount: string;
+    remainingUsdcAmount: string;
+};
+/** Amounts stay null until the buyer starts the first payment; `amountVersion` is 0 until then. */
+export type OpenAmountCheckoutOrder = CheckoutOrderBase & {
+    amountMode: typeof OrderAmountMode.OPEN;
+    requestedUsdcAmount: string | null;
+    remainingUsdcAmount: string | null;
+    openAmount: OpenAmountConfig;
+    amountVersion: number;
+};
+/** Narrow on `amountMode` before reading amounts. */
+export type CheckoutOrder = FixedAmountCheckoutOrder | OpenAmountCheckoutOrder;
+/** Hosted aggregate shape of an open order: effective range, saved input and lock state. */
+export type HostedOpenAmountCheckoutOrder = Omit<OpenAmountCheckoutOrder, 'openAmount'> & {
+    openAmount: HostedOpenAmount;
+    /** Computed server-side from the order's payments; null means the buyer may change the amount. */
+    amountLock: AmountLockReasonType | null;
+};
+export type HostedCheckoutOrder = FixedAmountCheckoutOrder | HostedOpenAmountCheckoutOrder;
 export type CheckoutPaymentQuote = {
+    /** Full-size economics when Peer funds a smaller executable intent. */
+    amountAdjustment?: {
+        requestedSignalAmountRaw: string;
+        buyerFiatAmount: string;
+    };
     conversionRate?: string;
     signalIntent: {
         processorName: string;
@@ -266,6 +393,8 @@ export type CheckoutNearbySuggestion = {
     tokenAmount: string;
     percentDifference: string;
     rail: string;
+    /** Open-amount orders only: the suggestion in the quote's `fiatCurrency`, 2 dp, rounded down. */
+    inputAmount?: string;
 };
 export type CheckoutNearbySuggestions = {
     status: 'suggestions' | 'none' | 'ineligible' | 'unavailable';
@@ -308,6 +437,31 @@ export type CheckoutQuotes = {
     fiatCurrency: string;
     platforms: CheckoutQuoteEntry[];
     nearbySuggestions?: CheckoutNearbySuggestions;
+    /** Open order with no saved amount and no `amount` query parameter: `platforms` is empty. */
+    amountRequired?: true;
+    /** Open orders, when `amount` (in `fiatCurrency`) was sent: the draft converted to USDC. */
+    amountUsdc?: string;
+    /** Open orders, when `amount` was sent: Apple Pay pricing of the draft. */
+    applePay?: {
+        chargeUsdcAmount: string | null;
+        eligible: boolean;
+    };
+    /** Unlocked open orders that are not fulfilled or cancelled, with or without `amount`: the range and presets in `fiatCurrency`. */
+    openAmountDisplay?: OpenAmountDisplay;
+};
+export declare const PaymentPenaltyKind: {
+    readonly PURCHASE_PROTECTION: "PURCHASE_PROTECTION";
+    readonly CROSS_CURRENCY: "CROSS_CURRENCY";
+};
+export type PaymentPenaltyKindType = (typeof PaymentPenaltyKind)[keyof typeof PaymentPenaltyKind];
+/** One attestation-applied reduction of the credited fiat amount. Amounts are in the payment's `currency`. */
+export type PaymentPenalty = {
+    kind: PaymentPenaltyKindType;
+    penaltyBps: number;
+    /** Pre-penalty amount in `payment.currency`, 2-decimal string. */
+    originalAmount: string;
+    /** Post-penalty amount actually credited, same units. */
+    attestedAmount: string;
 };
 export type CheckoutPayment = {
     id: string;
@@ -315,6 +469,7 @@ export type CheckoutPayment = {
     status: CheckoutPaymentStatusType;
     chargebackStatus: PaymentChargebackStatusType;
     chargeback: PaymentChargebackFact | null;
+    penalties: PaymentPenalty[];
     rail: string;
     paymentMethodId: string | null;
     proofMode: ProofMode;
@@ -346,15 +501,25 @@ export type CheckoutAggregatePayment = Omit<CheckoutPayment, 'paymentMethodId'>
     paymentMethodId?: string | null;
 };
 export type CheckoutAggregate = {
-    order: CheckoutOrder;
+    order: HostedCheckoutOrder;
     merchant: CheckoutMerchant;
     currentPayment: CheckoutAggregatePayment | null;
 };
+/** Public GET /api/v1/orders/:orderId responseObject. */
+export type HostedCheckoutResponse = CheckoutAggregate & {
+    paymentCreationPaused: boolean;
+};
 export type CreateOrderResponse = {
     order: CheckoutOrder;
+} & ({
     orderToken: string;
-};
-export type CreatePaymentRequest = {
+    idempotentReplay?: never;
+} | {
+    orderToken: null;
+    idempotentReplay: true;
+});
+type CreatePaymentRequestBase = {
+    onrampProvider?: 'coinbase_apple_pay';
     rail: string;
     paymentMethodId?: string;
     fiatCurrency?: string;
@@ -364,6 +529,23 @@ export type CreatePaymentRequest = {
     excludedPayToValues?: string[];
     refundTo?: string;
 };
+/**
+ * Open-amount orders: `amount`, the fiat `amountCurrency` it is typed in (the checkout's selected
+ * currency, sent on crypto and Apple Pay starts too) and the `amountVersion` the buyer loaded travel
+ * together, or not at all.
+ * On fiat rails, starts with `amount` require `fiatCurrency` to equal `amountCurrency`;
+ * omitted `fiatCurrency` means USD. A mismatch returns HTTP 400. Crypto and Apple Pay
+ * starts are exempt from this check.
+ */
+export type CreatePaymentRequest = CreatePaymentRequestBase & ({
+    amount?: never;
+    amountCurrency?: never;
+    expectedAmountVersion?: never;
+} | {
+    amount: string;
+    amountCurrency: string;
+    expectedAmountVersion: number;
+});
 export type CheckoutPaymentCreationResponse = CheckoutPayment & {
     relayerTransactionId?: string;
     recipientRecovery?: 'matched' | 'missed' | 'not_applicable';
@@ -371,9 +553,9 @@ export type CheckoutPaymentCreationResponse = CheckoutPayment & {
 export type PaymentDeeplinkResponse = {
     paymentId: string;
     orderId: string;
-    intentHash: string;
+    intentHash: string | null;
     url: string;
-    proofSubmissionUrl: string;
+    proofSubmissionUrl: string | null;
     checkoutReturnUrl: string;
     linkKind?: 'app_clip' | 'deeplink';
 };
@@ -382,7 +564,9 @@ export type MerchantConfig = {
     id: string;
     merchantId: string;
     feePayer: FeePayerType;
+    buyerFeeShareBps: number;
     enabledRails: string[];
+    applePayAvailable: boolean;
     defaultPaymentCurrency: string | null;
     destinationChainId: string;
     destinationToken: string;
@@ -393,15 +577,27 @@ export type MerchantConfig = {
     platformReferralFeeConfig: ReferralFeeConfig | null;
     referralSplitConfig: ReferralSplitConfig | null;
     flatFeePricing: boolean;
+    /** Admin-managed: this merchant may create Master Merchant Account sub-merchants. */
+    masterMerchantEnabled: boolean;
+    /** Admin-managed cap, in bps, for the master merchant fee on this merchant's sub-merchants; null means no Master Merchant Account-specific cap. */
+    masterMerchantMaxFeeBps: number | null;
     createdAt: string;
     updatedAt: string | null;
 };
+export declare const MerchantUserRole: {
+    readonly OWNER: "OWNER";
+    readonly MANAGER: "MANAGER";
+    readonly CASHIER: "CASHIER";
+};
+export type MerchantUserRoleType = typeof MerchantUserRole[keyof typeof MerchantUserRole];
 export type MerchantUser = {
     id: string;
     email: string | null;
     privyUserId: string | null;
     v1PrivyUserId: string | null;
-    role: 'OWNER' | 'MANAGER' | 'CASHIER';
+    role: MerchantUserRoleType;
+    /** Master Merchant Account seat after an ownership transfer: it cannot be removed by merchant users, only by an admin. */
+    removalLocked: boolean;
     merchantId: string | null;
     createdAt: string;
     updatedAt: string | null;
@@ -417,6 +613,8 @@ export type MerchantProfile = {
     onboardingCompletedAt: string | null;
     onboardingSkippedAt: string | null;
     apiKey: string;
+    /** Canonical IPv4/IPv6 CIDR entries allowed to use the API key; empty means the allowlist is off. */
+    apiKeyIpAllowlist: string[];
     environment: MerchantEnvironmentType;
     sandboxMerchantId: string | null;
     inPersonCheckoutEnabled: boolean;
@@ -425,12 +623,16 @@ export type MerchantProfile = {
     v1EvmWalletAddress: string | null;
     v1SolanaWalletAddress: string | null;
     tier: MerchantTierName | null;
+    /** The Master Merchant Account merchant that created this sub-merchant; null for every other merchant. */
+    masterMerchantId: string | null;
     createdAt: string;
     updatedAt: string | null;
     merchantConfig: MerchantConfig | null;
     merchantUsers: MerchantUser[];
 };
+export declare const PAYMENT_CREATION_PAUSED_MESSAGE = "Payments are temporarily paused. Please try again shortly.";
 export declare const OrderErrorCode: {
+    readonly PAYMENTS_PAUSED: "PAYMENTS_PAUSED";
     readonly PROOF_INVALID: "PROOF_INVALID";
     readonly PROOF_EXPIRED: "PROOF_EXPIRED";
     readonly PROOF_RECIPIENT_MISMATCH: "PROOF_RECIPIENT_MISMATCH";
@@ -443,6 +645,7 @@ export declare const OrderErrorCode: {
     readonly ATTESTATION_ERROR: "ATTESTATION_ERROR";
     readonly BRIDGE_TIMEOUT: "BRIDGE_TIMEOUT";
     readonly FEE_THRESHOLD_EXCEEDED: "FEE_THRESHOLD_EXCEEDED";
+    readonly INTENT_ABOVE_MAX: "INTENT_ABOVE_MAX";
     readonly SDK_ERROR: "SDK_ERROR";
     readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
 };
@@ -691,7 +894,14 @@ export type StartSessionRequest = {
     originToken: PayCryptoTokenSymbol;
 };
 export type RelayCryptoPaymentStatus = 'refund' | 'delayed' | 'waiting' | 'failure' | 'pending' | 'success';
+export type NearIntentsPaymentDetails = {
+    status: 'PENDING_DEPOSIT' | 'KNOWN_DEPOSIT_TX' | 'INCOMPLETE_DEPOSIT' | 'PROCESSING' | 'SUCCESS' | 'REFUNDED' | 'FAILED';
+    deadline: string;
+    refundAddress: string;
+    refundedAmount?: string;
+};
 export type CheckoutCryptoPayment = {
+    nearIntents?: NearIntentsPaymentDetails;
     requestId: string;
     status: RelayCryptoPaymentStatus;
     depositAddress: string;
@@ -788,6 +998,12 @@ export type OnboardingStepState = {
     status: OnboardingStepStatusValue;
     verifiedBy: OnboardingStepVerifiedByValue;
 };
+/**
+ * responseObject of GET /api/v1/merchants/dashboard/me/onboarding,
+ * POST /api/v1/merchants/dashboard/me/onboarding/steps/:stepId/ack, and
+ * POST /api/v1/merchants/dashboard/me/onboarding/skip.
+ * For POST routes, this is the state after the write is applied.
+ */
 export type MerchantOnboardingResponse = {
     path: MerchantIntegrationPathValue | null;
     sandboxApiKey: string | null;
@@ -795,11 +1011,25 @@ export type MerchantOnboardingResponse = {
     skippedAt: string | null;
     steps: OnboardingStepState[];
 };
+export declare const MERCHANT_REFERRAL_FEE_BPS_BY_TIER: Readonly<Record<MerchantTierName, number>>;
+export type MerchantReferralReferredMerchant = {
+    id: string;
+    name: string;
+    createdAt: string;
+};
+export type MerchantReferralProgramResponse = {
+    code: string;
+    referralFeeBpsByTier: Readonly<Record<MerchantTierName, number>>;
+    recipientAddress: string;
+    totalReferred: number;
+    referredMerchants: MerchantReferralReferredMerchant[];
+};
 export declare const WebhookEventType: {
     readonly ORDER_CREATED: "ORDER_CREATED";
     readonly ORDER_FULFILLED: "ORDER_FULFILLED";
     readonly ORDER_CANCELLED: "ORDER_CANCELLED";
     readonly ORDER_RESIZED: "ORDER_RESIZED";
+    readonly ORDER_AMOUNT_SET: "ORDER_AMOUNT_SET";
     readonly PAYMENT_CREATED: "PAYMENT_CREATED";
     readonly PAYMENT_SETTLED: "PAYMENT_SETTLED";
     readonly PAYMENT_CANCELLED: "PAYMENT_CANCELLED";
@@ -814,8 +1044,21 @@ export declare const WebhookEventType: {
     readonly PAYMENT_CHARGEBACKED: "PAYMENT_CHARGEBACKED";
     readonly ORDER_PARTIALLY_CHARGEBACKED: "ORDER_PARTIALLY_CHARGEBACKED";
     readonly ORDER_CHARGEBACKED: "ORDER_CHARGEBACKED";
+    readonly CASHOUT_ORDER_CREATED: "CASHOUT_ORDER_CREATED";
+    readonly CASHOUT_ORDER_CANCELLED: "CASHOUT_ORDER_CANCELLED";
+    readonly CASHOUT_ORDER_PARTIALLY_FUNDED: "CASHOUT_ORDER_PARTIALLY_FUNDED";
+    readonly CASHOUT_ORDER_FUNDED: "CASHOUT_ORDER_FUNDED";
+    readonly CASHOUT_ORDER_MATCHED: "CASHOUT_ORDER_MATCHED";
+    readonly CASHOUT_ORDER_PARTIALLY_PAID: "CASHOUT_ORDER_PARTIALLY_PAID";
+    readonly CASHOUT_ORDER_SETTLED: "CASHOUT_ORDER_SETTLED";
+    readonly CASHOUT_ORDER_EXPIRED: "CASHOUT_ORDER_EXPIRED";
 };
 export type WebhookEventTypeValue = typeof WebhookEventType[keyof typeof WebhookEventType];
+/** Cashout events carry a CashoutView, not the order envelope. */
+export declare const CASHOUT_WEBHOOK_EVENT_TYPES: readonly ["CASHOUT_ORDER_CREATED", "CASHOUT_ORDER_CANCELLED", "CASHOUT_ORDER_PARTIALLY_FUNDED", "CASHOUT_ORDER_FUNDED", "CASHOUT_ORDER_MATCHED", "CASHOUT_ORDER_PARTIALLY_PAID", "CASHOUT_ORDER_SETTLED", "CASHOUT_ORDER_EXPIRED"];
+export type CashoutWebhookEventTypeValue = typeof CASHOUT_WEBHOOK_EVENT_TYPES[number];
+export type OrderWebhookEventTypeValue = Exclude<WebhookEventTypeValue, CashoutWebhookEventTypeValue>;
+export declare function isCashoutWebhookEventType(type: string): type is CashoutWebhookEventTypeValue;
 export declare const WebhookDeliveryStatus: {
     readonly PENDING: "PENDING";
     readonly DELIVERED: "DELIVERED";
@@ -848,9 +1091,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;
@@ -868,8 +1111,49 @@ export type WebhookPayload = {
             previousAmountUsdc: string;
             newAmountUsdc: string;
         };
+        /** Only on `ORDER_AMOUNT_SET`. */
+        amountChange?: OrderAmountChange;
+    };
+};
+/** Bumped only on a breaking change to a cashout payload. */
+export declare const CASHOUT_WEBHOOK_VERSION = 1;
+/** One buyer payment that left part of the cashout unpaid; decimal USDC. */
+export interface CashoutPartialPayment {
+    /** The cashout'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;
     };
+}
+export type CashoutWebhookEventData = {
+    readonly type: Exclude<CashoutWebhookEventTypeValue, typeof WebhookEventType.CASHOUT_ORDER_PARTIALLY_PAID>;
+    readonly data: CashoutView;
+} | {
+    readonly type: typeof WebhookEventType.CASHOUT_ORDER_PARTIALLY_PAID;
+    readonly data: CashoutView;
+    readonly partialPayment: CashoutPartialPayment;
+};
+export type CashoutWebhookPayload = {
+    id: string;
+    type: Exclude<CashoutWebhookEventTypeValue, typeof WebhookEventType.CASHOUT_ORDER_PARTIALLY_PAID>;
+    timestamp: string;
+    version: typeof CASHOUT_WEBHOOK_VERSION;
+    data: CashoutView;
+} | {
+    id: string;
+    type: typeof WebhookEventType.CASHOUT_ORDER_PARTIALLY_PAID;
+    timestamp: string;
+    version: typeof CASHOUT_WEBHOOK_VERSION;
+    data: CashoutView;
+    partialPayment: CashoutPartialPayment;
 };
+export type WebhookPayload = OrderWebhookPayload | CashoutWebhookPayload;
+export declare function isCashoutWebhook(payload: WebhookPayload): payload is CashoutWebhookPayload;
 export type CreateWebhookRequest = {
     url: string;
     events?: WebhookEventTypeValue[];
@@ -897,4 +1181,687 @@ export type TestWebhookResponse = {
     responseCode?: number | null;
     error?: string | null;
 };
+/**
+ * Wallet-snapshot fence rejections (ownership-transfer era rule). PR 4-6 add keys to this object.
+ * MERCHANT_OWNERSHIP_CHANGED is retryable: an order insert lost the era it read its wallet in.
+ * ORDER_FROM_PREVIOUS_OWNER is final: the order belongs to an earlier owner's era.
+ */
+export declare const MerchantOwnershipErrorCode: {
+    readonly MERCHANT_OWNERSHIP_CHANGED: "MERCHANT_OWNERSHIP_CHANGED";
+    readonly ORDER_FROM_PREVIOUS_OWNER: "ORDER_FROM_PREVIOUS_OWNER";
+    readonly MEMBER_LOCKED: "MEMBER_LOCKED";
+    /** 403: the current merchant is not an enabled, LIVE, eligible Master Merchant Account. */
+    readonly MASTER_MERCHANT_NOT_ENABLED: "MASTER_MERCHANT_NOT_ENABLED";
+    /** 422: the master merchant fee is above the Master Merchant Account's masterMerchantMaxFeeBps, only when the Master Merchant Account has a cap. */
+    readonly MASTER_MERCHANT_FEE_EXCEEDS_CAP: "MASTER_MERCHANT_FEE_EXCEEDS_CAP";
+    /** 422: a payment method's configured fees for some amount band would exceed the max fee. */
+    readonly MASTER_MERCHANT_FEE_EXCEEDS_MAX_FEE: "MASTER_MERCHANT_FEE_EXCEEDS_MAX_FEE";
+    /** 409: the Master Merchant Account can no longer change this sub merchant's fee (transferred, or a transfer is pending). */
+    readonly MASTER_MERCHANT_FEE_LOCKED: "MASTER_MERCHANT_FEE_LOCKED";
+    readonly TRANSFER_ALREADY_PENDING: "TRANSFER_ALREADY_PENDING";
+    readonly WALLET_SETUP_REQUIRED: "WALLET_SETUP_REQUIRED";
+    readonly TERMS_CHANGED: "TERMS_CHANGED";
+    readonly TRANSFER_NOT_FOUND: "TRANSFER_NOT_FOUND";
+    readonly TRANSFER_EMAIL_MISMATCH: "TRANSFER_EMAIL_MISMATCH";
+    readonly TRANSFER_UNAVAILABLE: "TRANSFER_UNAVAILABLE";
+};
+export type MerchantOwnershipErrorCodeType = typeof MerchantOwnershipErrorCode[keyof typeof MerchantOwnershipErrorCode];
+export declare const MERCHANT_OWNERSHIP_CHANGED_MESSAGE = "The merchant account changed owners while this order was being created. Retry to create it for the new owner.";
+export declare const ORDER_FROM_PREVIOUS_OWNER_MESSAGE = "This order was created before the merchant account changed owners. Ask the merchant for a new payment link.";
+export declare const ORDER_FROM_PREVIOUS_OWNER_REFUND_MESSAGE = "This order was created before the merchant account changed owners, so it cannot be refunded from this account.";
+/** Response copy for MEMBER_LOCKED: the Master Merchant Account seat after an ownership transfer can only be removed by an admin. */
+export declare const MEMBER_LOCKED_MESSAGE = "Locked merchant member can only be removed by an admin";
+export type OwnershipTransferErrorCodeType = typeof MerchantOwnershipErrorCode.TRANSFER_ALREADY_PENDING | typeof MerchantOwnershipErrorCode.WALLET_SETUP_REQUIRED | typeof MerchantOwnershipErrorCode.TERMS_CHANGED | typeof MerchantOwnershipErrorCode.TRANSFER_NOT_FOUND | typeof MerchantOwnershipErrorCode.TRANSFER_EMAIL_MISMATCH | typeof MerchantOwnershipErrorCode.TRANSFER_UNAVAILABLE;
+/** One user-facing message per ownership-transfer error; the API and the CLI simulator both send these. */
+export declare const OWNERSHIP_TRANSFER_ERROR_MESSAGES: Readonly<Record<OwnershipTransferErrorCodeType, string>>;
+/**
+ * Routing states POST /auth/login returns (HTTP 200, `merchant: null`) instead of auto-claiming an
+ * invite or auto-creating a merchant, while an ownership transfer applies to a user with no merchant.
+ */
+export declare const OwnershipTransferLoginState: {
+    readonly PENDING_OWNERSHIP_TRANSFER: "PENDING_OWNERSHIP_TRANSFER";
+    readonly OWNERSHIP_TRANSFER_EMAIL_MISMATCH: "OWNERSHIP_TRANSFER_EMAIL_MISMATCH";
+    readonly OWNERSHIP_TRANSFER_UNAVAILABLE: "OWNERSHIP_TRANSFER_UNAVAILABLE";
+};
+export type OwnershipTransferLoginStateType = typeof OwnershipTransferLoginState[keyof typeof OwnershipTransferLoginState];
+/** Discriminator of POST /auth/ownership-transfers/preview. EMAIL_MISMATCH is the spec's `emailMatches: false`. */
+export declare const OwnershipTransferPreviewState: {
+    readonly PENDING: "PENDING";
+    readonly EMAIL_MISMATCH: "EMAIL_MISMATCH";
+    readonly ACCEPTED: "ACCEPTED";
+};
+export type OwnershipTransferPreviewStateType = typeof OwnershipTransferPreviewState[keyof typeof OwnershipTransferPreviewState];
+/** Mirrors the Prisma enum MerchantOwnershipTransferStatus for pure (Prisma-free) wire schemas. */
+export declare const OwnershipTransferStatus: {
+    readonly PENDING: "PENDING";
+    readonly ACCEPTED: "ACCEPTED";
+    readonly CANCELLED: "CANCELLED";
+    readonly EXPIRED: "EXPIRED";
+};
+export type OwnershipTransferStatusType = typeof OwnershipTransferStatus[keyof typeof OwnershipTransferStatus];
+export declare const MerchantOwnershipTransferCancelReason: {
+    readonly MASTER_MERCHANT_CANCELLED: "MASTER_MERCHANT_CANCELLED";
+    readonly TERMS_CHANGED: "TERMS_CHANGED";
+    readonly MASTER_MERCHANT_FLAG_REMOVED: "MASTER_MERCHANT_FLAG_REMOVED";
+};
+export type MerchantOwnershipTransferCancelReasonType = typeof MerchantOwnershipTransferCancelReason[keyof typeof MerchantOwnershipTransferCancelReason];
+export declare const OwnershipTransferMasterMerchantPermission: {
+    readonly CHECKOUT_CONFIG: "CHECKOUT_CONFIG";
+    readonly TEAM: "TEAM";
+};
+export type OwnershipTransferMasterMerchantPermissionType = typeof OwnershipTransferMasterMerchantPermission[keyof typeof OwnershipTransferMasterMerchantPermission];
+/** What the Master Merchant Account's locked MANAGER seat keeps after a transfer (spec decisions 2 and 9; refunds are OWNER-only); the accept page lists exactly these. */
+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 CashoutStatus: {
+    readonly AWAITING_FUNDING: "AWAITING_FUNDING";
+    readonly FUNDED: "FUNDED";
+    readonly READY: "READY";
+    readonly LISTING: "LISTING";
+    readonly PAYING: "PAYING";
+    readonly SETTLED: "SETTLED";
+    readonly CANCELLING: "CANCELLING";
+    readonly CANCELLED: "CANCELLED";
+    readonly EXPIRED: "EXPIRED";
+};
+export type CashoutStatusType = typeof CashoutStatus[keyof typeof CashoutStatus];
+export declare const CashoutFundingStatus: {
+    readonly AWAITING_FUNDING: "AWAITING_FUNDING";
+    readonly PARTIALLY_FUNDED: "PARTIALLY_FUNDED";
+    readonly FUNDED: "FUNDED";
+    readonly FUNDING_EXPIRED: "FUNDING_EXPIRED";
+};
+export type CashoutFundingStatusType = typeof CashoutFundingStatus[keyof typeof CashoutFundingStatus];
+export declare const CashoutCancelSource: {
+    readonly CHECKOUT: "CHECKOUT";
+    readonly MERCHANT: "MERCHANT";
+    readonly PEER_APP: "PEER_APP";
+};
+export type CashoutCancelSourceType = typeof CashoutCancelSource[keyof typeof CashoutCancelSource];
+export declare const CashoutPayoutKind: {
+    readonly ESCROW: "ESCROW";
+    readonly CRYPTO: "CRYPTO";
+};
+export type CashoutPayoutKindType = typeof CashoutPayoutKind[keyof typeof CashoutPayoutKind];
+export declare const CashoutAttemptStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CLOSED: "CLOSED";
+    readonly SETTLED: "SETTLED";
+    readonly FAILED: "FAILED";
+};
+export type CashoutAttemptStatusType = typeof CashoutAttemptStatus[keyof typeof CashoutAttemptStatus];
+/** Fiat payout methods, in the order players see them: SAR rails, then buyer-proof rails. */
+export declare const CashoutFiatRail: {
+    readonly VENMO: "venmo";
+    readonly CASHAPP: "cashapp";
+    readonly PAYPAL: "paypal";
+    readonly ZELLE: "zelle";
+    readonly REVOLUT: "revolut";
+    readonly CHIME: "chime";
+};
+export type CashoutFiatRailType = typeof CashoutFiatRail[keyof typeof CashoutFiatRail];
+/** 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 CashoutCryptoRail: {
+    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 CashoutCryptoRailType = typeof CashoutCryptoRail[keyof typeof CashoutCryptoRail];
+/** Every cashout rail, in rail order: fiat, then the crypto networks. */
+export declare const CashoutRail: {
+    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 CashoutRailType = CashoutFiatRailType | CashoutCryptoRailType;
+/** Fiat rails whose account the player connects so Peer can confirm buyer payments; derived from SAR_SUPPORTED_FIAT_RAILS. */
+export type CashoutSarRailType = Extract<CashoutFiatRailType, SarSupportedFiatRail>;
+/** Fiat rails with no connect step: the buyer proves the payment with the PeerAuth extension or the Peer app. */
+export type CashoutBuyerProofRailType = Exclude<CashoutFiatRailType, CashoutSarRailType>;
+export declare const CashoutPayoutProvider: {
+    readonly RELAY: "RELAY";
+    readonly NEAR_INTENTS: "NEAR_INTENTS";
+};
+export type CashoutPayoutProviderType = typeof CashoutPayoutProvider[keyof typeof CashoutPayoutProvider];
+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 CashoutCryptoDestination {
+    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: CashoutCryptoRailType;
+    tokenAddress: string;
+    address: string;
+}
+/** A crypto payout method: the network's rail and where on it the player takes the payout. */
+export interface CashoutCryptoMethod {
+    rail: CashoutCryptoRailType;
+    destination: CashoutCryptoDestination;
+}
+/** POST /api/v1/cashout-checkout/:id/payout-quote. Not a promise. */
+export interface CashoutPayoutQuote {
+    destination: CashoutCryptoDestination;
+    /** 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: CashoutPayoutProviderType;
+    status: Exclude<CashoutPayoutBridgeStatusType, typeof CashoutPayoutBridgeStatus.NOT_SENT>;
+    destination: CashoutCryptoDestination;
+    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 CashoutPartialFillView {
+    /** Decimal USDC this buyer paid. */
+    amount: string;
+    txHash: string;
+    paidAt: string;
+}
+/** Where a SETTLED cashout's USDC ended up; decimal USDC, "0.00" for a part that did not happen. */
+export interface CashoutSettlementBreakdown {
+    /** Paid by buyers through the escrow, across every listing. */
+    buyerPaidAmount: string;
+    /** 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 cashout. Never includes the Peer fee, the player's email, wallet or payee handle. */
+export interface CashoutView {
+    cashoutId: string;
+    merchantReference: string | null;
+    status: CashoutStatusType;
+    fundingStatus: CashoutFundingStatusType;
+    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 cashout 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: CashoutPartialFillView[];
+    /** Only when status is SETTLED. */
+    settlement: CashoutSettlementBreakdown | null;
+    attempt: {
+        kind: CashoutPayoutKindType;
+        rail: string | null;
+        status: CashoutAttemptStatusType;
+    } | 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: CashoutPayoutProviderType | null;
+    } | null;
+    cancelSource: CashoutCancelSourceType | null;
+    returnUrl: string | null;
+    expiresAt: string;
+    fundedAt: string | null;
+    settledAt: string | null;
+    cancelledAt: string | null;
+    createdAt: string;
+}
+export interface CreateCashoutRequest {
+    merchantReference?: string;
+    customerEmail: string;
+    payout: {
+        amount: string;
+        chainId: number;
+        tokenAddress: string;
+    };
+    funding: {
+        chainId: number;
+        tokenAddress: string;
+        refundAddress?: string;
+    };
+    returnUrl?: string;
+    /** Limits the cashout to these rails; never widens the merchant's (any-coin spec "Cashout rails"). */
+    rails?: CashoutRailType[];
+}
+/** A replay with the same key and body returns the current checkout link, marked `idempotentReplay: true`. */
+export type CreateCashoutResponse = CashoutView & {
+    checkoutUrl: string;
+    idempotentReplay: boolean;
+};
+export interface ListCashoutsResponse {
+    items: CashoutView[];
+    page: number;
+    limit: number;
+    total: number;
+}
+/** A moment on a cashout's dashboard timeline. */
+export declare const CashoutTimelineEventType: {
+    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";
+    readonly CANCEL_STARTED: "CANCEL_STARTED";
+    /** 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 CashoutTimelineEventTypeValue = typeof CashoutTimelineEventType[keyof typeof CashoutTimelineEventType];
+/** Largest merchant cashout payout step, in whole USDC. The smallest is the API's CASHOUT_MIN_USDC (10 in production). */
+export declare const CASHOUT_PAYOUT_STEP_MAX_USDC = 1000;
+/** Whole-USDC bounds for a merchant's cashout payout step in this environment. */
+export interface CashoutPayoutStepRange {
+    min: number;
+    max: number;
+}
+/** A merchant's cashout settings; the Peer fee is not the merchant's to see. */
+export interface CashoutSettings {
+    rails: CashoutRailType[];
+    /** 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 CashoutFundingIssueKind: {
+    readonly LATE_FUNDS: "LATE_FUNDS";
+    readonly OVERPAYMENT: "OVERPAYMENT";
+    readonly ROUTE_REFUND: "ROUTE_REFUND";
+};
+export type CashoutFundingIssueKindType = typeof CashoutFundingIssueKind[keyof typeof CashoutFundingIssueKind];
+export declare const CashoutFundingIssueResolution: {
+    readonly RETURNED: "RETURNED";
+    readonly CLAIMED: "CLAIMED";
+};
+export type CashoutFundingIssueResolutionType = typeof CashoutFundingIssueResolution[keyof typeof CashoutFundingIssueResolution];
+/** A funding token as offered to a merchant: `key` is "chainId:lowercaseAddress". */
+export interface CashoutFundingTokenOption {
+    key: string;
+    chainId: number;
+    address: string;
+    symbol: string;
+}
+/** GET /merchants/me/cashout-settings: the saved settings plus what Peer currently allows. */
+export interface CashoutSettingsView extends CashoutSettings {
+    availableRails: CashoutRailType[];
+    availableFundingTokens: CashoutFundingTokenOption[];
+    payoutStepRange: CashoutPayoutStepRange;
+}
+/** Merchant-facing; never includes the admin's note or name. */
+export interface MerchantCashoutFundingIssue {
+    kind: CashoutFundingIssueKindType;
+    /** Decimal USDC; null for a route refund, which is paid back in the origin token. */
+    amountUsdc: string | null;
+    txHash: string | null;
+    detectedAt: string;
+    resolution: CashoutFundingIssueResolutionType | null;
+    resolutionTxHash: string | null;
+    resolvedAt: string | null;
+}
+export type CashoutPayoutMethodView = {
+    rail: CashoutFiatRailType;
+    handle: string;
+} | CashoutCryptoMethod;
+/** The dashboard's cashout: the API view plus what only the merchant's staff may see. */
+export interface MerchantCashoutView extends CashoutView {
+    /** The player's email as given at create, stored lower-cased. */
+    customerEmail: string;
+    payoutMethod: CashoutPayoutMethodView | null;
+    /** Null once the cashout is final. */
+    checkoutUrl: string | null;
+}
+export interface CashoutTimelineEntry {
+    type: CashoutTimelineEventTypeValue;
+    text: string;
+    txHash: string | null;
+    /** The chain txHash is on; null when txHash isn't linked. */
+    txChainId: number | null;
+    occurredAt: string;
+}
+export interface CashoutWebhookDeliveryView {
+    eventType: string;
+    status: string;
+    attempts: number;
+    responseCode: number | null;
+    lastAttemptAt: string | null;
+    createdAt: string;
+}
+export interface MerchantCashoutDetail {
+    cashout: MerchantCashoutView;
+    timeline: CashoutTimelineEntry[];
+    /** Not stored: what happens next from the current status, or null when final. */
+    nextStep: string | null;
+    webhooks: CashoutWebhookDeliveryView[];
+    fundingIssues: MerchantCashoutFundingIssue[];
+}
+/** The dashboard's create form result; a replay returns the same cashout and its current link. */
+export type CreateMerchantCashoutResponse = MerchantCashoutView & {
+    idempotentReplay: boolean;
+};
+export interface ListMerchantCashoutsResponse {
+    items: MerchantCashoutView[];
+    page: number;
+    limit: number;
+    total: number;
+}
+export interface AdminCashoutSettings {
+    disabledRails: CashoutRailType[];
+    disabledFundingTokens: string[];
+    peerFeeRecipient: string;
+    supportedFundingTokens: CashoutFundingTokenOption[];
+    updatedAt: string;
+}
+export interface AdminCashoutMerchantConfig {
+    merchantId: string;
+    peerFeeBps: number;
+    payoutStepUsdc: number;
+    payoutStepRange: CashoutPayoutStepRange;
+    fundingTokens: string[];
+    /** Merchant cashout rails, edited by the merchant and Peer admins, in rail order. */
+    rails: CashoutRailType[];
+    /** 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: CashoutRailType[];
+    merchantFeeBps: number;
+    merchantFeeRecipient: string | null;
+}
+export interface AdminCashoutFundingIssue extends MerchantCashoutFundingIssue {
+    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 CANCEL: "CANCEL";
+    readonly FINISH_CANCEL: "FINISH_CANCEL";
+    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: CashoutRailType;
+    /** 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 {
+    rail: CashoutSarRailType;
+    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 {
+    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: CashoutStatusType;
+    rails: CashoutRailOption[];
+    returnUrl: string | null;
+}
+/** GET /api/v1/cashout-checkout/:id/state (link token + Peer app login). */
+export interface CashoutCheckoutState {
+    cashoutId: string;
+    status: CashoutStatusType;
+    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 | CashoutCryptoMethod | null;
+    /** Prefill from this player's last cashout on an available rail; never a deposit address. */
+    lastPayoutTarget: CashoutPayoutMethodView | null;
+    attempt: {
+        attemptId: string;
+        status: CashoutAttemptStatusType;
+        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. Only CANCEL is offered then. */
+    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: CashoutFundingStatusType;
+        receivedAmount: string | null;
+    };
+    /** Who cancelled; PEER_APP when the player took the cashout back in the Peer app. */
+    cancelSource: CashoutCancelSourceType | 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: {
+        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: CashoutSettlementBreakdown | null;
+    actions: CashoutPlayerActionType[];
+}
+export type SetCashoutPayoutMethodRequest = {
+    rail: typeof CashoutRail.VENMO | typeof CashoutRail.CASHAPP;
+    payeeHandle: string;
+}
+/** The App Clip checks the connected PayPal account against this email. */
+ | {
+    rail: typeof CashoutRail.PAYPAL;
+    payeeHandle: string;
+    paypalEmail: string;
+}
+/** Buyer-proof rails need only the payout account; there is no connect step. */
+ | {
+    rail: CashoutBuyerProofRailType;
+    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: CashoutRailType | null;
+    status: CashoutStatusType;
+    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 {};