import { Attribute, DB, EntryBase, ForeignKeyOptions, Transaction, Type } from "./db";
export { Attribute, base, DB, deepCopy, deepDiff, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, loaded, size, Table, Transaction, transaction, TxAction, Type } from "./db";
export interface AttributeOptions<T, N extends boolean> {
    defaultValue?: T;
    fieldName?: string;
    notNull?: N;
    unique?: boolean;
}
export type AttributeOptionsFKey<T, N extends boolean> = ForeignKeyOptions & AttributeOptions<T, N>;
export interface AttributeOptionsSize<T, N extends boolean> extends AttributeOptions<T, N> {
    size?: number;
}
type NotNull<O> = O extends {
    notNull: true;
} ? true : false;
type AttributesDefinitionBase = {
    [key: string]: [unknown, boolean, unknown];
};
export type AttributesDefinition<N extends AttributesDefinitionBase = AttributesDefinitionBase> = keyof N extends never ? {
    [s: string]: Type<unknown, boolean, unknown>;
} : {
    [key in keyof N]: Type<N[key][0], N[key][1], N[key][2]>;
};
declare const attributes: unique symbol;
declare const methods: unique symbol;
type ForeignKeysAttributes<T, k> = T extends Type<unknown, boolean, infer E> ? (E extends EntryBase ? k : never) : never;
type ForeignKeys<A extends AttributesDefinition> = Exclude<{
    [a in keyof A]?: ForeignKeysAttributes<A[a], a>;
}[keyof A], undefined>;
type Native<T> = T extends Type<infer N, infer NN, unknown> ? (NN extends true ? N : N | null) : never;
export type IndexAttributes = string[] | string;
export interface IndexOptions {
    attributes: IndexAttributes;
    type?: "btree" | "hash";
    unique?: boolean;
}
export type IndexDefinition = IndexAttributes | IndexOptions;
export type IndexesDefinition = {
    [key: string]: IndexDefinition;
};
interface BaseModelOptions {
    indexes?: IndexesDefinition;
    sync?: boolean;
    tableName?: string;
}
export interface ModelOptions extends BaseModelOptions {
    int8id?: boolean;
    parent?: Attribute<unknown, boolean, EntryBase>;
    primaryKey?: string;
}
type ConditionAttribute<T> = T | ["=" | ">" | "<" | ">=" | "<=" | "<>", T] | ["IN", T[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
type ConditionBase<A extends AttributesDefinition> = string | {
    [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
};
type Condition<A extends AttributesDefinition> = ConditionBase<A> | ["NOT", Condition<A>] | ["AND", ...Condition<A>[]] | ["OR", ...Condition<A>[]];
type Order_<A extends AttributesDefinition> = keyof A | `-${string & keyof A}`;
type Order<A extends AttributesDefinition> = Order_<A> | Order_<A>[];
type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
type BaseKeyType<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
type KeyType<B extends boolean, P extends ModelStd> = P extends new () => EntryBase ? (P extends Attribute<infer T, boolean, EntryBase> ? T : never) : BaseKeyType<B>;
type ForeignKey<A> = A extends Type<unknown, boolean, infer E> ? () => Promise<E> : never;
type EntryBaseAttributes<A extends AttributesDefinition> = {
    [a in keyof A]: Native<A[a]>;
};
type EntryMethodsBase<P extends ModelStd> = P extends new () => EntryBase ? P[typeof methods] : EntryBase;
type EntryMethodsFK<A extends AttributesDefinition> = {
    [a in ForeignKeys<A> & string as `${a}Load`]: ForeignKey<A[a]>;
};
type EntryMethods<A extends AttributesDefinition, P extends ModelStd> = keyof EntryMethodsFK<A> extends never ? EntryMethodsBase<P> : EntryMethodsBase<P> & EntryMethodsFK<A>;
type ModelAttributesIf<A extends AttributesDefinition, T> = keyof A extends never ? T : T & A;
type ModelAttributes<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd> = K extends keyof A ? A : ModelAttributesIf<A, P extends new () => EntryBase ? P[typeof attributes] : {
    id: Type<BaseKeyType<B>, true, unknown>;
}>;
export interface ModelLoad<A extends AttributesDefinition, E extends EntryBase> {
    load(where: Condition<A>, order?: Order<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
    load(where: Condition<A>, order?: Order<A>, tx?: Transaction, lock?: boolean): Promise<E[]>;
    load(where: Condition<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
    load(where: Condition<A>, tx: Transaction, lock?: boolean): Promise<E[]>;
    cancel(where: Condition<A>, tx?: Transaction): Promise<number>;
}
type ModelBase<T, A extends AttributesDefinition, EA extends Record<string, unknown>, EM extends EntryBase, E extends EntryBase> = (new (from?: Partial<EA>, tx?: Transaction) => E) & Attribute<T, true, E> & {
    [attributes]: A;
    foreignKeys: Record<string, boolean>;
    [methods]: EM;
    parent?: ModelStd;
    tableName: string;
} & {
    [a in keyof A]: Attribute<Native<A[a]>, boolean, E>;
} & ModelLoad<A, E>;
type Model<T, A extends AttributesDefinition, EM extends EntryBase> = ModelBase<T, A, EntryBaseAttributes<A>, EM, EntryBaseAttributes<A> & EM>;
type ModelStd = Attribute<unknown, true, EntryBase> & {
    [attributes]: AttributesDefinition;
    foreignKeys: Record<string, boolean>;
    [methods]: EntryBase;
    parent?: ModelStd;
};
export type Entry<M> = M extends new () => infer E ? E : never;
export type OrderBy<M> = M extends {
    load(where: unknown, order?: infer T): void;
    load(where: unknown, limit?: number): void;
    load(where: unknown, tx?: Transaction): void;
} ? Exclude<T, undefined> : never;
export type Where<M> = M extends {
    load(where: infer T): void;
} ? T : never;
export interface SedentaryOptions {
    autoSync?: boolean;
    log?: ((message: string) => void) | null;
    sync?: boolean;
}
/**
 * Converts a JavaScript name to the default SQL name (snake_case).
 * Uppercase letters become lowercase preceded by underscore, except the first character
 * which is only lowercased without underscore.
 */
export declare function toSqlName(name: string): string;
export declare class Sedentary<D extends DB<T>, T extends Transaction> {
    protected autoSync: boolean;
    protected db: D;
    protected doSync: boolean;
    protected log: (message: string) => void;
    private models;
    constructor(options?: SedentaryOptions);
    Boolean<O extends AttributeOptions<boolean, boolean> | undefined = undefined>(options?: O): Type<boolean, NotNull<O>, unknown>;
    DateTime<O extends AttributeOptions<Date, boolean> | undefined = undefined>(options?: O): Type<Date, NotNull<O>, unknown>;
    FKey<T, E extends EntryBase>(attribute: Attribute<T, boolean, E>): Type<T, false, E>;
    FKey<T, E extends EntryBase>(attribute: Attribute<T, boolean, E>, options: {
        notNull: true;
    } & AttributeOptionsFKey<T, boolean>): Type<T, true, E>;
    FKey<T, E extends EntryBase>(attribute: Attribute<T, boolean, E>, options: AttributeOptionsFKey<T, boolean>): Type<T, boolean, E>;
    Float<O extends AttributeOptionsSize<number, boolean> | undefined = undefined>(options?: O): Type<number, NotNull<O>, unknown>;
    Int<O extends AttributeOptionsSize<number, boolean> | undefined = undefined>(options?: O): Type<number, NotNull<O>, unknown>;
    Int8<O extends AttributeOptions<bigint, boolean> | undefined = undefined>(options?: O): Type<bigint, NotNull<O>, unknown>;
    JSON<T = unknown>(): Type<T, false, unknown>;
    JSON<T = unknown>(options: {
        notNull: true;
    } & AttributeOptions<T, boolean>): Type<T, true, unknown>;
    JSON<T = unknown>(options: AttributeOptions<T, boolean>): Type<T, boolean, unknown>;
    Number<O extends AttributeOptions<number, boolean> | undefined = undefined>(options?: O): Type<number, NotNull<O>, unknown>;
    None<T = unknown>(): Type<T, false, unknown>;
    None<T = unknown>(options: {
        notNull: true;
    } & AttributeOptions<unknown, boolean>): Type<T, true, unknown>;
    None<T = unknown>(options: AttributeOptions<unknown, boolean>): Type<T, boolean, unknown>;
    VarChar<S extends string = string>(): Type<S, false, unknown>;
    VarChar<S extends string = string>(options: {
        notNull: true;
    } & AttributeOptionsSize<S, boolean>): Type<S, true, unknown>;
    VarChar<S extends string = string>(options: AttributeOptionsSize<S, boolean>): Type<S, boolean, unknown>;
    private checkDB;
    private checkOptions;
    private checkOrderBy;
    private checkSize;
    private createWhere;
    connect(sync?: boolean): Promise<void>;
    sync(): Promise<void>;
    end(): Promise<void>;
    begin(): Promise<T>;
    escape(value: unknown): string;
    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EM extends EntryMethods<A, P>>(modelName: string, attributes: A, options?: BaseModelOptions & {
        int8id?: B;
        parent?: P;
        primaryKey?: K | keyof A;
    }): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM>;
    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EA extends EntryBaseAttributes<ModelAttributes<A, B, K, P>>, EM extends EntryMethods<A, P>, M extends Record<string, <S extends M>(this: EA & EM & S, ...args: any[]) => void>>(modelName: string, attributes: A, options: BaseModelOptions & {
        int8id?: B;
        parent?: P;
        primaryKey?: K | keyof A;
    }, methods: M & Record<keyof M, (this: EA & EM & M, ...args: any[]) => void>): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM & M>;
}