import { z } from "zod";
export declare const IDSchema: z.ZodString;
export declare const MinorUnitSchema: z.ZodNumber;
export declare const CurrencyCodeSchema: z.ZodString;
export declare const RoundingModeSchema: z.ZodEnum<["HALF_UP", "HALF_DOWN", "FLOOR", "CEILING"]>;
export declare const WalletOwnerSchema: z.ZodObject<{
    ownerId: z.ZodString;
    ownerType: z.ZodString;
}, "strip", z.ZodTypeAny, {
    ownerId: string;
    ownerType: string;
}, {
    ownerId: string;
    ownerType: string;
}>;
export declare const WalletConstraintsSchema: z.ZodObject<{
    /** Minimum available balance floor — available must remain >= this after any debit (§21). */
    minBalance: z.ZodOptional<z.ZodNumber>;
    /** Maximum booked balance ceiling — booked must remain <= this after any credit (§21). */
    maxBalance: z.ZodOptional<z.ZodNumber>;
    /** Rolling 24h debit limit in minor units (§21). */
    dailyDebitLimit: z.ZodOptional<z.ZodNumber>;
    /** Rolling 7-day debit limit in minor units (§21). */
    weeklyDebitLimit: z.ZodOptional<z.ZodNumber>;
    /** Rolling 30-day debit limit in minor units (§21). */
    monthlyDebitLimit: z.ZodOptional<z.ZodNumber>;
    /** Rolling 24h credit limit in minor units (§21). */
    dailyCreditLimit: z.ZodOptional<z.ZodNumber>;
    /**
     * Freeze mode (§21).
     * 'debits'  — only debit entries blocked.
     * 'credits' — only credit entries blocked.
     * 'all'     — all new entries blocked.
     * 'none'    — no freeze (default).
     */
    freeze: z.ZodDefault<z.ZodEnum<["none", "debits", "credits", "all"]>>;
}, "strip", z.ZodTypeAny, {
    freeze: "none" | "debits" | "credits" | "all";
    minBalance?: number | undefined;
    maxBalance?: number | undefined;
    dailyDebitLimit?: number | undefined;
    weeklyDebitLimit?: number | undefined;
    monthlyDebitLimit?: number | undefined;
    dailyCreditLimit?: number | undefined;
}, {
    minBalance?: number | undefined;
    maxBalance?: number | undefined;
    dailyDebitLimit?: number | undefined;
    weeklyDebitLimit?: number | undefined;
    monthlyDebitLimit?: number | undefined;
    dailyCreditLimit?: number | undefined;
    freeze?: "none" | "debits" | "credits" | "all" | undefined;
}>;
export type WalletConstraints = z.infer<typeof WalletConstraintsSchema>;
export declare const WalletSchema: z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    currency: z.ZodString;
    ownerId: z.ZodString;
    ownerType: z.ZodString;
    /** Human-readable label, optional */
    label: z.ZodOptional<z.ZodString>;
    /** Whether this wallet can go below zero */
    allowNegativeBalance: z.ZodDefault<z.ZodBoolean>;
    /** Default finality mode for operations on this wallet */
    defaultFinalityMode: z.ZodDefault<z.ZodEnum<["soft", "hard"]>>;
    /** Optional spend/receive constraints enforced synchronously before entry creation (§21). */
    constraints: z.ZodOptional<z.ZodObject<{
        /** Minimum available balance floor — available must remain >= this after any debit (§21). */
        minBalance: z.ZodOptional<z.ZodNumber>;
        /** Maximum booked balance ceiling — booked must remain <= this after any credit (§21). */
        maxBalance: z.ZodOptional<z.ZodNumber>;
        /** Rolling 24h debit limit in minor units (§21). */
        dailyDebitLimit: z.ZodOptional<z.ZodNumber>;
        /** Rolling 7-day debit limit in minor units (§21). */
        weeklyDebitLimit: z.ZodOptional<z.ZodNumber>;
        /** Rolling 30-day debit limit in minor units (§21). */
        monthlyDebitLimit: z.ZodOptional<z.ZodNumber>;
        /** Rolling 24h credit limit in minor units (§21). */
        dailyCreditLimit: z.ZodOptional<z.ZodNumber>;
        /**
         * Freeze mode (§21).
         * 'debits'  — only debit entries blocked.
         * 'credits' — only credit entries blocked.
         * 'all'     — all new entries blocked.
         * 'none'    — no freeze (default).
         */
        freeze: z.ZodDefault<z.ZodEnum<["none", "debits", "credits", "all"]>>;
    }, "strip", z.ZodTypeAny, {
        freeze: "none" | "debits" | "credits" | "all";
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
    }, {
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
        freeze?: "none" | "debits" | "credits" | "all" | undefined;
    }>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
    /** Soft-delete support */
    deletedAt: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    ownerId: string;
    ownerType: string;
    id: string;
    tenantId: string;
    currency: string;
    allowNegativeBalance: boolean;
    defaultFinalityMode: "soft" | "hard";
    createdAt: Date;
    updatedAt: Date;
    label?: string | undefined;
    constraints?: {
        freeze: "none" | "debits" | "credits" | "all";
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
    } | undefined;
    deletedAt?: Date | undefined;
}, {
    ownerId: string;
    ownerType: string;
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    label?: string | undefined;
    allowNegativeBalance?: boolean | undefined;
    defaultFinalityMode?: "soft" | "hard" | undefined;
    constraints?: {
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
        freeze?: "none" | "debits" | "credits" | "all" | undefined;
    } | undefined;
    deletedAt?: Date | undefined;
}>;
export type Wallet = z.infer<typeof WalletSchema>;
/**
 * Reserved ownerType values that callers must not use via the public createWallet path.
 * IC-1: 'checkout_session' is exclusively created via the internal createTransitWallet factory.
 * 'payment_page' is reserved for forward-compatibility.
 */
export declare const RESERVED_OWNER_TYPES: readonly ["checkout_session", "payment_page"];
export declare const CreateWalletInputSchema: z.ZodEffects<z.ZodObject<Pick<{
    id: z.ZodString;
    tenantId: z.ZodString;
    currency: z.ZodString;
    ownerId: z.ZodString;
    ownerType: z.ZodString;
    /** Human-readable label, optional */
    label: z.ZodOptional<z.ZodString>;
    /** Whether this wallet can go below zero */
    allowNegativeBalance: z.ZodDefault<z.ZodBoolean>;
    /** Default finality mode for operations on this wallet */
    defaultFinalityMode: z.ZodDefault<z.ZodEnum<["soft", "hard"]>>;
    /** Optional spend/receive constraints enforced synchronously before entry creation (§21). */
    constraints: z.ZodOptional<z.ZodObject<{
        /** Minimum available balance floor — available must remain >= this after any debit (§21). */
        minBalance: z.ZodOptional<z.ZodNumber>;
        /** Maximum booked balance ceiling — booked must remain <= this after any credit (§21). */
        maxBalance: z.ZodOptional<z.ZodNumber>;
        /** Rolling 24h debit limit in minor units (§21). */
        dailyDebitLimit: z.ZodOptional<z.ZodNumber>;
        /** Rolling 7-day debit limit in minor units (§21). */
        weeklyDebitLimit: z.ZodOptional<z.ZodNumber>;
        /** Rolling 30-day debit limit in minor units (§21). */
        monthlyDebitLimit: z.ZodOptional<z.ZodNumber>;
        /** Rolling 24h credit limit in minor units (§21). */
        dailyCreditLimit: z.ZodOptional<z.ZodNumber>;
        /**
         * Freeze mode (§21).
         * 'debits'  — only debit entries blocked.
         * 'credits' — only credit entries blocked.
         * 'all'     — all new entries blocked.
         * 'none'    — no freeze (default).
         */
        freeze: z.ZodDefault<z.ZodEnum<["none", "debits", "credits", "all"]>>;
    }, "strip", z.ZodTypeAny, {
        freeze: "none" | "debits" | "credits" | "all";
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
    }, {
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
        freeze?: "none" | "debits" | "credits" | "all" | undefined;
    }>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
    /** Soft-delete support */
    deletedAt: z.ZodOptional<z.ZodDate>;
}, "ownerId" | "ownerType" | "currency" | "label" | "allowNegativeBalance" | "defaultFinalityMode" | "constraints">, "strip", z.ZodTypeAny, {
    ownerId: string;
    ownerType: string;
    currency: string;
    allowNegativeBalance: boolean;
    defaultFinalityMode: "soft" | "hard";
    label?: string | undefined;
    constraints?: {
        freeze: "none" | "debits" | "credits" | "all";
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
    } | undefined;
}, {
    ownerId: string;
    ownerType: string;
    currency: string;
    label?: string | undefined;
    allowNegativeBalance?: boolean | undefined;
    defaultFinalityMode?: "soft" | "hard" | undefined;
    constraints?: {
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
        freeze?: "none" | "debits" | "credits" | "all" | undefined;
    } | undefined;
}>, {
    ownerId: string;
    ownerType: string;
    currency: string;
    allowNegativeBalance: boolean;
    defaultFinalityMode: "soft" | "hard";
    label?: string | undefined;
    constraints?: {
        freeze: "none" | "debits" | "credits" | "all";
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
    } | undefined;
}, {
    ownerId: string;
    ownerType: string;
    currency: string;
    label?: string | undefined;
    allowNegativeBalance?: boolean | undefined;
    defaultFinalityMode?: "soft" | "hard" | undefined;
    constraints?: {
        minBalance?: number | undefined;
        maxBalance?: number | undefined;
        dailyDebitLimit?: number | undefined;
        weeklyDebitLimit?: number | undefined;
        monthlyDebitLimit?: number | undefined;
        dailyCreditLimit?: number | undefined;
        freeze?: "none" | "debits" | "credits" | "all" | undefined;
    } | undefined;
}>;
export type CreateWalletInput = z.input<typeof CreateWalletInputSchema>;
export declare const WalletBalanceSchema: z.ZodObject<{
    walletId: z.ZodString;
    currency: z.ZodString;
    /** Sum of completed credits minus completed debits (settled ledger balance) */
    booked: z.ZodNumber;
    /** Sum of pending debit entries (funds reserved but not yet settled) */
    reserved: z.ZodNumber;
    /** Spendable balance: booked - reserved */
    available: z.ZodNumber;
    /** Net of pending credits minus pending debits (informational) */
    pending: z.ZodNumber;
    /** Timestamp of the most recent entry contributing to this balance */
    asOf: z.ZodDate;
    /** Credit entry breakdown by status (for audit/reporting) */
    credit: z.ZodObject<{
        pending: z.ZodNumber;
        completed: z.ZodNumber;
        failed: z.ZodNumber;
        reversed: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        pending: number;
        completed: number;
        failed: number;
        reversed: number;
    }, {
        pending: number;
        completed: number;
        failed: number;
        reversed: number;
    }>;
    /** Debit entry breakdown by status (for audit/reporting) */
    debit: z.ZodObject<{
        pending: z.ZodNumber;
        completed: z.ZodNumber;
        failed: z.ZodNumber;
        reversed: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        pending: number;
        completed: number;
        failed: number;
        reversed: number;
    }, {
        pending: number;
        completed: number;
        failed: number;
        reversed: number;
    }>;
}, "strip", z.ZodTypeAny, {
    currency: string;
    walletId: string;
    booked: number;
    reserved: number;
    available: number;
    pending: number;
    asOf: Date;
    credit: {
        pending: number;
        completed: number;
        failed: number;
        reversed: number;
    };
    debit: {
        pending: number;
        completed: number;
        failed: number;
        reversed: number;
    };
}, {
    currency: string;
    walletId: string;
    booked: number;
    reserved: number;
    available: number;
    pending: number;
    asOf: Date;
    credit: {
        pending: number;
        completed: number;
        failed: number;
        reversed: number;
    };
    debit: {
        pending: number;
        completed: number;
        failed: number;
        reversed: number;
    };
}>;
export type WalletBalance = z.infer<typeof WalletBalanceSchema>;
export declare const FxSnapshotSchema: z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    fromCurrency: z.ZodString;
    toCurrency: z.ZodString;
    /**
     * Rate expressed as: 1 fromCurrency = rate toCurrency, stored as string for precision.
     * Format: plain decimal only — no scientific notation, no sign prefix.
     * Regex: /^\d+(\.\d{1,18})?$/ — max 18 decimal digits.
     * Use a decimal library (e.g. decimal.js) for arithmetic to avoid floating-point drift.
     */
    rate: z.ZodString;
    provider: z.ZodString;
    fetchedAt: z.ZodDate;
    /** Optional expiry — after this the snapshot must not be reused for new ops */
    expiresAt: z.ZodOptional<z.ZodDate>;
    roundingMode: z.ZodOptional<z.ZodEnum<["HALF_UP", "HALF_DOWN", "FLOOR", "CEILING"]>>;
}, "strip", z.ZodTypeAny, {
    id: string;
    tenantId: string;
    fromCurrency: string;
    toCurrency: string;
    rate: string;
    provider: string;
    fetchedAt: Date;
    expiresAt?: Date | undefined;
    roundingMode?: "HALF_UP" | "HALF_DOWN" | "FLOOR" | "CEILING" | undefined;
}, {
    id: string;
    tenantId: string;
    fromCurrency: string;
    toCurrency: string;
    rate: string;
    provider: string;
    fetchedAt: Date;
    expiresAt?: Date | undefined;
    roundingMode?: "HALF_UP" | "HALF_DOWN" | "FLOOR" | "CEILING" | undefined;
}>;
export type FxSnapshot = z.infer<typeof FxSnapshotSchema>;
export declare const LedgerEntrySchema: z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    walletId: z.ZodString;
    operationId: z.ZodString;
    entryType: z.ZodEnum<["credit", "debit"]>;
    status: z.ZodEnum<["pending", "completed", "failed", "reversed"]>;
    amount: z.ZodNumber;
    currency: z.ZodString;
    /** Running balance after this entry is applied (computed at write time within wallet lock). */
    runningBalance: z.ZodOptional<z.ZodNumber>;
    /** Ordering tiebreaker — monotonically increasing integer per wallet */
    sequence: z.ZodNumber;
    /** Business-effective timestamp (may differ from createdAt for backdated entries) */
    effectiveAt: z.ZodDate;
    /** Write-once creation timestamp */
    createdAt: z.ZodDate;
    /** Allowed to change only when status changes */
    updatedAt: z.ZodDate;
    /** Set when this entry reverses another */
    reversalOfEntryId: z.ZodOptional<z.ZodString>;
    /** Arbitrary metadata provided by the caller */
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    status: "pending" | "completed" | "failed" | "reversed";
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    walletId: string;
    operationId: string;
    entryType: "credit" | "debit";
    amount: number;
    sequence: number;
    effectiveAt: Date;
    runningBalance?: number | undefined;
    reversalOfEntryId?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
}, {
    status: "pending" | "completed" | "failed" | "reversed";
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    walletId: string;
    operationId: string;
    entryType: "credit" | "debit";
    amount: number;
    sequence: number;
    effectiveAt: Date;
    runningBalance?: number | undefined;
    reversalOfEntryId?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
}>;
export type LedgerEntry = z.infer<typeof LedgerEntrySchema>;
export declare const OperationSchema: z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    type: z.ZodEnum<["deposit", "withdrawal", "transfer", "conversion", "payment", "fee", "reversal", "adjustment"]>;
    status: z.ZodEnum<["pending", "processing", "completed", "failed", "cancelled", "reversed"]>;
    /** Primary wallet — the one being debited or credited as the main side */
    walletId: z.ZodString;
    /** Counterparty wallet for transfers and conversions */
    counterpartyWalletId: z.ZodOptional<z.ZodString>;
    amount: z.ZodNumber;
    currency: z.ZodString;
    /** For conversion ops: the resulting amount in the target currency */
    convertedAmount: z.ZodOptional<z.ZodNumber>;
    convertedCurrency: z.ZodOptional<z.ZodString>;
    /** FX rate snapshot used for conversion ops */
    fxSnapshotId: z.ZodOptional<z.ZodString>;
    /** Fee applied on top of / extracted from this operation */
    feeAmount: z.ZodOptional<z.ZodNumber>;
    feeCurrency: z.ZodOptional<z.ZodString>;
    /** Caller-supplied idempotency key — unique per tenant */
    idempotencyKey: z.ZodOptional<z.ZodString>;
    /** External reference from a payment provider */
    externalId: z.ZodOptional<z.ZodString>;
    /** Name of the payment provider adapter that handled this operation */
    provider: z.ZodOptional<z.ZodString>;
    /**
     * Links this operation to its logical parent. Carries three distinct semantics (IC-6):
     * 1. `fee` operations — links to the originating operation that incurred the fee.
     * 2. `reversal` operations — links to the operation being reversed.
     * 3. Checkout session Op B (`conversion` or `transfer`) — links to the paired
     *    Op A (`deposit`) that received funds into the transit wallet, establishing
     *    the cross-leg settlement chain (\u00a79).
     * Wallet payment operations (single `transfer` or `conversion`) are standalone and
     * do not use `parentOperationId`.
     */
    parentOperationId: z.ZodOptional<z.ZodString>;
    /**
     * Payment processing fee reported by the external provider at settlement,
     * in minor units (e.g. kobo for NGN). Stored for audit and reconciliation.
     */
    providerFees: z.ZodOptional<z.ZodNumber>;
    providerFeesCurrency: z.ZodOptional<z.ZodString>;
    finalityMode: z.ZodDefault<z.ZodEnum<["soft", "hard"]>>;
    /**
     * Timestamp when the operation transitioned to 'completed' status.
     * Set at creation for hard-finality ops; set by settle() for soft-finality ops.
     * Used as the start of the reversal window (§36).
     */
    completedAt: z.ZodOptional<z.ZodDate>;
    /**
     * Expiry timestamp for multi-payment pending operations.
     * When set and the current time is past this value, `expireOverdue()` or lazy
     * triggers in `operations.get()` and `webhooks.handleWithEvent()` will settle
     * the operation at `metadata._pay_totalPaid` (if > 0) or fail it.
     * Set by providers like 100Pay on underpaid deposit operations.
     */
    pendingExpiresAt: z.ZodOptional<z.ZodDate>;
    /** Arbitrary metadata provided by the caller */
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    /**
     * Links this operation to a PayoutRecipient (D23).
     * Set on payout withdrawal operations only.
     * Indexed for efficient listPayouts({ recipientId }) queries.
     */
    recipientId: z.ZodOptional<z.ZodString>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    type: "deposit" | "withdrawal" | "transfer" | "conversion" | "payment" | "fee" | "reversal" | "adjustment";
    status: "pending" | "completed" | "failed" | "reversed" | "processing" | "cancelled";
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    walletId: string;
    amount: number;
    finalityMode: "soft" | "hard";
    provider?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    counterpartyWalletId?: string | undefined;
    convertedAmount?: number | undefined;
    convertedCurrency?: string | undefined;
    fxSnapshotId?: string | undefined;
    feeAmount?: number | undefined;
    feeCurrency?: string | undefined;
    idempotencyKey?: string | undefined;
    externalId?: string | undefined;
    parentOperationId?: string | undefined;
    providerFees?: number | undefined;
    providerFeesCurrency?: string | undefined;
    completedAt?: Date | undefined;
    pendingExpiresAt?: Date | undefined;
    recipientId?: string | undefined;
}, {
    type: "deposit" | "withdrawal" | "transfer" | "conversion" | "payment" | "fee" | "reversal" | "adjustment";
    status: "pending" | "completed" | "failed" | "reversed" | "processing" | "cancelled";
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    walletId: string;
    amount: number;
    provider?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    counterpartyWalletId?: string | undefined;
    convertedAmount?: number | undefined;
    convertedCurrency?: string | undefined;
    fxSnapshotId?: string | undefined;
    feeAmount?: number | undefined;
    feeCurrency?: string | undefined;
    idempotencyKey?: string | undefined;
    externalId?: string | undefined;
    parentOperationId?: string | undefined;
    providerFees?: number | undefined;
    providerFeesCurrency?: string | undefined;
    finalityMode?: "soft" | "hard" | undefined;
    completedAt?: Date | undefined;
    pendingExpiresAt?: Date | undefined;
    recipientId?: string | undefined;
}>;
export type Operation = z.infer<typeof OperationSchema>;
/**
 * A pre-registered external bank / mobile-money recipient that can receive
 * payouts via `pay.payouts.send()`. Scoped per (tenantId, provider).
 */
export declare const PayoutRecipientSchema: z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    /** The payment provider that holds this recipient's registration. */
    provider: z.ZodString;
    /**
     * Provider-assigned recipient code — returned after createRecipient() and
     * used when initiating transfers via that provider.
     * Unique constraint: (tenantId, provider, providerRecipientCode).
     */
    providerRecipientCode: z.ZodString;
    /**
     * Currency code for this recipient's account (ISO 4217 or crypto ticker).
     * All payouts to this recipient must be in this currency.
     */
    currency: z.ZodString;
    /**
     * Provider-resolved account holder name, returned after account verification.
     * Stored for audit and display.
     */
    resolvedName: z.ZodOptional<z.ZodString>;
    /**
     * Optional owner linkage — the wallet owner (user/merchant) this recipient
     * belongs to. Enables per-user recipient lists.
     */
    ownerId: z.ZodOptional<z.ZodString>;
    ownerType: z.ZodOptional<z.ZodString>;
    /**
     * Opaque provider-specific details bag (e.g. { accountNumber, bankCode } for NGN).
     * Stored as-is and passed to provider adapter methods.
     */
    details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    /**
     * Raw response from the provider's recipient registration call.
     * Stored for audit/debugging; not used for business logic.
     */
    raw: z.ZodOptional<z.ZodUnknown>;
    /** Arbitrary caller metadata. */
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    /** When set, this recipient is archived and cannot receive new payouts. */
    archivedAt: z.ZodOptional<z.ZodDate>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    provider: string;
    providerRecipientCode: string;
    details: Record<string, unknown>;
    ownerId?: string | undefined;
    ownerType?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    resolvedName?: string | undefined;
    raw?: unknown;
    archivedAt?: Date | undefined;
}, {
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    provider: string;
    providerRecipientCode: string;
    details: Record<string, unknown>;
    ownerId?: string | undefined;
    ownerType?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    resolvedName?: string | undefined;
    raw?: unknown;
    archivedAt?: Date | undefined;
}>;
export type PayoutRecipient = z.infer<typeof PayoutRecipientSchema>;
export declare const PaymentPageSchema: z.ZodEffects<z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    /** List of allowed payment provider adapter names for this page. */
    allowedProviders: z.ZodArray<z.ZodString, "many">;
    /** The currency the merchant will receive after settlement. */
    settlementCurrency: z.ZodString;
    /** Optional allowlist of payer currencies; omitted = any FX-convertible currency. */
    acceptedCurrencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    /** The wallet that receives settled funds. Must be in settlementCurrency. */
    settlementWalletId: z.ZodString;
    /** Fixed amount in minor units (fixed-amount pages). */
    amountMinor: z.ZodOptional<z.ZodNumber>;
    /** Minimum amount for range pages. */
    minAmountMinor: z.ZodOptional<z.ZodNumber>;
    /** Maximum amount for range pages. */
    maxAmountMinor: z.ZodOptional<z.ZodNumber>;
    sessionPolicy: z.ZodDefault<z.ZodEnum<["open", "gated"]>>;
    callbackUrl: z.ZodString;
    title: z.ZodOptional<z.ZodString>;
    mode: z.ZodEnum<["hosted", "embedded"]>;
    active: z.ZodDefault<z.ZodBoolean>;
    expiresAt: z.ZodOptional<z.ZodDate>;
    status: z.ZodDefault<z.ZodEnum<["active", "completed", "expired", "cancelled"]>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, z.UnknownKeysParam, z.ZodTypeAny, {
    status: "completed" | "cancelled" | "active" | "expired";
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    allowedProviders: string[];
    settlementCurrency: string;
    settlementWalletId: string;
    sessionPolicy: "open" | "gated";
    callbackUrl: string;
    mode: "hosted" | "embedded";
    active: boolean;
    expiresAt?: Date | undefined;
    metadata?: Record<string, unknown> | undefined;
    acceptedCurrencies?: string[] | undefined;
    amountMinor?: number | undefined;
    minAmountMinor?: number | undefined;
    maxAmountMinor?: number | undefined;
    title?: string | undefined;
}, {
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    allowedProviders: string[];
    settlementCurrency: string;
    settlementWalletId: string;
    callbackUrl: string;
    mode: "hosted" | "embedded";
    status?: "completed" | "cancelled" | "active" | "expired" | undefined;
    expiresAt?: Date | undefined;
    metadata?: Record<string, unknown> | undefined;
    acceptedCurrencies?: string[] | undefined;
    amountMinor?: number | undefined;
    minAmountMinor?: number | undefined;
    maxAmountMinor?: number | undefined;
    sessionPolicy?: "open" | "gated" | undefined;
    title?: string | undefined;
    active?: boolean | undefined;
}>, {
    status: "completed" | "cancelled" | "active" | "expired";
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    allowedProviders: string[];
    settlementCurrency: string;
    settlementWalletId: string;
    sessionPolicy: "open" | "gated";
    callbackUrl: string;
    mode: "hosted" | "embedded";
    active: boolean;
    expiresAt?: Date | undefined;
    metadata?: Record<string, unknown> | undefined;
    acceptedCurrencies?: string[] | undefined;
    amountMinor?: number | undefined;
    minAmountMinor?: number | undefined;
    maxAmountMinor?: number | undefined;
    title?: string | undefined;
}, {
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    allowedProviders: string[];
    settlementCurrency: string;
    settlementWalletId: string;
    callbackUrl: string;
    mode: "hosted" | "embedded";
    status?: "completed" | "cancelled" | "active" | "expired" | undefined;
    expiresAt?: Date | undefined;
    metadata?: Record<string, unknown> | undefined;
    acceptedCurrencies?: string[] | undefined;
    amountMinor?: number | undefined;
    minAmountMinor?: number | undefined;
    maxAmountMinor?: number | undefined;
    sessionPolicy?: "open" | "gated" | undefined;
    title?: string | undefined;
    active?: boolean | undefined;
}>;
export type PaymentPage = z.infer<typeof PaymentPageSchema>;
export declare const CreatePaymentPageInputSchema: z.ZodEffects<z.ZodObject<Omit<{
    id: z.ZodString;
    tenantId: z.ZodString;
    /** List of allowed payment provider adapter names for this page. */
    allowedProviders: z.ZodArray<z.ZodString, "many">;
    /** The currency the merchant will receive after settlement. */
    settlementCurrency: z.ZodString;
    /** Optional allowlist of payer currencies; omitted = any FX-convertible currency. */
    acceptedCurrencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    /** The wallet that receives settled funds. Must be in settlementCurrency. */
    settlementWalletId: z.ZodString;
    /** Fixed amount in minor units (fixed-amount pages). */
    amountMinor: z.ZodOptional<z.ZodNumber>;
    /** Minimum amount for range pages. */
    minAmountMinor: z.ZodOptional<z.ZodNumber>;
    /** Maximum amount for range pages. */
    maxAmountMinor: z.ZodOptional<z.ZodNumber>;
    sessionPolicy: z.ZodDefault<z.ZodEnum<["open", "gated"]>>;
    callbackUrl: z.ZodString;
    title: z.ZodOptional<z.ZodString>;
    mode: z.ZodEnum<["hosted", "embedded"]>;
    active: z.ZodDefault<z.ZodBoolean>;
    expiresAt: z.ZodOptional<z.ZodDate>;
    status: z.ZodDefault<z.ZodEnum<["active", "completed", "expired", "cancelled"]>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "status" | "id" | "tenantId" | "createdAt" | "updatedAt">, z.UnknownKeysParam, z.ZodTypeAny, {
    allowedProviders: string[];
    settlementCurrency: string;
    settlementWalletId: string;
    sessionPolicy: "open" | "gated";
    callbackUrl: string;
    mode: "hosted" | "embedded";
    active: boolean;
    expiresAt?: Date | undefined;
    metadata?: Record<string, unknown> | undefined;
    acceptedCurrencies?: string[] | undefined;
    amountMinor?: number | undefined;
    minAmountMinor?: number | undefined;
    maxAmountMinor?: number | undefined;
    title?: string | undefined;
}, {
    allowedProviders: string[];
    settlementCurrency: string;
    settlementWalletId: string;
    callbackUrl: string;
    mode: "hosted" | "embedded";
    expiresAt?: Date | undefined;
    metadata?: Record<string, unknown> | undefined;
    acceptedCurrencies?: string[] | undefined;
    amountMinor?: number | undefined;
    minAmountMinor?: number | undefined;
    maxAmountMinor?: number | undefined;
    sessionPolicy?: "open" | "gated" | undefined;
    title?: string | undefined;
    active?: boolean | undefined;
}>, {
    allowedProviders: string[];
    settlementCurrency: string;
    settlementWalletId: string;
    sessionPolicy: "open" | "gated";
    callbackUrl: string;
    mode: "hosted" | "embedded";
    active: boolean;
    expiresAt?: Date | undefined;
    metadata?: Record<string, unknown> | undefined;
    acceptedCurrencies?: string[] | undefined;
    amountMinor?: number | undefined;
    minAmountMinor?: number | undefined;
    maxAmountMinor?: number | undefined;
    title?: string | undefined;
}, {
    allowedProviders: string[];
    settlementCurrency: string;
    settlementWalletId: string;
    callbackUrl: string;
    mode: "hosted" | "embedded";
    expiresAt?: Date | undefined;
    metadata?: Record<string, unknown> | undefined;
    acceptedCurrencies?: string[] | undefined;
    amountMinor?: number | undefined;
    minAmountMinor?: number | undefined;
    maxAmountMinor?: number | undefined;
    sessionPolicy?: "open" | "gated" | undefined;
    title?: string | undefined;
    active?: boolean | undefined;
}>;
export type CreatePaymentPageInput = z.input<typeof CreatePaymentPageInputSchema>;
export declare const CheckoutSessionSchema: z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    pageId: z.ZodString;
    /** Caller-supplied payer identity; normalized for deep-equality lookup. */
    payerRef: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    /**
     * Stable hash of the normalized payerRef (sorted keys). Used for storage
     * lookup without full JSON scan. Internal field — not exposed in API responses.
     */
    payerRefHash: z.ZodOptional<z.ZodString>;
    status: z.ZodEnum<["active", "closing", "closed", "expired", "settled"]>;
    expiresAt: z.ZodDate;
    closedAt: z.ZodOptional<z.ZodDate>;
    closedBy: z.ZodOptional<z.ZodEnum<["merchant", "ttl"]>>;
    transitWalletId: z.ZodOptional<z.ZodString>;
    receivedAmountMinor: z.ZodDefault<z.ZodNumber>;
    receivedCurrency: z.ZodString;
    remainingAmountMinor: z.ZodOptional<z.ZodNumber>;
    fulfillmentStatus: z.ZodOptional<z.ZodEnum<["under", "exact", "over"]>>;
    activeQuoteId: z.ZodOptional<z.ZodString>;
    settlementOperationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    requiresManualResolution: z.ZodOptional<z.ZodBoolean>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "active" | "expired" | "closing" | "closed" | "settled";
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    expiresAt: Date;
    pageId: string;
    receivedAmountMinor: number;
    receivedCurrency: string;
    metadata?: Record<string, unknown> | undefined;
    payerRef?: Record<string, unknown> | undefined;
    payerRefHash?: string | undefined;
    closedAt?: Date | undefined;
    closedBy?: "merchant" | "ttl" | undefined;
    transitWalletId?: string | undefined;
    remainingAmountMinor?: number | undefined;
    fulfillmentStatus?: "exact" | "under" | "over" | undefined;
    activeQuoteId?: string | undefined;
    settlementOperationIds?: string[] | undefined;
    requiresManualResolution?: boolean | undefined;
}, {
    status: "active" | "expired" | "closing" | "closed" | "settled";
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    expiresAt: Date;
    pageId: string;
    receivedCurrency: string;
    metadata?: Record<string, unknown> | undefined;
    payerRef?: Record<string, unknown> | undefined;
    payerRefHash?: string | undefined;
    closedAt?: Date | undefined;
    closedBy?: "merchant" | "ttl" | undefined;
    transitWalletId?: string | undefined;
    receivedAmountMinor?: number | undefined;
    remainingAmountMinor?: number | undefined;
    fulfillmentStatus?: "exact" | "under" | "over" | undefined;
    activeQuoteId?: string | undefined;
    settlementOperationIds?: string[] | undefined;
    requiresManualResolution?: boolean | undefined;
}>;
export type CheckoutSession = z.infer<typeof CheckoutSessionSchema>;
export declare const CheckoutQuoteSchema: z.ZodObject<{
    id: z.ZodString;
    sessionId: z.ZodString;
    pageId: z.ZodString;
    tenantId: z.ZodString;
    fxSnapshot: z.ZodObject<{
        rate: z.ZodString;
        fxProvider: z.ZodString;
        fetchedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        rate: string;
        fetchedAt: Date;
        fxProvider: string;
    }, {
        rate: string;
        fetchedAt: Date;
        fxProvider: string;
    }>;
    payerCurrency: z.ZodString;
    payerAmountMinor: z.ZodNumber;
    settlementAmountMinor: z.ZodNumber;
    /** Captured at sessions.pay() time (quote → used). */
    quotedPayerAmountMinor: z.ZodOptional<z.ZodNumber>;
    /** Set during webhook processing on provider confirmation. */
    confirmedPayerAmountMinor: z.ZodOptional<z.ZodNumber>;
    status: z.ZodDefault<z.ZodEnum<["active", "used", "expired"]>>;
    expiresAt: z.ZodDate;
    usedAt: z.ZodOptional<z.ZodDate>;
    createdAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "active" | "expired" | "used";
    id: string;
    tenantId: string;
    createdAt: Date;
    expiresAt: Date;
    pageId: string;
    sessionId: string;
    fxSnapshot: {
        rate: string;
        fetchedAt: Date;
        fxProvider: string;
    };
    payerCurrency: string;
    payerAmountMinor: number;
    settlementAmountMinor: number;
    quotedPayerAmountMinor?: number | undefined;
    confirmedPayerAmountMinor?: number | undefined;
    usedAt?: Date | undefined;
}, {
    id: string;
    tenantId: string;
    createdAt: Date;
    expiresAt: Date;
    pageId: string;
    sessionId: string;
    fxSnapshot: {
        rate: string;
        fetchedAt: Date;
        fxProvider: string;
    };
    payerCurrency: string;
    payerAmountMinor: number;
    settlementAmountMinor: number;
    status?: "active" | "expired" | "used" | undefined;
    quotedPayerAmountMinor?: number | undefined;
    confirmedPayerAmountMinor?: number | undefined;
    usedAt?: Date | undefined;
}>;
export type CheckoutQuote = z.infer<typeof CheckoutQuoteSchema>;
export declare const CheckoutPaymentSchema: z.ZodObject<{
    id: z.ZodString;
    sessionId: z.ZodString;
    pageId: z.ZodString;
    tenantId: z.ZodString;
    quoteId: z.ZodString;
    /** Op A — provider-side inbound DEPOSIT operation id (provider path only). */
    operationId: z.ZodString;
    /** 'provider' (default) or 'wallet' — determines which pay path was used. */
    paymentMethod: z.ZodDefault<z.ZodEnum<["provider", "wallet"]>>;
    selectedProvider: z.ZodOptional<z.ZodString>;
    providerRef: z.ZodOptional<z.ZodString>;
    /** Payer's internal wallet id — set for wallet payment path only. */
    payerWalletId: z.ZodOptional<z.ZodString>;
    conversionOperationId: z.ZodOptional<z.ZodString>;
    payerCurrency: z.ZodString;
    payerAmountMinor: z.ZodNumber;
    settlementAmountMinor: z.ZodNumber;
    confirmedAmountMinor: z.ZodOptional<z.ZodNumber>;
    status: z.ZodDefault<z.ZodEnum<["pending", "completed", "failed"]>>;
    failureReason: z.ZodOptional<z.ZodString>;
    flaggedForReview: z.ZodOptional<z.ZodBoolean>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "pending" | "completed" | "failed";
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    operationId: string;
    pageId: string;
    sessionId: string;
    payerCurrency: string;
    payerAmountMinor: number;
    settlementAmountMinor: number;
    quoteId: string;
    paymentMethod: "provider" | "wallet";
    selectedProvider?: string | undefined;
    providerRef?: string | undefined;
    payerWalletId?: string | undefined;
    conversionOperationId?: string | undefined;
    confirmedAmountMinor?: number | undefined;
    failureReason?: string | undefined;
    flaggedForReview?: boolean | undefined;
}, {
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    operationId: string;
    pageId: string;
    sessionId: string;
    payerCurrency: string;
    payerAmountMinor: number;
    settlementAmountMinor: number;
    quoteId: string;
    status?: "pending" | "completed" | "failed" | undefined;
    paymentMethod?: "provider" | "wallet" | undefined;
    selectedProvider?: string | undefined;
    providerRef?: string | undefined;
    payerWalletId?: string | undefined;
    conversionOperationId?: string | undefined;
    confirmedAmountMinor?: number | undefined;
    failureReason?: string | undefined;
    flaggedForReview?: boolean | undefined;
}>;
export type CheckoutPayment = z.infer<typeof CheckoutPaymentSchema>;
export declare const ScheduledPayoutStatusSchema: z.ZodEnum<["active", "firing", "paused", "cancelled", "completed"]>;
export declare const ScheduledPayoutSchema: z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    walletId: z.ZodString;
    recipientId: z.ZodString;
    amountMinor: z.ZodNumber;
    currency: z.ZodString;
    narration: z.ZodOptional<z.ZodString>;
    /**
     * One-time mode: fire once at this timestamp, then status → "completed".
     * Mutually exclusive with cronExpression.
     */
    scheduledAt: z.ZodOptional<z.ZodDate>;
    /**
     * Recurring mode: standard 5-field cron expression (minute hour dom month dow).
     * Example: "0 9 * * 5" = every Friday at 09:00.
     * Mutually exclusive with scheduledAt.
     */
    cronExpression: z.ZodOptional<z.ZodString>;
    /** Auto-cancel the schedule when now >= endsAt on a fire tick. */
    endsAt: z.ZodOptional<z.ZodDate>;
    /** What to do when send() fails. "pause" (default) or "continue". */
    onFailure: z.ZodDefault<z.ZodEnum<["pause", "continue"]>>;
    status: z.ZodEnum<["active", "firing", "paused", "cancelled", "completed"]>;
    /**
     * Next fire timestamp. Auto-computed from cronExpression when cronParser is configured.
     * Callers must supply it manually when cronParser is not configured.
     */
    nextFireAt: z.ZodOptional<z.ZodDate>;
    lastFiredAt: z.ZodOptional<z.ZodDate>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "completed" | "cancelled" | "active" | "firing" | "paused";
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    walletId: string;
    recipientId: string;
    amountMinor: number;
    onFailure: "pause" | "continue";
    metadata?: Record<string, unknown> | undefined;
    narration?: string | undefined;
    scheduledAt?: Date | undefined;
    cronExpression?: string | undefined;
    endsAt?: Date | undefined;
    nextFireAt?: Date | undefined;
    lastFiredAt?: Date | undefined;
}, {
    status: "completed" | "cancelled" | "active" | "firing" | "paused";
    id: string;
    tenantId: string;
    currency: string;
    createdAt: Date;
    updatedAt: Date;
    walletId: string;
    recipientId: string;
    amountMinor: number;
    metadata?: Record<string, unknown> | undefined;
    narration?: string | undefined;
    scheduledAt?: Date | undefined;
    cronExpression?: string | undefined;
    endsAt?: Date | undefined;
    onFailure?: "pause" | "continue" | undefined;
    nextFireAt?: Date | undefined;
    lastFiredAt?: Date | undefined;
}>;
export type ScheduledPayout = z.infer<typeof ScheduledPayoutSchema>;
export type ScheduledPayoutStatus = z.infer<typeof ScheduledPayoutStatusSchema>;
export declare const ScheduledPayoutExecutionSchema: z.ZodObject<{
    id: z.ZodString;
    scheduledPayoutId: z.ZodString;
    tenantId: z.ZodString;
    operationId: z.ZodOptional<z.ZodString>;
    firedAt: z.ZodDate;
    status: z.ZodEnum<["succeeded", "failed"]>;
    failureReason: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    status: "failed" | "succeeded";
    id: string;
    tenantId: string;
    scheduledPayoutId: string;
    firedAt: Date;
    operationId?: string | undefined;
    failureReason?: string | undefined;
}, {
    status: "failed" | "succeeded";
    id: string;
    tenantId: string;
    scheduledPayoutId: string;
    firedAt: Date;
    operationId?: string | undefined;
    failureReason?: string | undefined;
}>;
export type ScheduledPayoutExecution = z.infer<typeof ScheduledPayoutExecutionSchema>;
/**
 * Zod schema for a recipient identifier input (mirrors RecipientIdentifierInput
 * from interfaces.ts). Used in ScheduledTransferSchema and bulk transfer inputs.
 */
export declare const RecipientIdentifierInputSchema: z.ZodObject<{
    type: z.ZodEnum<["owner", "email", "username", "paytag"]>;
    value: z.ZodOptional<z.ZodString>;
    ownerId: z.ZodOptional<z.ZodString>;
    ownerType: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: "owner" | "email" | "username" | "paytag";
    ownerId?: string | undefined;
    ownerType?: string | undefined;
    value?: string | undefined;
}, {
    type: "owner" | "email" | "username" | "paytag";
    ownerId?: string | undefined;
    ownerType?: string | undefined;
    value?: string | undefined;
}>;
export declare const ScheduledTransferStatusSchema: z.ZodEnum<["active", "firing", "paused", "cancelled", "completed"]>;
export declare const ScheduledTransferSchema: z.ZodObject<{
    id: z.ZodString;
    tenantId: z.ZodString;
    fromWalletId: z.ZodString;
    /**
     * Fast-path destination wallet. Takes precedence over `recipient` when both
     * are present. At least one of `toWalletId` or `recipient` must be provided.
     */
    toWalletId: z.ZodOptional<z.ZodString>;
    /**
     * Identity-based destination resolution. Resolved at each fire via the
     * configured recipientResolver. Used when toWalletId is absent.
     */
    recipient: z.ZodOptional<z.ZodObject<{
        identifiers: z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<["owner", "email", "username", "paytag"]>;
            value: z.ZodOptional<z.ZodString>;
            ownerId: z.ZodOptional<z.ZodString>;
            ownerType: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "owner" | "email" | "username" | "paytag";
            ownerId?: string | undefined;
            ownerType?: string | undefined;
            value?: string | undefined;
        }, {
            type: "owner" | "email" | "username" | "paytag";
            ownerId?: string | undefined;
            ownerType?: string | undefined;
            value?: string | undefined;
        }>, "many">;
        walletCurrency: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        identifiers: {
            type: "owner" | "email" | "username" | "paytag";
            ownerId?: string | undefined;
            ownerType?: string | undefined;
            value?: string | undefined;
        }[];
        walletCurrency?: string | undefined;
    }, {
        identifiers: {
            type: "owner" | "email" | "username" | "paytag";
            ownerId?: string | undefined;
            ownerType?: string | undefined;
            value?: string | undefined;
        }[];
        walletCurrency?: string | undefined;
    }>>;
    /** Source currency. */
    fromCurrency: z.ZodString;
    /**
     * Destination currency. When absent (or equal to fromCurrency) the schedule
     * fires a same-currency crossUser transfer. When present and different, it
     * fires a transferWithConversion.
     */
    toCurrency: z.ZodOptional<z.ZodString>;
    amountMinor: z.ZodNumber;
    narration: z.ZodOptional<z.ZodString>;
    /**
     * One-time mode: fire once at this timestamp, then status → "completed".
     * Mutually exclusive with cronExpression.
     */
    scheduledAt: z.ZodOptional<z.ZodDate>;
    /**
     * Recurring mode: standard 5-field cron expression.
     * Mutually exclusive with scheduledAt.
     */
    cronExpression: z.ZodOptional<z.ZodString>;
    /** Auto-cancel the schedule when now >= endsAt on a fire tick. */
    endsAt: z.ZodOptional<z.ZodDate>;
    /** What to do when the transfer fails. "pause" (default) or "continue". */
    onFailure: z.ZodDefault<z.ZodEnum<["pause", "continue"]>>;
    status: z.ZodEnum<["active", "firing", "paused", "cancelled", "completed"]>;
    nextFireAt: z.ZodOptional<z.ZodDate>;
    lastFiredAt: z.ZodOptional<z.ZodDate>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "completed" | "cancelled" | "active" | "firing" | "paused";
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    fromCurrency: string;
    amountMinor: number;
    onFailure: "pause" | "continue";
    fromWalletId: string;
    toCurrency?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    narration?: string | undefined;
    scheduledAt?: Date | undefined;
    cronExpression?: string | undefined;
    endsAt?: Date | undefined;
    nextFireAt?: Date | undefined;
    lastFiredAt?: Date | undefined;
    toWalletId?: string | undefined;
    recipient?: {
        identifiers: {
            type: "owner" | "email" | "username" | "paytag";
            ownerId?: string | undefined;
            ownerType?: string | undefined;
            value?: string | undefined;
        }[];
        walletCurrency?: string | undefined;
    } | undefined;
}, {
    status: "completed" | "cancelled" | "active" | "firing" | "paused";
    id: string;
    tenantId: string;
    createdAt: Date;
    updatedAt: Date;
    fromCurrency: string;
    amountMinor: number;
    fromWalletId: string;
    toCurrency?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    narration?: string | undefined;
    scheduledAt?: Date | undefined;
    cronExpression?: string | undefined;
    endsAt?: Date | undefined;
    onFailure?: "pause" | "continue" | undefined;
    nextFireAt?: Date | undefined;
    lastFiredAt?: Date | undefined;
    toWalletId?: string | undefined;
    recipient?: {
        identifiers: {
            type: "owner" | "email" | "username" | "paytag";
            ownerId?: string | undefined;
            ownerType?: string | undefined;
            value?: string | undefined;
        }[];
        walletCurrency?: string | undefined;
    } | undefined;
}>;
export type ScheduledTransfer = z.infer<typeof ScheduledTransferSchema>;
export type ScheduledTransferStatus = z.infer<typeof ScheduledTransferStatusSchema>;
export declare const ScheduledTransferExecutionSchema: z.ZodObject<{
    id: z.ZodString;
    scheduledTransferId: z.ZodString;
    tenantId: z.ZodString;
    /** The crossUser or withConversion operation id that was created on success. */
    operationId: z.ZodOptional<z.ZodString>;
    firedAt: z.ZodDate;
    status: z.ZodEnum<["succeeded", "failed"]>;
    failureReason: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    status: "failed" | "succeeded";
    id: string;
    tenantId: string;
    firedAt: Date;
    scheduledTransferId: string;
    operationId?: string | undefined;
    failureReason?: string | undefined;
}, {
    status: "failed" | "succeeded";
    id: string;
    tenantId: string;
    firedAt: Date;
    scheduledTransferId: string;
    operationId?: string | undefined;
    failureReason?: string | undefined;
}>;
export type ScheduledTransferExecution = z.infer<typeof ScheduledTransferExecutionSchema>;
//# sourceMappingURL=schemas.d.ts.map