import * as internal from "./internal.js";
import { ExpressionValue } from "./expression.js";
type ExtractMatrixKeys<T> = Exclude<keyof T & string, "include" | "exclude"> | (T extends {
    include: readonly (infer I)[];
} ? keyof I & string : never);
/**
 * A build matrix. Each matrix key is exposed as a property holding the
 * `matrix.<key>` expression, so keys can be referenced directly in step
 * configuration and conditions.
 */
export declare class Matrix<_K extends string> {
    constructor(def: Record<string, unknown>, keys: string[]);
    /** Serializes the matrix definition to its YAML form. */
    [internal.toYaml](): Record<string, unknown>;
}
/**
 * Returns the raw definition a matrix was built from, with any Condition and
 * ExpressionValue entries left intact.
 *
 * Needed to infer job `needs` from expressions embedded in a matrix — the
 * definition is otherwise only reachable through its serialized form, which
 * has already flattened those entries to strings.
 */
export declare function matrixDefOf(matrix: Matrix<string>): Record<string, unknown>;
type MatrixWithExprs<K extends string> = Matrix<K> & {
    readonly [P in K]: ExpressionValue;
};
/**
 * Defines a build matrix, returning it with a typed property per matrix key
 * (including keys introduced by `include` entries) holding that key's
 * `matrix.<key>` expression.
 */
export declare function defineMatrix<const T extends Record<string, unknown>>(def: T): MatrixWithExprs<ExtractMatrixKeys<T>>;
export {};
//# sourceMappingURL=matrix.d.ts.map