import { PadroneProgress, PadroneRuntime } from "../core/runtime.mjs";
import { PadroneSchema } from "./schema.mjs";
import { FindDirectChild, FlattenCommands, FullCommandName, MaybePromise, OrAsync, OrAsyncMeta, PickCommandByName, PickCommandByPossibleCommands, PossibleCommands, RepathCommands, ReplaceOrAppendCommand, SafeString } from "../util/type-utils.mjs";
import { PadroneLogger } from "../extension/logger.mjs";
import { PadroneTracer } from "../extension/tracing.mjs";
import { PadroneMcpPreferences } from "../feature/mcp.mjs";
import { PadroneServePreferences } from "../feature/serve.mjs";
import { WrapConfig, WrapResult } from "../feature/wrap.mjs";
import { HelpPreferences } from "../output/help.mjs";
import { ExtractInterceptorContext, InterceptorFactory, InterceptorMeta, InterceptorRequiresCheck, InterceptorRequiresError, PadroneContextInterceptor, PadroneInterceptorFn } from "./interceptor.mjs";
import { AnyPadroneCommand, CommandTypesBase, GetArgsMeta, PadroneActionContext, PadroneCommand, PadroneCommandConfig, PadroneProgramMeta } from "./command.mjs";
import { PadroneCliPreferences, PadroneEvalPreferences, PadroneReplPreferences } from "./preferences.mjs";
import { GetArguments, MaybePromiseCommandResult, PadroneAPI, PadroneCommandResult, PadroneDrainResult, PadroneParseResult } from "./result.mjs";
import { StandardSchemaV1 } from "@standard-schema/spec";
import { Tool } from "ai";

//#region src/types/builder.d.ts
/**
 * Helper type to set aliases on a command type.
 * Uses intersection to override just the aliases while preserving all other type information.
 */
type WithAliases<TCommand extends AnyPadroneCommand, TAliases extends string[]> = Omit<TCommand, 'aliases' | '~types'> & {
  aliases?: TAliases;
  '~types': Omit<TCommand['~types'], 'aliases'> & {
    aliases: TAliases;
  };
};
/**
 * Resolves aliases for a command override: if new aliases are provided (non-empty), use them;
 * otherwise, preserve the existing command's aliases.
 */
type ResolvedAliases<TCommands extends [...AnyPadroneCommand[]], TNameNested extends string, TAliases extends string[]> = TAliases extends [] ? FindDirectChild<TCommands, TNameNested> extends infer E extends AnyPadroneCommand ? E['~types']['aliases'] : [] : TAliases;
/**
 * When TContext is `unknown` (no `.context()` called), context param is optional.
 * Otherwise it is required.
 */
type ContextParam<TContext> = unknown extends TContext ? {
  context?: TContext;
} : {
  context: TContext;
};
/** Options for the `mount()` method. */
type MountOptions<TContext, TNewContext> = {
  context: (ctx: TContext) => TNewContext;
};
/**
 * Resolves the initial builder type for a `.command()` call.
 * If TNameNested already exists in TCommands, the builder starts pre-populated with that command's types.
 * Otherwise, a fresh builder with default types is used.
 */
type InitialCommandBuilder<TProgramName extends string, TNameNested extends string, TParentPath extends string, TParentArgs extends PadroneSchema, TCommands extends [...AnyPadroneCommand[]], TParentContext> = [FindDirectChild<TCommands, TNameNested>] extends [never] ? PadroneBuilder<TProgramName, TNameNested, TParentPath, PadroneSchema<void>, void, [], TParentArgs, false, TParentContext> : FindDirectChild<TCommands, TNameNested> extends infer E extends AnyPadroneCommand ? PadroneBuilder<TProgramName, TNameNested, TParentPath, E['~types']['argsSchema'], E['~types']['result'], E['~types']['commands'], TParentArgs, E['~types']['async'], E['~types']['context'], E['~types']['contextProvided']> : PadroneBuilder<TProgramName, TNameNested, TParentPath, PadroneSchema<void>, void, [], TParentArgs, false, TParentContext>;
type AnyPadroneBuilder = InitialCommandBuilder<string, string, string, PadroneSchema, [...AnyPadroneCommand[]], unknown>;
/**
 * Like InitialCommandBuilder but uses `any` for args in the fresh case.
 * Used as the default for TBuilder when no builderFn is provided.
 */
type DefaultCommandBuilder<TProgramName extends string, TNameNested extends string, TParentPath extends string, TParentArgs extends PadroneSchema, TCommands extends [...AnyPadroneCommand[]], TParentContext> = [FindDirectChild<TCommands, TNameNested>] extends [never] ? PadroneBuilder<TProgramName, TNameNested, TParentPath, any, void, [], TParentArgs, false, TParentContext> : FindDirectChild<TCommands, TNameNested> extends infer E extends AnyPadroneCommand ? PadroneBuilder<TProgramName, TNameNested, TParentPath, E['~types']['argsSchema'], E['~types']['result'], E['~types']['commands'], TParentArgs, E['~types']['async'], E['~types']['context'], E['~types']['contextProvided']> : PadroneBuilder<TProgramName, TNameNested, TParentPath, any, void, [], TParentArgs, false, TParentContext>;
/**
 * Conditional type that returns either PadroneBuilder or PadroneProgram based on TReturn.
 * Used to avoid repetition in PadroneBuilderMethods return types.
 */
type BuilderOrProgram<TReturn extends 'builder' | 'program', TProgramName extends string, TName extends string, TParentName extends string, TArgs extends PadroneSchema, TRes, TCommands extends [...AnyPadroneCommand[]], TParentArgs extends PadroneSchema, TAsync extends boolean, TContext, TContextProvided = unknown> = TReturn extends 'builder' ? PadroneBuilder<TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided> : PadroneProgram<TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided>;
/**
 * Base builder methods shared between PadroneBuilder and PadroneProgram.
 * These methods are used for defining command structure (arguments, action, subcommands).
 */
type PadroneBuilderMethods<TProgramName extends string, TName extends string, TParentName extends string, TArgs extends PadroneSchema, TRes, TCommands extends [...AnyPadroneCommand[]], TParentArgs extends PadroneSchema, TAsync extends boolean, TContext, TContextProvided, /** The return type for builder methods - either PadroneBuilder or PadroneProgram */TReturn extends 'builder' | 'program'> = {
  /** Apply a build-time extension that transforms this builder/program. @category Builder */extend: <TResult extends CommandTypesBase>(extension: PadroneExtension<BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided>, TResult>) => TResult; /** Register a runtime interceptor for lifecycle phases (parse, validate, execute, etc.). @category Builder */
  intercept: {
    /** Context-providing interceptor — extends context type. Rejects if required context is not satisfied. */<TInterceptor extends PadroneContextInterceptor<any, StandardSchemaV1.InferOutput<TArgs>, TRes, any>>(interceptor: TInterceptor): InterceptorRequiresCheck<TInterceptor, TContext & TContextProvided> extends true ? BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided & ExtractInterceptorContext<TInterceptor>> : InterceptorRequiresError; /** Plain interceptor — no context change. Rejects if required context is not satisfied. */
    <TInterceptor extends PadroneInterceptorFn<StandardSchemaV1.InferOutput<TArgs>, TRes, any>>(interceptor: TInterceptor): InterceptorRequiresCheck<TInterceptor, TContext & TContextProvided> extends true ? BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided> : InterceptorRequiresError; /** Register an interceptor with static metadata and a factory function. Context is strongly typed. */
    (meta: InterceptorMeta, factory: InterceptorFactory<StandardSchemaV1.InferOutput<TArgs>, TRes, TContext & TContextProvided>): BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided>;
  }; /** Set command metadata like title, description, version, hidden, deprecated, etc. @category Builder */
  configure: (config: PadroneCommandConfig) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided>; /** Override the runtime adapter (process, IO, environment). @category Builder */
  runtime: (runtime: PadroneRuntime) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided>; /** Mark this command as async, forcing all return types to be `Promise`-wrapped. @category Builder */
  async: () => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, true, TContext, TContextProvided>;
  /**
   * Declare or transform the user-defined context type for this command.
   *
   * - Without a callback: narrows the context type (type-only, no runtime transform).
   * - With a callback: transforms the parent/current context into a new type. Chainable — multiple calls compose.
   *
   * Interceptor-provided context (`TContextProvided`) is preserved across `.context()` calls.
   * @category Builder
   */
  context: {
    <TNewContext>(): BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TNewContext, TContextProvided>;
    <TNewContext>(transform: (ctx: TContext) => TNewContext): BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TNewContext, TContextProvided>;
  }; /** Define the argument/option schema for this command. Accepts a Standard Schema or a function that extends the parent schema. @category Builder */
  arguments: <TNewArgs extends PadroneSchema = PadroneSchema<void>, TMeta extends GetArgsMeta<TNewArgs> = GetArgsMeta<TNewArgs>>(schema?: TNewArgs | ((parentSchema: TParentArgs) => TNewArgs), meta?: TMeta) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TNewArgs, TRes, TCommands, TParentArgs, OrAsyncMeta<OrAsync<TAsync, TNewArgs>, TMeta>, TContext, TContextProvided>; /** Set the handler function that runs when this command is executed. @category Builder */
  action: <TNewRes>(handler?: (args: StandardSchemaV1.InferOutput<TArgs>, ctx: PadroneActionContext<TContext & TContextProvided>, base: (args: StandardSchemaV1.InferOutput<TArgs>, ctx: PadroneActionContext<TContext & TContextProvided>) => TRes) => TNewRes) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TNewRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided>; /** Wrap an external CLI tool, delegating execution to a shell command. @category Builder */
  wrap: <TWrapArgs extends PadroneSchema = TArgs>(config: WrapConfig<TArgs, TWrapArgs>) => BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, Promise<WrapResult>, TCommands, TParentArgs, TAsync, TContext, TContextProvided>; /** Add or override a subcommand. Pass a builder function to define its schema, action, and nested commands. @category Builder */
  command: {
    <TNameNested extends string, TAliases extends string[] = [], TBuilder extends CommandTypesBase = DefaultCommandBuilder<TProgramName, TNameNested, FullCommandName<TName, TParentName>, TArgs, TCommands, TContext & TContextProvided>>(name: TNameNested | readonly [TNameNested, ...TAliases], builderFn?: (builder: InitialCommandBuilder<TProgramName, TNameNested, FullCommandName<TName, TParentName>, TArgs, TCommands, TContext & TContextProvided>) => TBuilder): BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands extends [] ? [WithAliases<TBuilder['~types']['command'], TAliases>] : AnyPadroneCommand[] extends TCommands ? [WithAliases<TBuilder['~types']['command'], TAliases>] : ReplaceOrAppendCommand<TCommands, TNameNested, WithAliases<TBuilder['~types']['command'], ResolvedAliases<TCommands, TNameNested, TAliases>>>, TParentArgs, TAsync, TContext, TContextProvided>;
    <TNameNested extends string, TAliases extends string[] = [], TBuilder extends CommandTypesBase = CommandTypesBase, TReq = unknown>(name: TNameNested | readonly [TNameNested, ...TAliases], builderFn: ((builder: any) => TBuilder) & {
      '~contextRequires': (ctx: TReq) => void;
    }): TContext & TContextProvided extends TReq ? BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands extends [] ? [WithAliases<TBuilder['~types']['command'], TAliases>] : AnyPadroneCommand[] extends TCommands ? [WithAliases<TBuilder['~types']['command'], TAliases>] : ReplaceOrAppendCommand<TCommands, TNameNested, WithAliases<TBuilder['~types']['command'], ResolvedAliases<TCommands, TNameNested, TAliases>>>, TParentArgs, TAsync, TContext, TContextProvided> : DefineCommandRequiresError;
    <TNameNested extends string, TAliases extends string[] = [], TBuilder extends CommandTypesBase = CommandTypesBase>(name: TNameNested | readonly [TNameNested, ...TAliases], builderFn?: (builder: any) => TBuilder): BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands extends [] ? [WithAliases<TBuilder['~types']['command'], TAliases>] : AnyPadroneCommand[] extends TCommands ? [WithAliases<TBuilder['~types']['command'], TAliases>] : ReplaceOrAppendCommand<TCommands, TNameNested, WithAliases<TBuilder['~types']['command'], ResolvedAliases<TCommands, TNameNested, TAliases>>>, TParentArgs, TAsync, TContext, TContextProvided>;
  }; /** Mount an existing program as a subcommand, optionally transforming the context. @category Builder */
  mount: {
    <TNameNested extends string, TAliases extends string[] = [], TProgram extends CommandTypesBase = CommandTypesBase>(name: TNameNested | readonly [TNameNested, ...TAliases], program: TProgram): BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands extends [] ? [WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['async'], TContext & TContextProvided>, TAliases>] : AnyPadroneCommand[] extends TCommands ? [WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['async'], TContext & TContextProvided>, TAliases>] : ReplaceOrAppendCommand<TCommands, TNameNested, WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['async'], TContext & TContextProvided>, ResolvedAliases<TCommands, TNameNested, TAliases>>>, TParentArgs, TAsync, TContext, TContextProvided>;
    <TNameNested extends string, TAliases extends string[] = [], TProgram extends CommandTypesBase = CommandTypesBase, TNewContext = unknown>(name: TNameNested | readonly [TNameNested, ...TAliases], program: TProgram, options: MountOptions<TContext & TContextProvided, TNewContext>): BuilderOrProgram<TReturn, TProgramName, TName, TParentName, TArgs, TRes, TCommands extends [] ? [WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['async'], TNewContext>, TAliases>] : AnyPadroneCommand[] extends TCommands ? [WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['async'], TNewContext>, TAliases>] : ReplaceOrAppendCommand<TCommands, TNameNested, WithAliases<PadroneCommand<TNameNested, FullCommandName<TName, TParentName>, TProgram['~types']['command']['~types']['argsSchema'], TProgram['~types']['command']['~types']['result'], RepathCommands<TProgram['~types']['command']['~types']['commands'], FullCommandName<TNameNested, FullCommandName<TName, TParentName>>>, [], TProgram['~types']['command']['~types']['async'], TNewContext>, ResolvedAliases<TCommands, TNameNested, TAliases>>>, TParentArgs, TAsync, TContext, TContextProvided>;
  }; /** @deprecated Internal use only */
  '~types': {
    programName: TProgramName;
    name: TName;
    parentName: TParentName;
    path: FullCommandName<TName, TParentName>;
    aliases: [];
    argsSchema: TArgs;
    result: TRes;
    commands: TCommands;
    async: TAsync;
    context: TContext;
    contextProvided: TContextProvided;
    command: PadroneCommand<TName, TParentName, TArgs, TRes, TCommands, [], TAsync, TContext, TContextProvided>;
  };
};
type PadroneBuilder<TProgramName extends string = '', TName extends string = string, TParentName extends string = '', TArgs extends PadroneSchema = PadroneSchema<DefaultArgs>, TRes = void, TCommands extends [...AnyPadroneCommand[]] = [], TParentArgs extends PadroneSchema = PadroneSchema<void>, TAsync extends boolean = false, TContext = unknown, TContextProvided = unknown> = PadroneBuilderMethods<TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided, 'builder'>;
type PadroneProgram<TProgramName extends string = '', TName extends string = string, TParentName extends string = '', TArgs extends PadroneSchema = PadroneSchema<DefaultArgs>, TRes = void, TCommands extends [...AnyPadroneCommand[]] = [], TParentArgs extends PadroneSchema = PadroneSchema<void>, TAsync extends boolean = false, TContext = unknown, TContextProvided = unknown> = PadroneBuilderMethods<TProgramName, TName, TParentName, TArgs, TRes, TCommands, TParentArgs, TAsync, TContext, TContextProvided, 'program'> & {
  /** Execute a command by name with pre-validated args (skips parsing and validation). @category Execution */run: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], true, true>>(name: TCommand | SafeString, args: NoInfer<GetArguments<'in', PickCommandByName<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>>, prefs?: ContextParam<TContext>) => PadroneCommandResult<PickCommandByName<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>; /** Parse and execute a string input through the full interceptor pipeline. @category Execution */
  eval: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], true, true>>(input: TCommand | SafeString, prefs?: PadroneEvalPreferences & ContextParam<TContext>) => MaybePromiseCommandResult<PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>, PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>['~types']['async']>; /** Parse and execute from `process.argv` through the full interceptor pipeline. @category Execution */
  cli: (prefs?: PadroneCliPreferences & ContextParam<TContext>) => MaybePromiseCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>, TAsync>; /** Parse and validate input without executing the action. @category Execution */
  parse: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], true, false>>(input?: TCommand | SafeString) => MaybePromise<PadroneParseResult<PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>, PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>['~types']['async']>; /** Serialize args back into a CLI string. @category Utility */
  stringify: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], false, true>>(command?: TCommand | SafeString, args?: GetArguments<'out', PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TCommand>>) => string; /** Look up a command definition by name. @category Utility */
  find: <const TFind extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], false, true>>(command: TFind | SafeString) => PickCommandByPossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], TFind> | undefined; /** Get a structured API representation of all commands. @category Utility */
  api: () => PadroneAPI<PadroneCommand<'', '', TArgs, TRes, TCommands>>; /** Start an interactive REPL session. @category Execution */
  repl: (options?: PadroneReplPreferences<PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>) => AsyncIterable<PadroneCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>> & {
    drain: () => Promise<PadroneDrainResult<PadroneCommandResult<FlattenCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>]>>[]>>;
  }; /** Export as an AI SDK tool. @category Utility */
  tool: () => Tool<{
    command: string;
  }>; /** Generate help text for a command. @category Utility */
  help: <const TCommand extends PossibleCommands<[PadroneCommand<'', '', TArgs, TRes, TCommands>], false, true>>(command?: TCommand, prefs?: HelpPreferences) => string; /** Generate shell completion script. @category Utility */
  completion: (shell?: 'bash' | 'zsh' | 'fish' | 'powershell') => Promise<string>; /** Start a Model Context Protocol server. @category Server */
  mcp: (prefs?: PadroneMcpPreferences) => Promise<void>; /** Start a REST HTTP server with OpenAPI docs. @category Server */
  serve: (prefs?: PadroneServePreferences) => Promise<void>; /** Read-only metadata about the program (name, version, description, commands, etc.). @category Utility */
  info: PadroneProgramMeta<TProgramName>;
};
type AnyPadroneProgram = PadroneProgram<string, string, string, any, any, [...AnyPadroneCommand[]]>;
/**
 * A build-time extension that transforms a builder/program.
 * Extensions can add commands, arguments, interceptors, configure settings, etc.
 *
 * Use with `.extend(extension)`:
 * ```ts
 * const withAuth = (b) => b.arguments(authSchema).command('login', ...)
 * program.extend(withAuth)
 * ```
 */
type PadroneExtension<TIn extends CommandTypesBase = CommandTypesBase, TOut extends CommandTypesBase = TIn> = (builder: TIn) => TOut;
/**
 * Default context type for commands defined with `defineCommand()`.
 * Includes optional context properties provided by common extensions (logger, tracing, progress).
 *
 * Override globally via module augmentation to add your application's context:
 * ```ts
 * declare module 'padrone' {
 *   interface DefineCommandContext {
 *     db: Database;
 *   }
 * }
 * ```
 */
interface DefineCommandContext {
  logger?: PadroneLogger;
  tracing?: PadroneTracer;
  progress?: PadroneProgress;
}
/** Error brand returned by `.command()` when a `defineCommand.requires()` context requirement is not satisfied. */
type DefineCommandRequiresError = {
  readonly '~error': 'Required context not satisfied. Ensure required interceptors are registered on the program.';
};
/**
 * Type for a command builder callback used with `.command()`.
 * Use this when defining commands in separate files where full return type inference isn't needed.
 *
 * For full type preservation at the parent, use `defineCommand()` instead.
 *
 * @example
 * ```ts
 * // my-command.ts
 * export const myCommand: DefineCommand = (c) =>
 *   c.arguments(z.object({ name: z.string() }))
 *    .action((args) => console.log(args.name));
 *
 * // cli.ts
 * createPadrone('test').command('my-command', myCommand)
 * ```
 */
type DefineCommand<TContext = unknown, TParentArgs extends PadroneSchema = PadroneSchema> = (builder: PadroneBuilder<string, string, string, PadroneSchema<void>, void, [], TParentArgs, false, TContext, DefineCommandContext>) => CommandTypesBase;
/**
 * Builder returned by `defineCommand()` (no-arg form).
 * Call `.requires<T>()` to declare context dependencies, then `.command()` to provide the builder callback.
 *
 * @example
 * ```ts
 * const adminCommand = defineCommand()
 *   .requires<{ adminDb: AdminDB }>()
 *   .define((c) => c.action((_args, ctx) => ctx.context.adminDb.query(...)));
 * ```
 */
type DefineCommandBuilder<TContextProvided = DefineCommandContext, TBrand = unknown> = {
  /** Declare context types this command requires. Purely type-level — no runtime effect. */requires: <TRequires>() => DefineCommandBuilder<DefineCommandContext & TRequires, {
    '~contextRequires': (ctx: TRequires) => void;
  }>; /** Provide the command builder callback. */
  define: <TContext = unknown, TOut extends CommandTypesBase = CommandTypesBase>(fn: (builder: PadroneBuilder<string, string, string, PadroneSchema<void>, void, [], any, false, TContext, TContextProvided>) => TOut) => typeof fn & TBrand;
};
type DefaultArgs = Record<string, unknown> | void;
//#endregion
export { AnyPadroneBuilder, AnyPadroneProgram, DefineCommand, DefineCommandBuilder, DefineCommandContext, DefineCommandRequiresError, PadroneBuilder, PadroneBuilderMethods, PadroneExtension, PadroneProgram };
//# sourceMappingURL=builder.d.mts.map