@orion-js/dogs 4.3.6 → 4.5.0

package/dist/defineJob/index.d.ts

@@ -0,0 +1,10 @@
+import { SchemaInAnyOrionForm } from '@orion-js/schema';
+import { CreateEventJobOptions, CreateJobOptions, CreateRecurrentJobOptions, EventJobDefinition, JobDefinition, RecurrentJobDefinition } from '../types/JobsDefinition';
+export declare function createEventJob<TParamsSchema extends SchemaInAnyOrionForm>(options: CreateEventJobOptions<TParamsSchema>): EventJobDefinition<TParamsSchema>;
+export declare function createRecurrentJob(options: CreateRecurrentJobOptions): RecurrentJobDefinition;
+/**
+ * @deprecated Use `createEventJob` or `createRecurrentJob` instead.
+ */
+export declare const defineJob: (options: CreateJobOptions & {
+    type: 'event' | 'recurrent';
+}) => JobDefinition;

package/dist/index.d.ts

@@ -1,345 +1,14 @@
-import { SchemaInAnyOrionForm, Blackbox, InferSchemaType } from '@orion-js/schema';
-import { OrionLogger } from '@orion-js/logger';
-import { Collection, MongoDB } from '@orion-js/mongodb';
-
-/**
- * Base type for schedule params that varies based on schema presence
- */
-type ScheduleJobParamsType<TParamsSchema extends SchemaInAnyOrionForm> = TParamsSchema extends undefined ? {
-    params?: Blackbox;
-} : {
-    params: InferSchemaType<TParamsSchema>;
-};
-/**
- * Common options shared by all schedule job variants (without name)
- */
-type ScheduleJobCommonOptions = {
-    priority?: number;
-    uniqueIdentifier?: string;
-};
-/**
- * Schedule options without name - used by job definition's schedule method.
- * This is a distributive type that properly handles runIn/runAt variants.
- */
-type ScheduleJobOptionsWithoutName<TParamsSchema extends SchemaInAnyOrionForm = any> = (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema> & {
-    runIn: number;
-}) | (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema> & {
-    runAt: Date;
-}) | (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema>);
-/**
- * Full schedule options including job name - used by direct scheduleJob calls
- */
-type ScheduleJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = ScheduleJobOptionsWithoutName<TParamsSchema> & {
-    name: string;
-};
-/**
- * Legacy type aliases for backwards compatibility
- */
-type ScheduleJobOptionsBase<TParamsSchema extends SchemaInAnyOrionForm> = {
-    name: string;
-    priority?: number;
-    uniqueIdentifier?: string;
-} & ScheduleJobParamsType<TParamsSchema>;
-type ScheduleJobOptionsRunIn<TParamsSchema extends SchemaInAnyOrionForm> = ScheduleJobOptionsBase<TParamsSchema> & {
-    runIn: number;
-};
-type ScheduleJobOptionsRunAt<TParamsSchema extends SchemaInAnyOrionForm> = ScheduleJobOptionsBase<TParamsSchema> & {
-    runAt: Date;
-};
-interface ScheduleJobRecordOptions {
-    name: string;
-    params: Blackbox;
-    nextRunAt: Date;
-    priority: number;
-    uniqueIdentifier?: string;
-}
-type ScheduleJobsOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = ScheduleJobOptions<TParamsSchema>[];
-interface ScheduleJobsResult {
-    scheduledCount: number;
-    skippedCount: number;
-    errors: Array<{
-        index: number;
-        error: Error;
-        job: ScheduleJobOptions;
-    }>;
-}
-
-declare const HistoryRecordSchema: any;
-type HistoryRecord = InferSchemaType<typeof HistoryRecordSchema>;
-
-/**
- * Enum representing the status of a job record.
- * - 'pending': Job is active and can be executed (default for existing records)
- * - 'maxTriesReached': Event job has exhausted all retry attempts and won't be executed
- */
-declare const JobStatusEnum: any;
-declare const JobRecordSchema: any;
-type JobRecord = InferSchemaType<typeof JobRecordSchema>;
-
-interface JobToRun {
-    jobId: string;
-    executionId: string;
-    name: string;
-    type: 'event' | 'recurrent';
-    params: Blackbox;
-    tries: number;
-    lockTime: number;
-    priority: number;
-    uniqueIdentifier?: string;
-    wasStale?: boolean;
-}
-interface ExecutionContext {
-    record: JobToRun;
-    definition: JobDefinition;
-    tries: number;
-    logger: OrionLogger;
-    extendLockTime: (extraTime: number) => Promise<void>;
-    clearStaleTimeout: () => void;
-}
-interface WorkerInstance {
-    running: boolean;
-    workerIndex: number;
-    stop: () => Promise<void>;
-    respawn: () => Promise<void>;
-    promise?: Promise<any>;
-}
-interface WorkersInstance {
-    running: boolean;
-    workersCount: number;
-    workers: WorkerInstance[];
-    runningJobsByName: Map<string, number>;
-    jobAcquisitionLock: Promise<void>;
-    /**
-     * Stop all workers and wait for them to finish
-     */
-    stop: () => Promise<void>;
-}
-
-interface JobRetryResultBase {
-    action: 'retry' | 'dismiss';
-}
-type JobRetryResultRunIn = JobRetryResultBase & {
-    runIn: number;
-};
-type JobRetryResultRunAt = JobRetryResultBase & {
-    runAt: Date;
-};
-type JobRetryResult = JobRetryResultRunIn | JobRetryResultRunAt | JobRetryResultBase;
-interface BaseJobDefinition {
-    /**
-     * Called if the job fails.
-     */
-    onError?: (error: Error, params: Blackbox, context: ExecutionContext) => Promise<JobRetryResult>;
-    /**
-     * Called if the job locktime is expired. The job will be executed again.
-     */
-    onStale?: (params: Blackbox, context: ExecutionContext) => Promise<void>;
-    /**
-     * Save the executions of the job time in milliseconds. Default is 1 week. Set to 0 to disable.
-     */
-    saveExecutionsFor?: number;
-    /**
-     * The name of the job.
-     * This is set automatically when the job is passed to startWorkers.
-     */
-    jobName?: string;
-    /**
-     * Time in milliseconds to lock this specific job for execution.
-     * Overrides the defaultLockTime set in startWorkers config.
-     * If not set, the defaultLockTime from config will be used.
-     */
-    lockTime?: number;
-}
-interface RecurrentJobDefinition extends BaseJobDefinition {
-    /**
-     * Type of the job.
-     */
-    type: 'recurrent';
-    /**
-     * A function executed after each execution that returns the date of the next run.
-     */
-    getNextRun?: () => Date;
-    /**
-     * Run every x milliseconds. This will be ignored if getNextRun is defined.
-     */
-    runEvery?: number;
-    /**
-     * Cron expression used to calculate the next run. Requires timezone.
-     */
-    cron?: string;
-    /**
-     * IANA timezone used to calculate cron-based schedules.
-     */
-    timezone?: string;
-    /**
-     * The priority of the job. Higher is more priority. Default is 100.
-     */
-    priority?: number;
-    /**
-     * The function to execute when the job is executed.
-     */
-    resolve: (_: any, context: ExecutionContext) => Promise<Blackbox | void>;
-}
-interface EventJobDefinition<TParamsSchema extends SchemaInAnyOrionForm = any> extends BaseJobDefinition {
-    /**
-     * Type of the job.
-     */
-    type: 'event';
-    /**
-     * Maximum number of tries for this specific event job before it is marked as 'maxTriesReached'.
-     * Overrides the global maxTries set in startWorkers config.
-     * If not set, the global maxTries from config will be used.
-     */
-    maxTries?: number;
-    /**
-     * Schedule of the job. Supports optional runIn (milliseconds) or runAt (Date) for delayed execution.
-     */
-    schedule: (options: ScheduleJobOptionsWithoutName<TParamsSchema>) => Promise<void>;
-    /**
-     * Schedule multiple jobs at once. Each job supports optional runIn or runAt for delayed execution.
-     */
-    scheduleJobs: (jobs: Array<ScheduleJobOptionsWithoutName<TParamsSchema>>) => Promise<ScheduleJobsResult>;
-    /**
-     * The schema of the params of the job.
-     */
-    params?: TParamsSchema;
-    /**
-     * Maximum number of executions of this job that can run in parallel on the same server.
-     * If not set, the job can use all available workers on the current server.
-     */
-    maxParallelExecutionsPerServer?: number;
-    /**
-     * The function to execute when the job is executed.
-     */
-    resolve: (params: InferSchemaType<TParamsSchema>, context: ExecutionContext) => Promise<any>;
-}
-type CreateEventJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = Omit<EventJobDefinition<TParamsSchema>, 'type' | 'schedule' | 'scheduleJobs'>;
-type CreateRecurrentJobBaseOptions = Omit<RecurrentJobDefinition, 'type' | 'runEvery' | 'cron' | 'timezone'>;
-type CreateRecurrentJobRunEveryOptions = CreateRecurrentJobBaseOptions & {
-    /**
-     * Run every x milliseconds.
-     * Accepts https://github.com/jkroso/parse-duration strings.
-     */
-    runEvery: number | string;
-    cron?: never;
-    timezone?: string;
-};
-type CreateRecurrentJobCronOptions = CreateRecurrentJobBaseOptions & {
-    /**
-     * Cron expression used to calculate the next run.
-     */
-    cron: string;
-    /**
-     * IANA timezone used to calculate cron-based schedules.
-     */
-    timezone: string;
-    runEvery?: never;
-};
-type CreateRecurrentJobOptions = CreateRecurrentJobRunEveryOptions | CreateRecurrentJobCronOptions;
-type CreateJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = CreateEventJobOptions<TParamsSchema> | CreateRecurrentJobOptions;
-type JobDefinition<TParamsSchema extends SchemaInAnyOrionForm = any> = RecurrentJobDefinition | EventJobDefinition<TParamsSchema>;
-type JobDefinitionWithName<TParamsSchema extends SchemaInAnyOrionForm = any> = JobDefinition<TParamsSchema> & {
-    name: string;
-};
-interface JobsDefinition {
-    [jobName: string]: JobDefinition;
-}
-
-type LogLevels = 'debug' | 'info' | 'warn' | 'error' | 'none';
-interface StartWorkersConfig {
-    /**
-     * Object map of the jobs that this workers will execute
-     */
-    jobs: JobsDefinition;
-    /**
-     * Maximum number of tries for an event job before it is marked as 'maxTriesReached'.
-     * This is a global default that can be overridden per event job definition.
-     */
-    maxTries?: number;
-    /**
-     * Callback invoked when an event job reaches its maximum tries limit.
-     * Use this to notify administrators (e.g., send an email alert).
-     * The job will remain in the database with status 'maxTriesReached'.
-     */
-    onMaxTriesReached?: (job: JobToRun) => Promise<void>;
-    /**
-     * Time in milliseconds to wait between each look without results for a job
-     * to run at the database. Default is 3000.
-     */
-    pollInterval?: number;
-    /**
-     * Time in milliseconds to wait too look for a job after a job execution. Default is 100.
-     */
-    cooldownPeriod?: number;
-    /**
-     * Number of workers to start. Default is 1.
-     */
-    workersCount?: number;
-    /**
-     * Default time in milliseconds to lock a job for execution. Default is 30000 (30 seconds).
-     * If a job is locked for longer than this time, it will be considered as failed.
-     * This is to prevent a job from being executed multiple times at the same time.
-     * You can extend this time inside a job by calling extendLockTime from context.
-     * Individual jobs can override this value by setting their own lockTime.
-     */
-    defaultLockTime?: number;
-}
-
-declare class JobsHistoryRepo {
-    history: Collection<HistoryRecord>;
-    saveExecution(record: MongoDB.WithoutId<HistoryRecord>): Promise<void>;
-    getExecutions(jobName: string, limit?: number, skip?: number): Promise<HistoryRecord[]>;
-}
-
-declare class JobsRepo {
-    jobs: Collection<JobRecord>;
-    getJobAndLock(jobNames: string[], lockTime: number): Promise<JobToRun>;
-    setJobRecordPriority(jobId: string, priority: number): Promise<void>;
-    scheduleNextRun(options: {
-        jobId: string;
-        nextRunAt: Date;
-        resetTries: boolean;
-        priority: number;
-    }): Promise<void>;
-    deleteEventJob(jobId: string): Promise<void>;
-    /**
-     * Marks an event job as having reached its maximum tries limit.
-     * The job will remain in the database but won't be picked up for execution.
-     */
-    markJobAsMaxTriesReached(jobId: string): Promise<void>;
-    extendLockTime(jobId: string, extraTime: number): Promise<void>;
-    /**
-     * Updates the lock time for a job to the specified duration from now.
-     * Can be used to both extend or shorten the lock time.
-     */
-    updateLockTime(jobId: string, lockDuration: number): Promise<void>;
-    unlockAllJobs(): Promise<number>;
-    ensureJobRecord(job: JobDefinitionWithName): Promise<void>;
-    scheduleJob(options: ScheduleJobRecordOptions): Promise<void>;
-    scheduleJobs(jobs: ScheduleJobRecordOptions[]): Promise<ScheduleJobsResult>;
-}
-
-declare function Jobs(): (target: any, context: ClassDecoratorContext<any>) => void;
-declare function RecurrentJob(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
-declare function RecurrentJob(options: Omit<RecurrentJobDefinition, 'resolve' | 'type'>): (method: any, context: ClassMethodDecoratorContext) => any;
-declare function EventJob(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
-declare function EventJob(options: Omit<CreateEventJobOptions<any>, 'resolve'>): (method: any, context: ClassMethodDecoratorContext) => any;
-declare function getServiceJobs(target: any): {
-    [key: string]: JobDefinition;
-};
-
-declare function createEventJob<TParamsSchema extends SchemaInAnyOrionForm>(options: CreateEventJobOptions<TParamsSchema>): EventJobDefinition<TParamsSchema>;
-declare function createRecurrentJob(options: CreateRecurrentJobOptions): RecurrentJobDefinition;
-/**
- * @deprecated Use `createEventJob` or `createRecurrentJob` instead.
- */
-declare const defineJob: (options: CreateJobOptions & {
-    type: "event" | "recurrent";
-}) => JobDefinition;
-
+import { StartWorkersConfig } from './types/StartConfig';
+import { ScheduleJobOptions, ScheduleJobsOptions, ScheduleJobsResult } from './types/Events';
+import { JobsHistoryRepo } from './repos/JobsHistoryRepo';
+import { JobsRepo } from './repos/JobsRepo';
+import { SchemaInAnyOrionForm } from '@orion-js/schema';
+export * from './types';
+export * from './service';
+export * from './defineJob';
 declare const jobsHistoryRepo: JobsHistoryRepo;
 declare const jobsRepo: JobsRepo;
-declare const startWorkers: (config: StartWorkersConfig) => WorkersInstance;
+declare const startWorkers: (config: StartWorkersConfig) => import("./types").WorkersInstance;
 /**
  * @deprecated Use the event job definition.schedule method instead.
  */
@@ -349,5 +18,4 @@ declare const scheduleJob: <TParamsSchema extends SchemaInAnyOrionForm = any>(op
  * @deprecated Use the event job definition.scheduleJobs method instead.
  */
 declare const scheduleJobs: <TParamsSchema extends SchemaInAnyOrionForm = any>(jobs: ScheduleJobsOptions<TParamsSchema>) => Promise<ScheduleJobsResult>;
-
-export { type BaseJobDefinition, type CreateEventJobOptions, type CreateJobOptions, type CreateRecurrentJobCronOptions, type CreateRecurrentJobOptions, type CreateRecurrentJobRunEveryOptions, EventJob, type EventJobDefinition, type ExecutionContext, type HistoryRecord, HistoryRecordSchema, type JobDefinition, type JobDefinitionWithName, type JobRecord, JobRecordSchema, type JobRetryResult, type JobRetryResultBase, type JobRetryResultRunAt, type JobRetryResultRunIn, JobStatusEnum, type JobToRun, Jobs, type JobsDefinition, type LogLevels, RecurrentJob, type RecurrentJobDefinition, type ScheduleJobOptions, type ScheduleJobOptionsBase, type ScheduleJobOptionsRunAt, type ScheduleJobOptionsRunIn, type ScheduleJobOptionsWithoutName, type ScheduleJobRecordOptions, type ScheduleJobsOptions, type ScheduleJobsResult, type StartWorkersConfig, type WorkerInstance, type WorkersInstance, createEventJob, createRecurrentJob, defineJob, getServiceJobs, jobsHistoryRepo, jobsRepo, scheduleJob, scheduleJobs, startWorkers };
+export { startWorkers, scheduleJob, scheduleJobs, jobsHistoryRepo, jobsRepo };

package/dist/repos/JobsHistoryRepo.d.ts

@@ -0,0 +1,7 @@
+import { Collection, MongoDB } from '@orion-js/mongodb';
+import { HistoryRecord } from '../types/HistoryRecord';
+export declare class JobsHistoryRepo {
+    history: Collection<HistoryRecord>;
+    saveExecution(record: MongoDB.WithoutId<HistoryRecord>): Promise<void>;
+    getExecutions(jobName: string, limit?: number, skip?: number): Promise<HistoryRecord[]>;
+}

package/dist/repos/JobsRepo.d.ts

@@ -0,0 +1,32 @@
+import { Collection } from '@orion-js/mongodb';
+import { ScheduleJobRecordOptions, ScheduleJobsResult } from '../types/Events';
+import { JobRecord } from '../types/JobRecord';
+import { JobDefinitionWithName } from '../types/JobsDefinition';
+import { JobToRun } from '../types/Worker';
+export declare class JobsRepo {
+    jobs: Collection<JobRecord>;
+    getJobAndLock(jobNames: string[], lockTime: number): Promise<JobToRun>;
+    setJobRecordPriority(jobId: string, priority: number): Promise<void>;
+    scheduleNextRun(options: {
+        jobId: string;
+        nextRunAt: Date;
+        resetTries: boolean;
+        priority: number;
+    }): Promise<void>;
+    deleteEventJob(jobId: string): Promise<void>;
+    /**
+     * Marks an event job as having reached its maximum tries limit.
+     * The job will remain in the database but won't be picked up for execution.
+     */
+    markJobAsMaxTriesReached(jobId: string): Promise<void>;
+    extendLockTime(jobId: string, extraTime: number): Promise<void>;
+    /**
+     * Updates the lock time for a job to the specified duration from now.
+     * Can be used to both extend or shorten the lock time.
+     */
+    updateLockTime(jobId: string, lockDuration: number): Promise<void>;
+    unlockAllJobs(): Promise<number>;
+    ensureJobRecord(job: JobDefinitionWithName): Promise<void>;
+    scheduleJob(options: ScheduleJobRecordOptions): Promise<void>;
+    scheduleJobs(jobs: ScheduleJobRecordOptions[]): Promise<ScheduleJobsResult>;
+}

package/dist/service/index.d.ts

@@ -0,0 +1,9 @@
+import type { CreateEventJobOptions, JobDefinition, RecurrentJobDefinition } from '../types';
+export declare function Jobs(): (target: any, context: ClassDecoratorContext<any>) => void;
+export declare function RecurrentJob(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
+export declare function RecurrentJob(options: Omit<RecurrentJobDefinition, 'resolve' | 'type'>): (method: any, context: ClassMethodDecoratorContext) => any;
+export declare function EventJob(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
+export declare function EventJob(options: Omit<CreateEventJobOptions<any>, 'resolve'>): (method: any, context: ClassMethodDecoratorContext) => any;
+export declare function getServiceJobs(target: any): {
+    [key: string]: JobDefinition;
+};

package/dist/services/EventsService.d.ts

@@ -0,0 +1,6 @@
+import { ScheduleJobOptions, ScheduleJobsOptions, ScheduleJobsResult } from '../types/Events';
+export declare class EventsService {
+    private jobsRepo;
+    scheduleJob(options: ScheduleJobOptions): Promise<void>;
+    scheduleJobs(jobs: ScheduleJobsOptions): Promise<ScheduleJobsResult>;
+}

package/dist/services/Executor.d.ts

@@ -0,0 +1,43 @@
+import { Blackbox } from '@orion-js/schema';
+import { EventJobDefinition, JobDefinition, JobsDefinition } from '../types/JobsDefinition';
+import { ExecutionContext, JobToRun } from '../types/Worker';
+/**
+ * Configuration for job execution including max tries settings.
+ */
+export interface ExecuteJobConfig {
+    jobs: JobsDefinition;
+    maxTries?: number;
+    onMaxTriesReached?: (job: JobToRun) => Promise<void>;
+}
+export declare class Executor {
+    private readonly jobsRepo;
+    private readonly jobsHistoryRepo;
+    /**
+     * Determines the effective lock time for a job execution.
+     * Job-specific lockTime takes precedence over the default lockTime from config.
+     */
+    getEffectiveLockTime(job: JobDefinition, jobToRun: JobToRun): number;
+    getContext(job: JobDefinition, jobToRun: JobToRun, onStale: Function): ExecutionContext;
+    getJobDefinition(jobToRun: JobToRun, jobs: JobsDefinition): JobDefinition<any>;
+    /**
+     * Determines the effective max tries for an event job.
+     * Job-specific maxTries takes precedence over the global maxTries from config.
+     */
+    getEffectiveMaxTries(job: EventJobDefinition, globalMaxTries?: number): number | undefined;
+    /**
+     * Handles when a job has reached its maximum retry attempts.
+     * Marks the job in the database and invokes the onMaxTriesReached callback when provided.
+     */
+    handleMaxTriesReached(jobToRun: JobToRun, onMaxTriesReached?: (job: JobToRun) => Promise<void>): Promise<void>;
+    onError(error: unknown, job: JobDefinition, jobToRun: JobToRun, context: ExecutionContext): Promise<void>;
+    saveExecution(options: {
+        startedAt: Date;
+        status: 'stale' | 'error' | 'success';
+        errorMessage?: string;
+        result?: Blackbox;
+        job: JobDefinition;
+        jobToRun: JobToRun;
+    }): Promise<void>;
+    afterExecutionSuccess(job: JobDefinition, jobToRun: JobToRun, context: ExecutionContext): Promise<void>;
+    executeJob(config: ExecuteJobConfig, jobToRun: JobToRun, respawnWorker: () => void): Promise<void>;
+}

package/dist/services/WorkerService.d.ts

@@ -0,0 +1,26 @@
+import { JobDefinitionWithName, JobsDefinition } from '../types/JobsDefinition';
+import { StartWorkersConfig } from '../types/StartConfig';
+import { JobToRun, WorkerInstance, WorkersInstance } from '../types/Worker';
+import { ExecuteJobConfig } from './Executor';
+export declare class WorkerService {
+    private jobsRepo;
+    private executor;
+    getJobNames(jobs: JobsDefinition): string[];
+    getJobs(jobs: JobsDefinition): JobDefinitionWithName[];
+    getAvailableJobNames(config: StartWorkersConfig, workersInstance: WorkersInstance, jobNames: string[]): string[];
+    reserveJobExecution(workersInstance: WorkersInstance, jobName: string): void;
+    releaseJobExecution(workersInstance: WorkersInstance, jobName: string): void;
+    withJobAcquisitionLock<T>(workersInstance: WorkersInstance, callback: () => Promise<T>): Promise<T>;
+    getJobAndReserveExecution(config: StartWorkersConfig, workersInstance: WorkersInstance, jobNames: string[]): Promise<JobToRun | undefined>;
+    runWorkerLoop(config: StartWorkersConfig, workersInstance: WorkersInstance, workerInstance: WorkerInstance, jobNames: string[], executeConfig: ExecuteJobConfig): Promise<boolean>;
+    startWorker(config: StartWorkersConfig, workersInstance: WorkersInstance, workerInstance: WorkerInstance): Promise<void>;
+    createWorkersInstanceDefinition(config: StartWorkersConfig): WorkersInstance;
+    ensureRecords(config: StartWorkersConfig): Promise<void>;
+    startANewWorker(config: StartWorkersConfig, workersInstance: WorkersInstance, workerIndex?: number): Promise<void>;
+    runWorkers(config: StartWorkersConfig, workersInstance: WorkersInstance): Promise<void>;
+    /**
+     * Starts the job workers with the provided configuration.
+     * @param userConfig - Configuration for the workers. Required field: jobs
+     */
+    startWorkers(userConfig: StartWorkersConfig): WorkersInstance;
+}

package/dist/services/getNextRunDate.d.ts

@@ -0,0 +1,12 @@
+export type Options = {
+    getNextRun?: () => Date;
+    runIn?: number;
+    runEvery?: number;
+    runAt?: Date;
+    cron?: string;
+    timezone?: string;
+    currentDate?: Date | string | number;
+} & {
+    [key: string]: any;
+};
+export declare const getNextRunDate: (options: Options) => Date;

package/dist/types/Events.d.ts

@@ -0,0 +1,63 @@
+import { Blackbox, InferSchemaType, SchemaInAnyOrionForm } from '@orion-js/schema';
+/**
+ * Base type for schedule params that varies based on schema presence
+ */
+type ScheduleJobParamsType<TParamsSchema extends SchemaInAnyOrionForm> = TParamsSchema extends undefined ? {
+    params?: Blackbox;
+} : {
+    params: InferSchemaType<TParamsSchema>;
+};
+/**
+ * Common options shared by all schedule job variants (without name)
+ */
+type ScheduleJobCommonOptions = {
+    priority?: number;
+    uniqueIdentifier?: string;
+};
+/**
+ * Schedule options without name - used by job definition's schedule method.
+ * This is a distributive type that properly handles runIn/runAt variants.
+ */
+export type ScheduleJobOptionsWithoutName<TParamsSchema extends SchemaInAnyOrionForm = any> = (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema> & {
+    runIn: number;
+}) | (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema> & {
+    runAt: Date;
+}) | (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema>);
+/**
+ * Full schedule options including job name - used by direct scheduleJob calls
+ */
+export type ScheduleJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = ScheduleJobOptionsWithoutName<TParamsSchema> & {
+    name: string;
+};
+/**
+ * Legacy type aliases for backwards compatibility
+ */
+export type ScheduleJobOptionsBase<TParamsSchema extends SchemaInAnyOrionForm> = {
+    name: string;
+    priority?: number;
+    uniqueIdentifier?: string;
+} & ScheduleJobParamsType<TParamsSchema>;
+export type ScheduleJobOptionsRunIn<TParamsSchema extends SchemaInAnyOrionForm> = ScheduleJobOptionsBase<TParamsSchema> & {
+    runIn: number;
+};
+export type ScheduleJobOptionsRunAt<TParamsSchema extends SchemaInAnyOrionForm> = ScheduleJobOptionsBase<TParamsSchema> & {
+    runAt: Date;
+};
+export interface ScheduleJobRecordOptions {
+    name: string;
+    params: Blackbox;
+    nextRunAt: Date;
+    priority: number;
+    uniqueIdentifier?: string;
+}
+export type ScheduleJobsOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = ScheduleJobOptions<TParamsSchema>[];
+export interface ScheduleJobsResult {
+    scheduledCount: number;
+    skippedCount: number;
+    errors: Array<{
+        index: number;
+        error: Error;
+        job: ScheduleJobOptions;
+    }>;
+}
+export {};

package/dist/types/HistoryRecord.d.ts

@@ -0,0 +1,58 @@
+import { InferSchemaType } from '@orion-js/schema';
+export declare const HistoryRecordSchema: {
+    _id: {
+        type: "string";
+    };
+    jobId: {
+        type: "string";
+    };
+    executionId: {
+        type: "string";
+    };
+    jobName: {
+        type: "string";
+    };
+    type: {
+        type: "string";
+    };
+    priority: {
+        type: "number";
+    };
+    tries: {
+        type: "number";
+    };
+    uniqueIdentifier: {
+        type: "string";
+        optional: true;
+    };
+    startedAt: {
+        type: "date";
+    };
+    endedAt: {
+        type: "date";
+    };
+    duration: {
+        type: "number";
+    };
+    expiresAt: {
+        type: "date";
+        optional: true;
+    };
+    status: {
+        type: "string";
+        enum: string[];
+    };
+    errorMessage: {
+        type: "string";
+        optional: true;
+    };
+    params: {
+        type: "blackbox";
+        optional: true;
+    };
+    result: {
+        type: "any";
+        optional: true;
+    };
+};
+export type HistoryRecord = InferSchemaType<typeof HistoryRecordSchema>;

package/dist/types/JobRecord.d.ts

@@ -0,0 +1,53 @@
+import { InferSchemaType } from '@orion-js/schema';
+/**
+ * Enum representing the status of a job record.
+ * - 'pending': Job is active and can be executed (default for existing records)
+ * - 'maxTriesReached': Event job has exhausted all retry attempts and won't be executed
+ */
+export declare const JobStatusEnum: import("@orion-js/schema").FieldType<"maxTriesReached" | "pending">;
+export declare const JobRecordSchema: {
+    _id: {
+        type: "string";
+    };
+    jobName: {
+        type: "string";
+    };
+    type: {
+        type: import("@orion-js/schema").FieldType<"event" | "recurrent">;
+    };
+    priority: {
+        type: "number";
+    };
+    uniqueIdentifier: {
+        type: "string";
+        optional: true;
+    };
+    nextRunAt: {
+        type: "date";
+    };
+    lastRunAt: {
+        type: "date";
+        optional: true;
+    };
+    lockedUntil: {
+        type: "date";
+        optional: true;
+    };
+    tries: {
+        type: "number";
+        optional: true;
+    };
+    params: {
+        type: "blackbox";
+        optional: true;
+    };
+    /**
+     * Status of the job. Optional for backwards compatibility with existing records.
+     * Records without this field are treated as 'pending'.
+     */
+    status: {
+        type: import("@orion-js/schema").FieldType<"maxTriesReached" | "pending">;
+        optional: true;
+    };
+};
+export type JobRecord = InferSchemaType<typeof JobRecordSchema>;

package/dist/types/JobsDefinition.d.ts

@@ -0,0 +1,133 @@
+import { Blackbox, InferSchemaType, SchemaInAnyOrionForm } from '@orion-js/schema';
+import { ScheduleJobOptionsWithoutName, ScheduleJobsResult } from './Events';
+import { ExecutionContext } from './Worker';
+export interface JobRetryResultBase {
+    action: 'retry' | 'dismiss';
+}
+export type JobRetryResultRunIn = JobRetryResultBase & {
+    runIn: number;
+};
+export type JobRetryResultRunAt = JobRetryResultBase & {
+    runAt: Date;
+};
+export type JobRetryResult = JobRetryResultRunIn | JobRetryResultRunAt | JobRetryResultBase;
+export interface BaseJobDefinition {
+    /**
+     * Called if the job fails.
+     */
+    onError?: (error: Error, params: Blackbox, context: ExecutionContext) => Promise<JobRetryResult>;
+    /**
+     * Called if the job locktime is expired. The job will be executed again.
+     */
+    onStale?: (params: Blackbox, context: ExecutionContext) => Promise<void>;
+    /**
+     * Save the executions of the job time in milliseconds. Default is 1 week. Set to 0 to disable.
+     */
+    saveExecutionsFor?: number;
+    /**
+     * The name of the job.
+     * This is set automatically when the job is passed to startWorkers.
+     */
+    jobName?: string;
+    /**
+     * Time in milliseconds to lock this specific job for execution.
+     * Overrides the defaultLockTime set in startWorkers config.
+     * If not set, the defaultLockTime from config will be used.
+     */
+    lockTime?: number;
+}
+export interface RecurrentJobDefinition extends BaseJobDefinition {
+    /**
+     * Type of the job.
+     */
+    type: 'recurrent';
+    /**
+     * A function executed after each execution that returns the date of the next run.
+     */
+    getNextRun?: () => Date;
+    /**
+     * Run every x milliseconds. This will be ignored if getNextRun is defined.
+     */
+    runEvery?: number;
+    /**
+     * Cron expression used to calculate the next run. Requires timezone.
+     */
+    cron?: string;
+    /**
+     * IANA timezone used to calculate cron-based schedules.
+     */
+    timezone?: string;
+    /**
+     * The priority of the job. Higher is more priority. Default is 100.
+     */
+    priority?: number;
+    /**
+     * The function to execute when the job is executed.
+     */
+    resolve: (_: any, context: ExecutionContext) => Promise<Blackbox | void>;
+}
+export interface EventJobDefinition<TParamsSchema extends SchemaInAnyOrionForm = any> extends BaseJobDefinition {
+    /**
+     * Type of the job.
+     */
+    type: 'event';
+    /**
+     * Maximum number of tries for this specific event job before it is marked as 'maxTriesReached'.
+     * Overrides the global maxTries set in startWorkers config.
+     * If not set, the global maxTries from config will be used.
+     */
+    maxTries?: number;
+    /**
+     * Schedule of the job. Supports optional runIn (milliseconds) or runAt (Date) for delayed execution.
+     */
+    schedule: (options: ScheduleJobOptionsWithoutName<TParamsSchema>) => Promise<void>;
+    /**
+     * Schedule multiple jobs at once. Each job supports optional runIn or runAt for delayed execution.
+     */
+    scheduleJobs: (jobs: Array<ScheduleJobOptionsWithoutName<TParamsSchema>>) => Promise<ScheduleJobsResult>;
+    /**
+     * The schema of the params of the job.
+     */
+    params?: TParamsSchema;
+    /**
+     * Maximum number of executions of this job that can run in parallel on the same server.
+     * If not set, the job can use all available workers on the current server.
+     */
+    maxParallelExecutionsPerServer?: number;
+    /**
+     * The function to execute when the job is executed.
+     */
+    resolve: (params: InferSchemaType<TParamsSchema>, context: ExecutionContext) => Promise<any>;
+}
+export type CreateEventJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = Omit<EventJobDefinition<TParamsSchema>, 'type' | 'schedule' | 'scheduleJobs'>;
+type CreateRecurrentJobBaseOptions = Omit<RecurrentJobDefinition, 'type' | 'runEvery' | 'cron' | 'timezone'>;
+export type CreateRecurrentJobRunEveryOptions = CreateRecurrentJobBaseOptions & {
+    /**
+     * Run every x milliseconds.
+     * Accepts https://github.com/jkroso/parse-duration strings.
+     */
+    runEvery: number | string;
+    cron?: never;
+    timezone?: string;
+};
+export type CreateRecurrentJobCronOptions = CreateRecurrentJobBaseOptions & {
+    /**
+     * Cron expression used to calculate the next run.
+     */
+    cron: string;
+    /**
+     * IANA timezone used to calculate cron-based schedules.
+     */
+    timezone: string;
+    runEvery?: never;
+};
+export type CreateRecurrentJobOptions = CreateRecurrentJobRunEveryOptions | CreateRecurrentJobCronOptions;
+export type CreateJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = CreateEventJobOptions<TParamsSchema> | CreateRecurrentJobOptions;
+export type JobDefinition<TParamsSchema extends SchemaInAnyOrionForm = any> = RecurrentJobDefinition | EventJobDefinition<TParamsSchema>;
+export type JobDefinitionWithName<TParamsSchema extends SchemaInAnyOrionForm = any> = JobDefinition<TParamsSchema> & {
+    name: string;
+};
+export interface JobsDefinition {
+    [jobName: string]: JobDefinition;
+}
+export {};

package/dist/types/StartConfig.d.ts

@@ -0,0 +1,41 @@
+import { JobsDefinition } from './JobsDefinition';
+import { JobToRun } from './Worker';
+export type LogLevels = 'debug' | 'info' | 'warn' | 'error' | 'none';
+export interface StartWorkersConfig {
+    /**
+     * Object map of the jobs that this workers will execute
+     */
+    jobs: JobsDefinition;
+    /**
+     * Maximum number of tries for an event job before it is marked as 'maxTriesReached'.
+     * This is a global default that can be overridden per event job definition.
+     */
+    maxTries?: number;
+    /**
+     * Callback invoked when an event job reaches its maximum tries limit.
+     * Use this to notify administrators (e.g., send an email alert).
+     * The job will remain in the database with status 'maxTriesReached'.
+     */
+    onMaxTriesReached?: (job: JobToRun) => Promise<void>;
+    /**
+     * Time in milliseconds to wait between each look without results for a job
+     * to run at the database. Default is 3000.
+     */
+    pollInterval?: number;
+    /**
+     * Time in milliseconds to wait too look for a job after a job execution. Default is 100.
+     */
+    cooldownPeriod?: number;
+    /**
+     * Number of workers to start. Default is 1.
+     */
+    workersCount?: number;
+    /**
+     * Default time in milliseconds to lock a job for execution. Default is 30000 (30 seconds).
+     * If a job is locked for longer than this time, it will be considered as failed.
+     * This is to prevent a job from being executed multiple times at the same time.
+     * You can extend this time inside a job by calling extendLockTime from context.
+     * Individual jobs can override this value by setting their own lockTime.
+     */
+    defaultLockTime?: number;
+}

package/dist/types/Worker.d.ts

@@ -0,0 +1,41 @@
+import { OrionLogger } from '@orion-js/logger';
+import { Blackbox } from '@orion-js/schema';
+import { JobDefinition } from './JobsDefinition';
+export interface JobToRun {
+    jobId: string;
+    executionId: string;
+    name: string;
+    type: 'event' | 'recurrent';
+    params: Blackbox;
+    tries: number;
+    lockTime: number;
+    priority: number;
+    uniqueIdentifier?: string;
+    wasStale?: boolean;
+}
+export interface ExecutionContext {
+    record: JobToRun;
+    definition: JobDefinition;
+    tries: number;
+    logger: OrionLogger;
+    extendLockTime: (extraTime: number) => Promise<void>;
+    clearStaleTimeout: () => void;
+}
+export interface WorkerInstance {
+    running: boolean;
+    workerIndex: number;
+    stop: () => Promise<void>;
+    respawn: () => Promise<void>;
+    promise?: Promise<any>;
+}
+export interface WorkersInstance {
+    running: boolean;
+    workersCount: number;
+    workers: WorkerInstance[];
+    runningJobsByName: Map<string, number>;
+    jobAcquisitionLock: Promise<void>;
+    /**
+     * Stop all workers and wait for them to finish
+     */
+    stop: () => Promise<void>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Events';
+export * from './HistoryRecord';
+export * from './JobRecord';
+export * from './JobsDefinition';
+export * from './StartConfig';
+export * from './Worker';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/dogs",
-  "version": "4.3.6",
+  "version": "4.5.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -17,25 +17,25 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@orion-js/helpers": "4.3.1",
-    "@orion-js/schema": "4.3.1",
-    "@orion-js/services": "4.3.1",
-    "@orion-js/typed-model": "4.3.1",
+    "@orion-js/helpers": "4.5.0",
+    "@orion-js/schema": "4.5.0",
+    "@orion-js/services": "4.5.0",
+    "@orion-js/typed-model": "4.5.0",
     "cron-parser": "^5.5.0",
     "dataloader": "2.2.2",
     "dot-object": "^2.1.5",
     "parse-duration": "^2.1.3"
   },
   "peerDependencies": {
-    "@orion-js/logger": "4.3.1",
-    "@orion-js/mongodb": "4.3.1"
+    "@orion-js/logger": "4.5.0",
+    "@orion-js/mongodb": "4.5.0"
   },
   "devDependencies": {
-    "@orion-js/logger": "4.3.1",
-    "@orion-js/mongodb": "4.3.1",
+    "@orion-js/logger": "4.5.0",
+    "@orion-js/mongodb": "4.5.0",
     "mongodb-memory-server": "^10.1.4",
     "tsup": "^8.0.1",
-    "typescript": "^5.4.5"
+    "typescript": "^7.0.2"
   },
   "publishConfig": {
     "access": "public"
@@ -44,7 +44,7 @@
   "scripts": {
     "test": "bun test",
     "clean": "rm -rf ./dist",
-    "build": "tsup",
+    "build": "tsup && bun run ../../scripts/emit-declarations.ts",
     "dev": "tsup --watch"
   }
 }

package/dist/index.d.cts

@@ -1,353 +0,0 @@
-import { SchemaInAnyOrionForm, Blackbox, InferSchemaType } from '@orion-js/schema';
-import { OrionLogger } from '@orion-js/logger';
-import { Collection, MongoDB } from '@orion-js/mongodb';
-
-/**
- * Base type for schedule params that varies based on schema presence
- */
-type ScheduleJobParamsType<TParamsSchema extends SchemaInAnyOrionForm> = TParamsSchema extends undefined ? {
-    params?: Blackbox;
-} : {
-    params: InferSchemaType<TParamsSchema>;
-};
-/**
- * Common options shared by all schedule job variants (without name)
- */
-type ScheduleJobCommonOptions = {
-    priority?: number;
-    uniqueIdentifier?: string;
-};
-/**
- * Schedule options without name - used by job definition's schedule method.
- * This is a distributive type that properly handles runIn/runAt variants.
- */
-type ScheduleJobOptionsWithoutName<TParamsSchema extends SchemaInAnyOrionForm = any> = (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema> & {
-    runIn: number;
-}) | (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema> & {
-    runAt: Date;
-}) | (ScheduleJobCommonOptions & ScheduleJobParamsType<TParamsSchema>);
-/**
- * Full schedule options including job name - used by direct scheduleJob calls
- */
-type ScheduleJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = ScheduleJobOptionsWithoutName<TParamsSchema> & {
-    name: string;
-};
-/**
- * Legacy type aliases for backwards compatibility
- */
-type ScheduleJobOptionsBase<TParamsSchema extends SchemaInAnyOrionForm> = {
-    name: string;
-    priority?: number;
-    uniqueIdentifier?: string;
-} & ScheduleJobParamsType<TParamsSchema>;
-type ScheduleJobOptionsRunIn<TParamsSchema extends SchemaInAnyOrionForm> = ScheduleJobOptionsBase<TParamsSchema> & {
-    runIn: number;
-};
-type ScheduleJobOptionsRunAt<TParamsSchema extends SchemaInAnyOrionForm> = ScheduleJobOptionsBase<TParamsSchema> & {
-    runAt: Date;
-};
-interface ScheduleJobRecordOptions {
-    name: string;
-    params: Blackbox;
-    nextRunAt: Date;
-    priority: number;
-    uniqueIdentifier?: string;
-}
-type ScheduleJobsOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = ScheduleJobOptions<TParamsSchema>[];
-interface ScheduleJobsResult {
-    scheduledCount: number;
-    skippedCount: number;
-    errors: Array<{
-        index: number;
-        error: Error;
-        job: ScheduleJobOptions;
-    }>;
-}
-
-declare const HistoryRecordSchema: any;
-type HistoryRecord = InferSchemaType<typeof HistoryRecordSchema>;
-
-/**
- * Enum representing the status of a job record.
- * - 'pending': Job is active and can be executed (default for existing records)
- * - 'maxTriesReached': Event job has exhausted all retry attempts and won't be executed
- */
-declare const JobStatusEnum: any;
-declare const JobRecordSchema: any;
-type JobRecord = InferSchemaType<typeof JobRecordSchema>;
-
-interface JobToRun {
-    jobId: string;
-    executionId: string;
-    name: string;
-    type: 'event' | 'recurrent';
-    params: Blackbox;
-    tries: number;
-    lockTime: number;
-    priority: number;
-    uniqueIdentifier?: string;
-    wasStale?: boolean;
-}
-interface ExecutionContext {
-    record: JobToRun;
-    definition: JobDefinition;
-    tries: number;
-    logger: OrionLogger;
-    extendLockTime: (extraTime: number) => Promise<void>;
-    clearStaleTimeout: () => void;
-}
-interface WorkerInstance {
-    running: boolean;
-    workerIndex: number;
-    stop: () => Promise<void>;
-    respawn: () => Promise<void>;
-    promise?: Promise<any>;
-}
-interface WorkersInstance {
-    running: boolean;
-    workersCount: number;
-    workers: WorkerInstance[];
-    runningJobsByName: Map<string, number>;
-    jobAcquisitionLock: Promise<void>;
-    /**
-     * Stop all workers and wait for them to finish
-     */
-    stop: () => Promise<void>;
-}
-
-interface JobRetryResultBase {
-    action: 'retry' | 'dismiss';
-}
-type JobRetryResultRunIn = JobRetryResultBase & {
-    runIn: number;
-};
-type JobRetryResultRunAt = JobRetryResultBase & {
-    runAt: Date;
-};
-type JobRetryResult = JobRetryResultRunIn | JobRetryResultRunAt | JobRetryResultBase;
-interface BaseJobDefinition {
-    /**
-     * Called if the job fails.
-     */
-    onError?: (error: Error, params: Blackbox, context: ExecutionContext) => Promise<JobRetryResult>;
-    /**
-     * Called if the job locktime is expired. The job will be executed again.
-     */
-    onStale?: (params: Blackbox, context: ExecutionContext) => Promise<void>;
-    /**
-     * Save the executions of the job time in milliseconds. Default is 1 week. Set to 0 to disable.
-     */
-    saveExecutionsFor?: number;
-    /**
-     * The name of the job.
-     * This is set automatically when the job is passed to startWorkers.
-     */
-    jobName?: string;
-    /**
-     * Time in milliseconds to lock this specific job for execution.
-     * Overrides the defaultLockTime set in startWorkers config.
-     * If not set, the defaultLockTime from config will be used.
-     */
-    lockTime?: number;
-}
-interface RecurrentJobDefinition extends BaseJobDefinition {
-    /**
-     * Type of the job.
-     */
-    type: 'recurrent';
-    /**
-     * A function executed after each execution that returns the date of the next run.
-     */
-    getNextRun?: () => Date;
-    /**
-     * Run every x milliseconds. This will be ignored if getNextRun is defined.
-     */
-    runEvery?: number;
-    /**
-     * Cron expression used to calculate the next run. Requires timezone.
-     */
-    cron?: string;
-    /**
-     * IANA timezone used to calculate cron-based schedules.
-     */
-    timezone?: string;
-    /**
-     * The priority of the job. Higher is more priority. Default is 100.
-     */
-    priority?: number;
-    /**
-     * The function to execute when the job is executed.
-     */
-    resolve: (_: any, context: ExecutionContext) => Promise<Blackbox | void>;
-}
-interface EventJobDefinition<TParamsSchema extends SchemaInAnyOrionForm = any> extends BaseJobDefinition {
-    /**
-     * Type of the job.
-     */
-    type: 'event';
-    /**
-     * Maximum number of tries for this specific event job before it is marked as 'maxTriesReached'.
-     * Overrides the global maxTries set in startWorkers config.
-     * If not set, the global maxTries from config will be used.
-     */
-    maxTries?: number;
-    /**
-     * Schedule of the job. Supports optional runIn (milliseconds) or runAt (Date) for delayed execution.
-     */
-    schedule: (options: ScheduleJobOptionsWithoutName<TParamsSchema>) => Promise<void>;
-    /**
-     * Schedule multiple jobs at once. Each job supports optional runIn or runAt for delayed execution.
-     */
-    scheduleJobs: (jobs: Array<ScheduleJobOptionsWithoutName<TParamsSchema>>) => Promise<ScheduleJobsResult>;
-    /**
-     * The schema of the params of the job.
-     */
-    params?: TParamsSchema;
-    /**
-     * Maximum number of executions of this job that can run in parallel on the same server.
-     * If not set, the job can use all available workers on the current server.
-     */
-    maxParallelExecutionsPerServer?: number;
-    /**
-     * The function to execute when the job is executed.
-     */
-    resolve: (params: InferSchemaType<TParamsSchema>, context: ExecutionContext) => Promise<any>;
-}
-type CreateEventJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = Omit<EventJobDefinition<TParamsSchema>, 'type' | 'schedule' | 'scheduleJobs'>;
-type CreateRecurrentJobBaseOptions = Omit<RecurrentJobDefinition, 'type' | 'runEvery' | 'cron' | 'timezone'>;
-type CreateRecurrentJobRunEveryOptions = CreateRecurrentJobBaseOptions & {
-    /**
-     * Run every x milliseconds.
-     * Accepts https://github.com/jkroso/parse-duration strings.
-     */
-    runEvery: number | string;
-    cron?: never;
-    timezone?: string;
-};
-type CreateRecurrentJobCronOptions = CreateRecurrentJobBaseOptions & {
-    /**
-     * Cron expression used to calculate the next run.
-     */
-    cron: string;
-    /**
-     * IANA timezone used to calculate cron-based schedules.
-     */
-    timezone: string;
-    runEvery?: never;
-};
-type CreateRecurrentJobOptions = CreateRecurrentJobRunEveryOptions | CreateRecurrentJobCronOptions;
-type CreateJobOptions<TParamsSchema extends SchemaInAnyOrionForm = any> = CreateEventJobOptions<TParamsSchema> | CreateRecurrentJobOptions;
-type JobDefinition<TParamsSchema extends SchemaInAnyOrionForm = any> = RecurrentJobDefinition | EventJobDefinition<TParamsSchema>;
-type JobDefinitionWithName<TParamsSchema extends SchemaInAnyOrionForm = any> = JobDefinition<TParamsSchema> & {
-    name: string;
-};
-interface JobsDefinition {
-    [jobName: string]: JobDefinition;
-}
-
-type LogLevels = 'debug' | 'info' | 'warn' | 'error' | 'none';
-interface StartWorkersConfig {
-    /**
-     * Object map of the jobs that this workers will execute
-     */
-    jobs: JobsDefinition;
-    /**
-     * Maximum number of tries for an event job before it is marked as 'maxTriesReached'.
-     * This is a global default that can be overridden per event job definition.
-     */
-    maxTries?: number;
-    /**
-     * Callback invoked when an event job reaches its maximum tries limit.
-     * Use this to notify administrators (e.g., send an email alert).
-     * The job will remain in the database with status 'maxTriesReached'.
-     */
-    onMaxTriesReached?: (job: JobToRun) => Promise<void>;
-    /**
-     * Time in milliseconds to wait between each look without results for a job
-     * to run at the database. Default is 3000.
-     */
-    pollInterval?: number;
-    /**
-     * Time in milliseconds to wait too look for a job after a job execution. Default is 100.
-     */
-    cooldownPeriod?: number;
-    /**
-     * Number of workers to start. Default is 1.
-     */
-    workersCount?: number;
-    /**
-     * Default time in milliseconds to lock a job for execution. Default is 30000 (30 seconds).
-     * If a job is locked for longer than this time, it will be considered as failed.
-     * This is to prevent a job from being executed multiple times at the same time.
-     * You can extend this time inside a job by calling extendLockTime from context.
-     * Individual jobs can override this value by setting their own lockTime.
-     */
-    defaultLockTime?: number;
-}
-
-declare class JobsHistoryRepo {
-    history: Collection<HistoryRecord>;
-    saveExecution(record: MongoDB.WithoutId<HistoryRecord>): Promise<void>;
-    getExecutions(jobName: string, limit?: number, skip?: number): Promise<HistoryRecord[]>;
-}
-
-declare class JobsRepo {
-    jobs: Collection<JobRecord>;
-    getJobAndLock(jobNames: string[], lockTime: number): Promise<JobToRun>;
-    setJobRecordPriority(jobId: string, priority: number): Promise<void>;
-    scheduleNextRun(options: {
-        jobId: string;
-        nextRunAt: Date;
-        resetTries: boolean;
-        priority: number;
-    }): Promise<void>;
-    deleteEventJob(jobId: string): Promise<void>;
-    /**
-     * Marks an event job as having reached its maximum tries limit.
-     * The job will remain in the database but won't be picked up for execution.
-     */
-    markJobAsMaxTriesReached(jobId: string): Promise<void>;
-    extendLockTime(jobId: string, extraTime: number): Promise<void>;
-    /**
-     * Updates the lock time for a job to the specified duration from now.
-     * Can be used to both extend or shorten the lock time.
-     */
-    updateLockTime(jobId: string, lockDuration: number): Promise<void>;
-    unlockAllJobs(): Promise<number>;
-    ensureJobRecord(job: JobDefinitionWithName): Promise<void>;
-    scheduleJob(options: ScheduleJobRecordOptions): Promise<void>;
-    scheduleJobs(jobs: ScheduleJobRecordOptions[]): Promise<ScheduleJobsResult>;
-}
-
-declare function Jobs(): (target: any, context: ClassDecoratorContext<any>) => void;
-declare function RecurrentJob(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
-declare function RecurrentJob(options: Omit<RecurrentJobDefinition, 'resolve' | 'type'>): (method: any, context: ClassMethodDecoratorContext) => any;
-declare function EventJob(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
-declare function EventJob(options: Omit<CreateEventJobOptions<any>, 'resolve'>): (method: any, context: ClassMethodDecoratorContext) => any;
-declare function getServiceJobs(target: any): {
-    [key: string]: JobDefinition;
-};
-
-declare function createEventJob<TParamsSchema extends SchemaInAnyOrionForm>(options: CreateEventJobOptions<TParamsSchema>): EventJobDefinition<TParamsSchema>;
-declare function createRecurrentJob(options: CreateRecurrentJobOptions): RecurrentJobDefinition;
-/**
- * @deprecated Use `createEventJob` or `createRecurrentJob` instead.
- */
-declare const defineJob: (options: CreateJobOptions & {
-    type: "event" | "recurrent";
-}) => JobDefinition;
-
-declare const jobsHistoryRepo: JobsHistoryRepo;
-declare const jobsRepo: JobsRepo;
-declare const startWorkers: (config: StartWorkersConfig) => WorkersInstance;
-/**
- * @deprecated Use the event job definition.schedule method instead.
- */
-declare const scheduleJob: <TParamsSchema extends SchemaInAnyOrionForm = any>(options: ScheduleJobOptions<TParamsSchema>) => Promise<void>;
-/**
- * Schedule multiple jobs at once for better performance.
- * @deprecated Use the event job definition.scheduleJobs method instead.
- */
-declare const scheduleJobs: <TParamsSchema extends SchemaInAnyOrionForm = any>(jobs: ScheduleJobsOptions<TParamsSchema>) => Promise<ScheduleJobsResult>;
-
-export { type BaseJobDefinition, type CreateEventJobOptions, type CreateJobOptions, type CreateRecurrentJobCronOptions, type CreateRecurrentJobOptions, type CreateRecurrentJobRunEveryOptions, EventJob, type EventJobDefinition, type ExecutionContext, type HistoryRecord, HistoryRecordSchema, type JobDefinition, type JobDefinitionWithName, type JobRecord, JobRecordSchema, type JobRetryResult, type JobRetryResultBase, type JobRetryResultRunAt, type JobRetryResultRunIn, JobStatusEnum, type JobToRun, Jobs, type JobsDefinition, type LogLevels, RecurrentJob, type RecurrentJobDefinition, type ScheduleJobOptions, type ScheduleJobOptionsBase, type ScheduleJobOptionsRunAt, type ScheduleJobOptionsRunIn, type ScheduleJobOptionsWithoutName, type ScheduleJobRecordOptions, type ScheduleJobsOptions, type ScheduleJobsResult, type StartWorkersConfig, type WorkerInstance, type WorkersInstance, createEventJob, createRecurrentJob, defineJob, getServiceJobs, jobsHistoryRepo, jobsRepo, scheduleJob, scheduleJobs, startWorkers };