import type { Action, ActionIdentifier, ActionVersion, ExecutedAction, GetActionOpts, ResolvedAction, StatusOnlyAction } from "@garden-io/grow-sdk/actions/action";
import type { ActionHooks } from "@garden-io/grow-sdk/actions/hooks";
import type { ActionConfigInput, ActionDependency, ActionOutputs, ResolvedActionSpec, ResolvedActionSpecInput, UnresolvedActionSpecInput } from "@garden-io/grow-sdk/actions/types";
import type { ActionInternalFields, DeclaredAction } from "@garden-io/grow-sdk/declarations/action";
import type { ActionType } from "@garden-io/grow-sdk/declarations/action-type";
import type { ConfigGraph, ResolvedConfigGraph } from "../graph/config-graph";
import type { ActionLog } from "../logger/log-entry";
import type { TreeVersion } from "../vcs/vcs";
export interface BaseActionParams<T extends ActionType> {
    actionType: T;
    config: ActionConfigInput;
    unresolvedSpec: UnresolvedActionSpecInput<T>;
    internal: ActionInternalFields;
    hooks: ActionHooks<T>;
    uid: string;
}
export declare class BaseAction<T extends ActionType> implements Action<T> {
    #private;
    readonly params: BaseActionParams<T>;
    readonly type: T["name"];
    readonly name: string;
    readonly uid: string;
    readonly resolved: boolean;
    readonly executed: boolean;
    readonly statusOnly: boolean;
    readonly actionType: T;
    protected readonly graph: ConfigGraph | undefined;
    constructor(params: BaseActionParams<T>);
    get unresolvedSpec(): UnresolvedActionSpecInput<T>;
    get sourcePath(): string;
    static fromDeclaredAction(sdkAction: DeclaredAction): BaseAction<ActionType<any, any, any, any>>;
    isResolved(): this is ResolvedAction<T>;
    isExecuted(): this is ExecutedAction<T>;
    isStatusOnly(): this is StatusOnlyAction<T>;
    reference(): ActionIdentifier;
    get key(): string;
    get longDescription(): string;
    get isDisabled(): boolean;
    get dependencyReferences(): ActionDependency[];
    getDependencies(opts?: GetActionOpts): BaseAction<ActionType>[];
    hasDependency(refOrString: string | ActionIdentifier): boolean;
    getDependency(ref: ActionIdentifier | string, opts?: GetActionOpts): BaseAction<ActionType> | null;
    get internal(): ActionInternalFields;
    get config(): {
        timeout: number;
        source: {
            path: string;
            repository?: {
                url: string;
            } | undefined;
        };
        dependencies: (ActionIdentifier | DeclaredAction<import("@garden-io/grow-sdk/declarations/action-type").ActionType<any, any, any, any>>)[];
        disabled: boolean;
        logOutput: boolean;
        description?: string | undefined;
        name?: string | undefined;
        include?: string[] | undefined;
        exclude?: string[] | undefined;
    };
    getOutputLog(log: ActionLog): ActionLog;
    get hooks(): ActionHooks<T>;
    matchesIdentifier(ref: ActionIdentifier): boolean;
    get statusConcurrencyLimit(): number | undefined;
    /**
     * Allows plugins to control the concurrency limit of action status task nodes.
     *
     * Falls back to default concurrency limit defined in the Task class.
     */
    set statusConcurrencyLimit(limit: number | undefined);
    /**
     * Allows plugins to control the concurrency limit of action execution task nodes.
     *
     * Falls back to default concurrency limit defined in the Task class.
     */
    set executeConcurrencyLimit(limit: number | undefined);
    get executeConcurrencyLimit(): number | undefined;
}
export interface ResolveActionParams<T extends ActionType> {
    resolvedGraph: ResolvedConfigGraph;
    executedDependencies: ExecutedAction[];
    unresolvedDependencies: Action[];
    resolvedDependencies: ResolvedAction[];
    statusOnlyDependencies: StatusOnlyAction[];
    spec: ResolvedActionSpecInput<T>;
    treeVersion: TreeVersion;
}
export type ResolveActionWrapperParams<T extends ActionType> = ResolveActionParams<T> & BaseActionParams<T>;
/**
 * This class represents a resolved action, which is an action that has had its spec resolved,
 * which is generally done by ResolveActionTask.
 */
export declare class ResolvedActionImpl<T extends ActionType> extends BaseAction<T> implements ResolvedAction<T> {
    #private;
    protected readonly graph: ResolvedConfigGraph;
    readonly params: ResolveActionWrapperParams<T>;
    readonly resolved: true;
    protected readonly _treeVersion: TreeVersion;
    constructor(params: ResolveActionWrapperParams<T>);
    get spec(): ResolvedActionSpec<T>;
    treeVersion(): TreeVersion;
    /**
     * The version of this action's config (not including files or dependencies)
     */
    get configVersion(): string;
    get actionVersion(): ActionVersion;
    get versionString(): string;
    get executedDependencies(): ExecutedAction<ActionType<any, any, any, any>>[];
    get unresolvedDependencies(): Action<ActionType<any, any, any, any>>[];
    get statusOnlyDependencies(): StatusOnlyAction<ActionType<any, any, any, any>>[];
    get resolvedDependencies(): ResolvedAction[];
}
export interface StatusOnlyActionParams<T extends ActionType> {
    outputs: Partial<ActionOutputs<T>>;
    dirty: boolean;
}
export type StatusOnlyActionWrapperParams<T extends ActionType> = ResolveActionWrapperParams<T> & StatusOnlyActionParams<T>;
export declare class StatusOnlyActionImpl<T extends ActionType> extends ResolvedActionImpl<T> implements StatusOnlyAction<T> {
    readonly outputs: Partial<ActionOutputs<T>>;
    readonly dirty: boolean;
    readonly statusOnly: true;
    constructor(params: StatusOnlyActionWrapperParams<T>);
}
export interface ExecuteActionParams<T extends ActionType> extends StatusOnlyActionParams<T> {
    outputs: ActionOutputs<T>;
}
export type ExecutedActionWrapperParams<T extends ActionType> = StatusOnlyActionWrapperParams<T> & ExecuteActionParams<T>;
/**
 * This class represents an executed action, which is an action that has had its spec resolved, has been executed
 * or has a ready status, and thus has its runtime outputs available.
 */
export declare class ExecutedActionImpl<T extends ActionType> extends StatusOnlyActionImpl<T> implements ExecutedAction<T> {
    readonly executed: true;
    constructor(params: ExecutedActionWrapperParams<T>);
}
/**
 * Creates a corresponding Resolved version of the given Action, given the additional parameters needed.
 */
export declare function actionToResolved<T extends ActionType>(action: BaseAction<T>, params: ResolveActionParams<T>): ResolvedActionImpl<T>;
/**
 * Creates a corresponding Executed version of the given resolved Action, given the additional parameters needed.
 */
export declare function resolvedActionToExecuted<T extends ActionType>(action: ResolvedActionImpl<T>, params: ExecuteActionParams<T>): ExecutedActionImpl<T>;
/**
 * Creates a corresponding StatusOnly version of the given resolved Action, given the additional parameters needed.
 */
export declare function resolvedActionToStatusOnly<T extends ActionType>(action: ResolvedActionImpl<T>, params: StatusOnlyActionParams<T>): StatusOnlyActionImpl<T>;