import { Filter, UpdateFilter } from 'mongodb';
import { PipeOutput, Pipe, PipeInput, ConditionalObjectKeys, DistributiveOmit, DeepPartial } from 'valleyed';
import { K as KafkaEventBus } from './kafka-Cf-TUJgv.js';

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",
    exists = "exists"
}
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;
}, {
    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>[];
    })[];
}>;
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): QueryParams;
type QueryParams = PipeOutput<ReturnType<typeof queryParamsPipe>>;
type QueryParamsInput = ConditionalObjectKeys<PipeInput<ReturnType<typeof queryParamsPipe>>>;
type QueryWhereClause = QueryParams['where'][number];
type QueryWhere = Extract<QueryWhereClause, {
    field: string;
}>;
type QueryWhereBlock = Exclude<QueryWhereClause, {
    field: string;
}>;
type QueryResults<T> = PipeOutput<ReturnType<typeof queryResultsPipe<T>>>;
declare const mongoDbConfigPipe: () => Pipe<{
    uri: string;
}, {
    uri: string;
}>;
type MongoDbConfig = PipeOutput<ReturnType<typeof mongoDbConfigPipe>>;

type DbChangeConfig = {
    eventBus: KafkaEventBus;
    debeziumUrl: string;
};
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>;
}

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 Sort = NonNullable<QueryParams['sort']>[number];
type Table<Id extends IdType, T extends Model<Id>, E extends Entity, Extras extends Record<string, unknown> = {}> = {
    query: (query: QueryParams) => Promise<QueryResults<E>>;
    findMany: (filter: Filter<T>, options?: {
        limit?: number;
        sort?: Sort | Sort[];
    }) => Promise<E[]>;
    findOne: (filter: Filter<T>) => Promise<E | null>;
    findById: (id: ModelId<T>) => Promise<E | 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) => E;
    options?: {
        skipAudit?: boolean;
    };
};

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