import { P as PartialCustomServiceSchema } from '../types-Cdh7thEZ.cjs';
import { Redis } from 'ioredis';
import { QueueOptions, Queue, JobsOptions, Job, QueueEventsOptions, QueueEvents, QueueBaseOptions, FlowProducer, RepeatOptions, WorkerOptions, Worker } from 'bullmq';
import { Service } from 'moleculer';
import 'bson';
import 'zod/v4';
import 'ajv/dist/2019.js';
import 'pino';
import 'pino-pretty';

type QueueMixinOptions = {
    brokerURL: string | (<TService extends Service = Service>(svc: TService) => Promise<string>);
};
/**
 * connection is mandatory for BullMQ but is managed by each mixins.
 */
type WithoutConnection<T> = Omit<T, 'connection'>;

/**
 * This Mixin add the capability to launch a job.
 */
declare function QueueClient<N extends string>(queueName: N, opts: WithoutConnection<QueueOptions> & QueueMixinOptions): PartialCustomServiceSchema<unknown, {
    _getQueues(): Map<string, Queue>;
    /**
     * Add a job to a specific queue. The queue name needs to be passed as parameters
     * to enable multiple queue clients in the same service.
     */
    addJob<D = unknown>(qName: N, name: string, data: D, jOpts?: JobsOptions): Promise<Job>;
    /**
     * Add jobs to a specific queue. The queue name needs to be passed as parameters
     * to enable multiple queue clients in the same service.
     */
    addBulkJob<D = unknown>(qName: N, name: string, data: D[], jOpts?: JobsOptions): Promise<Job[]>;
    /**
     * Get a queue bundle if you need specific features
     */
    getQueue(qName: N): Queue;
}, PartialCustomServiceSchema<unknown, {
    getStore(storeName: string): Map<string, {
        services: Set<unknown>;
        client: Redis;
        onClose: () => Promise<void> | void;
    }>;
    getFromStore(storeName: string, key: string): Redis | null;
    removeServiceFromStore(storeName: string, key: string): Promise<boolean>;
    setClientToStore(storeName: string, key: string, client: Redis, onClose: () => Promise<void> | void): void;
}, unknown>[]>;

/**
 * This Mixin add the capability to wait on a job.
 * WARNING: Needs to be used with QueueClient mixin.
 */
declare function QueueEventsClient<N extends string>(queueName: N, opts: WithoutConnection<QueueEventsOptions> & QueueMixinOptions): PartialCustomServiceSchema<unknown, {
    _getQueueEvents(): Map<string, {
        events: QueueEvents;
        running: boolean;
    }>;
    /**
     * Return the QueueEvents instance for the given queue name.
     * Will run the QueueEvents if it's not already running (lazy connect).
     * Will throw an error if the QueueEvents is not found.
     */
    getQueueEvents(qName: N): QueueEvents;
    /**
     * Same as addJob but will also wait for the job to finish before returning.
     */
    addAndWait<T = unknown, D = unknown>(qName: N, name: string, data: D, jOpts?: JobsOptions, ttl?: number): Promise<T>;
    /**
     * Same as addBulkJob but will also wait for the jobs to finish before returning.
     */
    addBulkAndWait<T = unknown, D = unknown>(qName: N, name: string, data: D[], jOpts?: JobsOptions, ttl?: number): Promise<T[]>;
}, PartialCustomServiceSchema<unknown, {
    getStore(storeName: string): Map<string, {
        services: Set<unknown>;
        client: Redis;
        onClose: () => Promise<void> | void;
    }>;
    getFromStore(storeName: string, key: string): Redis | null;
    removeServiceFromStore(storeName: string, key: string): Promise<boolean>;
    setClientToStore(storeName: string, key: string, client: Redis, onClose: () => Promise<void> | void): void;
}, unknown>[]>;

/**
 * This Mixin add the capability to launch a BullMQ flows.
 */
declare function QueueFlowProducerMixin(opts: WithoutConnection<QueueBaseOptions> & QueueMixinOptions): PartialCustomServiceSchema<unknown, {
    getFlowProducer(): FlowProducer;
}, unknown>;

type RepeatableJob = {
    name: string;
    data?: unknown;
} & RepeatOptions;
type QueueStaticRepeatableJobsOptions = {
    /**
     * Set to `false` to prevent deleting repeatable jobs not registered.
     */
    autoRemove?: boolean;
};
/**
 * This Mixin allow to register repeatable jobs and remove other ones.
 * It should mainly be setup on the same service as the related QueueWorker.
 */
declare function QueueStaticRepeatableJobs(queueName: string, jobs: RepeatableJob[], opts: QueueStaticRepeatableJobsOptions & QueueMixinOptions): PartialCustomServiceSchema<unknown, {
    registerRepeatableJobs(): Promise<void>;
}, PartialCustomServiceSchema<unknown, {
    getStore(storeName: string): Map<string, {
        services: Set<unknown>;
        client: Redis;
        onClose: () => Promise<void> | void;
    }>;
    getFromStore(storeName: string, key: string): Redis | null;
    removeServiceFromStore(storeName: string, key: string): Promise<boolean>;
    setClientToStore(storeName: string, key: string, client: Redis, onClose: () => Promise<void> | void): void;
}, unknown>[]>;

type JobMeta = {
    job?: Job;
    jobWorkerToken?: string;
};
type JobProcessorOptions = {
    /**
     * Use the job name as the action name.
     * When false (default), the action name is 'processor'.
     */
    useNamedFunctions?: boolean;
    /**
     * Skip normal info logs at the start and end of the job.
     * Will never disable logs on errors.
     */
    skipNormalLogs?: boolean;
    /**
     * Allow to log additional fields from the job data.
     * Currently, doesn't support nested fields.
     */
    logDataFields?: string[];
    /**
     * Optional wrapper that MUST call the passed function.
     */
    wrapper?: (job: Job, token: string | undefined, fn: (job: Job, token?: string) => Promise<unknown>) => Promise<unknown>;
};
/**
 * This Mixin create the worker system.
 */
declare function QueueWorker(queueName: string, opts: WithoutConnection<WorkerOptions> & QueueMixinOptions, processorOptions?: JobProcessorOptions): PartialCustomServiceSchema<unknown, {
    getWorker(): Worker;
    processJob(job: Job, token?: string): Promise<any>;
    _processJob(job: Job, token?: string): Promise<any>;
}, unknown>;

export { QueueClient, QueueEventsClient, QueueFlowProducerMixin, QueueStaticRepeatableJobs, QueueWorker };
export type { JobMeta, JobProcessorOptions, QueueMixinOptions, QueueStaticRepeatableJobsOptions, RepeatableJob };