import type { BaseTask, TaskResultType } from "../tasks/base";
import type { ValidResultType } from "../tasks/base-action";
import type { GraphResult } from "./results";
import { GraphResults } from "./results";
import type { GraphSolver } from "./solver";
export interface InternalNodeTypes {
    status: StatusTaskNode;
    process: ProcessTaskNode;
}
export interface NodeTypes extends InternalNodeTypes {
    request: RequestTaskNode;
}
export type NodeType = keyof NodeTypes;
export interface TaskNodeParams<T extends BaseTask> {
    solver: GraphSolver;
    task: T;
    dependant?: TaskNode;
    statusOnly: boolean;
}
export declare abstract class TaskNode<T extends BaseTask = BaseTask> {
    abstract readonly executionType: NodeType;
    readonly type: string;
    startedAt?: Date;
    readonly task: T;
    readonly statusOnly: boolean;
    abstract readonly concurrencyLimit: number;
    abstract readonly concurrencyGroupKey: string;
    protected solver: GraphSolver;
    protected dependants: {
        [key: string]: TaskNode;
    };
    protected result?: GraphResult<ValidResultType>;
    /**
     * When complete handler is called, we need to know if the run handler has been called (i.e. the process task node has been processed).
     *
     * The implementations of the TaskNode abstract class need to make that decision; The complete method will use this information to inform the result.
     */
    protected abstract processed: boolean;
    constructor({ solver, task, statusOnly }: TaskNodeParams<T>);
    abstract describe(): string;
    abstract getDependencies(): TaskNode[];
    abstract execute(): Promise<TaskResultType<T> | null>;
    getKey(): string;
    addDependant(node: TaskNode): void;
    /**
     * Returns all dependencies that does not yet have a result, i.e. is not resolved.
     */
    getRemainingDependencies(): TaskNode[];
    /**
     * Get the result for the given dependency node. Returns undefined if result is not yet set.
     */
    getDependencyResult<A extends BaseTask>(node: TaskNode<A>): GraphResult<TaskResultType<T>> | undefined;
    /**
     * Returns all dependency results.
     */
    getDependencyResults(): GraphResults;
    isComplete(): boolean;
    /**
     * Completes the node, setting its result and propagating it to each dependant node.
     *
     * If the node is aborted or an error is set, dependants are aborted.
     *
     * If the node was already completed, this is a no-op (may e.g. happen if the node has been completed
     * but a dependency fails and is aborting dependants).
     */
    complete({ startedAt, error, result, aborted, abortedKeys }: CompleteTaskParams): GraphResult<TaskResultType<T>>;
    /**
     * Returns the task result if the task is completed. Returns undefined if result is not available.
     */
    getStatus(): GraphResult<ValidResultType> | undefined;
    protected getNode<NT extends keyof InternalNodeTypes>(type: NT, task: BaseTask): TaskNode<BaseTask<ValidResultType>>;
}
export interface TaskRequestParams<T extends BaseTask = BaseTask> extends TaskNodeParams<T> {
    batchId: string;
    statusOnly: boolean;
    completeHandler: CompleteHandler<TaskResultType<T>>;
}
export declare class RequestTaskNode<TaskType extends BaseTask = BaseTask> extends TaskNode<TaskType> {
    readonly executionType: NodeType;
    readonly requestedAt: Date;
    readonly batchId: string;
    private readonly completeHandler;
    constructor(params: TaskRequestParams<TaskType>);
    get concurrencyLimit(): number;
    get concurrencyGroupKey(): keyof NodeTypes;
    get processed(): boolean;
    describe(): string;
    getKey(): string;
    getDependencies(): TaskNode[];
    complete(params: CompleteTaskParams): GraphResult<TaskResultType<TaskType>>;
    execute(): Promise<null>;
}
export declare class ProcessTaskNode<T extends BaseTask = BaseTask> extends TaskNode<T> {
    readonly executionType: NodeType;
    get concurrencyLimit(): number;
    /**
     * Tasks with different limits will be grouped in separate concurrency groups.
     *
     * E.g. if 50 build tasks have limit of 5, and 30 build tasks have limit of 10, then 15 build tasks will execute concurrently.
     */
    get concurrencyGroupKey(): string;
    get processed(): boolean;
    describe(): string;
    private getStatusResult;
    getDependencies(): TaskNode<BaseTask<ValidResultType>>[];
    execute(): Promise<ValidResultType>;
}
export declare class StatusTaskNode<T extends BaseTask = BaseTask> extends TaskNode<T> {
    readonly executionType: NodeType;
    get concurrencyLimit(): number;
    get processed(): boolean;
    /**
     * Tasks with different limits will be grouped in separate concurrency groups.
     *
     * E.g. if 50 build tasks have limit of 5, and 30 build tasks have limit of 10, then 15 build tasks will execute concurrently.
     */
    get concurrencyGroupKey(): string;
    describe(): string;
    getDependencies(): TaskNode<BaseTask<ValidResultType>>[];
    execute(): Promise<ValidResultType | null>;
}
export declare function getNodeKey(task: BaseTask, type: NodeType): string;
export type CompleteHandler<R extends ValidResultType> = (result: GraphResult<R>) => void;
export interface CompleteTaskParams {
    startedAt: Date | null;
    error: Error | null;
    result: ValidResultType | null;
    aborted: boolean;
    abortedKeys?: Set<string>;
}