import { Condition, type ExpressionSource, ExpressionValue } from "./expression.js";
export type ConditionLike = Condition | ExpressionValue | string;
export type ConfigValue = string | number | boolean | ExpressionValue;
export interface StepConfig<O extends string = never> {
    readonly name?: string;
    readonly id?: string;
    readonly uses?: string;
    readonly run?: string | string[];
    readonly with?: Readonly<Record<string, ConfigValue>>;
    readonly env?: Readonly<Record<string, ConfigValue>>;
    readonly if?: ConditionLike;
    readonly shell?: string;
    readonly workingDirectory?: string;
    readonly continueOnError?: boolean | string;
    readonly timeoutMinutes?: number;
    readonly outputs?: readonly O[];
}
export declare function resetStepCounter(): void;
export type StepLike = Step<string> | StepRef<string> | StepConfig;
export declare class Step<O extends string = never> implements ExpressionSource {
    #private;
    readonly config: StepConfig<O>;
    readonly outputs: {
        [K in O]: ExpressionValue;
    };
    readonly _crossJobDeps: readonly Step<string>[];
    readonly children: readonly StepLike[];
    constructor(config: StepConfig<O>, crossJobDeps?: Step<string>[]);
    constructor(children: readonly StepLike[]);
    get id(): string;
    dependsOn(...deps: StepLike[]): StepRef<O>;
    comesAfter(...deps: StepLike[]): StepRef<O>;
    if(condition: ConditionLike): StepRef<O>;
    toYaml(effectiveIf?: Condition): Record<string, unknown>;
}
export interface StepBuilder {
    <const O extends string = never>(...args: (StepConfig<O> | Step<string> | StepRef<string>)[]): StepRef<O>;
    if(condition: ConditionLike): StepBuilder;
    dependsOn(...deps: StepLike[]): StepBuilder;
    comesAfter(...deps: StepLike[]): StepBuilder;
}
export interface StepFunction {
    <const O extends string = never>(...args: (StepConfig<O> | Step<string> | StepRef<string>)[]): Step<O>;
    if(condition: ConditionLike): StepBuilder;
    dependsOn(...deps: StepLike[]): StepBuilder;
    comesAfter(...deps: StepLike[]): StepBuilder;
}
export declare const step: StepFunction;
export declare class StepRef<O extends string = never> {
    readonly step: Step<O>;
    readonly condition?: ConditionLike;
    readonly dependencies: readonly StepLike[];
    readonly afterDependencies: readonly StepLike[];
    constructor(step: Step<O>, init?: {
        condition?: ConditionLike;
        dependencies?: readonly StepLike[];
        afterDependencies?: readonly StepLike[];
    });
    get id(): string;
    get config(): StepConfig<O>;
    get outputs(): {
        [K in O]: ExpressionValue;
    };
    dependsOn(...deps: StepLike[]): StepRef<O>;
    comesAfter(...deps: StepLike[]): StepRef<O>;
    if(condition: ConditionLike): StepRef<O>;
}
export declare function serializeConditionLike(c: ConditionLike): string;
export declare function toCondition(c: ConditionLike): Condition;
export declare function serializeConfigValues(record: Record<string, ConfigValue>): Record<string, string | number | boolean>;
/** Normalizes a StepLike to a Step or StepRef, auto-wrapping plain objects. */
export declare function normalizeStepLike(item: StepLike): Step<string> | StepRef<string>;
/** Extracts the underlying Step from a StepLike (Step or StepRef). */
export declare function unwrapStep(item: StepLike): Step<string>;
/** Extracts all underlying leaf Steps from a StepLike (recursively for composites). */
export declare function unwrapSteps(item: StepLike): Step<string>[];
//# sourceMappingURL=step.d.ts.map