@serenity-js/core 3.41.1 → 3.42.0

package/esm/screenplay/notes/TakeNotes.js

@@ -0,0 +1,264 @@
+import { Ability } from '../abilities/index.js';
+import { Notepad } from './Notepad.js';
+/**
+ * An [`Ability`](https://serenity-js.org/api/core/class/Ability/) that enables an [`Actor`](https://serenity-js.org/api/core/class/Actor/) to remember information
+ * to be recalled during a test scenario.
+ *
+ * Under the hood, [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes/) uses a [`Notepad`](https://serenity-js.org/api/core/class/Notepad/), which state
+ * can be populated both during initialisation or while the test scenario is executed.
+ * Populating the notepad when it's initialised can be useful to associate authentication credentials
+ * or personal details with a given actor, while dynamic recording of notes during a test scenario
+ * can be useful when the data to be recorded is not known upfront - for example when we want
+ * the actor to remember a JWT stored in the browser and then use it when sending API requests.
+ *
+ * **Pro tip:** [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes/), [`Notepad`](https://serenity-js.org/api/core/class/Notepad/) and [`notes`](https://serenity-js.org/api/core/function/notes/) can be typed
+ * using [TypeScript generics](https://www.typescriptlang.org/docs/handbook/2/generics.html)
+ * to help you avoid typos when specifying note names.
+ *
+ * See [notes](https://serenity-js.org/api/core/function/notes) and [`Notepad`](https://serenity-js.org/api/core/class/Notepad/) for more usage examples.
+ *
+ * ## Remembering and retrieving a value
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core'
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.usingAnEmptyNotepad())
+ *   .attemptsTo(
+ *     notes().set('my_note', 'some value'),
+ *     Log.the(notes().get('my_note')),
+ *     // emits 'some value'
+ *   )
+ * ```
+ *
+ * ## Using generics
+ *
+ * ```ts
+ *  import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core'
+ *
+ *  interface MyNotes {
+ *    personalDetails: {
+ *      firstName: string;
+ *      lastName: string;
+ *    }
+ *  }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.usingAnEmptyNotepad<MyNotes>())
+ *   .attemptsTo(
+ *     Log.the(notes<MyNotes>().has('personalDetails')),
+ *     // emits false
+ *
+ *     Log.the(notes<MyNotes>().get('personalDetails').isPresent()),
+ *     // emits false
+ *
+ *     notes<MyNotes>().set('personalDetails', { firstName: 'Leonard', lastName: 'McLaud' }),
+ *
+ *     Log.the(notes<MyNotes>().has('personalDetails')),
+ *     // emits true
+ *
+ *     Log.the(notes<MyNotes>().get('personalDetails').isPresent()),
+ *     // emits true
+ *
+ *     Log.the(notes().get('personalDetails').firstName),
+ *     // emits 'Leonard'
+ *
+ *     Log.the(notes().get('personalDetails').firstName.toLocaleUpperCase()),
+ *     // emits 'LEONARD'
+ *   )
+ * ```
+ *
+ * ## Populating the notepad with initial state
+ *
+ * ```ts
+ * import { actorCalled, Log, Note, Notepad, TakeNotes } from '@serenity-js/core'
+ *
+ * interface MyNotes {
+ *   firstName: string;
+ *   lastName: string;
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(
+ *     TakeNotes.using(Notepad.with<MyNotes>({
+ *       firstName: 'Leonard',
+ *       lastName: 'McLaud',
+ *     }))
+ *   )
+ *   .attemptsTo(
+ *     notes<MyNotes>().set('lastName', 'Shelby'),
+ *     Log.the(notes().get('firstName')),
+ *     // emits 'Leonard'
+ *
+ *     Log.the(notes().get('lastName')),
+ *     // emits 'Shelby'
+ *   )
+ * ```
+ *
+ * ## Recording a dynamic note
+ *
+ * ```ts
+ * import { actorCalled, Log, Notepad, notes, TakeNotes } from '@serenity-js/core'
+ * import { By, Text, PageElement } from '@serenity-js/web'
+ * import { BrowseTheWebWithWebdriverIO } from '@serenity-js/webdriverio'
+ *
+ * interface OnlineShoppingNotes {
+ *   promoCode: string;
+ * }
+ *
+ * const promoCodeBanner = () =>
+ *   PageElement.located(By.css('[data-testid="promo-code"]'))
+ *     .describedAs('promo code');
+ *
+ * const promoCodeInput = () =>
+ *   PageElement.located(By.css('[data-testid="promo-code-input"]'))
+ *     .describedAs('promo code field');
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(
+ *     BrowseTheWebWithWebdriverIO.using(browser),
+ *     TakeNotes.using(Notepad.empty<OnlineShoppingNotes>())
+ *   )
+ *   .attemptsTo(
+ *     notes<OnlineShoppingNotes>().set('promoCode', Text.of(promoCode()),
+ *     // ...
+ *     Enter.theValue(notes<OnlineShoppingNotes>().get('promoCode'))
+ *       .into(promoCodeInput())
+ *   )
+ * ```
+ *
+ * ## Clearing a notepad before each test scenario (Mocha)
+ *
+ * ```ts
+ * import 'mocha';
+ *
+ * beforeEach(() =>
+ *   actorCalled('Leonard')
+ *     .attemptsTo(
+ *       notes().clear(),
+ *     ))
+ * ```
+ *
+ * ## Clearing a notepad before each test scenario (Cucumber)
+ *
+ * ```ts
+ * import { Before } from '@cucumber/cucumber'
+ *
+ * Before(() =>
+ *   actorCalled('Leonard')
+ *     .attemptsTo(
+ *       notes().clear(),
+ *     ));
+ * ```
+ *
+ * ## Importing notes from an API response
+ *
+ * ```ts
+ *  // given an example API:
+ *  //   GET /generate-test-user
+ *  // which returns:
+ *  //   { "first_name": "Leonard", "last_name": "Shelby" }
+ *
+ * import { actorCalled, Log, Notepad, notes, TakeNotes } from '@serenity-js/core'
+ * import { CallAnApi, GetRequest, Send } from '@serenity-js/rest'
+ *
+ * interface PersonalDetails {
+ *   first_name: string;
+ *   last_name: string;
+ * }
+ *
+ * interface MyNotes {
+ *   personalDetails?: PersonalDetails;
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(
+ *     CallAnApi.at('https://api.example.org/'),
+ *     TakeNotes.using(Notepad.empty<MyNotes>())
+ *   )
+ *   .attemptsTo(
+ *      Send.a(GetRequest.to('/generate-test-user')),
+ *      notes<MyNotes>().set('personalDetails', LastResponse.body<PersonalDetails>()),
+ *
+ *      Log.the(notes<MyNotes>().get('personalDetails').first_name),    // emits 'Leonard'
+ *      Log.the(notes<MyNotes>().get('personalDetails').last_name),     // emits 'Shelby'
+ *   )
+ * ```
+ *
+ * ## Using the QuestionAdapter
+ *
+ * ```ts
+ * import { actorCalled, Log, Notepad, notes, TakeNotes } from '@serenity-js/core'
+ *
+ * interface AuthCredentials {
+ *   username?: string;
+ *   password?: string;
+ * }
+ *
+ * interface MyNotes {
+ *   auth: AuthCredentials;
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(
+ *     TakeNotes.using(
+ *       Notepad.with<MyNotes>({     // typed initial state
+ *         auth: {
+ *           username: 'leonard@example.org',
+ *           password: 'SuperSecretP@ssword!',
+ *         }
+ *       })
+ *     )
+ *   )
+ *   .attemptsTo(
+ *     Log.the(
+ *       notes<MyNotes>()          // typed notes
+ *         .get('auth')            // returns QuestionAdapter<AuthCredentials>
+ *         .password               // returns QuestionAdapter<string>
+ *         .charAt(0)
+ *         .toLocaleLowerCase(),   // emits "s"
+ *     ),
+ *   )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - [notes](https://serenity-js.org/api/core/function/notes)
+ * - [`Notepad`](https://serenity-js.org/api/core/class/Notepad/)
+ *
+ * @group Notes
+ */
+export class TakeNotes extends Ability {
+    notepad;
+    /**
+     * Initialises an [`Ability`](https://serenity-js.org/api/core/class/Ability/) to [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes/) with [`Notepad.empty`](https://serenity-js.org/api/core/class/Notepad/#empty).
+     */
+    static usingAnEmptyNotepad() {
+        return TakeNotes.using(Notepad.empty());
+    }
+    /**
+     * Initialises an [`Ability`](https://serenity-js.org/api/core/class/Ability/) to [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes/) using
+     * a [`Notepad.with`](https://serenity-js.org/api/core/class/Notepad/#with) some initial state.
+     *
+     * @param notepad
+     */
+    static using(notepad) {
+        return new TakeNotes(notepad);
+    }
+    /**
+     * @param notepad
+     */
+    constructor(notepad) {
+        super();
+        this.notepad = notepad;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            options: {
+                notepad: this.notepad.toJSON(),
+            }
+        };
+    }
+}
+//# sourceMappingURL=TakeNotes.js.map

package/esm/screenplay/notes/TakeNotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TakeNotes.js","sourceRoot":"","sources":["../../../src/screenplay/notes/TakeNotes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAA0B,MAAM,uBAAuB,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmOG;AACH,MAAM,OAAO,SAA+C,SAAQ,OAAO;IAsB3C;IApB5B;;OAEG;IACH,MAAM,CAAC,mBAAmB;QACtB,OAAO,SAAS,CAAC,KAAK,CAAI,OAAO,CAAC,KAAK,EAAK,CAAC,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAA6B,OAAmB;QACxD,OAAO,IAAI,SAAS,CAAI,OAAO,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,YAA4B,OAA4B;QACpD,KAAK,EAAE,CAAC;QADgB,YAAO,GAAP,OAAO,CAAqB;IAExD,CAAC;IAED,MAAM;QACF,OAAO;YACH,GAAG,KAAK,CAAC,MAAM,EAAE;YACjB,OAAO,EAAE;gBACL,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;aACjC;SACJ,CAAC;IACN,CAAC;CACJ"}

package/esm/screenplay/notes/index.d.ts

@@ -0,0 +1,6 @@
+export * from './ChainableSetter.js';
+export * from './Notepad.js';
+export * from './NotepadAdapter.js';
+export * from './notes.js';
+export * from './TakeNotes.js';
+//# sourceMappingURL=index.d.ts.map

package/esm/screenplay/notes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/screenplay/notes/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC"}

package/esm/screenplay/notes/index.js

@@ -0,0 +1,6 @@
+export * from './ChainableSetter.js';
+export * from './Notepad.js';
+export * from './NotepadAdapter.js';
+export * from './notes.js';
+export * from './TakeNotes.js';
+//# sourceMappingURL=index.js.map

package/esm/screenplay/notes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/screenplay/notes/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC"}

package/esm/screenplay/notes/notes.d.ts

@@ -0,0 +1,117 @@
+import type { NotepadAdapter } from './NotepadAdapter.js';
+/**
+ * Alias for [`Notepad.notes`](https://serenity-js.org/api/core/class/Notepad/#notes).
+ *
+ * **Pro tip:** `notes<T>().get(subject)` returns a [`NotepadAdapter`](https://serenity-js.org/api/core/class/NotepadAdapter/) to make accessing the APIs
+ * of the underlying type easier. Check [`NotepadAdapter`](https://serenity-js.org/api/core/class/NotepadAdapter/) for more examples.
+ *
+ * ## Working with untyped notes
+ *
+ * You can use `notes<T>()` without parameterising it with an [interface](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+ * describing the structure of your notes.
+ *
+ * **Note:** this approach _is not type-safe_ and the type-safe alternative presented below should be used in most cases.
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core';
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.usingAnEmptyNotepad())
+ *   .attemptsTo(
+ *     notes().set('my_note', 'some value'),
+ *
+ *     Log.the(notes().get('my_note')),
+ *     // emits "some value"
+ *
+ *     Log.the(notes().get('my_note').toLocaleUpperCase()),
+ *     // emits "SOME VALUE"
+ *   );
+ * ```
+ *
+ * ## Working with typed notes
+ *
+ * The **recommended** way to use `notes<T>()` is to parameterise it
+ * with an [interface](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+ * describing the structure of your notes.
+ *
+ * **Note:** this approach _is type-safe_.
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core';
+ *
+ * interface MyNotes {
+ *   username: string;
+ *   token?: string;     // optional value
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.with<MyNotes>({
+ *     username: 'Leonard.McLaud@example.org',
+ *   }))
+ *   .attemptsTo(
+ *     notes<MyNotes>().set('token', 'my-auth-token')
+ *
+ *     Log.the(notes<MyNotes>().get('token').length),
+ *     // emits 13
+ *
+ *     Log.the(notes<MyNotes>().get('username').toLocaleLowerCase()),
+ *     // emits 'leonard.mclaud@example.org'
+ *   )
+ * ```
+ *
+ * ## Checking if a note is present
+ *
+ * ```ts
+ * import { actorCalled, Check, notes, TakeNotes } from '@serenity-js/core'
+ * import { isPresent } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.empty()))
+ *   .attemptsTo(
+ *     Check.whether(notes().get('token'), isPresent())
+ *      .andIfSo(
+ *        Authenticate.using(notes().get('token')),
+ *      )
+ *      .otherwise(
+ *        SignIn.using('username', 'password'),
+ *      )
+ *    )
+ * ```
+ *
+ * ## Working with complex data structures
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core'
+ *
+ * interface MyNotes {
+ *   recordedItems: string[];
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.with<MyNotes>({
+ *     recordedItems: [],
+ *   }))
+ *   .attemptsTo(
+ *      // push 3 items
+ *      notes().get('recordedItems').push('apples'),
+ *      notes().get('recordedItems').push('cucumbers'),
+ *      notes().get('recordedItems').push('bananas'),
+ *
+ *      // use QuestionAdapter to access Array.sort()
+ *      notes().get('recordedItems').sort(),
+ *
+ *      Log.the(notes().get('recordedItems')),
+ *      // emits 'apples', 'bananas', 'cucumbers'
+ *   )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - [`NotepadAdapter`](https://serenity-js.org/api/core/class/NotepadAdapter/)
+ * - [`Notepad.notes`](https://serenity-js.org/api/core/class/Notepad/#notes)
+ * - [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter)
+ *
+ * @group Notes
+ */
+export declare function notes<N extends Record<any, any>>(): NotepadAdapter<N>;
+//# sourceMappingURL=notes.d.ts.map

package/esm/screenplay/notes/notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../../../src/screenplay/notes/notes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC,CAErE"}

package/esm/screenplay/notes/notes.js

@@ -0,0 +1,119 @@
+import { Notepad } from './Notepad.js';
+/**
+ * Alias for [`Notepad.notes`](https://serenity-js.org/api/core/class/Notepad/#notes).
+ *
+ * **Pro tip:** `notes<T>().get(subject)` returns a [`NotepadAdapter`](https://serenity-js.org/api/core/class/NotepadAdapter/) to make accessing the APIs
+ * of the underlying type easier. Check [`NotepadAdapter`](https://serenity-js.org/api/core/class/NotepadAdapter/) for more examples.
+ *
+ * ## Working with untyped notes
+ *
+ * You can use `notes<T>()` without parameterising it with an [interface](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+ * describing the structure of your notes.
+ *
+ * **Note:** this approach _is not type-safe_ and the type-safe alternative presented below should be used in most cases.
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core';
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.usingAnEmptyNotepad())
+ *   .attemptsTo(
+ *     notes().set('my_note', 'some value'),
+ *
+ *     Log.the(notes().get('my_note')),
+ *     // emits "some value"
+ *
+ *     Log.the(notes().get('my_note').toLocaleUpperCase()),
+ *     // emits "SOME VALUE"
+ *   );
+ * ```
+ *
+ * ## Working with typed notes
+ *
+ * The **recommended** way to use `notes<T>()` is to parameterise it
+ * with an [interface](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+ * describing the structure of your notes.
+ *
+ * **Note:** this approach _is type-safe_.
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core';
+ *
+ * interface MyNotes {
+ *   username: string;
+ *   token?: string;     // optional value
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.with<MyNotes>({
+ *     username: 'Leonard.McLaud@example.org',
+ *   }))
+ *   .attemptsTo(
+ *     notes<MyNotes>().set('token', 'my-auth-token')
+ *
+ *     Log.the(notes<MyNotes>().get('token').length),
+ *     // emits 13
+ *
+ *     Log.the(notes<MyNotes>().get('username').toLocaleLowerCase()),
+ *     // emits 'leonard.mclaud@example.org'
+ *   )
+ * ```
+ *
+ * ## Checking if a note is present
+ *
+ * ```ts
+ * import { actorCalled, Check, notes, TakeNotes } from '@serenity-js/core'
+ * import { isPresent } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.empty()))
+ *   .attemptsTo(
+ *     Check.whether(notes().get('token'), isPresent())
+ *      .andIfSo(
+ *        Authenticate.using(notes().get('token')),
+ *      )
+ *      .otherwise(
+ *        SignIn.using('username', 'password'),
+ *      )
+ *    )
+ * ```
+ *
+ * ## Working with complex data structures
+ *
+ * ```ts
+ * import { actorCalled, Log, notes, TakeNotes } from '@serenity-js/core'
+ *
+ * interface MyNotes {
+ *   recordedItems: string[];
+ * }
+ *
+ * await actorCalled('Leonard')
+ *   .whoCan(TakeNotes.using(Notepad.with<MyNotes>({
+ *     recordedItems: [],
+ *   }))
+ *   .attemptsTo(
+ *      // push 3 items
+ *      notes().get('recordedItems').push('apples'),
+ *      notes().get('recordedItems').push('cucumbers'),
+ *      notes().get('recordedItems').push('bananas'),
+ *
+ *      // use QuestionAdapter to access Array.sort()
+ *      notes().get('recordedItems').sort(),
+ *
+ *      Log.the(notes().get('recordedItems')),
+ *      // emits 'apples', 'bananas', 'cucumbers'
+ *   )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - [`NotepadAdapter`](https://serenity-js.org/api/core/class/NotepadAdapter/)
+ * - [`Notepad.notes`](https://serenity-js.org/api/core/class/Notepad/#notes)
+ * - [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter)
+ *
+ * @group Notes
+ */
+export function notes() {
+    return Notepad.notes();
+}
+//# sourceMappingURL=notes.js.map

package/esm/screenplay/notes/notes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.js","sourceRoot":"","sources":["../../../src/screenplay/notes/notes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHG;AACH,MAAM,UAAU,KAAK;IACjB,OAAO,OAAO,CAAC,KAAK,EAAK,CAAC;AAC9B,CAAC"}

package/esm/screenplay/questions/AnswersQuestions.d.ts

@@ -0,0 +1,19 @@
+import type { Answerable } from '../Answerable.js';
+/**
+ * Describes an [`Actor`](https://serenity-js.org/api/core/class/Actor/) who can answer a [`Question`](https://serenity-js.org/api/core/class/Question/) about the system under test.
+ *
+ * ## Learn more
+ *
+ * - [`Question`](https://serenity-js.org/api/core/class/Question/)
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ *
+ * @group Actors
+ */
+export interface AnswersQuestions {
+    /**
+     * Makes the [`Actor`](https://serenity-js.org/api/core/class/Actor/) evaluate an [`Answerable`](https://serenity-js.org/api/core/#Answerable)
+     * and return the value it holds.
+     */
+    answer<T>(answerable: Answerable<T>): Promise<T>;
+}
+//# sourceMappingURL=AnswersQuestions.d.ts.map

package/esm/screenplay/questions/AnswersQuestions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnswersQuestions.d.ts","sourceRoot":"","sources":["../../../src/screenplay/questions/AnswersQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAE7B;;;OAGG;IACH,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACpD"}

package/esm/screenplay/questions/AnswersQuestions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AnswersQuestions.js.map

package/esm/screenplay/questions/AnswersQuestions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnswersQuestions.js","sourceRoot":"","sources":["../../../src/screenplay/questions/AnswersQuestions.ts"],"names":[],"mappings":""}

package/esm/screenplay/questions/ChainableMetaQuestion.d.ts

@@ -0,0 +1,26 @@
+import type { Answerable } from '../Answerable.js';
+import type { Question } from '../Question.js';
+import type { MetaQuestion } from './MetaQuestion.js';
+/**
+ * A chainable meta-question is a [`MetaQuestion`](https://serenity-js.org/api/core/interface/MetaQuestion/) that can be answered
+ * in the context of another [`Answerable`](https://serenity-js.org/api/core/#Answerable),
+ * and form a chain of transformations.
+ *
+ * [Meta-questions](https://serenity-js.org/api/core/interface/MetaQuestion/) are typically used when filtering a [`List`](https://serenity-js.org/api/core/class/List/).
+ *
+ * ## Learn more
+ * - [`List`](https://serenity-js.org/api/core/class/List/)
+ *
+ * @group Questions
+ */
+export interface ChainableMetaQuestion<Supported_Context_Type, Returned_Question_Type extends Question<unknown>> extends MetaQuestion<Supported_Context_Type, Returned_Question_Type & ChainableMetaQuestion<Supported_Context_Type, Returned_Question_Type>> {
+    /**
+     * Answers the given `ChainableMetaQuestion` in the context of another [`Answerable`](https://serenity-js.org/api/core/#Answerable)
+     * and returns another `ChainableMetaQuestion` ready for further chaining.
+     *
+     * #### Learn more
+     * - [`List`](https://serenity-js.org/api/core/class/List/)
+     */
+    of(context: Answerable<Supported_Context_Type>): Returned_Question_Type & ChainableMetaQuestion<Supported_Context_Type, Returned_Question_Type>;
+}
+//# sourceMappingURL=ChainableMetaQuestion.d.ts.map

package/esm/screenplay/questions/ChainableMetaQuestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainableMetaQuestion.d.ts","sourceRoot":"","sources":["../../../src/screenplay/questions/ChainableMetaQuestion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB,CAClC,sBAAsB,EACtB,sBAAsB,SAAS,QAAQ,CAAC,OAAO,CAAC,CAClD,SAAQ,YAAY,CAAC,sBAAsB,EAAE,sBAAsB,GAAG,qBAAqB,CAAC,sBAAsB,EAAE,sBAAsB,CAAC,CAAC;IAE1I;;;;;;OAMG;IACH,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,sBAAsB,CAAC,GAAG,sBAAsB,GAAG,qBAAqB,CAAC,sBAAsB,EAAE,sBAAsB,CAAC,CAAC;CACnJ"}

package/esm/screenplay/questions/ChainableMetaQuestion.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ChainableMetaQuestion.js.map

package/esm/screenplay/questions/ChainableMetaQuestion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainableMetaQuestion.js","sourceRoot":"","sources":["../../../src/screenplay/questions/ChainableMetaQuestion.ts"],"names":[],"mappings":""}

package/esm/screenplay/questions/Check.d.ts

@@ -0,0 +1,65 @@
+import type { PerformsActivities } from '../activities/index.js';
+import type { Activity } from '../Activity.js';
+import type { Answerable } from '../Answerable.js';
+import type { AnswersQuestions } from '../questions/index.js';
+import { Task } from '../Task.js';
+import type { Expectation } from './Expectation.js';
+/**
+ * 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

package/esm/screenplay/questions/Check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Check.d.ts","sourceRoot":"","sources":["../../../src/screenplay/questions/Check.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,KAAK,CAAC,MAAM,CAAE,SAAQ,IAAI;IAU/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IAX1C,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC,GAAG,UAAU,EAAE,QAAQ,EAAE,KAAK,KAAK,CAAC,WAAW,CAAC,CAAA;KAAE;IAOnK,SAAS,aACY,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAC1B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,UAAU,EAAE,QAAQ,EAAE,EACtB,qBAAqB,GAAE,QAAQ,EAAO;IAK3D;;;OAGG;IACH,SAAS,CAAC,GAAG,qBAAqB,EAAE,QAAQ,EAAE,GAAG,IAAI;IAIrD;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,gBAAgB,GAAG,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAO/E"}