/**
 * TestTargetResult
 * @template Outcome
 * @typedef TestTargetResult - TestResult for a single one of the test targets
 * @property {"TestResult"} type
 * @property {Outcome} outcome
 * @property {string} name
 * @property {unknown} pointer - pointer to the test target that was tested to produce this result
 */
/**
 * TestResult
 * https://www.w3.org/TR/EARL10-Schema/#TestResult
 * @template Outcome
 * @template [Pointer=unknown] - type of allowed pointers
 * @typedef TestResult
 * @property {"TestResult"} [type]
 * @property {string} [info] - additional info about the result in human-readable form
 * @property {Outcome} outcome
 * @property {TestTargetResult<Outcome>[]} [source]
 * @property {Pointer} [pointer]
 */
/**
 * @typedef TestEnvironment
 * @property {typeof globalThis.fetch} [fetch]
 */
/**
 * TestCase
 * @template Inputs
 * @typedef TestCase
 * @property {{ [I in keyof Inputs]: { help: string }}} inputs
 * @property {string} markdown
 * @property {string} name
 * @property {string} description
 * @property {string} slug
 * @property {URL} [url]
 * @property {string} uuid
 * @property {(inputs: Inputs, env?: TestEnvironment) => Promise<TestResult<Outcome>>} run
 * @property {Iterable<TestCaseExample<Inputs>>} inapplicableCases
 * @property {Iterable<TestCaseExample<Inputs>>} passedCases
 * @property {Iterable<TestCaseExample<Inputs>>} failedCases
 */
/**
 * Outcome
 * @typedef {"passed"|"failed"|"inapplicable"|"cantTell"|"untested"} Outcome
 * @see https://www.w3.org/TR/EARL10-Schema/#OutcomeValue
 */
/**
 * TestCaseExample
 * an example of applying a test case with specific inputs expected result
 * @template Inputs
 * @template {Outcome} [O=Outcome]
 * @typedef TestCaseExample
 * @property {string} name
 * @property {Inputs} inputs
 * @property {TestResult<O>} result
 * @property {any} [targets]
 */
/**
 * @template Inputs
 * @template Outcome
 * @param {object} test
 * @param {Iterable<TestCaseExample<Inputs>>} test.passedCases
 * @param {(inputs: Inputs) => Promise<TestResult<Outcome>>} test.run
 * @param {object} options
 * @param {number} [options.minimum=0] - minimum required passedCases
 */
export function testHasPassedCases<Inputs, Outcome_1>({ passedCases, run }: {
    passedCases: Iterable<TestCaseExample<Inputs, Outcome>>;
    run: (inputs: Inputs) => Promise<TestResult<Outcome_1, unknown>>;
}, { minimum }?: {
    minimum?: number | undefined;
}): Promise<void>;
/**
 * @template Inputs
 * @param {object} options
 * @param {Iterable<TestCaseExample<Inputs>>} options.failedCases
 * @param {(inputs: Inputs) => Promise<TestResult<Outcome>>} options.run
 * @param {object} options
 * @param {number} [options.minimum=0] - minimum required cases
 */
export function testHasFailedCases<Inputs>({ failedCases, run }: {
    failedCases: Iterable<TestCaseExample<Inputs, Outcome>>;
    run: (inputs: Inputs) => Promise<TestResult<Outcome>>;
}, { minimum }?: {
    minimum?: number | undefined;
}): Promise<void>;
/**
 * @template Inputs
 * @template Outcome
 * @param {object} options
 * @param {Iterable<TestCaseExample<Inputs>>} options.inapplicableCases
 * @param {(inputs: Inputs) => Promise<TestResult<Outcome>>} options.run
 * @param {object} options
 * @param {number} [options.minimum=0] - minimum required cases
 */
export function testHasInapplicableCases<Inputs, Outcome_1>({ inapplicableCases, run }: {
    inapplicableCases: Iterable<TestCaseExample<Inputs, Outcome>>;
    run: (inputs: Inputs) => Promise<TestResult<Outcome_1, unknown>>;
}, { minimum }?: {
    minimum?: number | undefined;
}): Promise<void>;
export const testingContextJsonUrl: "https://socialweb.coop/ns/testing/context.json";
export const assertionLdContext: string[];
/**
 * @template Inputs
 */
export class TestSummary<Inputs> {
    /**
     * @param {import("./test-utils").TestCase<Inputs>} options
     */
    constructor({ slug, url, description, name, uuid }: import("./test-utils").TestCase<Inputs>);
    slug: string;
    url: string | URL;
    description: string;
    name: string;
    uuid: string;
}
/**
 * @template Inputs
 * @template Outcome
 * @template [Pointer=unknown]
 */
export class Assertion<Inputs, Outcome, Pointer = unknown> {
    /**
     * @param {TestSummary<Inputs>} test
     * @param {Inputs} input
     * @param {import("./test-utils").TestResult<Outcome, Pointer>} result
     */
    constructor(test: TestSummary<Inputs>, input: Inputs, result: import("./test-utils").TestResult<Outcome, Pointer>);
    type: string[];
    result: TestResult<Outcome, Pointer>;
    test: TestSummary<Inputs>;
    input: Inputs;
    '@context': string[];
}
/**
 * - TestResult for a single one of the test targets
 */
export type TestTargetResult<Outcome_1> = {
    type: "TestResult";
    outcome: Outcome;
    name: string;
    /**
     * - pointer to the test target that was tested to produce this result
     */
    pointer: unknown;
};
/**
 * TestResult
 * https://www.w3.org/TR/EARL10-Schema/#TestResult
 */
export type TestResult<Outcome_1, Pointer = unknown> = {
    type?: "TestResult" | undefined;
    /**
     * - additional info about the result in human-readable form
     */
    info?: string | undefined;
    outcome: Outcome;
    source?: TestTargetResult<Outcome>[] | undefined;
    pointer?: Pointer | undefined;
};
export type TestEnvironment = {
    fetch?: typeof fetch | undefined;
};
/**
 * TestCase
 */
export type TestCase<Inputs> = {
    inputs: { [I in keyof Inputs]: {
        help: string;
    }; };
    markdown: string;
    name: string;
    description: string;
    slug: string;
    url?: URL | undefined;
    uuid: string;
    run: (inputs: Inputs, env?: TestEnvironment) => Promise<TestResult<Outcome>>;
    inapplicableCases: Iterable<TestCaseExample<Inputs>>;
    passedCases: Iterable<TestCaseExample<Inputs>>;
    failedCases: Iterable<TestCaseExample<Inputs>>;
};
/**
 * Outcome
 */
export type Outcome = "passed" | "failed" | "inapplicable" | "cantTell" | "untested";
/**
 * TestCaseExample
 * an example of applying a test case with specific inputs expected result
 */
export type TestCaseExample<Inputs, O extends Outcome = Outcome> = {
    name: string;
    inputs: Inputs;
    result: TestResult<O>;
    targets?: any;
};
//# sourceMappingURL=test-utils.d.ts.map