/**
 * 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]
 */
/**
 * @typedef InputDescription
 * @property {string} help
 * @property {boolean} [required]
 * @property {unknown} [default]
 * @property {string | string[]} [type]
 * @property {string[]} [rangeIncludes]
 * @property {unknown[]} [constraints]
 */
/**
 * TestCase
 * @template [Inputs=unknown]
 * @template {string} [_Outcome=Outcome]
 * @typedef TestCase
 * @property {{ [I in keyof Inputs]: InputDescription}} input
 * @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>>} [testCases]
 * @property {Iterable<TestCaseExample<Inputs, 'inapplicable'>>} [inapplicableCases]
 * @property {Iterable<TestCaseExample<Inputs, 'passed'>>} [passedCases]
 * @property {Iterable<TestCaseExample<Inputs, 'failed'>>} [failedCases]
 * @property {Iterable<URL>} [isPartOf]
 * @property {Iterable<{ id: URL, url?: URL }>} [requirementReference] - links to specification requirements that the test case is testing. a la https://solidproject.org/ED/qa#test-case-description
 * @property {string} [applicability] - https://www.w3.org/TR/act-rules-format/#applicability
 * @property {string} [expectations] - https://www.w3.org/TR/act-rules-format/#expectations
 * @property {string} [assumptions] - https://www.w3.org/TR/act-rules-format/#assumptions
 * @property {Array<string|{ name: string, url?: URL }>} [attributedTo]
 */
/**
 * 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 {string} [id]
 * @property {Inputs} input
 * @property {TestResult<O>} result
 * @property {any} [targets]
 */
/**
 * @template Inputs
 * @template Outcome
 * @param {object} test
 * @param {Iterable<TestCaseExample<Inputs>>} [test.passedCases]
 * @param {(input: 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>> | undefined;
    run: (input: Inputs) => Promise<TestResult<Outcome_1, unknown>>;
}, { minimum }?: {
    minimum?: number | undefined;
}): Promise<void>;
/**
 * @template Inputs
 * @template {string} Outcome
 * @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, Outcome_1 extends string>({ failedCases, run }: {
    failedCases?: Iterable<TestCaseExample<Inputs, Outcome>> | undefined;
    run: (inputs: Inputs) => Promise<TestResult<Outcome_1, unknown>>;
}, { 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>> | undefined;
    run: (inputs: Inputs) => Promise<TestResult<Outcome_1, unknown>>;
}, { minimum }?: {
    minimum?: number | undefined;
}): Promise<void>;
/**
 * Given a test input, and the test case description,
 * return a version of input that can go in an Assertion.
 * The returned value may omit sensitive values like security credentials.
 * @template Input
 * @template {string} Outcome
 * @param {Input} input
 * @param {import("./test-utils").TestCase<Input, Outcome>} testCase
 */
export function createAssertionInput<Input, Outcome_1 extends string>(input: Input, testCase: TestCase<Input, Outcome_1>, console?: Console): any;
export const testingContextJsonUrl: "https://socialweb.coop/ns/testing/context.json";
export const assertionLdContext: string[];
/**
 * @template Inputs
 * @template {string} Outcome
 */
export class TestSummary<Inputs, Outcome extends string> {
    /**
     * @param {import("./test-utils").TestCase<Inputs, Outcome>} options
     */
    constructor({ slug, url, description, name, uuid, requirementReference }: import("./test-utils").TestCase<Inputs, Outcome>);
    slug: string;
    url: URL | undefined;
    description: string;
    name: string;
    id: string;
    requirementReference: {
        id: string;
        url: string | undefined;
    }[];
}
/**
 * @template Inputs
 * @template {string} Outcome
 * @template [Pointer=unknown]
 */
export class Assertion<Inputs, Outcome extends string, Pointer = unknown> {
    /**
     * @param {TestSummary<Inputs, Outcome>} test
     * @param {Inputs} input
     * @param {import("./test-utils").TestResult<Outcome, Pointer>} result
     */
    constructor(test: TestSummary<Inputs, Outcome>, input: Inputs, result: import("./test-utils").TestResult<Outcome, Pointer>);
    type: string[];
    result: TestResult<Outcome, Pointer>;
    test: TestSummary<Inputs, Outcome>;
    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;
};
export type InputDescription = {
    help: string;
    required?: boolean | undefined;
    default?: unknown;
    type?: string | string[] | undefined;
    rangeIncludes?: string[] | undefined;
    constraints?: unknown[] | undefined;
};
/**
 * TestCase
 */
export type TestCase<Inputs = unknown, _Outcome extends string = Outcome> = {
    input: { [I in keyof Inputs]: InputDescription; };
    markdown?: string | undefined;
    name: string;
    description: string;
    slug: string;
    url?: URL | undefined;
    uuid: string;
    run: (inputs: Inputs, env?: TestEnvironment) => Promise<TestResult<_Outcome>>;
    testCases?: Iterable<TestCaseExample<Inputs, import("./test-utils").Outcome>> | undefined;
    inapplicableCases?: Iterable<TestCaseExample<Inputs, "inapplicable">> | undefined;
    passedCases?: Iterable<TestCaseExample<Inputs, "passed">> | undefined;
    failedCases?: Iterable<TestCaseExample<Inputs, "failed">> | undefined;
    isPartOf?: Iterable<URL> | undefined;
    /**
     * - links to specification requirements that the test case is testing. a la https://solidproject.org/ED/qa#test-case-description
     */
    requirementReference?: Iterable<{
        id: URL;
        url?: URL | undefined;
    }> | undefined;
    /**
     * - https://www.w3.org/TR/act-rules-format/#applicability
     */
    applicability?: string | undefined;
    /**
     * - https://www.w3.org/TR/act-rules-format/#expectations
     */
    expectations?: string | undefined;
    /**
     * - https://www.w3.org/TR/act-rules-format/#assumptions
     */
    assumptions?: string | undefined;
    attributedTo?: (string | {
        name: string;
        url?: URL | undefined;
    })[] | undefined;
};
/**
 * 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;
    id?: string | undefined;
    input: Inputs;
    result: TestResult<O>;
    targets?: any;
};
//# sourceMappingURL=test-utils.d.ts.map