import { ObjectId } from './objectid';
export declare class VirtualType<T = unknown> {
    private _getter?;
    private _setter?;
    get(fn: ((this: any) => T) | ((doc: any) => T)): this;
    set(fn: ((this: any, value: T) => void) | ((doc: any, value: T) => void)): this;
    applyGetter(doc: any): T | undefined;
    applySetter(doc: any, value: T): void;
    hasSetter(): boolean;
}
export type SaveHookContext<T> = {
    doc: T;
};
export type PreDeleteHookContext<T = Record<string, unknown>> = {
    query: Record<string, unknown>;
    _?: T;
};
export type PostDeleteHookContext<T> = {
    query: Record<string, unknown>;
    deletedCount: number;
    docs?: T[];
};
export type DeleteHookContext<T> = PreDeleteHookContext<T> | PostDeleteHookContext<T>;
export type PreUpdateHookContext<T> = {
    query: Record<string, unknown>;
    update?: Record<string, unknown>;
    doc?: T;
};
export type PostUpdateHookContext<T> = {
    query: Record<string, unknown>;
    update?: Record<string, unknown>;
    modifiedCount: number;
    docs?: T[];
};
export type UpdateHookContext<T> = PreUpdateHookContext<T> | PostUpdateHookContext<T>;
export type PreFindHookContext<T = Record<string, unknown>> = {
    query: Record<string, unknown>;
    _?: T;
};
export type PostFindHookContext<T> = {
    query: Record<string, unknown>;
    result?: T | null;
    results?: T[];
};
export type FindHookContext<T> = PreFindHookContext<T> | PostFindHookContext<T>;
export type HookFunction = (context: Record<string, unknown>) => void | Promise<void>;
export type ValidatorFunction = (value: unknown) => boolean | Promise<boolean>;
export type FieldOptions = {
    type?: any;
    required?: boolean | [boolean, string];
    default?: any | (() => any);
    min?: number | [number, string];
    max?: number | [number, string];
    minLength?: number | [number, string];
    maxLength?: number | [number, string];
    enum?: any[] | {
        values: any[];
        message?: string;
    };
    match?: RegExp | [RegExp, string];
    validate?: ValidatorFunction | {
        validator: ValidatorFunction;
        message?: string;
    };
    ref?: string;
    get?: (value: any) => any;
    set?: (value: any) => any;
    unique?: boolean;
};
export declare class ValidationError extends Error {
    constructor(message: string);
}
export declare class DuplicateKeyError extends Error {
    code: number;
    keyPattern: Record<string, number>;
    keyValue: Record<string, unknown>;
    constructor(fields: string[], values?: Record<string, unknown>);
}
export type SearchIndexDescriptor = {
    name?: string;
    type?: 'search' | 'vectorSearch';
    definition: Record<string, unknown>;
};
export type SchemaOptions = {
    timestamps?: boolean | {
        createdAt?: string | boolean;
        updatedAt?: string | boolean;
    };
    discriminatorKey?: string;
    autoSearchIndex?: boolean;
};
export declare class Schema<T extends object = Record<string, unknown>> {
    static Types: {
        ObjectId: typeof ObjectId;
    };
    private _definition;
    private _fieldOptions;
    private _indexes;
    private _uniqueIndexes?;
    private _ttlIndexes;
    private _virtuals;
    private _preHooks;
    private _postHooks;
    private _options;
    private _searchIndexes;
    methods: Record<string, (this: any, ...args: any[]) => any>;
    statics: Record<string, (...args: any[]) => any>;
    constructor(definition: Record<string, unknown>, options?: SchemaOptions);
    private _parseFieldDefinitions;
    index(fields: keyof T | Array<keyof T> | Record<string, 1 | -1>, options?: {
        unique?: boolean;
        ttl?: number;
    }): this;
    virtual(name: string): VirtualType;
    getIndexes(): Array<Array<keyof T>>;
    searchIndex(desc: SearchIndexDescriptor): this;
    getSearchIndexes(): ReadonlyArray<SearchIndexDescriptor>;
    getUniqueIndexes(): Set<string>;
    getTTLIndexes(): Map<string, number>;
    getVirtuals(): Map<string, VirtualType>;
    pre(event: 'save', fn: (context: SaveHookContext<T>) => void | Promise<void>): this;
    pre(event: 'delete', fn: (context: PreDeleteHookContext<T>) => void | Promise<void>): this;
    pre(event: 'update', fn: (context: PreUpdateHookContext<T>) => void | Promise<void>): this;
    pre(event: 'find' | 'findOne', fn: (context: PreFindHookContext<T>) => void | Promise<void>): this;
    post(event: 'save', fn: (context: SaveHookContext<T>) => void | Promise<void>): this;
    post(event: 'delete', fn: (context: PostDeleteHookContext<T>) => void | Promise<void>): this;
    post(event: 'update', fn: (context: PostUpdateHookContext<T>) => void | Promise<void>): this;
    post(event: 'find' | 'findOne', fn: (context: PostFindHookContext<T>) => void | Promise<void>): this;
    getPreHooks(event: string): HookFunction[];
    getPostHooks(event: string): HookFunction[];
    getFieldOptions(fieldName: keyof T): FieldOptions | undefined;
    getAllFieldOptions(): Map<keyof T, FieldOptions>;
    applyGetters(doc: any): any;
    applySetters(doc: any): void;
    applyDefaults(doc: any): void;
    getOptions(): SchemaOptions;
    getTimestampConfig(): {
        createdAt: string;
        updatedAt: string;
    } | null;
    /**
     * Load methods, statics, and virtuals from a class into the schema.
     * Instance methods (non-static methods) are added to schema.methods
     * Static methods are added to schema.statics
     * Getters and setters are added as virtuals
     *
     * @param classConstructor - The class to load methods from
     * @returns this for chaining
     */
    loadClass(classConstructor: new (...args: any[]) => any): this;
    validate(doc: Partial<T>): Promise<void>;
    /**
     * Serialize schema to a JSON-compatible format for storage tracking
     * This allows schema versions to be recorded and compared
     */
    toJSON(): {
        definition: Record<string, unknown>;
        indexes: Array<{
            fields: string[];
            unique: boolean;
        }>;
        options: SchemaOptions;
        version: string;
    };
}
//# sourceMappingURL=schema.d.ts.map