export declare function runSingleJobInQueue(job: Job, onError: (error: Value) => void, finished: () => void): void;
export interface JobQueue extends Markable {
    enqueueFinalizationRegistryCleanupJob(job: Job): void;
    enqueuePromiseJob(job: Job): void;
    enqueueTimeoutJob(job: Job): void;
    enqueueGenericJob(job: Job): void;
    onNewJob: Set<(job: Job) => void>;
    shift(): Job | undefined;
    shiftFinalizationRegistryCleanupJob?(): Job | undefined;
    shiftPromiseJob?(): Job | undefined;
    shiftTimeoutJob?(): Job | undefined;
    shiftGenericJob?(): Job | undefined;
    get length(): number;
}
export declare class BasicJobQueue extends Set<Job> implements JobQueue, Markable {}
export declare class ByTypeJobQueue implements JobQueue, Markable {}

/** https://nodejs.org/learn/asynchronous-work/event-loop-timers-and-nexttick */
export type NodeJSJobType = 'timers' | 'pending callbacks' | 'idle' | 'prepare' | 'poll' | 'check' | 'close callbacks';
export type EventLoopRunType = 'manual' | 'automatic';
export interface EventLoop extends Markable {
    /**
     * Enqueue a host job (macrotask) now.
     */
    enqueue(type: NodeJSJobType | string, job: Job): void;
    /**
     * Enqueue a host job (macrotask) in the future.
     * It will keep `hasPendingJobs` to be `true` until `enqueue` is called.
     */
    enqueueAsync(type: NodeJSJobType | string, job: Job, executor: (enqueue: () => void, cancel: () => void) => void): void;
    /** Change the automatic run type of the event loop and run it */
    run(type: EventLoopRunType): void;
    runOnce(): void;
    readonly hasPendingJobs: boolean;
    /**
     * Register a callback to be called when there are no async queued jobs.
     *
     * This can be used to implement a mechanism to exit the program when all code has finished executing.
     */
    onNoPendingJob: Set<() => void>;
}

export declare abstract class AbstractEventLoop implements EventLoop {}

export declare class MicroTaskEventLoop extends AbstractEventLoop {}

/** https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide/In_depth */
export declare class WebLikeEventLoop extends AbstractEventLoop {}

/** https://nodejs.org/learn/asynchronous-work/event-loop-timers-and-nexttick */
export declare class NodeJSLikeEventLoop extends AbstractEventLoop {
    fallbackType: NodeJSJobType;
}

const job: Job = {
  queueName: 'timer',
  callerRealm: surroundingAgent.currentRealmRecord,
  callerScriptOrModule: GetActiveScriptOrModule(),
  job: function* setTimeoutResolve() {
    return yield* Call(callback, Value.undefined, []);
  },
};
// enqueueAsync prevents the event loop from exiting.
surroundingAgent.eventLoop.enqueueAsync('timers', job, (enqueue) => {
  // enqueue() actually enqueues the job.
  setTimeout(enqueue, ms.value);
});