import { type mongodb, type ModuleInput } from '@unchainedshop/mongodb';
import { type DateFilterInput, type SortOption } from '@unchainedshop/utils';
import { type Work, WorkStatus } from '../db/WorkQueueCollection.ts';
export declare const DIRECTOR_MARKED_FAILED_ERROR = "DIRECTOR_MARKED_FAILED";
export type WorkData = Pick<Partial<Work>, 'input' | 'originalWorkId' | 'priority' | 'retries' | 'timeout' | 'worker' | 'scheduleId'> & Pick<Work, 'type' | 'scheduled'>;
export interface WorkResult<Result = unknown> {
    success: boolean;
    result?: Result;
    error?: any;
}
export declare const WorkerEventTypes: {
    readonly ADDED: "WORK_ADDED";
    readonly ALLOCATED: "WORK_ALLOCATED";
    readonly FINISHED: "WORK_FINISHED";
    readonly DELETED: "WORK_DELETED";
    readonly RESCHEDULED: "WORK_RESCHEDULED";
};
export type WorkerEventTypes = (typeof WorkerEventTypes)[keyof typeof WorkerEventTypes];
export interface WorkerSettingsOptions {
    blacklistedVariables?: string[];
}
export interface WorkerReport {
    type: string;
    newCount: number;
    errorCount: number;
    successCount: number;
    startCount: number;
    deleteCount: number;
}
export interface WorkQueueQuery {
    created?: {
        end?: Date;
        start?: Date;
    };
    types?: string[];
    status?: WorkStatus[];
    queryString?: string;
    scheduled?: {
        end?: Date;
        start?: Date;
    };
}
export declare const buildQuerySelector: ({ created, scheduled, types, status, workId, queryString, ...rest }: mongodb.Filter<Work> & {
    created?: {
        end?: Date;
        start?: Date;
    };
    scheduled?: {
        end?: Date;
        start?: Date;
    };
    status?: WorkStatus[];
    workId?: string;
    queryString?: string;
    types?: string[];
}) => {
    [x: string]: any;
    error?: any;
    timeout?: mongodb.Condition<number | undefined>;
    originalWorkId?: mongodb.Condition<string | undefined>;
    worker?: mongodb.Condition<string | null | undefined>;
    input?: mongodb.Condition<Record<string, any>> | undefined;
    type?: mongodb.Condition<string> | undefined;
    started?: mongodb.Condition<Date | undefined>;
    finished?: mongodb.Condition<Date | undefined>;
    priority?: mongodb.Condition<number> | undefined;
    retries?: mongodb.Condition<number> | undefined;
    scheduleId?: mongodb.Condition<string | undefined>;
    result?: any;
    success?: mongodb.Condition<boolean | undefined>;
    autoscheduled?: mongodb.Condition<boolean | undefined>;
    updated?: mongodb.Condition<Date | undefined>;
    deleted?: mongodb.Condition<Date | null | undefined>;
    _id?: mongodb.Condition<string> | undefined;
    $and?: mongodb.Filter<mongodb.WithId<Work>>[] | undefined;
    $nor?: mongodb.Filter<mongodb.WithId<Work>>[] | undefined;
    $or?: mongodb.Filter<mongodb.WithId<Work>>[] | undefined;
    $text?: {
        $search: string;
        $language?: string;
        $caseSensitive?: boolean;
        $diacriticSensitive?: boolean;
    };
    $where?: string | ((this: mongodb.WithId<Work>) => boolean) | undefined;
    $comment?: string | mongodb.BSON.Document;
    created?: mongodb.Condition<Date> | undefined;
    scheduled?: mongodb.Condition<Date> | undefined;
};
export declare const configureWorkerModule: ({ db, options }: ModuleInput<WorkerSettingsOptions>) => Promise<{
    workerId: string;
    activeWorkTypes: () => Promise<string[]>;
    findWork: (params: {
        workId: string;
    } | {
        originalWorkId: string;
    }) => Promise<mongodb.WithId<Work> | null>;
    findWorkQueue: ({ limit, skip, sort, ...selectorOptions }: WorkQueueQuery & {
        sort?: SortOption[];
        limit?: number;
        skip?: number;
    }) => Promise<Work[]>;
    count: (query: WorkQueueQuery) => Promise<number>;
    allocationMap: () => Promise<Record<string, number>>;
    workExists: ({ workId, originalWorkId, }: {
        workId?: string;
        originalWorkId?: string;
    }) => Promise<boolean>;
    status: (work: Work) => WorkStatus;
    addWork({ type, input, priority, scheduled, originalWorkId, worker, retries, }: Pick<Work, "type" | "originalWorkId" | "worker"> & Pick<Partial<Work>, "scheduled" | "priority" | "input" | "retries">): Promise<Work>;
    addWorkIfNotExists(workData: Pick<Work, "type"> & Pick<Partial<Work>, "scheduled" | "priority" | "input" | "retries">, existenceCheck: (work: Work) => boolean): Promise<Work | null>;
    rescheduleWork: (currentWork: Work, scheduled: Date) => Promise<mongodb.WithId<Work> | null>;
    allocateWork: ({ types, worker, }: {
        types: string[];
        worker: string;
    }) => Promise<mongodb.WithId<Work> | null>;
    ensureNoWork: ({ type, priority, scheduleId, }: {
        priority: number;
        type: string;
        scheduleId: string;
    }) => Promise<void>;
    ensureOneWork: ({ type, input, priority, scheduled, timeout, originalWorkId, retries, scheduleId, }: WorkData) => Promise<mongodb.WithId<Work> | null>;
    finishWork: (workId: string, { error, finished, result, started, success, worker, }: WorkResult<any> & {
        finished?: Date;
        started?: Date;
        worker?: string;
    }) => Promise<mongodb.WithId<Work> | null>;
    deleteWork: (workId: string) => Promise<mongodb.WithId<Work> | null>;
    markOldWorkAsFailed: ({ types, worker, referenceDate, }: {
        types: string[];
        worker: string;
        referenceDate: Date;
    }) => Promise<Work[]>;
    getReport: ({ types, dateRange, }: {
        types?: string[];
        dateRange?: DateFilterInput;
    }) => Promise<WorkerReport[]>;
}>;
export type WorkerModule = Awaited<ReturnType<typeof configureWorkerModule>>;