import type { ZodTypeAny } from "zod";
import type { ActionDeclarationInput } from "@garden-io/grow-sdk/actions/types";
import type { DeclaredAction, DeclaredActionAssociation } from "@garden-io/grow-sdk/declarations/action";
import type { ActionType } from "@garden-io/grow-sdk/declarations/action-type";
import type { CommandArgumentSpec, CommandOptionSpec, DeclaredCommand, ObjectFromSpecs } from "@garden-io/grow-sdk/declarations/command";
import { BooleanParameter, IntegerParameter, IntegersParameter, StringParameter, StringsParameter } from "@garden-io/grow-sdk/declarations/params";
import type { Parameter, ParameterValues } from "@garden-io/grow-sdk/declarations/params";
import { GrowError } from "@garden-io/grow-sdk/errors";
import type { s } from "@garden-io/grow-sdk/schema";
import type { EmptyObject, KeyedBy, PrimitiveMap } from "@garden-io/grow-sdk/util/types";
import type { GrowCli } from "../cli/cli";
import type { GlobalOptions } from "../cli/params";
import type { CloudApi } from "../cloud/api";
import type { BuiltinCommand } from "../commands/base";
import type { GrowContext } from "../context";
import { ConfigGraph } from "../graph/config-graph";
import type { Issue } from "../issues";
import type { Log } from "../logger/log-entry";
export declare abstract class ConfigWrapper {
    readonly path: string;
    readonly cliInputs: PrimitiveMap;
    private sdkModule;
    private didLoadModule;
    constructor(path: string, cliInputs: PrimitiveMap);
    /**
     * Will only be called once by the abstract base class.
     *
     * This method is expected to call the protected methods `registerAction` and `registerCommand` when discovering
     * declared actions or commands, which will return validation issues.
     *
     * `registerAction` and `registerCommand` can also be called dynamically in a command invocation through the `ctx.run` method.
     */
    abstract loadModule(log: Log): Promise<Issue[]>;
    getConfigDirPath(): string;
    getGraph(log: Log): Promise<ConfigGraph>;
    getModule(log: Log): Promise<ModuleWrapper>;
    refresh(log: Log): {
        message: string;
        type: "validation" | "processing" | "parsing";
        severity: "error" | "warning";
        entity?: {
            key: string;
            type: "command" | "action";
        } | undefined;
        detail?: any;
    }[];
    getActions(log: Log): Promise<DeclaredAction[]>;
    getCommands(log: Log): Promise<DeclaredCommand[]>;
    getCommandsWrapped(log: Log): Promise<CommandWrapper[]>;
    registerAction(log: Log, action: DeclaredAction, scanAssociatedActions?: boolean, scanDependencies?: boolean): Issue[];
    registerCommand(log: Log, command: DeclaredCommand): Issue[];
}
export declare class DummyConfigWrapper extends ConfigWrapper {
    getConfigDirPath(): string;
    loadModule(_: Log): Promise<Issue[]>;
}
export declare class TypescriptConfigWrapper extends ConfigWrapper {
    load(): Promise<unknown>;
    loadModule(log: Log): Promise<{
        message: string;
        type: "validation" | "processing" | "parsing";
        severity: "error" | "warning";
        entity?: {
            key: string;
            type: "command" | "action";
        } | undefined;
        detail?: any;
    }[]>;
}
export declare class ModuleWrapperMakeContext {
    readonly module: ModuleWrapper;
    constructor(module: ModuleWrapper);
    private createAction;
    run<T extends ActionType>(name: string, actionType: ActionType, config: Omit<ActionDeclarationInput<T>, "name">): DeclaredAction<ActionType>;
}
export declare class ModuleWrapper {
    readonly actions: Record<string, DeclaredAction<ActionType>>;
    readonly commands: {
        [name: string]: DeclaredCommand;
    };
    readonly make: ModuleWrapperMakeContext;
    readonly path: string | undefined;
    constructor(path: string);
    validateAction(action: DeclaredAction): Issue[];
    addAction(action: DeclaredAction<any>): Issue[];
    getActions(): DeclaredAction<ActionType<any, any, any, any>>[];
    validateCommand(command: DeclaredCommand): Issue[];
    addCommand(command: DeclaredCommand): Issue[];
    getCommands(): DeclaredCommand<CommandArgumentSpec[], CommandOptionSpec[], import("zod").ZodType<any, import("zod").ZodTypeDef, any>, Record<string, never>, import("@garden-io/grow-sdk/declarations/command").DefaultAdditionalHandlerArgs>[];
}
export declare function validateDeclaredAction(action: DeclaredAction): Issue[];
export declare function validateDeclaredCommand(command: DeclaredCommand): Issue[];
export type BuiltinCommandResult<T = unknown> = {
    readonly errors: GrowError[];
    readonly exitCode: number;
    readonly result: Omit<T, "errors">;
};
export interface BuiltinArgs {
    "$all"?: string[];
    "--"?: string[];
}
export interface CommandHandlerParams<T = EmptyObject, U = EmptyObject> {
    args: T & BuiltinArgs;
    opts: U;
    globalOpts: ParameterValues<GlobalOptions>;
    log: Log;
    cli?: GrowCli;
    grow: GrowContext;
}
export interface RunCommandParams<A = EmptyObject, O = EmptyObject> extends CommandHandlerParams<A, O> {
    cloudApi?: CloudApi;
    sessionId: string;
}
export declare abstract class CommandWrapper<Args extends readonly CommandArgumentSpec[] = readonly CommandArgumentSpec[], Opts extends readonly CommandOptionSpec[] = readonly CommandOptionSpec[], OutputsSchema extends s.ZodType<BuiltinCommandResult> = s.ZodType<BuiltinCommandResult>> {
    abstract name: string;
    abstract help: string;
    description?: string;
    aliases?: string[];
    allowUndefinedArguments: boolean;
    arguments: ParamSpecsToParameterObject<Args> | undefined;
    options: ParamSpecsToParameterObject<Opts> | undefined;
    needsConfig: boolean;
    usesCloud: boolean;
    isHidden: boolean;
    isCustom: boolean;
    ignoreOptions: boolean;
    enableAnalytics: boolean;
    terminated: boolean;
    constructor();
    /**
     * Shorthand helper to call the action method on the given command class.
     * Also validates the result against the outputsSchema on the command, if applicable.
     *
     * @returns The result from the command action
     */
    run(params: RunCommandParams<ObjectFromSpecs<Args>, ObjectFromSpecs<Opts>>): Promise<s.infer<OutputsSchema>>;
    getName(): string;
    getPath(): string[];
    /**
     * Returns all paths that this command should match, including all aliases and permutations of those.
     */
    getPaths(): string[][];
    describe(): {
        name: string;
        help: string;
        description: string | undefined;
        arguments: {
            help: string;
            type: string;
            schema: s.ZodSchema<unknown>;
            defaultValue: any;
            required: boolean;
            aliases?: string[];
            hints?: string;
            overrides: string[];
            hidden: boolean;
            spread: boolean;
            suggestionPriority: number;
            name: string;
            usageName: string;
        }[] | undefined;
        options: {
            help: string;
            type: string;
            schema: s.ZodSchema<unknown>;
            defaultValue: any;
            required: boolean;
            aliases?: string[];
            hints?: string;
            overrides: string[];
            hidden: boolean;
            spread: boolean;
            suggestionPriority: number;
            name: string;
            usageName: string;
        }[] | undefined;
    };
    /**
     * Called by e.g. the WebSocket server to terminate persistent commands.
     */
    terminate(): void;
    abstract action(params: CommandHandlerParams<ObjectFromSpecs<Args>, ObjectFromSpecs<Opts>>): Promise<s.infer<OutputsSchema>>;
    renderHelp(): string;
}
export declare class BuiltinCommandWrapper<Args extends readonly CommandArgumentSpec[], Opts extends readonly CommandOptionSpec[], OutputSchema extends s.ZodType<BuiltinCommandResult<Record<string, unknown>>>> extends CommandWrapper<Args, Opts, OutputSchema> {
    wrapped: BuiltinCommand<Args, Opts, OutputSchema>;
    name: string;
    help: string;
    constructor(wrapped: BuiltinCommand<Args, Opts, OutputSchema>);
    action({ grow, log, args, opts, globalOpts, }: CommandHandlerParams<ObjectFromSpecs<Args>, ObjectFromSpecs<Opts>>): Promise<s.infer<OutputSchema>>;
}
export declare class DeclaredCommandWrapper<Args extends CommandArgumentSpec[], Opts extends CommandOptionSpec[]> extends CommandWrapper<Args, Opts, ZodTypeAny> {
    wrapped: DeclaredCommand<Args, Opts, ZodTypeAny>;
    name: string;
    help: string;
    isCustom: boolean;
    allowUndefinedArguments: boolean;
    constructor(wrapped: DeclaredCommand<Args, Opts, ZodTypeAny>);
    action({ grow, log, args, opts, }: CommandHandlerParams<ObjectFromSpecs<Args>, ObjectFromSpecs<Opts>>): Promise<s.infer<ZodTypeAny>>;
}
type ParamSpecIsPlural<T extends CommandArgumentSpec | CommandOptionSpec, Singular extends Parameter<unknown>, Plural extends Parameter<unknown>> = T extends {
    many: true;
} | {
    spread: true;
} ? Plural : Singular;
export type ParamSpecToParameterClass<T extends CommandArgumentSpec | CommandOptionSpec> = T["type"] extends "string" ? ParamSpecIsPlural<T, StringParameter, StringsParameter> : T["type"] extends "integer" ? ParamSpecIsPlural<T, IntegerParameter, IntegersParameter> : T["type"] extends "boolean" ? BooleanParameter : never;
export type ParamSpecsToParameterClasses<T extends readonly CommandArgumentSpec[] | readonly CommandOptionSpec[]> = {
    [K in keyof T]: ParamSpecToParameterClass<T[K]>;
};
export type ParamSpecsToParameterObject<T extends readonly CommandArgumentSpec[] | readonly CommandOptionSpec[]> = {
    [K in keyof KeyedBy<T, "name">]: ParamSpecToParameterClass<KeyedBy<T, "name">[K]>;
};
export declare function convertParameterSpecs<A extends CommandArgumentSpec | CommandOptionSpec>(specs: readonly A[]): ParamSpecsToParameterObject<A[]>;
export declare function inferAssociatedActionName<T extends ActionType>({ partnerAction, association, }: {
    partnerAction: DeclaredAction<T>;
    association: DeclaredActionAssociation;
}): void;
export {};