import type * as DatabaseDev from "@antelopejs/interface-database";
import { type Constructible } from "../common";
export declare const MixinSymbol: unique symbol;
export type MixinType<T> = T extends {
    [MixinSymbol]: infer A;
} ? A : never;
export declare class Modifier<Meta extends object = object, Options extends object = object> {
    protected meta: Meta;
    protected options: Options;
}
export declare class OneWayModifier<LockedType, Args extends any[] = [], Meta extends object = object, Options extends object = object> extends Modifier<Meta, Options> {
    lock(_locked_value: LockedType | undefined, _value: unknown, ..._args: Args): LockedType;
    test(locked_value: LockedType, value: unknown, ...args: Args): boolean;
}
type ProxyOrValArray<T extends any[]> = {
    [K in keyof T]: DatabaseDev.ValueProxyOrValue<T[K]>;
};
export declare class TwoWayModifier<LockedType, Args extends any[] = [], Meta extends object = object, Options extends object = object> extends OneWayModifier<LockedType, Args, Meta, Options> {
    unlock(_locked_value: LockedType, ..._args: Args): unknown;
    unlockrequest(_data: DatabaseDev.ValueProxy<LockedType>, _meta: DatabaseDev.ValueProxy<Meta>, ..._args: ProxyOrValArray<Args>): DatabaseDev.ValueProxy<unknown>;
}
export declare class ContainerModifier<Meta extends object = object, Options extends object = object> extends TwoWayModifier<Record<string, unknown>, [
    key: string
], Meta, Options> {
    lock(locked_value: Record<string, unknown> | undefined, value: unknown, key: string): Record<string, unknown>;
    unlock(locked_value: Record<string, unknown>, key: string): unknown;
    unlockrequest(data: DatabaseDev.ValueProxy<Record<string, unknown>>, _meta: DatabaseDev.ValueProxy<Meta>, key: DatabaseDev.ValueProxyOrValue<string>): DatabaseDev.ValueProxy<unknown>;
}
interface InternalType {
    meta: Record<string, object>;
    data: Record<string, any>;
}
interface ModifiedField {
    id: string;
    modifier: Modifier;
    metaRef: {
        _ref: any;
    };
}
export declare class ModifiersStaticMetadata {
    static key: symbol;
    fields: Record<string, Array<ModifiedField>>;
    events: Map<string, [field: string, modified: ModifiedField][]>;
}
export declare class ModifiersDynamicMetadata {
    static key: symbol;
    staticMeta: ModifiersStaticMetadata;
    floating: Record<string, any>;
    fields: Record<string, Record<string, any[]>>;
    constructor(target: any);
    canGet(field: string): boolean;
    get(field: string, internal: InternalType): any;
    canSet(field: string): boolean;
    set(field: string, internal: InternalType, value: unknown): void;
}
export declare function fromPlainData<T extends Constructible>(rawObject: Record<string, any>, TableClass: T): InstanceType<T>;
export declare function toPlainData<T extends {
    constructor: any;
}>(object: T): Record<string, any>;
export declare function fromDatabase<T extends Constructible>(rawObject: any, TableClass: T): InstanceType<T>;
export declare function toDatabase<T extends {
    constructor: any;
}>(object: T): Record<string, any>;
type ExtractModifierOptions<T> = T extends Modifier<any, infer Options> ? Options : undefined;
type ExtractModifierArgs<T> = T extends OneWayModifier<any, infer Args> ? Args : [];
export declare function attachModifier<T extends Constructible, M extends Constructible<Modifier>>(TableClass: T, Modifier: M, field: keyof InstanceType<T>, options: ExtractModifierOptions<InstanceType<M>>): void;
export declare function getModifiedFields<T extends {
    constructor: any;
}, M extends Constructible<Modifier>>(object: T, Modifier: M): (keyof T)[];
export declare function unlock<T extends {
    constructor: any;
}, M extends Constructible<Modifier>>(object: T, Modifier: M, fields: Array<keyof T> | undefined, ...args: ExtractModifierArgs<InstanceType<M>>): void;
type ModifierWithProxyArgs = {
    modifier: Constructible<TwoWayModifier<any, any[], any, any>>;
    args: DatabaseDev.ValueProxyOrValue<any>[];
};
export declare function unlockrequest<T extends {}, K extends keyof T>(table: Constructible<T>, object: DatabaseDev.ValueProxy<T>, field: K, modifiers: ModifierWithProxyArgs[]): DatabaseDev.ValueProxy<T[K]>;
export declare function lock<T extends {
    constructor: any;
}, M extends Constructible<Modifier>>(object: T, Modifier: M, fields: Array<keyof T> | undefined, ...args: ExtractModifierArgs<InstanceType<M>> | []): void;
export declare function testValue<T extends {
    constructor: any;
}, K extends keyof T>(object: T, field: K, value: T[K]): unknown;
export declare function triggerEvent<T extends {
    constructor: any;
}>(object: T, event: string, ...args: unknown[]): void;
export {};