/**
 * Splits a list of test files into balanced groups using a greedy load-balancing algorithm.
 * Modeled after test_suite_splitter for RSpec.
 */
export default class TestSuiteSplitter {
    /**
     * Runs constructor.
     * @param {object} args - Options.
     * @param {number} args.groups - Total number of groups.
     * @param {number} args.groupNumber - Which group to return (1-indexed).
     * @param {string[]} args.testFiles - All discovered test file paths.
     * @param {string} [args.baseDirectory] - Base directory for relative path computation.
     */
    constructor({ groups, groupNumber, testFiles, baseDirectory, ...restArgs }: {
        groups: number;
        groupNumber: number;
        testFiles: string[];
        baseDirectory?: string | undefined;
    });
    _groups: number;
    _groupNumber: number;
    _testFiles: string[];
    _baseDirectory: string;
    /**
     * Returns the test files assigned to this group.
     * @returns {string[]} - File paths for the requested group.
     */
    getGroupFiles(): string[];
    /**
     * Computes weight for each test file based on directory type and file suffix.
     * @returns {SplitterFileEntry[]} - Weighted file entries.
     */
    computeWeightedFiles(): SplitterFileEntry[];
    /**
     * Computes the weight for a single file.
     * @param {string} filePath - Absolute file path.
     * @returns {number} - Weight value.
     */
    computeWeight(filePath: string): number;
    /**
     * Sorts files by weight descending, then by path for determinism.
     * @param {SplitterFileEntry[]} files - Weighted files.
     * @returns {SplitterFileEntry[]} - Sorted files.
     */
    sortByWeightDescending(files: SplitterFileEntry[]): SplitterFileEntry[];
    /**
     * Distributes files greedily into N balanced groups.
     * Each file is assigned to the group with the least accumulated weight.
     * @param {SplitterFileEntry[]} sortedFiles - Files sorted by weight descending.
     * @returns {GroupBucket[]} - Array of group buckets.
     */
    distributeGreedily(sortedFiles: SplitterFileEntry[]): GroupBucket[];
    /**
     * Finds the bucket with the least accumulated weight.
     * Ties are broken by bucket index (earlier bucket wins) for determinism.
     * @param {GroupBucket[]} buckets - Group buckets.
     * @returns {GroupBucket} - The lightest bucket.
     */
    findLightestBucket(buckets: GroupBucket[]): GroupBucket;
}
/**
 * SplitterFileEntry type.
 */
export type SplitterFileEntry = {
    /**
     * - Absolute file path.
     */
    filePath: string;
    /**
     * - Computed weight for load balancing.
     */
    weight: number;
};
/**
 * GroupBucket type.
 */
export type GroupBucket = {
    /**
     * - Accumulated weight.
     */
    totalWeight: number;
    /**
     * - Files assigned to this group.
     */
    files: string[];
};
//# sourceMappingURL=test-suite-splitter.d.ts.map