import { Databases } from 'appwrite';
import { TableDefinition, DatabaseSchema, JoinOptions } from '../shared/types';
import { WebTable } from './table';
export declare class WebORMInstance<T extends TableDefinition[]> {
    private databases;
    private databaseId;
    private schemas;
    private collectionIds;
    private client?;
    private config?;
    private tables;
    constructor(databases: Databases, databaseId: string, schemas: Map<string, DatabaseSchema>, collectionIds?: Map<string, string>, client?: any | undefined, config?: any | undefined);
    /**
     * Get a table instance by name (similar to SQLAlchemy's table access)
     */
    table<K extends T[number]['name']>(name: K): WebTable<Extract<T[number], {
        name: K;
    }>['schema'], any>;
    /**
     * Legacy method - Create a new document with validation
     * @deprecated Use table(name).create() instead
     */
    create<K extends T[number]['name']>(collection: K, data: any): Promise<any>;
    /**
     * Legacy method - Update a document with validation
     * @deprecated Use table(name).update() instead
     */
    update<K extends T[number]['name']>(collection: K, documentId: string, data: any): Promise<any>;
    /**
     * Legacy method - Get a document by ID
     * @deprecated Use table(name).get() instead
     */
    get<K extends T[number]['name']>(collection: K, documentId: string): Promise<any>;
    /**
     * Legacy method - List documents with optional queries
     * @deprecated Use table(name).query() or table(name).all() instead
     */
    list<K extends T[number]['name']>(collection: K, queries?: string[]): Promise<{
        documents: any[];
        total: number;
    }>;
    /**
     * Legacy method - Delete a document
     * @deprecated Use table(name).delete() instead
     */
    delete<K extends T[number]['name']>(collection: K, documentId: string): Promise<void>;
    /**
     * Join two collections by fetching related documents
     * This performs a client-side join by fetching documents from both collections
     */
    join<K1 extends T[number]['name'], K2 extends T[number]['name']>(collection1: K1, collection2: K2, options: JoinOptions, filters1?: Record<string, unknown>, filters2?: Record<string, unknown>): Promise<any[]>;
    /**
     * Left join two collections - includes all documents from collection1 even if no match in collection2
     */
    leftJoin<K1 extends T[number]['name'], K2 extends T[number]['name']>(collection1: K1, collection2: K2, options: JoinOptions, filters1?: Record<string, unknown>, filters2?: Record<string, unknown>): Promise<any[]>;
    /**
     * Inner join two collections - only includes documents where there's a match in both collections
     */
    innerJoin<K1 extends T[number]['name'], K2 extends T[number]['name']>(collection1: K1, collection2: K2, options: JoinOptions, filters1?: Record<string, unknown>, filters2?: Record<string, unknown>): Promise<any[]>;
    /**
     * Close all listeners across all tables (useful for test cleanup)
     */
    closeListeners(): void;
    /**
     * Export all data from all tables to JSON
     * Returns a JSON string with all collections and their documents
     */
    exportDataToJSON(): Promise<string>;
    /**
     * Export all data from all tables as an object
     * Returns an object with collection names as keys and document arrays as values
     */
    exportDataToObject(): Promise<Record<string, any[]>>;
    /**
     * Export data from specific tables to JSON
     */
    exportTablesDataToJSON(tableNames: string[]): Promise<string>;
    /**
     * Export data from specific tables as an object
     */
    exportTablesDataToObject(tableNames: string[]): Promise<Record<string, any[]>>;
}
//# sourceMappingURL=orm-instance.d.ts.map