@serenity-js/core/lib/screenplay/questions/Check.d.ts

The core Serenity/JS framework, providing the Screenplay Pattern interfaces, as well as the test reporting and integration infrastructure

import type { PerformsActivities } from '../activities';
import type { Activity } from '../Activity';
import type { Answerable } from '../Answerable';
import type { AnswersQuestions } from '../questions';
import { Task } from '../Task';
import type { Expectation } from './Expectation';
/**
 * A [flow control statement](https://en.wikipedia.org/wiki/Control_flow)
 * that enables an [`Actor`](https://serenity-js.org/api/core/class/Actor/) to decide between two alternate series of [activities](https://serenity-js.org/api/core/class/Activity/).
 *
 * Think of it as a Screenplay Pattern equivalent of the traditional `if` statement.
 *
 * ## Choose between two alternative sequences of activities
 *
 * ```ts
 * import { equals } from '@serenity-js/assertions'
 * import { actorCalled, Check } from '@serenity-js/core'
 *
 * await actorCalled('Chuck').attemptsTo(
 *   Check.whether(process.env.MODE, equals('prod'))
 *     .andIfSo(
 *       LogInAsProdUser(),
 *     )
 *     .otherwise(
 *       LogInAsTestUser(),
 *     )
 * )
 * ```
 *
 * ## Perform a sequence of activities when a condition is met
 *
 * ```ts
 * import { actorCalled, Check } from '@serenity-js/core'
 * import { isVisible } from '@serenity-js/web'
 *
 * await actorCalled('Chuck').attemptsTo(
 *   Check.whether(CookieConsentBanner(), isVisible())
 *     .andIfSo(
 *         AcceptNecessaryCookies(),
 *     )
 * )
 * ```
 *
 * @group Activities
 */
export declare class Check<Actual> extends Task {
    private readonly actual;
    private readonly expectation;
    private readonly activities;
    private readonly alternativeActivities;
    static whether<Actual_Type>(actual: Answerable<Actual_Type>, expectation: Expectation<Actual_Type>): {
        andIfSo: (...activities: Activity[]) => Check<Actual_Type>;
    };
    protected constructor(actual: Answerable<Actual>, expectation: Expectation<Actual>, activities: Activity[], alternativeActivities?: Activity[]);
    /**
     * @param alternativeActivities
     *  A sequence of [activities](https://serenity-js.org/api/core/class/Activity/) to perform when the [`Expectation`](https://serenity-js.org/api/core/class/Expectation/) is not met.
     */
    otherwise(...alternativeActivities: Activity[]): Task;
    /**
     * @inheritDoc
     */
    performAs(actor: AnswersQuestions & PerformsActivities): Promise<void>;
}
//# sourceMappingURL=Check.d.ts.map