import { type ValidListActionsArgs, type ValidListOutputsArgs } from '@bsv/sdk/wallet/validationHelpers';
import { InternalizeActionArgs, ListActionsResult, ListOutputsResult, TelemetrySpan } from '@bsv/sdk';
import { TableCertificate, TableCertificateField, TableCertificateX, TableCommission, TableMonitorEvent, TableOutput, TableOutputBasket, TableOutputTag, TableOutputTagMap, TableProvenTx, TableProvenTxReq, TableSettings, TableSyncState, TableTransaction, TableTxLabel, TableTxLabelMap, TableUser } from './schema/tables';
import { TableActionBatch, TableActionBatchBlob, TableActionBatchOutput } from './schema/tables/TableActionBatch';
import { TablePreparedBeef } from './schema/tables/TablePreparedBeef.interfaces';
import { Knex } from 'knex';
import { AdminStatsResult, StorageProvider, StorageProviderOptions } from './StorageProvider';
import { DBType } from './StorageReader';
import { WalletServices } from '../sdk/WalletServices.interfaces';
import { AuthId, StorageInternalizeActionResult, FindCertificateFieldsArgs, FindCertificatesArgs, FindCommissionsArgs, FindForUserSincePagedArgs, FindMonitorEventsArgs, FindOutputBasketsArgs, FindOutputsArgs, FindOutputTagMapsArgs, FindOutputTagsArgs, FindPartialSincePagedArgs, FindProvenTxReqsArgs, FindProvenTxsArgs, FindStaleMerkleRootsArgs, FindSyncStatesArgs, FindTransactionsArgs, FindTxLabelMapsArgs, FindTxLabelsArgs, FindUsersArgs, ProvenOrRawTx, PurgeParams, PurgeResults, TrxToken, RequestSyncChunkArgs, SyncChunkTotals, WalletStorageProvider } from '../sdk/WalletStorage.interfaces';
import { EntityTimeStamp, TransactionStatus } from '../sdk/types';
import type { ManagedChangeInputCandidate } from './methods/availableManagedChange';
import { PreparedBeefLookupResult, PreparedBeefOptions, PreparedBeefPolicy, PreparedBeefPreparation, PreparedBeefRoot } from './methods/preparedBeef';
import type { Brc177NoSendExpiryState } from '../utility/brc177NoSendExpiry';
export interface StorageKnexOptions extends StorageProviderOptions {
    /**
     * Knex database interface initialized with valid connection configuration.
     */
    knex: Knex;
    /** Optional prepared-BEEF (COOK) rollout controls. Disabled by default. */
    preparedBeef?: PreparedBeefOptions;
}
export declare class StorageKnex extends StorageProvider implements WalletStorageProvider {
    knex: Knex;
    readonly preparedBeefPolicy: PreparedBeefPolicy;
    private readonly preparedBeefCoordinator;
    private readonly preparedBeefReadSuspensions;
    private nextPreparedBeefReadSuspension;
    private readonly querySpans;
    private readonly onQuery;
    private readonly onQueryResponse;
    private readonly onQueryError;
    constructor(options: StorageKnexOptions);
    private receiptClockMs;
    private receiptLeaseMs;
    private acquireInternalizeReceipt;
    internalizeAction(auth: AuthId, args: InternalizeActionArgs): Promise<StorageInternalizeActionResult>;
    private databaseSystem;
    private endQuerySpan;
    protected supportsActionBatchPersistence(): boolean;
    protected supportsNoSendExpiryPersistence(): boolean;
    protected requiresActionBatchCleanupBeforeCreateAction(): boolean;
    makeAvailable(): Promise<TableSettings>;
    setServices(services: WalletServices): void;
    readSettings(trx?: TrxToken): Promise<TableSettings>;
    getProvenOrRawTx(txid: string, trx?: TrxToken): Promise<ProvenOrRawTx>;
    getProvenOrRawTxs(txids: string[], trx?: TrxToken): Promise<Map<string, ProvenOrRawTx>>;
    findPreparedBeefs(userId: number, rootTxids: string[], trx?: TrxToken): Promise<TablePreparedBeef[]>;
    /**
     * Metadata-only foreground preflight for fragmented actions. SQL computes
     * the actual blob lengths; BEEF bytes are not transferred to the process.
     */
    readPreparedBeefLookupByteLength(userId: number, rootTxids: string[]): Promise<number>;
    readPreparedBeefProofEpoch(trx?: TrxToken): Promise<number>;
    /**
     * Cheap worker preflight. It prevents a large tenant-controlled no-send BEEF
     * from being loaded and parsed merely to discover that COOK will reject it.
     */
    readPreparedBeefSourceByteLength(rootTxid: string): Promise<number | undefined>;
    upsertPreparedBeef(artifact: TablePreparedBeef, expectedProofEpoch: number): Promise<boolean>;
    findPreparedBeefBackfillRoots(limit: number, formatVersion: number): Promise<PreparedBeefRoot[]>;
    invalidatePreparedBeefs(trx?: TrxToken): Promise<number>;
    lookupPreparedBeefs(userId: number, rootTxids: string[], parent?: TelemetrySpan): Promise<PreparedBeefLookupResult>;
    preparedBeefReadsEnabled(): boolean;
    /**
     * Synchronously close the local prepared-read gate before asynchronous reorg
     * invalidation waits for manager/database locks. The returned release is
     * idempotent; callers release it only after invalidation commits.
     */
    suspendPreparedBeefReads(): () => void;
    preparedBeefWritesEnabled(): boolean;
    /** Queue best-effort preparation after foreground action work has completed. */
    enqueuePreparedBeef(preparation: PreparedBeefPreparation): boolean;
    /** Start the optional, rate-limited existing-wallet backfill. */
    startPreparedBeefBackfill(): void;
    /** Test/operator hook for waiting until currently queued work is complete. */
    waitForPreparedBeefTasks(): Promise<void>;
    /** Stop accepting background work and settle an active preparation before shutdown. */
    stopPreparedBeefTasks(): Promise<void>;
    private rawTxSliceExpression;
    private getRawTxSlice;
    getRawTxOfKnownValidTransaction(txid?: string, offset?: number, length?: number, trx?: TrxToken): Promise<number[] | undefined>;
    getProvenTxsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder;
    getProvenTxsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTx[]>;
    getProvenTxReqsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder;
    getProvenTxReqsForUser(args: FindForUserSincePagedArgs): Promise<TableProvenTxReq[]>;
    getTxLabelMapsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder;
    getTxLabelMapsForUser(args: FindForUserSincePagedArgs): Promise<TableTxLabelMap[]>;
    getOutputTagMapsForUserQuery(args: FindForUserSincePagedArgs): Knex.QueryBuilder;
    getOutputTagMapsForUser(args: FindForUserSincePagedArgs): Promise<TableOutputTagMap[]>;
    private countSyncQuery;
    getSyncChunkTotals(args: RequestSyncChunkArgs, userId: number): Promise<SyncChunkTotals>;
    listActions(auth: AuthId, vargs: ValidListActionsArgs): Promise<ListActionsResult>;
    listOutputs(auth: AuthId, vargs: ValidListOutputsArgs): Promise<ListOutputsResult>;
    /**
     * Insert one row and return its auto-increment primary key. MySQL and SQLite
     * report the id as the insert result; Postgres requires a RETURNING clause.
     */
    private insertReturningId;
    /**
     * The findOrInsert helpers catch a failed insert and find the row again in
     * the same transaction. MySQL and SQLite allow that. Postgres aborts the
     * whole transaction on any statement error, so there the insert runs in a
     * savepoint that is rolled back on its own.
     */
    private inSavepoint;
    insertProvenTx(tx: TableProvenTx, trx?: TrxToken): Promise<number>;
    insertActionBatch(batch: TableActionBatch, trx?: TrxToken): Promise<number>;
    findActionBatch(userId: number, batchId: string, trx?: TrxToken): Promise<TableActionBatch | undefined>;
    findActionBatchForUpdate(userId: number, batchId: string, trx: TrxToken): Promise<TableActionBatch | undefined>;
    findExpiredActionBatches(now: Date, trx?: TrxToken): Promise<TableActionBatch[]>;
    updateActionBatch(actionBatchId: number, update: Partial<TableActionBatch>, trx?: TrxToken): Promise<number>;
    deleteActionBatch(actionBatchId: number, trx?: TrxToken): Promise<void>;
    reserveActionBatchOutputs(reservations: TableActionBatchOutput[], trx?: TrxToken): Promise<void>;
    findActionBatchOutputIds(actionBatchId: number, trx?: TrxToken): Promise<number[]>;
    findReservedActionBatchOutputIds(outputIds: number[], trx?: TrxToken): Promise<number[]>;
    deleteActionBatchOutputReservations(actionBatchId: number, trx?: TrxToken): Promise<void>;
    putActionBatchBlobRecord(blob: TableActionBatchBlob, trx?: TrxToken): Promise<void>;
    findActionBatchBlobRecord(actionBatchId: number, digest: string, trx?: TrxToken): Promise<TableActionBatchBlob | undefined>;
    findActionBatchBlobRecords(actionBatchId: number, digests: string[], trx?: TrxToken): Promise<TableActionBatchBlob[]>;
    putActionBatchBlobRecords(blobs: TableActionBatchBlob[], trx?: TrxToken): Promise<void>;
    deleteActionBatchBlobRecords(actionBatchId: number, trx?: TrxToken): Promise<void>;
    insertProvenTxReq(tx: TableProvenTxReq, trx?: TrxToken): Promise<number>;
    insertUser(user: TableUser, trx?: TrxToken): Promise<number>;
    insertCertificateAuth(auth: AuthId, certificate: TableCertificateX): Promise<number>;
    insertCertificate(certificate: TableCertificateX, trx?: TrxToken): Promise<number>;
    insertCertificateField(certificateField: TableCertificateField, trx?: TrxToken): Promise<void>;
    insertOutputBasket(basket: TableOutputBasket, trx?: TrxToken): Promise<number>;
    insertTransaction(tx: TableTransaction, trx?: TrxToken): Promise<number>;
    insertCommission(commission: TableCommission, trx?: TrxToken): Promise<number>;
    insertOutput(output: TableOutput, trx?: TrxToken): Promise<number>;
    insertOutputs(outputs: TableOutput[], trx?: TrxToken): Promise<void>;
    insertOutputTag(tag: TableOutputTag, trx?: TrxToken): Promise<number>;
    insertOutputTagMap(tagMap: TableOutputTagMap, trx?: TrxToken): Promise<void>;
    insertTxLabel(label: TableTxLabel, trx?: TrxToken): Promise<number>;
    insertTxLabelMap(labelMap: TableTxLabelMap, trx?: TrxToken): Promise<void>;
    insertMonitorEvent(event: TableMonitorEvent, trx?: TrxToken): Promise<number>;
    insertSyncState(syncState: TableSyncState, trx?: TrxToken): Promise<number>;
    updateCertificateField(certificateId: number, fieldName: string, update: Partial<TableCertificateField>, trx?: TrxToken): Promise<number>;
    updateCertificate(id: number, update: Partial<TableCertificate>, trx?: TrxToken): Promise<number>;
    updateCommission(id: number, update: Partial<TableCommission>, trx?: TrxToken): Promise<number>;
    updateOutputBasket(id: number, update: Partial<TableOutputBasket>, trx?: TrxToken): Promise<number>;
    updateOutput(id: number, update: Partial<TableOutput>, trx?: TrxToken): Promise<number>;
    updateOutputTagMap(outputId: number, tagId: number, update: Partial<TableOutputTagMap>, trx?: TrxToken): Promise<number>;
    updateOutputTag(id: number, update: Partial<TableOutputTag>, trx?: TrxToken): Promise<number>;
    updateProvenTxReq(id: number | number[], update: Partial<TableProvenTxReq>, trx?: TrxToken): Promise<number>;
    updateProvenTx(id: number, update: Partial<TableProvenTx>, trx?: TrxToken): Promise<number>;
    updateSyncState(id: number, update: Partial<TableSyncState>, trx?: TrxToken): Promise<number>;
    updateTransaction(id: number | number[], update: Partial<TableTransaction>, trx?: TrxToken): Promise<number>;
    compareAndSetNoSendExpiryState(transactionId: number, expected: Brc177NoSendExpiryState, next: Brc177NoSendExpiryState, trx?: TrxToken): Promise<boolean>;
    updateTxLabelMap(transactionId: number, txLabelId: number, update: Partial<TableTxLabelMap>, trx?: TrxToken): Promise<number>;
    updateTxLabel(id: number, update: Partial<TableTxLabel>, trx?: TrxToken): Promise<number>;
    updateUser(id: number, update: Partial<TableUser>, trx?: TrxToken): Promise<number>;
    updateMonitorEvent(id: number, update: Partial<TableMonitorEvent>, trx?: TrxToken): Promise<number>;
    setupQuery<T extends object>(table: string, args: FindPartialSincePagedArgs<T>): Knex.QueryBuilder;
    findCertificateFieldsQuery(args: FindCertificateFieldsArgs): Knex.QueryBuilder;
    findCertificatesQuery(args: FindCertificatesArgs): Knex.QueryBuilder;
    findCommissionsQuery(args: FindCommissionsArgs): Knex.QueryBuilder;
    findOutputBasketsQuery(args: FindOutputBasketsArgs): Knex.QueryBuilder;
    findOutputsQuery(args: FindOutputsArgs, count?: boolean): Knex.QueryBuilder;
    findOutputTagMapsQuery(args: FindOutputTagMapsArgs): Knex.QueryBuilder;
    findOutputTagsQuery(args: FindOutputTagsArgs): Knex.QueryBuilder;
    findProvenTxReqsQuery(args: FindProvenTxReqsArgs): Knex.QueryBuilder;
    findProvenTxsQuery(args: FindProvenTxsArgs): Knex.QueryBuilder;
    findStaleMerkleRootsQuery(args: FindStaleMerkleRootsArgs): Knex.QueryBuilder;
    findSyncStatesQuery(args: FindSyncStatesArgs): Knex.QueryBuilder;
    findTransactionsQuery(args: FindTransactionsArgs, count?: boolean): Knex.QueryBuilder;
    findTxLabelMapsQuery(args: FindTxLabelMapsArgs): Knex.QueryBuilder;
    findTxLabelsQuery(args: FindTxLabelsArgs): Knex.QueryBuilder;
    findUsersQuery(args: FindUsersArgs): Knex.QueryBuilder;
    findMonitorEventsQuery(args: FindMonitorEventsArgs): Knex.QueryBuilder;
    findCertificatesAuth(auth: AuthId, args: FindCertificatesArgs): Promise<TableCertificateX[]>;
    findProvenTxReqsAuth(auth: AuthId, args: FindProvenTxReqsArgs): Promise<TableProvenTxReq[]>;
    findOutputBasketsAuth(auth: AuthId, args: FindOutputBasketsArgs): Promise<TableOutputBasket[]>;
    findOutputsAuth(auth: AuthId, args: FindOutputsArgs): Promise<TableOutput[]>;
    findCertificateFields(args: FindCertificateFieldsArgs): Promise<TableCertificateField[]>;
    findCertificates(args: FindCertificatesArgs): Promise<TableCertificateX[]>;
    findCommissions(args: FindCommissionsArgs): Promise<TableCommission[]>;
    findOutputBaskets(args: FindOutputBasketsArgs): Promise<TableOutputBasket[]>;
    findOutputs(args: FindOutputsArgs): Promise<TableOutput[]>;
    findOutputTagMaps(args: FindOutputTagMapsArgs): Promise<TableOutputTagMap[]>;
    findOutputTags(args: FindOutputTagsArgs): Promise<TableOutputTag[]>;
    findProvenTxReqs(args: FindProvenTxReqsArgs): Promise<TableProvenTxReq[]>;
    findProvenTxs(args: FindProvenTxsArgs): Promise<TableProvenTx[]>;
    findStaleMerkleRoots(args: FindStaleMerkleRootsArgs): Promise<string[]>;
    findSyncStates(args: FindSyncStatesArgs): Promise<TableSyncState[]>;
    findTransactions(args: FindTransactionsArgs): Promise<TableTransaction[]>;
    findTxLabelMaps(args: FindTxLabelMapsArgs): Promise<TableTxLabelMap[]>;
    findTxLabels(args: FindTxLabelsArgs): Promise<TableTxLabel[]>;
    findUsers(args: FindUsersArgs): Promise<TableUser[]>;
    recentlyActiveUsers(limit?: number, trx?: TrxToken): Promise<TableUser[]>;
    findMonitorEvents(args: FindMonitorEventsArgs): Promise<TableMonitorEvent[]>;
    getCount<T extends object>(q: Knex.QueryBuilder<T, T[]>): Promise<number>;
    countCertificateFields(args: FindCertificateFieldsArgs): Promise<number>;
    countCertificates(args: FindCertificatesArgs): Promise<number>;
    countCommissions(args: FindCommissionsArgs): Promise<number>;
    countOutputBaskets(args: FindOutputBasketsArgs): Promise<number>;
    countOutputs(args: FindOutputsArgs): Promise<number>;
    countOutputTagMaps(args: FindOutputTagMapsArgs): Promise<number>;
    countOutputTags(args: FindOutputTagsArgs): Promise<number>;
    countProvenTxReqs(args: FindProvenTxReqsArgs): Promise<number>;
    countProvenTxs(args: FindProvenTxsArgs): Promise<number>;
    countSyncStates(args: FindSyncStatesArgs): Promise<number>;
    countTransactions(args: FindTransactionsArgs): Promise<number>;
    countTxLabelMaps(args: FindTxLabelMapsArgs): Promise<number>;
    countTxLabels(args: FindTxLabelsArgs): Promise<number>;
    countUsers(args: FindUsersArgs): Promise<number>;
    countMonitorEvents(args: FindMonitorEventsArgs): Promise<number>;
    destroy(): Promise<void>;
    migrate(storageName: string, storageIdentityKey: string): Promise<string>;
    dropAllData(): Promise<void>;
    transaction<T>(scope: (trx: TrxToken) => Promise<T>, trx?: TrxToken): Promise<T>;
    /**
     * Convert the standard optional `TrxToken` parameter into either a direct knex database instance,
     * or a Knex.Transaction as appropriate.
     */
    toDb(trx?: TrxToken): Knex | Knex.Transaction<any, any[]>;
    validateRawTransaction(t: TableTransaction, trx?: TrxToken): Promise<void>;
    _verifiedReadyForDatabaseAccess: boolean;
    /**
     * Make sure database is ready for access:
     *
     * - dateScheme is known
     * - foreign key constraints are enabled
     *
     * @param trx
     */
    verifyReadyForDatabaseAccess(trx?: TrxToken): Promise<DBType>;
    /** Convert every byte-array value to a Buffer and every undefined to null on an arbitrary object. */
    private serialiseForKnex;
    /** Apply optional date-field coercion list in-place. */
    private coerceDateFields;
    /** Apply optional boolean-field coercion list in-place. */
    private coerceBooleanFields;
    /**
     * Helper to force uniform behavior across database engines.
     * Use to process the update template for entities being updated.
     */
    validatePartialForUpdate<T extends EntityTimeStamp>(update: Partial<T>, dateFields?: string[], booleanFields?: string[]): Partial<T>;
    /**
     * Helper to force uniform behavior across database engines.
     * Use to process new entities being inserted into the database.
     */
    validateEntityForInsert<T extends EntityTimeStamp>(entity: T, trx?: TrxToken, dateFields?: string[], booleanFields?: string[]): Promise<any>;
    getLabelsForTransactionId(transactionId?: number, trx?: TrxToken): Promise<TableTxLabel[]>;
    getTagsForOutputId(outputId: number, trx?: TrxToken): Promise<TableOutputTag[]>;
    purgeData(params: PurgeParams, trx?: TrxToken): Promise<PurgeResults>;
    reviewStatus(args: {
        agedLimit: Date;
        trx?: TrxToken;
    }): Promise<{
        log: string;
    }>;
    /**
     * Counts wallet-managed BRC-29 change outputs for userId in basketId that
     * are currently eligible for automatic allocation
     * AND whose transaction status is one of:
     * - completed
     * - unproven
     * - sending (if excludeSending is false)
     */
    countChangeInputs(userId: number, basketId: number, excludeSending: boolean): Promise<number>;
    findAvailableManagedChangeInputs(userId: number, basketId: number, excludeSending: boolean, trx?: TrxToken): Promise<TableOutput[]>;
    findAvailableManagedChangeInputCandidates(userId: number, basketId: number, excludeSending: boolean, trx?: TrxToken): Promise<ManagedChangeInputCandidate[]>;
    findOutputsByIds(outputIds: number[], trx?: TrxToken): Promise<Record<number, TableOutput>>;
    findOutputsByOutpoints(userId: number, outpoints: Array<{
        txid: string;
        vout: number;
    }>, trx?: TrxToken): Promise<Record<string, TableOutput>>;
    findOutputsByOutpointsForUpdate(userId: number, outpoints: Array<{
        txid: string;
        vout: number;
    }>, trx: TrxToken, noScript?: boolean): Promise<Record<string, TableOutput>>;
    findTransactionStatusesByIds(userId: number, transactionIds: number[], trx?: TrxToken): Promise<Map<number, TransactionStatus>>;
    findFundingOutputsForUpdate(userId: number, outputIds: number[], statuses: TransactionStatus[], trx: TrxToken): Promise<Record<number, TableOutput>>;
    findOrInsertOutputBasketsBulk(userId: number, names: string[], trx?: TrxToken): Promise<Record<string, TableOutputBasket>>;
    findOrInsertOutputTagsBulk(userId: number, tags: string[], trx?: TrxToken): Promise<Record<string, TableOutputTag>>;
    findOrInsertTxLabelsBulk(userId: number, labels: string[], trx?: TrxToken): Promise<Record<string, TableTxLabel>>;
    sumSpendableSatoshisInBasket(userId: number, basketId: number, excludeSending: boolean, trx?: TrxToken): Promise<number>;
    /**
     *  Finds closest matching available change output to use as input for new transaction.
     *
     * Transactionally allocate the output such that
     */
    allocateChangeInput(userId: number, basketId: number, targetSatoshis: number, exactSatoshis: number | undefined, excludeSending: boolean, transactionId: number): Promise<TableOutput | undefined>;
    markChangeInputsSpent(outputIds: number[], transactionId: number, trx: TrxToken): Promise<number>;
    /** Convert null→undefined and Buffer→number[] on a retrieved entity in-place. */
    private deserialiseFromKnex;
    /**
     * Helper to force uniform behavior across database engines.
     * Use to process all individual records with time stamps retreived from database.
     */
    validateEntity<T extends EntityTimeStamp>(entity: T, dateFields?: string[], booleanFields?: string[]): T;
    /**
     * Helper to force uniform behavior across database engines.
     * Use to process all arrays of records with time stamps retreived from database.
     * @returns input `entities` array with contained values validated.
     */
    validateEntities<T extends EntityTimeStamp>(entities: T[], dateFields?: string[], booleanFields?: string[]): T[];
    adminStats(adminIdentityKey: string): Promise<AdminStatsResult>;
}
//# sourceMappingURL=StorageKnex.d.ts.map