import { ClearOptions, CollectionNameFromModels, CollectionQuery, Models, Roles, Schema, PossibleDataViolation, QueryResultCardinality } from '@triplit/db';
import { DBChanges, Triple, KVStore, EntitySyncStore, EntityWriteOptions } from './types.js';
import { HybridLogicalClock, Timestamp } from './hybrid-clock.js';
import { IVM, IVMOptions } from './ivm.js';
import { DBTransaction } from './db-transaction.js';
import { Logger } from '@triplit/types/logger';
import { DBSession } from './session.js';
type SubscriptionResultsCallback = (results: any[]) => void;
type FetchOptions = {
    skipRules?: boolean;
};
type OnCommitCallback = (changes: DBChanges) => Promise<void>;
export interface DBOptions<M extends Models = Models, E extends EntitySyncStore = EntitySyncStore> {
    kv?: KVStore;
    clientId?: string;
    entityStore?: E;
    schema?: DBSchema<M>;
    ivm?: IVM;
    variables?: Record<string, any>;
    logger?: Logger;
    ivmOptions?: IVMOptions;
}
export type DBSchema<M extends Models = Models> = {
    collections: M;
    roles?: Roles;
};
export declare class DB<M extends Models = Models, E extends EntitySyncStore = EntitySyncStore> {
    entityStore: E;
    clock: HybridLogicalClock;
    session: DBSession | undefined;
    globalVars: Record<string, any>;
    logger: Logger;
    subscribedQueries: Map<string, {
        query: CollectionQuery;
        resultsListeners: Set<SubscriptionResultsCallback>;
        lastResult?: any[];
    }>;
    readonly clientId: string;
    ivm: IVM;
    schema: DBSchema | undefined;
    onCommitListeners: Set<OnCommitCallback>;
    readonly kv: KVStore;
    private typeConverters?;
    constructor(options?: DBOptions<M, E>);
    static getSchemaFromStorage(kv: KVStore): Promise<DBSchema | undefined>;
    getSchema(): DBSchema<Models> | undefined;
    subscribe(query: CollectionQuery<M>, onResults: (results: any[]) => void | Promise<void>, onError?: ErrorCallback, options?: FetchOptions): () => void;
    subscribeWithPagination(query: CollectionQuery<M>, onResults: (results: any[]) => void | Promise<void>): () => void;
    subscribeWithExpand(query: CollectionQuery<M>, onResults: (results: any[], info: {
        hasMore: boolean;
    }) => void | Promise<void>): () => void;
    subscribeChanges(query: CollectionQuery, onResults: (results: DBChanges) => void | Promise<void>, options?: {
        queryState?: {
            timestamp: Timestamp;
            entityIds: Record<string, string[]>;
        };
    }): () => void;
    fetch(query: CollectionQuery<M>, options?: FetchOptions): Promise<any[]>;
    rawFetch(query: CollectionQuery<M>): Promise<any[]>;
    applyTypeConversions(result: any[] | any, query: CollectionQuery<M>, cardinality: QueryResultCardinality): any;
    fetchTriples(query: CollectionQuery<M>, options?: FetchOptions): Promise<DBChanges>;
    fetchOne(query: CollectionQuery<M>, options?: FetchOptions): Promise<any>;
    fetchById(collectionName: string, id: string, options?: FetchOptions): Promise<any>;
    insert(collectionName: string, data: any, options?: EntityWriteOptions): Promise<any>;
    insertTriples(triples: Triple[], options?: {
        triggerReactivity: boolean;
    }): Promise<void>;
    update(collectionName: string, id: string, data: any, options?: EntityWriteOptions): Promise<{
        output: void | undefined;
        isCanceled: boolean;
    }>;
    delete(collectionName: string, id: string, options?: EntityWriteOptions): Promise<{
        output: void | undefined;
        isCanceled: boolean;
    }>;
    onCommit(callback: OnCommitCallback): () => void;
    updateQueryViews(): Promise<void>;
    broadcastToQuerySubscribers(): void;
    transact<Output>(callback: (tx: DBTransaction) => Promise<Output>, options?: EntityWriteOptions): Promise<{
        output: Output | undefined;
        isCanceled: boolean;
    }>;
    applyChanges(changes: DBChanges, options: EntityWriteOptions): Promise<void>;
    applyChangesWithTimestamp(changes: DBChanges, timestamp: Timestamp, options: EntityWriteOptions): Promise<void>;
    getCollectionStats(): Promise<Map<string, number>>;
    overrideSchema(newSchema: DBSchema, { failOnBackwardsIncompatibleChange }?: {
        failOnBackwardsIncompatibleChange?: boolean | undefined;
    }): Promise<{
        successful: boolean;
        issues: PossibleDataViolation[];
    }>;
    setMetadata(key: string[], value: any): Promise<void>;
    getMetadata(key: string[]): Promise<any>;
    updateSchema(schema: DBSchema): Promise<void>;
    /**
     * WARNING: (I think) using `this` in the constructor will not pick up the proxy information created here
     * Example: new IVM(this) // db.session will be undefined
     */
    withSessionVars(variables: Record<string, any>): DB<M, E>;
    onSchemaChange(callback: (schema: Schema) => void): void;
    query<CN extends CollectionNameFromModels<M>>(collectionName: CN, params?: Omit<CollectionQuery<M, CN>, 'collectionName'>): import("@triplit/db").QueryBuilder<M, CN, import("@triplit/db").CollectionQueryDefault<M, CN>>;
    clear(options?: ClearOptions): Promise<void>;
    updateGlobalVariables(vars: Record<string, any>): void;
    get systemVars(): {
        $global: Record<string, any>;
        $session: Record<string, any>;
    };
    getClientId(): Promise<string>;
    private validateEntityChange;
    private checkWritePermission;
}
export declare function changesToTriples(changes: DBChanges, timestamp: Timestamp): Triple[];
export declare function createDB(options: DBOptions): Promise<DB<Models, EntitySyncStore>>;
export {};