import type { TierStep } from './config.js';
import { type GateReport } from './report.js';
import { type MachineLoad } from './timeout.js';
export type StepResult = {
    exitCode: number;
    output: string;
};
export type StepRun = (command: string) => StepResult;
export declare const shellRun: (cwd: string) => StepRun;
export declare const stepIds: (planned: TierStep[]) => string[];
export declare const runSteps: ({ load, run, steps: planned, tier }: {
    load?: () => MachineLoad;
    run: StepRun;
    steps: TierStep[];
    tier: string;
}) => GateReport;
export type AsyncStepRun = (command: string) => Promise<StepResult>;
export declare const shellRunAsync: (cwd: string, env?: NodeJS.ProcessEnv, base?: NodeJS.ProcessEnv) => AsyncStepRun;
export type PlannedStep = TierStep & {
    id: string;
    scopes?: string[];
    skippedFor?: string;
    workspace?: string;
};
export declare const workspacesOf: (step: Pick<TierStep, 'command' | 'exclude'>, all: string[]) => string[];
export declare const shardsOf: (step: Pick<TierStep, 'command' | 'shards'>) => {
    command: string;
    shard: string;
}[];
export declare const excludeArgs: (files: string[]) => string;
export declare const atOnceNote: (steps: readonly PlannedStep[], jobs: number) => string;
export type Turbo = {
    bin: string;
    concurrency: number;
    scripts: ReadonlyMap<string, readonly string[]>;
};
export declare const turboIn: (root: string, concurrency: number) => Turbo | undefined;
export declare const byTurbo: (turbo: Turbo, task: string, workspaces: readonly string[]) => {
    own: string[];
    turbo: string[];
};
export declare const turboCommand: (turbo: Turbo, step: Pick<TierStep, 'force' | 'turbo'>, workspaces: string[]) => string;
export declare const planSteps: ({ affected, all, graph, known, steps, turbo }: {
    affected: string[] | undefined;
    all: string[];
    graph?: string;
    known?: (step: TierStep) => string[];
    steps: TierStep[];
    turbo?: Turbo;
}) => PlannedStep[];
export declare const LOG_BYTES: number;
export declare const boundedLog: (output: string, limit?: number) => string;
export declare const logFileOf: (id: string) => string;
export declare const runGroups: ({ afterGroup, jobs, load, logs, onReport, retries, root, run, steps, tier }: {
    afterGroup?: (ids: string[]) => void;
    jobs: number;
    load?: () => MachineLoad;
    logs?: string;
    onReport?: (step: PlannedStep, report: unknown) => void;
    retries?: number;
    root?: string;
    run: AsyncStepRun;
    steps: PlannedStep[];
    tier: string;
}) => Promise<GateReport>;