import type { StorageAdapterInternal, Page, PageOptions } from "../interfaces.js";
import type { ID, OperationStatus, EntryStatus } from "../types.js";
import type { Wallet, WalletBalance, LedgerEntry, Operation, FxSnapshot, PaymentPage, CheckoutSession, CheckoutQuote, CheckoutPayment, PayoutRecipient, ScheduledPayout, ScheduledPayoutExecution, ScheduledPayoutStatus, ScheduledTransfer, ScheduledTransferExecution, ScheduledTransferStatus } from "../schemas.js";
/**
 * Fully in-memory StorageAdapter — intended for testing and local development only.
 *
 * Balance derivation: replays LedgerEntries ordered by (effectiveAt ASC, sequence ASC),
 * exactly as a production adapter must.
 *
 * Concurrency: uses a per-wallet mutex (promise chain) to make debit balance-check +
 * entry-write atomic within the same JS event loop.
 */
export declare class InMemoryStorageAdapter implements StorageAdapterInternal {
    private wallets;
    private entries;
    private operations;
    private fxSnapshots;
    private paymentPages;
    private checkoutSessions;
    private checkoutQuotes;
    private checkoutPayments;
    private payoutRecipients;
    private scheduledPayouts;
    private scheduledPayoutExecutions;
    private scheduledTransfers;
    private scheduledTransferExecutions;
    /** Per-wallet serialisation locks — ensures atomic debit operations */
    private walletLocks;
    /** Per-wallet monotonic sequence counters — keyed by "tenantId:walletId" */
    private walletSeqCounters;
    private walletKey;
    private deriveBalance;
    private withWalletLock;
    private paginate;
    createWallet(wallet: Wallet): Promise<Wallet>;
    getWallet(tenantId: ID, walletId: ID): Promise<Wallet | null>;
    listWalletsByOwner(tenantId: ID, ownerId: ID, ownerType: string, page?: PageOptions): Promise<Page<Wallet>>;
    updateWallet(tenantId: ID, walletId: ID, patch: Partial<Wallet>): Promise<Wallet>;
    archiveWallet(tenantId: ID, walletId: ID): Promise<Wallet>;
    createEntries(tenantId: ID, entries: LedgerEntry[]): Promise<LedgerEntry[]>;
    getEntry(tenantId: ID, entryId: ID): Promise<LedgerEntry | null>;
    listEntriesByWallet(tenantId: ID, walletId: ID, page?: PageOptions, filter?: {
        beforeEffectiveAt?: Date;
        afterSequence?: number;
    }): Promise<Page<LedgerEntry>>;
    updateEntryStatus(tenantId: ID, entryId: ID, status: EntryStatus): Promise<LedgerEntry>;
    createOperation(operation: Operation): Promise<Operation>;
    getOperation(tenantId: ID, operationId: ID): Promise<Operation | null>;
    getOperationByIdempotencyKey(tenantId: ID, idempotencyKey: string): Promise<Operation | null>;
    getOperationByExternalId(tenantId: ID, externalId: string, provider: string): Promise<Operation | null>;
    updateOperationStatus(tenantId: ID, operationId: ID, status: OperationStatus, patch?: Partial<Pick<Operation, "providerFees" | "providerFeesCurrency" | "completedAt" | "externalId" | "provider">>): Promise<Operation>;
    mergeOperationMetadata(tenantId: ID, operationId: ID, patch: Record<string, unknown>): Promise<Operation>;
    listOperationsByWallet(tenantId: ID, walletId: ID, page?: PageOptions): Promise<Page<Operation>>;
    listOperations(tenantId: ID, page?: PageOptions, filter?: {
        walletId?: string;
        types?: string[];
        statuses?: string[];
        provider?: string;
        fromEffectiveAt?: Date;
        toEffectiveAt?: Date;
        idempotencyKey?: string;
        recipientId?: string;
    }): Promise<Page<Operation>>;
    getBalance(tenantId: ID, walletId: ID): Promise<WalletBalance>;
    getBalanceAt(tenantId: ID, walletId: ID, at: Date): Promise<WalletBalance>;
    /**
     * Returns the current reserved amount (sum of pending debits) for a wallet.
     * Called exclusively from createEntries under the wallet-level lock (§13 rule 6a).
     * NOT part of the public StorageAdapter surface.
     */
    getReserved(tenantId: ID, walletId: ID): Promise<number>;
    /**
     * Create a transit wallet with upsert semantics (IC-4).
     * If a wallet with (tenantId, ownerId, ownerType='checkout_session', currency) already
     * exists, return it without error (prevents duplicate transit wallets under concurrent races).
     */
    createTransitWallet(wallet: Wallet): Promise<Wallet>;
    createFxSnapshot(snapshot: FxSnapshot): Promise<FxSnapshot>;
    getFxSnapshot(tenantId: ID, snapshotId: ID): Promise<FxSnapshot | null>;
    createPaymentPage(page: PaymentPage): Promise<PaymentPage>;
    getPaymentPage(tenantId: ID, pageId: ID): Promise<PaymentPage | null>;
    updatePaymentPage(tenantId: ID, pageId: ID, patch: Partial<PaymentPage>): Promise<PaymentPage>;
    listPaymentPages(tenantId: ID, page?: PageOptions): Promise<Page<PaymentPage>>;
    createCheckoutSession(session: CheckoutSession): Promise<CheckoutSession>;
    getCheckoutSession(tenantId: ID, sessionId: ID): Promise<CheckoutSession | null>;
    findCheckoutSessionByPayerRef(tenantId: ID, pageId: ID, payerRefHash: string): Promise<CheckoutSession | null>;
    updateCheckoutSession(tenantId: ID, sessionId: ID, patch: Partial<CheckoutSession>): Promise<CheckoutSession>;
    listCheckoutSessionsByPage(tenantId: ID, pageId: ID, page?: PageOptions): Promise<Page<CheckoutSession>>;
    createCheckoutQuote(quote: CheckoutQuote): Promise<CheckoutQuote>;
    getCheckoutQuote(tenantId: ID, quoteId: ID): Promise<CheckoutQuote | null>;
    updateCheckoutQuote(tenantId: ID, quoteId: ID, patch: Partial<CheckoutQuote>): Promise<CheckoutQuote>;
    createCheckoutPayment(payment: CheckoutPayment): Promise<CheckoutPayment>;
    getCheckoutPayment(tenantId: ID, paymentId: ID): Promise<CheckoutPayment | null>;
    findCheckoutPaymentByProviderRef(tenantId: ID, providerRef: string): Promise<CheckoutPayment | null>;
    updateCheckoutPayment(tenantId: ID, paymentId: ID, patch: Partial<CheckoutPayment>): Promise<CheckoutPayment>;
    listCheckoutPaymentsBySession(tenantId: ID, sessionId: ID, page?: PageOptions): Promise<Page<CheckoutPayment>>;
    createPayoutRecipient(recipient: PayoutRecipient): Promise<PayoutRecipient>;
    getPayoutRecipient(tenantId: ID, recipientId: ID): Promise<PayoutRecipient | null>;
    updatePayoutRecipient(tenantId: ID, recipientId: ID, patch: Partial<PayoutRecipient>): Promise<PayoutRecipient>;
    listPayoutRecipients(tenantId: ID, page?: PageOptions, filter?: {
        provider?: string;
        currency?: string;
        ownerId?: string;
        ownerType?: string;
        includeArchived?: boolean;
    }): Promise<Page<PayoutRecipient>>;
    archivePayoutRecipient(tenantId: ID, recipientId: ID): Promise<PayoutRecipient>;
    /** Clear all state — useful between tests */
    clear(): void;
    createScheduledPayout(schedule: ScheduledPayout): Promise<ScheduledPayout>;
    getScheduledPayout(tenantId: ID, scheduleId: ID): Promise<ScheduledPayout | null>;
    updateScheduledPayout(tenantId: ID, scheduleId: ID, patch: Partial<ScheduledPayout>): Promise<ScheduledPayout>;
    listScheduledPayouts(tenantId: ID, page?: PageOptions, filter?: {
        walletId?: string;
        recipientId?: string;
        status?: ScheduledPayoutStatus;
    }): Promise<Page<ScheduledPayout>>;
    listDueScheduledPayouts(tenantId: ID, now: Date): Promise<ScheduledPayout[]>;
    claimScheduledPayout(tenantId: ID, scheduleId: ID, now: Date): Promise<ScheduledPayout | null>;
    createScheduledPayoutExecution(exec: ScheduledPayoutExecution): Promise<ScheduledPayoutExecution>;
    listScheduledPayoutExecutions(tenantId: ID, scheduleId: ID, page?: PageOptions): Promise<Page<ScheduledPayoutExecution>>;
    createScheduledTransfer(schedule: ScheduledTransfer): Promise<ScheduledTransfer>;
    getScheduledTransfer(tenantId: ID, scheduleId: ID): Promise<ScheduledTransfer | null>;
    updateScheduledTransfer(tenantId: ID, scheduleId: ID, patch: Partial<ScheduledTransfer>): Promise<ScheduledTransfer>;
    listScheduledTransfers(tenantId: ID, page?: PageOptions, filter?: {
        fromWalletId?: string;
        status?: ScheduledTransferStatus;
    }): Promise<Page<ScheduledTransfer>>;
    listDueScheduledTransfers(tenantId: ID, now: Date): Promise<ScheduledTransfer[]>;
    claimScheduledTransfer(tenantId: ID, scheduleId: ID, now: Date): Promise<ScheduledTransfer | null>;
    createScheduledTransferExecution(exec: ScheduledTransferExecution): Promise<ScheduledTransferExecution>;
    listScheduledTransferExecutions(tenantId: ID, scheduleId: ID, page?: PageOptions): Promise<Page<ScheduledTransferExecution>>;
}
//# sourceMappingURL=memory.d.ts.map