import { EventEmitter } from 'node:events';
import { Logger, LoggerOptions } from '@tachybase/logger';
import { AsyncEmitter } from '@tachybase/utils';
import merge from 'deepmerge';
import { ModelStatic, Options, QueryInterfaceDropAllTablesOptions, QueryOptions, Sequelize, SyncOptions, Transactionable } from 'sequelize';
import { ConnectionManager } from 'sequelize/types/dialects/abstract/connection-manager';
import { Umzug } from 'umzug';
import { Collection, CollectionOptions, RepositoryType } from './collection';
import { CollectionFactory } from './collection-factory';
import { CollectionGroupManager } from './collection-group-manager';
import { ImportFileExtension } from './collection-importer';
import DatabaseUtils from './database-utils';
import ReferencesMap from './features/references-map';
import { ArrayFieldRepository } from './field-repository/array-field-repository';
import * as FieldTypes from './fields';
import { Field, FieldContext, RelationField } from './fields';
import InheritanceMap from './inherited-map';
import { MigrationItem, Migrations } from './migration';
import { Model } from './model';
import { ModelHook } from './model-hook';
import QueryInterface from './query-interface/query-interface';
import { RelationRepository } from './relation-repository/relation-repository';
import { Repository } from './repository';
import { AfterDefineCollectionListener, BeforeDefineCollectionListener, CreateListener, CreateWithAssociationsListener, DatabaseAfterDefineCollectionEventType, DatabaseAfterRemoveCollectionEventType, DatabaseBeforeDefineCollectionEventType, DatabaseBeforeRemoveCollectionEventType, DestroyListener, EventType, ModelCreateEventTypes, ModelCreateWithAssociationsEventTypes, ModelDestroyEventTypes, ModelSaveEventTypes, ModelSaveWithAssociationsEventTypes, ModelUpdateEventTypes, ModelUpdateWithAssociationsEventTypes, ModelValidateEventTypes, RemoveCollectionListener, SaveListener, SaveWithAssociationsListener, SyncListener, UpdateListener, UpdateWithAssociationsListener, ValidateListener } from './types';
import { BaseValueParser } from './value-parsers';
export type MergeOptions = merge.Options;
export interface PendingOptions {
    field: RelationField;
    model: ModelStatic<Model>;
}
interface MapOf<T> {
    [key: string]: T;
}
export interface IDatabaseOptions extends Options {
    tablePrefix?: string;
    migrator?: any;
    usingBigIntForId?: boolean;
    underscored?: boolean;
    logger?: LoggerOptions | Logger;
    customHooks?: any;
    instanceId?: string;
}
export type DatabaseOptions = IDatabaseOptions;
interface RegisterOperatorsContext {
    db?: Database;
    path?: string;
    field?: Field;
    app?: any;
}
export interface CleanOptions extends QueryInterfaceDropAllTablesOptions {
    drop?: boolean;
}
export type AddMigrationsOptions = {
    context?: any;
    namespace?: string;
    extensions?: string[];
    directory: string;
};
type OperatorFunc = (value: any, ctx?: RegisterOperatorsContext) => any;
export declare const DialectVersionAccessors: {
    sqlite: {
        sql: string;
        get: (v: string) => string;
    };
    mysql: {
        sql: string;
        get: (v: string) => string;
    };
    mariadb: {
        sql: string;
        get: (v: string) => string;
    };
    postgres: {
        sql: string;
        get: (v: string) => string;
    };
};
declare class DatabaseVersion {
    db: Database;
    constructor(db: Database);
    satisfies(versions: any): Promise<boolean>;
}
declare module 'sequelize' {
    interface Sequelize {
        dialect: any;
        readonly connectionManager: ConnectionManager;
    }
}
export declare class Database extends EventEmitter implements AsyncEmitter {
    sequelize: Sequelize;
    migrator: Umzug;
    migrations: Migrations;
    fieldTypes: Map<any, any>;
    fieldValueParsers: Map<any, any>;
    options: IDatabaseOptions;
    models: Map<string, ModelStatic<Model<any, any>>>;
    repositories: Map<string, typeof Repository>;
    operators: Map<any, any>;
    collections: Map<string, Collection<any, any>>;
    pendingFields: Map<string, FieldTypes.RelationField[]>;
    modelCollection: Map<ModelStatic<any>, Collection<any, any>>;
    tableNameCollectionMap: Map<string, Collection<any, any>>;
    context: any;
    queryInterface: QueryInterface;
    utils: DatabaseUtils;
    referenceMap: ReferencesMap;
    inheritanceMap: InheritanceMap;
    importedFrom: Map<string, Set<string>>;
    modelHook: ModelHook;
    version: DatabaseVersion;
    delayCollectionExtend: Map<string, {
        collectionOptions: CollectionOptions;
        mergeOptions?: any;
    }[]>;
    logger: Logger;
    collectionGroupManager: CollectionGroupManager;
    collectionFactory: CollectionFactory;
    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
    constructor(options: DatabaseOptions);
    _instanceId: string;
    get instanceId(): string;
    createMigrator({ migrations }: {
        migrations: any;
    }): Umzug<any>;
    setContext(context: any): void;
    sequelizeOptions(options: any): any;
    initListener(): void;
    addMigration(item: MigrationItem): void;
    addMigrations(options: AddMigrationsOptions): void;
    inDialect(...dialect: string[]): boolean;
    isMySQLCompatibleDialect(): boolean;
    /**
     * Add collection to database
     * @param options
     */
    collection<Attributes = any, CreateAttributes = Attributes>(options: CollectionOptions): Collection<Attributes, CreateAttributes>;
    getTablePrefix(): string;
    getFieldByPath(path: string): any;
    /**
     * get exists collection by its name
     * @param name
     */
    getCollection(name: string): Collection;
    hasCollection(name: string): boolean;
    removeCollection(name: string): Collection<any, any>;
    getModel<M extends Model>(name: string): ModelStatic<M>;
    getRepository<R extends Repository>(name: string): R;
    getRepository<R extends RelationRepository>(name: string, relationId: string | number): R;
    getRepository<R extends ArrayFieldRepository>(name: string, relationId: string | number): R;
    addPendingField(field: RelationField): void;
    removePendingField(field: RelationField): void;
    registerFieldTypes(fieldTypes: MapOf<typeof Field>): void;
    registerFieldValueParsers(parsers: MapOf<any>): void;
    buildFieldValueParser<T extends BaseValueParser>(field: Field, ctx: any): T;
    registerModels(models: MapOf<ModelStatic<any>>): void;
    registerRepositories(repositories: MapOf<RepositoryType>): void;
    initOperators(): void;
    registerOperators(operators: MapOf<OperatorFunc>): void;
    buildField(options: any, context: FieldContext): any;
    sync(options?: SyncOptions): Promise<Sequelize>;
    clean(options: CleanOptions): Promise<void>;
    collectionExistsInDb(name: string, options?: Transactionable): Promise<boolean>;
    isSqliteMemory(): boolean;
    auth(options?: Omit<QueryOptions, 'retry'> & {
        retry?: number | Pick<QueryOptions, 'retry'>;
    }): Promise<void>;
    checkVersion(): Promise<boolean>;
    prepare(): Promise<void>;
    reconnect(): Promise<void>;
    closed(): any;
    close(): Promise<void>;
    on(event: EventType, listener: any): this;
    on(event: ModelValidateEventTypes, listener: SyncListener): this;
    on(event: ModelValidateEventTypes, listener: ValidateListener): this;
    on(event: ModelCreateEventTypes, listener: CreateListener): this;
    on(event: ModelUpdateEventTypes, listener: UpdateListener): this;
    on(event: ModelSaveEventTypes, listener: SaveListener): this;
    on(event: ModelDestroyEventTypes, listener: DestroyListener): this;
    on(event: ModelCreateWithAssociationsEventTypes, listener: CreateWithAssociationsListener): this;
    on(event: ModelUpdateWithAssociationsEventTypes, listener: UpdateWithAssociationsListener): this;
    on(event: ModelSaveWithAssociationsEventTypes, listener: SaveWithAssociationsListener): this;
    on(event: DatabaseBeforeDefineCollectionEventType, listener: BeforeDefineCollectionListener): this;
    on(event: DatabaseAfterDefineCollectionEventType, listener: AfterDefineCollectionListener): this;
    on(event: DatabaseBeforeRemoveCollectionEventType | DatabaseAfterRemoveCollectionEventType, listener: RemoveCollectionListener): this;
    extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): void;
    import(options: {
        directory: string;
        from?: string;
        extensions?: ImportFileExtension[];
    }): Promise<Map<string, Collection>>;
    private registerCollectionType;
}
export declare type CollectionDef = {
    collectionOptions: CollectionOptions;
    mergeOptions: MergeOptions;
    extend: boolean;
};
export declare function extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): CollectionDef;
export declare const extend: typeof extendCollection;
export declare const defineCollection: (collectionOptions: CollectionOptions) => CollectionOptions;
export default Database;