import type { ActionIdentifier } from "@garden-io/grow-sdk/actions/action";
import type { ActionOutputs, ResolvedActionSpec } from "@garden-io/grow-sdk/actions/types";
import type { ActionType } from "@garden-io/grow-sdk/declarations/action-type";
import type { BaseAction, ExecutedActionImpl, ResolvedActionImpl, StatusOnlyActionImpl } from "../actions/base";
import type { ConfigGraph } from "../graph/config-graph";
import type { GraphResults } from "../graph/results";
import type { ActionLog } from "../logger/log-entry";
import { BaseTask } from "./base";
import type { BaseActionTaskParams, ResolveProcessDependenciesParams, TaskProcessParams, TaskStatusParams } from "./base";
export type ValidResultType = Record<string, unknown> & {
    needsProcessing: boolean;
};
export declare abstract class BaseActionTask<T extends ActionType, O extends ValidResultType> extends BaseTask<O> {
    readonly action: BaseAction<T>;
    readonly graph: ConfigGraph;
    readonly forceActions: ActionIdentifier[];
    readonly skipRuntimeDependencies: boolean;
    log: ActionLog;
    constructor(params: BaseActionTaskParams<T>);
    abstract getStatus(params: TaskProcessParams<O>): null | Promise<O | null>;
    abstract process(params: TaskProcessParams<O>): Promise<O>;
    getDescription(): string;
    getName(): string;
    resolveStatusDependencies(): BaseTask[];
    resolveProcessDependencies({ status }: ResolveProcessDependenciesParams<ValidResultType>): BaseTask[];
    /**
     * For this task type, we can use the runtime outputs schema to decide which fields to include in the export
     * (e.g. for the machine-readable command result).
     */
    export(result: O): import("@garden-io/grow-sdk/util/types").JSONObject;
    getDependencyParams(): BaseActionTaskParams<T>;
    /**
     * Given a set of graph results, return a resolved version of the action.
     * Throws if the dependency results don't contain the required task results.
     */
    getResolvedAction(dependencyResults: GraphResults): ResolvedActionImpl<T>;
}
export type ResolveActionResults<T extends ActionType> = {
    resolvedAction: ResolvedActionImpl<T>;
    needsProcessing: boolean;
};
export declare class ResolveActionTask<T extends ActionType> extends BaseActionTask<T, ResolveActionResults<T>> {
    readonly executeConcurrencyLimit = 10;
    readonly statusConcurrencyLimit = 10;
    readonly type = "resolve-action";
    getDescription(): string;
    getName(): string;
    getStatus({}: TaskStatusParams): Promise<null>;
    resolveStatusDependencies(): never[];
    resolveProcessDependencies(): BaseTask[];
    process({ dependencyResults }: TaskProcessParams<ResolveActionResults<T>>): Promise<ResolveActionResults<T>>;
    validateSpec(spec: unknown): ResolvedActionSpec<T>;
}
export type ExecuteActionOutputs<T extends ActionType> = {
    action: ExecutedActionImpl<T> | StatusOnlyActionImpl<T>;
    outputs: Partial<ActionOutputs<T>>;
    needsProcessing: boolean;
};
export declare class ExecuteActionTask<T extends ActionType> extends BaseActionTask<T, ExecuteActionOutputs<T>> {
    get executeConcurrencyLimit(): number;
    get statusConcurrencyLimit(): number;
    get concurrencyGroup(): string;
    readonly type = "execute-action";
    getStatus({ dependencyResults }: TaskStatusParams): Promise<ExecuteActionOutputs<T> | null>;
    process({ dependencyResults }: TaskProcessParams<ExecuteActionOutputs<T>>): Promise<ExecuteActionOutputs<T>>;
}
/**
 * Creates an ExecuteActionTask for the given BaseAction.
 */
export declare function makeExecuteTask<T extends ActionType>(params: BaseActionTaskParams<T>): ExecuteActionTask<T>;
/**
 * Returns the ResolveActionTask for the given BaseAction.
 */
export declare function makeResolveTask<T extends ActionType>(params: BaseActionTaskParams<T>): ResolveActionTask<T>;