interface Vertex$1<T> {
    name: string;
    value: T;
    inEdges: Set<Vertex$1<T>>;
    outEdges: Set<Vertex$1<T>>;
    excludeFromSort: boolean;
    get outEdgeCount(): number;
    get inEdgeCount(): number;
}
interface DirectedGraph$1<T> {
    addVertex(value: T, options: {
        name?: string;
        excludeFromSort?: boolean;
    }): Vertex$1<T>;
    topSort(): T[];
    exists(value: T): boolean;
    hasEdge(from: T, to: T): boolean;
    addEdge(from: T, to: T): void;
    excludeFromSort(value: T, exclude: boolean): void;
    name(value: T, name: string): void;
    removeVertex(value: T): void;
    removeEdge(from: T, to: T): void;
    getVertex(value: T): Vertex$1<T> | undefined;
    addVertexToEndOfGraph(value: T, options: {
        name?: string;
        excludeFromSort?: boolean;
    }): void;
    isPathWithoutDirectEdge(from: Vertex$1<T>, to: Vertex$1<T>): boolean;
    transitiveReduction(): void;
    asciiVisualize(): void;
    sorted: T[];
}

declare global {
    namespace Scheduler {
        interface Context {
        }
    }
}
type Runnable<T extends Scheduler.Context = Scheduler.Context> = (context: T) => void | Promise<void>;
interface Schedule$1<T extends Scheduler.Context = Scheduler.Context> {
    dag: DirectedGraph$1<Runnable<T>>;
    tags: Map<symbol | string, Tag<T>>;
    symbols: Map<symbol | string, Runnable<T>>;
}
type Options<T extends Scheduler.Context = Scheduler.Context> = {
    schedule: Schedule$1<T>;
    dag: DirectedGraph$1<Runnable<T>>;
    runnable?: Runnable<T>;
    tag?: Tag<T>;
};
type OptionsFn<T extends Scheduler.Context = Scheduler.Context> = SingleOptionsFn<T> | MultiOptionsFn<T>;
type SingleOptionsFn<T extends Scheduler.Context = Scheduler.Context> = ((options: Options<T>) => void) & {
    __type: 'single' | 'multi';
};
type MultiOptionsFn<T extends Scheduler.Context = Scheduler.Context> = ((options: Options<T>) => void) & {
    __type: 'multi';
};
type Tag<T extends Scheduler.Context = Scheduler.Context> = {
    id: symbol | string;
    before: Runnable<T>;
    after: Runnable<T>;
};

declare class Vertex<T> {
    name: string;
    value: T;
    inEdges: Set<Vertex<T>>;
    outEdges: Set<Vertex<T>>;
    excludeFromSort: boolean;
    get outEdgeCount(): number;
    get inEdgeCount(): number;
    constructor(value: T, { name, excludeFromSort }: {
        name?: string;
        excludeFromSort?: boolean;
    });
}
declare class DirectedGraph<T> {
    private _vertices;
    private _topsort;
    private _lastAddedVertex;
    constructor();
    exists(value: T): boolean;
    hasEdge(from: T, to: T): boolean;
    getVertex(value: T): Vertex<T> | undefined;
    addVertex(value: T, options: {
        name?: string;
        excludeFromSort?: boolean;
    }): Vertex<T>;
    excludeFromSort(value: T, exclude: boolean): void;
    name(value: T, name: string): void;
    removeVertex(value: T): void;
    addVertexToEndOfGraph(value: T, options: {
        name?: string;
        excludeFromSort?: boolean;
    }): void;
    addEdge(from: T, to: T): void;
    removeEdge(from: T, to: T): void;
    get sorted(): T[];
    topSort(): T[];
    isPathWithoutDirectEdge(from: Vertex<T>, to: Vertex<T>): boolean;
    transitiveReduction(): void;
    asciiVisualize(): void;
}

type OptionsObject<T extends Scheduler.Context = Scheduler.Context> = {
    before?: symbol | string | Runnable<T> | (symbol | string | Runnable<T>)[];
    after?: symbol | string | Runnable<T> | (symbol | string | Runnable<T>)[];
    tag?: symbol | string | (symbol | string)[];
};
type SingleOptionsObject<T extends Scheduler.Context = Scheduler.Context> = OptionsObject<T> & {
    id?: string | symbol;
};

declare class Schedule<T extends Scheduler.Context = Scheduler.Context> {
    dag: DirectedGraph<Runnable<T>>;
    tags: Map<symbol | string, Tag<any>>;
    symbols: Map<symbol | string, Runnable<T>>;
    constructor();
    add(runnable: Runnable<T>[], options?: OptionsObject<T>): Schedule<T>;
    add(runnable: Runnable<T>, options?: SingleOptionsObject<T>): Schedule<T>;
    has(runnable: Runnable<T>): boolean;
    run(context: T): Promise<Schedule<T>>;
    build(): Schedule<T>;
    remove(runnable: Runnable<T>): Schedule<T>;
    debug(): Schedule<T>;
    createTag(id: symbol | string, options?: OptionsObject<T>): Schedule<T>;
    removeTag(id: symbol | string): Schedule<T>;
    hasTag(id: symbol | string): boolean;
    getRunnable(id: symbol | string): Runnable<T> | undefined;
}

export { type MultiOptionsFn as M, type OptionsFn as O, type Runnable as R, type SingleOptionsFn as S, type Tag as T, type Schedule$1 as a, Schedule as b, type OptionsObject as c, type SingleOptionsObject as d, type Options as e };