/// <reference types="node" />
import * as fs from "fs";
import { SystemInfo, PackageBenchmarkSummary, PackageBenchmark } from "./types";
import { PackageId, DirectoryParsedTypingVersion, PackageIdWithDefiniteVersion } from "@definitelytyped/definitions-parser";
export declare const pathExists: typeof fs.exists.__promisify__;
export declare function ensureExists(...pathNames: string[]): string;
export declare function compact<T>(arr: (T | null | undefined)[]): T[];
export declare function assertString(input: any, name?: string): string;
export declare function assertNumber(input: any, name?: string): number;
export declare function getSystemInfo(): SystemInfo;
export interface GetChangedPackagesOptions {
    diffFrom?: string;
    diffTo: string;
    definitelyTypedPath: string;
}
export declare function getChangedPackages({ diffFrom, diffTo, definitelyTypedPath, }: GetChangedPackagesOptions): Promise<PackageId[] | undefined>;
export declare function packageIdsAreEqual(a: PackageId): (b: PackageId) => boolean;
export declare function packageIdsAreEqual(a: PackageId, b: PackageId): boolean;
export declare function getPercentDiff(actual: number, expected: number): number;
export declare function isWithin(actual: number, expected: number, tolerance: number): boolean;
export declare function isVersionedBenchmark(obj: any): obj is Pick<PackageBenchmark, "packageVersionMajor" | "packageVersionMinor">;
export declare function packageVersionsAreEqual(a: PackageBenchmarkSummary | PackageBenchmark, b: PackageBenchmarkSummary | PackageBenchmark): boolean;
export declare function parsePackageKey(key: string): PackageId;
export declare function toPackageKey(name: string, version: string | DirectoryParsedTypingVersion): string;
export declare function toPackageKey(packageId: PackageIdWithDefiniteVersion | PackageBenchmark | PackageBenchmarkSummary): string;
export declare function getSourceVersion(cwd: string): string;
export declare function shuffle<T>(array: readonly T[]): T[];
export declare function not<P extends unknown[]>(fn: (...args: P) => boolean): (...args: P) => boolean;
export declare function findLast<T>(arr: T[], predicate: (element: T) => boolean): T | undefined;
export declare function forEachWithTimeLimit<T>(limitMs: number, array: readonly T[], inTimeAction: (item: T) => unknown, outOfTimeAction: (item: T) => void): Promise<{
    startTime: number;
    duration: number;
    overtime: boolean;
    complete: boolean;
}>;