import { ArrayExpectation, BooleanExpectation, FinishedExpectation, NumberExpectation, ObjectExpectation, StringExpectation } from './Interfaces';
/**
 * Create a new expectation over an element. The type of the returned expectation
 * depends on the type of the element passed, and thus, different matchers may be
 * executed over the expectation.
 * The generic matchers can be called over any expectation for any element, this include:
 * * {@link Expectations/Matchers.toBe | toBe}
 * * {@link Expectations/Matchers.toBe | toBe}
 * * {@link Expectations/Matchers.toBeLike | toBeLike}
 * * {@link Expectations/Matchers.toBeDefined | toBeDefined}
 * * {@link Expectations/Matchers.toBeUndefined | toBeUndefined}
 * * {@link Expectations/Matchers.toBeNull | toBeNull}
 * * {@link Expectations/Matchers.toBeTruthy | toBeTruthy}
 * * {@link Expectations/Matchers.toBeFalsy | toBeFalsy}
 * * {@link Expectations/Matchers.toHaveType | toHaveType}
 *
 * If the given element is a number, then an {@link NumberExpectation} is returned, and so
 * the following additional matchers are added to the previous list:
 * * {@link Expectations/Matchers.toBeGreaterThan | toBeGreaterThan}
 * * {@link Expectations/Matchers.toBeGreaterThanOrEqual | toBeGreaterThanOrEqual}
 * * {@link Expectations/Matchers.toBeLowerThan | toBeLowerThan}
 * * {@link Expectations/Matchers.toBeLowerThanOrEqual | toBeLowerThanOrEqual}
 * * {@link Expectations/Matchers.toBeBetween | toBeBetween}
 * * {@link Expectations/Matchers.toBeInfinity | toBeInfinity}
 * * {@link Expectations/Matchers.toBeNaN | toBeNaN}
 * * {@link Expectations/Matchers.toBeCloseTo | toBeCloseTo}
 *
 * If a string is used instead, the list is expanded with the following matchers:
 * * {@link Expectations/Matchers.toHaveSubstring | toHaveSubstring}
 * * {@link Expectations/Matchers.toStartWith | toStartWith}
 * * {@link Expectations/Matchers.toEndWith | toEndWith}
 * * {@link Expectations/Matchers.toMatch | toMatch}
 * Note that matchers for string to not check things such as size, if you want that,
 * we recommend calling expect over the string length and not the whole string.
 *
 * For the case of arrays, additional to the general ones, the following matchers
 * are provided, that allow to test things over the elements of the array.
 * * {@link Expectations/Matchers.toHaveLength | toHaveLength}
 * * {@link Expectations/Matchers.toContain | toContain}
 * * {@link Expectations/Matchers.toHaveAtPosition | toHaveAtPosition}
 * * {@link Expectations/Matchers.allToSatisfy | allToSatisfy}
 * * {@link Expectations/Matchers.anyToSatisfy | anyToSatisfy}
 * * {@link Expectations/Matchers.amountToSatisfy | amountToSatisfy}
 *
 * For object, the focus of the matcher is put on the instance type (class it belongs to)
 * and the properties it contains (attribute keys), extending so with:
 * * {@link Expectations/Matchers.toHavePropertyCount | toHavePropertyCount}
 * * {@link Expectations/Matchers.toHaveAtLeast | toHaveAtLeast}
 * * {@link Expectations/Matchers.toHaveNoOtherThan | toHaveNoOtherThan}
 * * {@link Expectations/Matchers.toHaveProperty | toHaveProperty}
 * * {@link Expectations/Matchers.toBeInstanceOf | toBeInstanceOf}
 *
 * @param element - The element that is going to be queried by the created expectation.
 */
export declare function expect(element?: boolean): BooleanExpectation;
export declare function expect(element?: number): NumberExpectation;
export declare function expect(element?: string): StringExpectation;
export declare function expect<T>(element?: T[]): ArrayExpectation<T>;
export declare function expect<T>(element?: T): ObjectExpectation<T>;
/**
 * Create a new {@link JoinedExpectation} where all the expectations need to
 * have a `true` result in order for the result of the joined one to be also
 * `true`. That is, an expectation that joins it's components with a logical and.
 * @param expectations - A list of expectations that need to be fulfilled in order to
 *      return `true` as result.
 */
export declare const and: (...expectations: FinishedExpectation[]) => FinishedExpectation;
/**
 * Create a new {@link JoinedExpectation} where any of the expectations need to
 * have a `true` result in order for the result of the joined one to be also
 * `true`. That is, an expectation that joins it's components with a logical or.
 * @param expectations - A list of expectations where one need to be fulfilled in order to
 *      return `true` as result.
 */
export declare const or: (...expectations: FinishedExpectation[]) => FinishedExpectation;
//# sourceMappingURL=expect.d.ts.map