import { AssertValue, AssertEqual, AssertMatch, AssertRejects, AssertThrows, AssertionMessage, AsyncTestCb, TestCb, Describe, Code, Configs, ConfigFile } from './_shared.js';
export { Configs$1 as Configs, poku, VERSION as version } from './_shared.js';

declare const assert: ((value: unknown, message?: string | Error | undefined) => void) & {
    ok: AssertValue;
    equal: AssertEqual;
    deepEqual: AssertEqual;
    strictEqual: AssertEqual;
    deepStrictEqual: AssertEqual;
    doesNotMatch: AssertMatch;
    doesNotReject: AssertRejects;
    throws: AssertThrows;
    doesNotThrow: AssertThrows;
    notEqual: AssertEqual;
    notDeepEqual: AssertEqual;
    notStrictEqual: AssertEqual;
    notDeepStrictEqual: AssertEqual;
    match: AssertMatch;
    ifError: AssertValue;
    fail: (message?: AssertionMessage) => never;
    rejects: AssertRejects;
};

declare const strict: ((value: unknown, message?: string | Error | undefined) => void) & {
    ok: AssertValue;
    equal: AssertEqual;
    deepEqual: AssertEqual;
    strictEqual: AssertEqual;
    deepStrictEqual: AssertEqual;
    doesNotMatch: AssertMatch;
    doesNotReject: AssertRejects;
    throws: AssertThrows;
    doesNotThrow: AssertThrows;
    notEqual: AssertEqual;
    notDeepEqual: AssertEqual;
    notStrictEqual: AssertEqual;
    notDeepStrictEqual: AssertEqual;
    match: AssertMatch;
    ifError: AssertValue;
    fail: (message?: AssertionMessage) => never;
    rejects: AssertRejects;
};

type Todo = {
    (message: string): void;
    (message: string, cb?: AsyncTestCb): Promise<void>;
    (message: string, cb?: TestCb): void;
};
type Modifier = {
    (message: string, cb: AsyncTestCb): Promise<void>;
    (message: string, cb: TestCb): void;
    (cb: AsyncTestCb): Promise<void>;
    (cb: TestCb): void;
};

type It = {
    (title: string, cb: AsyncTestCb): Promise<void>;
    (title: string, cb: TestCb): void;
    (cb: AsyncTestCb): Promise<void>;
    (cb: TestCb): void;
};

declare const test: It & {
    todo: Todo;
    skip: Modifier;
    only: Modifier;
};

declare const describe: Describe & {
    todo: Todo;
    skip: Modifier;
    only: Modifier;
};

declare const it: It & {
    todo: Todo;
    skip: Modifier;
    only: Modifier;
};

declare const envFile: (filePath?: string) => Promise<void>;

declare const skip: (message?: string) => never;

type Control = {
    pause: () => void;
    continue: () => void;
    reset: () => void;
};
type EachOptions = {
    immediate?: boolean;
};

declare const beforeEach: (callback: () => unknown, options?: EachOptions) => Control;
declare const afterEach: (callback: () => unknown) => Control;

type RetryConfig = {
    attempts: number;
    delay?: number;
};

declare function retry(config: number | RetryConfig, callback: () => unknown | Promise<unknown>): Promise<void>;

type Runner = 'npm' | 'bun' | 'deno' | 'yarn' | 'pnpm';

type BackgroundProcessOptions = {
    startAfter?: string | number;
    timeout?: number;
    verbose?: boolean;
    cwd?: string | undefined;
};
type StartScriptOptions = {
    readonly runner?: Runner;
} & BackgroundProcessOptions;
type StartServiceOptions = BackgroundProcessOptions;
type End = (port?: number | number[]) => Promise<void>;

declare const startService: (file: string, options?: StartServiceOptions) => Promise<{
    end: End;
}>;
declare const startScript: (script: string, options?: StartScriptOptions) => Promise<{
    end: End;
}>;

type WaitForExpectedResultOptions = {
    interval?: number;
    timeout?: number;
    delay?: number;
    strict?: boolean;
};
type WaitForPortOptions = {
    host?: string;
} & Omit<WaitForExpectedResultOptions, 'strict'>;

declare const sleep: (milliseconds: number) => Promise<unknown>;
declare const waitForExpectedResult: (callback: () => unknown | Promise<unknown>, expectedResult: unknown, options?: WaitForExpectedResultOptions) => Promise<void>;
declare const waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;

declare const kill: {
    pid: (PID: number | number[]) => Promise<void>;
    port: (port: number | number[]) => Promise<void>;
    range: (startsAt: number, endsAt: number) => Promise<void>;
};

declare const getPIDs: ((port: number | number[]) => Promise<number[]>) & {
    range: (startsAt: number, endsAt: number) => Promise<number[]>;
};

declare const exit: (code: Code, quiet?: boolean) => void;

declare const log: (...args: unknown[]) => void;

declare const listFiles: (targetDir: string, configs?: Configs) => Promise<string[]>;

declare const defineConfig: (options: ConfigFile) => ConfigFile;

export { Code, ConfigFile, Configs as ListFilesConfigs, afterEach, assert, beforeEach, defineConfig, describe, envFile, exit, getPIDs, it, kill, listFiles, log, retry, skip, sleep, startScript, startService, strict, test, waitForExpectedResult, waitForPort };
export type { RetryConfig, StartScriptOptions, StartServiceOptions, WaitForExpectedResultOptions, WaitForPortOptions };