import SearchObject from '../SearchObject.js';
import type { Query, Context, Select, Operator } from '../../resources/ResourceInterface.ts';
import BridgeMethods from './BridgeMethods.js';
import { DeleteTransactionLogsBeforeResults } from './DeleteTransactionLogsBeforeResults.ts';
import type { Readable } from 'node:stream';
export type SearchByConditionsRequest = Query & Context & {
    schema?: string;
    database?: string;
    table: string;
    get_attributes: Select;
    reverse?: boolean;
    operator?: Operator;
};
/**
 * Bridge between the operations/REST/SQL API layer and the underlying resource layer.
 * Handles search (by conditions, hash, or value), schema/table/attribute CRUD, record
 * create/update/upsert/delete, audit log read/purge, and backup operations.
 */
export declare class ResourceBridge extends BridgeMethods {
    searchByConditions(searchObject: SearchByConditionsRequest): Promise<any>;
    /**
     * Writes new table data to the system tables creates the environment file and creates two datastores to track created and updated
     * timestamps for new table data.
     * @param tableSystemData
     * @param tableCreateObj
     */
    createTable(tableSystemData: any, tableCreateObj: any): Promise<void>;
    createAttribute(createAttributeObj: any): Promise<string>;
    dropAttribute(dropAttributeObj: any): Promise<string>;
    dropTable(dropTableObject: any): Promise<void>;
    createSchema(createSchemaObj: any): Promise<any>;
    dropSchema(dropSchemaObj: any): Promise<void>;
    updateRecords(updateObj: any): Promise<{
        txn_time: any;
        written_hashes: any[];
        new_attributes: any;
        skipped_hashes: any[];
    }>;
    createRecords(updateObj: any): Promise<{
        txn_time: any;
        written_hashes: any[];
        new_attributes: any;
        skipped_hashes: any[];
    }>;
    upsertRecords(upsertObj: any): Promise<{
        txn_time: any;
        written_hashes: any[];
        new_attributes: any;
        skipped_hashes: any[];
    }>;
    deleteRecords(deleteObj: any): Promise<{
        message: string;
        deleted_hashes: any;
        skipped_hashes: any;
        txn_time: any;
    }>;
    /**
     * Deletes all records in a schema.table that fall behind a passed date.
     * @param deleteObj
     * {
     *     operation: 'delete_records_before' <string>,
     *     date: ISO-8601 format YYYY-MM-DD <string>,
     *     schema: Schema where table resides <string>,
     *     table: Table to delete records from <string>,
     * }
     * @returns {undefined}
     */
    deleteRecordsBefore(deleteObj: any): Promise<{
        message: string;
        deleted_hashes: any;
        skipped_hashes: any;
        txn_time: any;
    } | {
        message: string;
    }>;
    /**
     * fetches records by their hash values and returns an Array of the results
     * @param {SearchByHashObject} searchObject
     */
    searchByHash(searchObject: any): {
        [Symbol.asyncIterator](): {
            next(): Promise<{
                value: any;
                done?: undefined;
            } | {
                done: boolean;
                value?: undefined;
            }>;
            return(value: any): {
                value: any;
                done: boolean;
            };
            throw(error: any): {
                done: boolean;
            };
        };
    };
    /**
     * Called by some SQL functions
     * @param searchObject
     */
    getDataByHash(searchObject: any): Promise<Map<any, any>>;
    searchByValue(searchObject: SearchObject, comparator?: string): any;
    getDataByValue(searchObject: SearchObject, comparator?: string): Promise<Map<any, any>>;
    resetReadTxn(schema: any, table: any): void;
    /**
     * Deletes transaction logs before a given timestamp.
     * @param deleteObj The request body
     * @returns
     */
    deleteTransactionLogsBefore(deleteObj: {
        schema?: string;
        database?: string;
        table?: string;
        timestamp: Date | number | string;
        cleanup_deleted_records?: boolean;
    }): Promise<DeleteTransactionLogsBeforeResults>;
    readAuditLog(readAuditLogObj: any): Promise<{}>;
    getBackup(getBackupObj: {
        database?: string;
        schema?: string;
        table?: string;
        tables?: string[];
    }): Promise<Readable>;
}
