import { Filter, UpdateFilter } from 'mongodb';
import * as valleyed from 'valleyed';
import { PipeOutput, Pipe, PipeInput, ConditionalObjectKeys, DistributiveOmit, DeepPartial } from 'valleyed';
import { KafkaEventBus } from './events/adapters/kafka/index.js';

declare const dbChangeConfigPipe: () => valleyed.Pipe<{
    debeziumUrl: string;
    eventBus: KafkaEventBus;
}, {
    debeziumUrl: string;
    eventBus: KafkaEventBus;
}>;
type DbChangeConfig = PipeOutput<ReturnType<typeof dbChangeConfigPipe>>;
type DbConfig = {
    changes?: DbChangeConfig;
};

declare abstract class DbChange<Model extends Model<IdType>, Entity extends Entity> {
    protected config: DbChangeConfig;
    protected callbacks: DbChangeCallbacks<Model, Entity>;
    protected mapper: (model: Model) => Entity;
    constructor(config: DbChangeConfig, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
    protected configureConnector(key: string, data: Record<string, string>): Promise<any>;
}

declare enum QueryKeys {
    and = "and",
    or = "or"
}
declare enum Conditions {
    lt = "lt",
    lte = "lte",
    gt = "gt",
    gte = "gte",
    eq = "eq",
    ne = "ne",
    in = "in",
    nin = "nin"
}
declare const queryKeys: Pipe<QueryKeys | undefined, QueryKeys>;
declare const queryWhere: Pipe<{
    field: string;
    value: any;
    condition: Conditions | undefined;
}, {
    field: string;
    value: any;
    condition: Conditions;
}>;
declare function queryParamsPipe(): Pipe<{
    all: boolean | undefined;
    limit: number | undefined;
    page: number | undefined;
    search: {
        value: string;
        fields: string[];
    } | null | undefined;
    sort: {
        field: string;
        desc: boolean | undefined;
    }[] | undefined;
    whereType: QueryKeys | undefined;
    where: ({
        field: string;
        value: any;
        condition: Conditions | undefined;
    } | {
        condition: PipeInput<typeof queryKeys>;
        value: PipeInput<typeof queryWhere>[];
    })[] | undefined;
    select: string[] | undefined;
}, {
    auth: ({
        field: string;
        value: any;
        condition: Conditions;
    } | {
        condition: PipeOutput<typeof queryKeys>;
        value: PipeOutput<typeof queryWhere>[];
    })[];
    authType: QueryKeys;
    all: boolean;
    limit: number;
    page: number;
    search: {
        value: string;
        fields: string[];
    } | null;
    sort: {
        field: string;
        desc: boolean;
    }[];
    whereType: QueryKeys;
    where: ({
        field: string;
        value: any;
        condition: Conditions;
    } | {
        condition: PipeOutput<typeof queryKeys>;
        value: PipeOutput<typeof queryWhere>[];
    })[];
    select: string[] | undefined;
}>;
declare function queryResultsPipe<T>(model: Pipe<any, T>): Pipe<{
    pages: {
        current: number;
        start: number;
        last: number;
        previous: number | null;
        next: number | null;
    };
    docs: {
        limit: number;
        total: number;
        count: number;
    };
    results: any[];
}, {
    pages: {
        current: number;
        start: number;
        last: number;
        previous: number | null;
        next: number | null;
    };
    docs: {
        limit: number;
        total: number;
        count: number;
    };
    results: T[];
}>;
declare function wrapQueryParams(params: QueryParamsInput): QueryParamsBase;
type QueryParamsBase = PipeOutput<ReturnType<typeof queryParamsPipe>>;
type QueryParams<T, S extends Select<T> | undefined = undefined> = Omit<QueryParamsBase, 'select'> & {
    select?: S extends undefined ? QueryParamsBase['select'] : S;
};
type QueryParamsInput = ConditionalObjectKeys<PipeInput<ReturnType<typeof queryParamsPipe>>>;
type QueryWhereClause = QueryParamsBase['where'][number];
type QueryWhere = Extract<QueryWhereClause, {
    field: string;
}>;
type QueryWhereBlock = Exclude<QueryWhereClause, {
    field: string;
}>;
type QueryResults<T> = PipeOutput<ReturnType<typeof queryResultsPipe<T>>>;

type IdType = {
    _id: string;
} | {
    id: string;
};
type Entity = {
    toJSON: () => Record<string, unknown>;
};
type ModelId<T> = T extends Model<infer Id> ? Id[keyof Id] : never;
type Model<IdKey extends IdType> = IdKey & {
    createdAt?: number;
    updatedAt?: number;
};
type Select<T> = (keyof T)[];
type SelectEntity<E, S> = S extends readonly (keyof E)[] ? (S[number] extends never ? E : Pick<E, S[number]>) : E;
type Sort = NonNullable<QueryParamsBase['sort']>[number];
type FindManyOptions<T, S extends Select<T> | undefined = undefined> = {
    limit?: number;
    sort?: Sort | Sort[];
    select?: S;
};
type FindOneOptions<T, S extends Select<T> | undefined = undefined> = {
    select?: S;
};
type Table<Id extends IdType, T extends Model<Id>, E extends Entity, Extras extends Record<string, unknown> = {}> = {
    query: <const S extends Select<T> | undefined = undefined>(query: QueryParams<T, S>) => Promise<QueryResults<SelectEntity<E, S>>>;
    findMany: <const S extends Select<T> | undefined = undefined>(filter: Filter<T>, options?: FindManyOptions<T, S>) => Promise<SelectEntity<E, S>[]>;
    findOne: <const S extends Select<T> | undefined = undefined>(filter: Filter<T>, options?: FindOneOptions<T, S>) => Promise<SelectEntity<E, S> | null>;
    findById: <const S extends Select<T> | undefined = undefined>(id: ModelId<T>, options?: FindOneOptions<T, S>) => Promise<SelectEntity<E, S> | null>;
    insertOne: (values: CreateInput<T>, options?: {
        makeId?: () => string;
        getTime?: () => Date;
    }) => Promise<E>;
    insertMany: (values: CreateInput<T>[], options?: {
        makeId?: (i: number) => string;
        getTime?: () => Date;
    }) => Promise<E[]>;
    updateMany: (filter: Filter<T>, values: UpdateInput<T>, options?: {
        getTime?: () => Date;
    }) => Promise<E[]>;
    updateOne: (filter: Filter<T>, values: UpdateInput<T>, options?: {
        getTime?: () => Date;
    }) => Promise<E | null>;
    updateById: (id: ModelId<T>, values: UpdateInput<T>, options?: {
        getTime?: () => Date;
    }) => Promise<E | null>;
    upsertOne: (filter: Filter<T>, values: {
        insert: CreateInput<T>;
    } | {
        insert: Partial<CreateInput<T>>;
        update: UpdateInput<T>;
    }, options?: {
        makeId?: () => string;
        getTime?: () => Date;
    }) => Promise<E>;
    deleteOne: (filter: Filter<T>) => Promise<E | null>;
    deleteById: (id: ModelId<T>) => Promise<E | null>;
    deleteMany: (filter: Filter<T>) => Promise<E[]>;
    bulkWrite: (operations: BulkWriteOperation<T>[], options?: {
        getTime?: () => Date;
    }) => Promise<void>;
    readonly config: Config<T, E>;
    readonly extras: Extras;
    watch: (callbacks: DbChangeCallbacks<T, E>) => DbChange<T, E>;
};

type AllKeys<T> = T extends any ? keyof T : never;
type EntityInput<T extends Model<any>> = ConditionalObjectKeys<DistributiveOmit<T, AllKeys<IdType> | keyof Model<IdType>>>;
type CreateInput<T extends Model<any>> = EntityInput<T>;
type UpdateInput<T extends Model<any>> = DistributiveOmit<UpdateFilter<CreateInput<T>>, '$setOnInsert'>;
type BulkWriteOperation<T extends Model<any>> = {
    op: 'insert';
    value: CreateInput<T>;
    makeId?: (i: number) => string;
} | {
    op: 'update';
    filter: Filter<T>;
    value: UpdateInput<T>;
} | ({
    op: 'upsert';
    filter: Filter<T>;
    makeId?: (i: number) => string;
} & ({
    insert: CreateInput<T>;
} | {
    insert: Partial<CreateInput<T>>;
    update: UpdateInput<T>;
})) | {
    op: 'delete';
    filter: Filter<T>;
};
type DbChangeCallbacks<M extends Model<IdType>, E extends Entity> = {
    created?: (data: {
        before: null;
        after: E;
    }) => Promise<void>;
    updated?: (data: {
        before: E;
        after: E;
        changes: DeepPartial<M>;
    }) => Promise<void>;
    deleted?: (data: {
        before: E;
        after: null;
    }) => Promise<void>;
};
type Config<M extends Model<IdType>, E extends Entity> = {
    db: string;
    col: string;
    mapper: (model: M, select?: Select<E>) => E;
    options?: {
        skipAudit?: boolean;
    };
};

export { type BulkWriteOperation as B, type Config as C, DbChange as D, type Entity as E, type IdType as I, type Model as M, QueryKeys as Q, type Select as S, type Table as T, type UpdateInput as U, type DbChangeConfig as a, type DbChangeCallbacks as b, type DbConfig as c, type EntityInput as d, type CreateInput as e, dbChangeConfigPipe as f, Conditions as g, queryResultsPipe as h, type QueryParamsBase as i, type QueryParams as j, type QueryParamsInput as k, type QueryWhereClause as l, type QueryWhere as m, type QueryWhereBlock as n, type QueryResults as o, queryParamsPipe as q, wrapQueryParams as w };