import { TSpecl, TWorld, TRuntime, TModuleOptions, CStepper, TFeatureStep } from '../defs.js';
import { TNotOKActionResult, TOKActionResult, TSeqPath, TDebugSignal } from '../../schema/protocol.js';
import { TAnyFixme } from '../fixme.js';
import { AStepper } from '../astepper.js';
import { TArtifactEvent } from '../../schema/protocol.js';
export * from './actualURI.js';
export * from './secret-utils.js';
export declare function getStepTerm(featureStep: TFeatureStep, key: string): string | undefined;
export declare function isLiteralValue(term: string): boolean;
type TClass = {
    new <T>(...args: unknown[]): T;
};
export declare const basesFrom: (s: string | undefined) => string[];
/**
 * Resolve and import a stepper module.
 * Supports:
 * - Package names: @haibun/monitor-tui → resolves main from package.json
 * - Explicit paths: @haibun/monitor-tui/build/index → imports directly
 * - Relative paths: ./build-local/test-server → imports from cwd
 */
export declare function use(module: string): Promise<TClass>;
export declare function checkModuleIsClass(re: object, module: string): void;
export declare function actionNotOK(message: string, w?: {
    artifact?: TArtifactEvent;
    controlSignal?: TDebugSignal;
    topics?: Record<string, unknown>;
}): TNotOKActionResult;
export declare function randomString(): string;
export declare function actionOK(w?: {
    artifact?: TArtifactEvent;
    controlSignal?: TDebugSignal;
    topics?: Record<string, unknown>;
}): TOKActionResult;
export declare function createSteppers(steppers: CStepper[]): AStepper[];
export declare function getDefaultOptions(): TSpecl;
export declare function getActionable(value: string): string;
export declare function constructorName(stepper: AStepper): string;
export declare function describeSteppers(steppers: AStepper[]): string;
export declare function isLowerCase(str: string): boolean;
export declare const sleep: (ms: number) => Promise<unknown>;
export declare function verifyExtraOptions(inExtraOptions: TModuleOptions, csteppers: CStepper[]): void;
export declare function setStepperWorldsAndDomains(steppers: AStepper[], world: TWorld): Promise<void>;
export declare function getPre(stepper: AStepper): string;
/**
 * Find a stepper by option value from a list of steppers
 */
export declare function getStepperOptionValue(key: string, value: string, csteppers: CStepper[]): {
    parseError?: string;
    env?: import("../defs.js").TEnvVariables;
    result?: TAnyFixme;
};
export declare function verifyRequiredOptions(steppers: CStepper[], options: TModuleOptions): void;
export declare function getStepperOptionName(stepper: AStepper | CStepper, name: string): string;
export declare function getStepperOption(stepper: AStepper, name: string, moduleOptions: TModuleOptions): string;
/**
 * Find a stepper by option value from a list of steppers
 */
export declare function maybeFindStepperFromOption<Type>(steppers: AStepper[], stepper: AStepper, moduleOptions: TModuleOptions, ...optionNames: string[]): Type;
export declare function findStepperFromOption<Type>(steppers: AStepper[], stepper: AStepper, moduleOptions: TModuleOptions, ...optionNames: string[]): Type;
/**
 * Find a stepper by option value, or fall back to finding a single stepper of the given kind.
 * If no stepper-level option is defined, returns any single stepper matching the first optionName as kind.
 * Throws if multiple steppers match the kind and no option is specified.
 */
export declare function findStepperFromOptionOrKind<Type>(steppers: AStepper[], stepper: AStepper, moduleOptions: TModuleOptions, ...optionNames: string[]): Type;
export declare function findStepper<Type>(steppers: AStepper[], name: string): Type;
export declare function getFromRuntime<Type>(runtime: TRuntime, name: string): Type;
export declare const shortenURI: (uri: string) => string;
export declare function slugify(s: string): string;
export declare const intOrError: (val: string) => {
    parseError: string;
    result?: undefined;
} | {
    result: number;
    parseError?: undefined;
};
export declare const boolOrError: (val: string) => {
    parseError: string;
    result?: undefined;
} | {
    result: boolean;
    parseError?: undefined;
};
export declare const stringOrError: (val: string) => {
    parseError: string;
    result?: undefined;
} | {
    result: string;
    parseError?: undefined;
};
export declare const optionOrError: (val: string, options: string[]) => {
    parseError: string;
    result?: undefined;
} | {
    result: string;
    parseError?: undefined;
};
export declare function trying<TResult>(fun: () => void): Promise<Error | TResult>;
export declare function asError(e: unknown): Error;
export declare function dePolite(s: string): string;
export declare function formattedSteppers(steppers: AStepper[]): {
    [name: string]: {
        description: string;
        steps: string[];
    };
};
export declare const formatCurrentSection: (runtime: TRuntime) => string;
export declare const formatCurrentSeqPath: (seqPath: TSeqPath) => string;
//# sourceMappingURL=index.d.ts.map