@serenity-js/core 3.41.1 → 3.42.0

package/esm/screenplay/Answerable.d.ts

@@ -0,0 +1,9 @@
+import type { Question } from './Question.js';
+/**
+ * A union type that provides a convenient way to represent any value
+ * that can be resolved by [`Actor.answer`](https://serenity-js.org/api/core/class/Actor/#answer).
+ *
+ * @group Questions
+ */
+export type Answerable<T> = Question<Promise<T>> | Question<T> | Promise<T> | T;
+//# sourceMappingURL=Answerable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Answerable.d.ts","sourceRoot":"","sources":["../../src/screenplay/Answerable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC"}

package/esm/screenplay/Answerable.js

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

package/esm/screenplay/Answerable.js.map

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

package/esm/screenplay/Answered.d.ts

@@ -0,0 +1,13 @@
+import type { Question } from './Question.js';
+/**
+ * Describes the type of answer a given [`Answerable`](https://serenity-js.org/api/core/#Answerable) would
+ * resolve to when given to [`Actor.answer`](https://serenity-js.org/api/core/class/Actor/#answer).
+ *
+ * ```ts
+ * Answered<Answerable<T>> === T
+ * ```
+ *
+ * @group Questions
+ */
+export type Answered<T> = T extends null | undefined ? T : T extends Question<Promise<infer A>> | Question<infer A> | Promise<infer A> ? Awaited<A> : T;
+//# sourceMappingURL=Answered.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Answered.d.ts","sourceRoot":"","sources":["../../src/screenplay/Answered.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAClB,CAAC,SAAS,IAAI,GAAG,SAAS,GAAG,CAAC,GAC1B,CAAC,SAAS,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACpF,CAAC,CAAC"}

package/esm/screenplay/Answered.js

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

package/esm/screenplay/Answered.js.map

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

package/esm/screenplay/Interaction.d.ts

@@ -0,0 +1,91 @@
+import type { UsesAbilities } from './abilities/index.js';
+import { Activity } from './Activity.js';
+import type { Answerable } from './Answerable.js';
+import type { CollectsArtifacts } from './artifacts/index.js';
+import type { AnswersQuestions } from './questions/index.js';
+/**
+ * **Interactions** are low-level [activities](https://serenity-js.org/api/core/class/Activity/) that encapsulate
+ * a handful of instructions for an [actor](https://serenity-js.org/api/core/class/Actor/) on how to use their [abilities](https://serenity-js.org/api/core/class/Ability/)
+ * to perform an individual interaction with the given interface of the system under test.
+ *
+ * :::tip Tasks or interactions?
+ * Because of their low-level nature, interactions are named using the vocabulary of the [solution domain](https://blog.mattwynne.net/2013/01/17/the-problem-with-solutions/),
+ * and represent an individual interaction with the given interface, e.g. [`Click`](https://serenity-js.org/api/web/class/Click/), [`Enter`](https://serenity-js.org/api/web/class/Enter/), or [`Send`](https://serenity-js.org/api/rest/class/Send/).
+ *
+ * Interactions follow the [Single Responsibility Principle](https://en.wikipedia.org/wiki/Single_responsibility_principle) which means that they do _one thing and one thing only_.
+ * If you're considering implementing an "interaction" that performs more than one logical activity, e.g. checks if the button is visible and then clicks on it if is,
+ * consider using separate interactions for separate responsibilities and then composing them using a [task](https://serenity-js.org/api/core/class/Task/).
+ * :::
+ *
+ * Interactions are the core building block of the [Screenplay Pattern](https://serenity-js.org/handbook/design/screenplay-pattern),
+ * along with [actors](https://serenity-js.org/api/core/class/Actor/), [abilities](https://serenity-js.org/api/core/class/Ability/), [questions](https://serenity-js.org/api/core/class/Question/), and [tasks](https://serenity-js.org/api/core/class/Task/).
+ *
+ * ![Screenplay Pattern](https://serenity-js.org/images/design/serenity-js-screenplay-pattern.png)
+ *
+ * Learn more about:
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ * - [Abilities](https://serenity-js.org/api/core/class/Ability/)
+ * - [Activities](https://serenity-js.org/api/core/class/Activity/)
+ *
+ * ## Writing a custom interaction
+ *
+ * [Serenity/JS modules](https://serenity-js.org/handbook/architecture/) ship with dozens of interactions to help you compose your test scenarios.
+ * However, if you need to interact with a non-standard interface, or want to create a flavour of a given interaction that behaves slightly differently than the built-in version,
+ * you can easily create your own implementations using the [`Interaction.where`](https://serenity-js.org/api/core/class/Interaction/#where) factory method.
+ *
+ * ```ts
+ * import { Actor, Interaction, the } from '@serenity-js/core'
+ * import { BrowseTheWeb, Page } from '@serenity-js/web'
+ *
+ * export const ClearLocalStorage = () =>
+ *   Interaction.where(the`#actor clears local storage`, async (actor: Actor) => {
+ *     // Interaction to ClearLocalStorage directly uses Actor's ability to BrowseTheWeb
+ *     const page: Page = await BrowseTheWeb.as(actor).currentPage()
+ *     await page.executeScript(() => window.localStorage.clear())
+ *   })
+ * ```
+ *
+ * ## Using a custom interaction
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core';
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import { By, Navigate, PageElement } from '@serenity-js/web'
+ * import { Ensure, equals } from '@serenity-js/assertions'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * const browser = await chromium.launch({ headless: true })
+ *
+ * await actorCalled('Inês')
+ *   .whoCan(BrowseTheWebWithPlaywright.using(browser))
+ *   .attemptsTo(
+ *     Navigate.to(`https://serenity-js.org`),
+ *     ClearLocalStorage(), // reported as "Inês clears local storage"
+ *   )
+ * ```
+ *
+ * @group Screenplay Pattern
+ */
+export declare abstract class Interaction extends Activity {
+    /**
+     * @param description
+     *  Description to be used when reporting this interaction, for example `#actor clears local storage`.
+     *  Note that `#actor` will be replaced with the name of the actor performing this interaction.
+     *
+     * @param interaction
+     */
+    static where(description: Answerable<string>, interaction: (actor: UsesAbilities & AnswersQuestions & CollectsArtifacts) => Promise<void> | void): Interaction;
+    /**
+     * Instructs the provided [`Actor`](https://serenity-js.org/api/core/class/Actor/) to perform this [`Interaction`](https://serenity-js.org/api/core/class/Interaction/).
+     *
+     * #### Learn more
+     * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+     * - [`PerformsActivities`](https://serenity-js.org/api/core/interface/PerformsActivities/)
+     * - [`UsesAbilities`](https://serenity-js.org/api/core/interface/UsesAbilities/)
+     * - [`AnswersQuestions`](https://serenity-js.org/api/core/interface/AnswersQuestions/)
+     *
+     * @param actor
+     */
+    abstract performAs(actor: UsesAbilities & AnswersQuestions): Promise<void>;
+}
+//# sourceMappingURL=Interaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Interaction.d.ts","sourceRoot":"","sources":["../../src/screenplay/Interaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,8BAAsB,WAAY,SAAQ,QAAQ;IAE9C;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CACR,WAAW,EAAE,UAAU,CAAC,MAAM,CAAC,EAC/B,WAAW,EAAE,CAAC,KAAK,EAAE,aAAa,GAAG,gBAAgB,GAAG,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GACnG,WAAW;IAId;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,aAAa,GAAG,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;CAC7E"}

package/esm/screenplay/Interaction.js

@@ -0,0 +1,95 @@
+import { Activity } from './Activity.js';
+/**
+ * **Interactions** are low-level [activities](https://serenity-js.org/api/core/class/Activity/) that encapsulate
+ * a handful of instructions for an [actor](https://serenity-js.org/api/core/class/Actor/) on how to use their [abilities](https://serenity-js.org/api/core/class/Ability/)
+ * to perform an individual interaction with the given interface of the system under test.
+ *
+ * :::tip Tasks or interactions?
+ * Because of their low-level nature, interactions are named using the vocabulary of the [solution domain](https://blog.mattwynne.net/2013/01/17/the-problem-with-solutions/),
+ * and represent an individual interaction with the given interface, e.g. [`Click`](https://serenity-js.org/api/web/class/Click/), [`Enter`](https://serenity-js.org/api/web/class/Enter/), or [`Send`](https://serenity-js.org/api/rest/class/Send/).
+ *
+ * Interactions follow the [Single Responsibility Principle](https://en.wikipedia.org/wiki/Single_responsibility_principle) which means that they do _one thing and one thing only_.
+ * If you're considering implementing an "interaction" that performs more than one logical activity, e.g. checks if the button is visible and then clicks on it if is,
+ * consider using separate interactions for separate responsibilities and then composing them using a [task](https://serenity-js.org/api/core/class/Task/).
+ * :::
+ *
+ * Interactions are the core building block of the [Screenplay Pattern](https://serenity-js.org/handbook/design/screenplay-pattern),
+ * along with [actors](https://serenity-js.org/api/core/class/Actor/), [abilities](https://serenity-js.org/api/core/class/Ability/), [questions](https://serenity-js.org/api/core/class/Question/), and [tasks](https://serenity-js.org/api/core/class/Task/).
+ *
+ * ![Screenplay Pattern](https://serenity-js.org/images/design/serenity-js-screenplay-pattern.png)
+ *
+ * Learn more about:
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ * - [Abilities](https://serenity-js.org/api/core/class/Ability/)
+ * - [Activities](https://serenity-js.org/api/core/class/Activity/)
+ *
+ * ## Writing a custom interaction
+ *
+ * [Serenity/JS modules](https://serenity-js.org/handbook/architecture/) ship with dozens of interactions to help you compose your test scenarios.
+ * However, if you need to interact with a non-standard interface, or want to create a flavour of a given interaction that behaves slightly differently than the built-in version,
+ * you can easily create your own implementations using the [`Interaction.where`](https://serenity-js.org/api/core/class/Interaction/#where) factory method.
+ *
+ * ```ts
+ * import { Actor, Interaction, the } from '@serenity-js/core'
+ * import { BrowseTheWeb, Page } from '@serenity-js/web'
+ *
+ * export const ClearLocalStorage = () =>
+ *   Interaction.where(the`#actor clears local storage`, async (actor: Actor) => {
+ *     // Interaction to ClearLocalStorage directly uses Actor's ability to BrowseTheWeb
+ *     const page: Page = await BrowseTheWeb.as(actor).currentPage()
+ *     await page.executeScript(() => window.localStorage.clear())
+ *   })
+ * ```
+ *
+ * ## Using a custom interaction
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core';
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import { By, Navigate, PageElement } from '@serenity-js/web'
+ * import { Ensure, equals } from '@serenity-js/assertions'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * const browser = await chromium.launch({ headless: true })
+ *
+ * await actorCalled('Inês')
+ *   .whoCan(BrowseTheWebWithPlaywright.using(browser))
+ *   .attemptsTo(
+ *     Navigate.to(`https://serenity-js.org`),
+ *     ClearLocalStorage(), // reported as "Inês clears local storage"
+ *   )
+ * ```
+ *
+ * @group Screenplay Pattern
+ */
+export class Interaction extends Activity {
+    /**
+     * @param description
+     *  Description to be used when reporting this interaction, for example `#actor clears local storage`.
+     *  Note that `#actor` will be replaced with the name of the actor performing this interaction.
+     *
+     * @param interaction
+     */
+    static where(description, interaction) {
+        return new DynamicallyGeneratedInteraction(description, interaction);
+    }
+}
+/**
+ * @package
+ */
+class DynamicallyGeneratedInteraction extends Interaction {
+    interaction;
+    constructor(description, interaction) {
+        super(description, Interaction.callerLocation(4));
+        this.interaction = interaction;
+    }
+    performAs(actor) {
+        try {
+            return Promise.resolve(this.interaction(actor));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+}
+//# sourceMappingURL=Interaction.js.map

package/esm/screenplay/Interaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Interaction.js","sourceRoot":"","sources":["../../src/screenplay/Interaction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAM,OAAgB,WAAY,SAAQ,QAAQ;IAE9C;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CACR,WAA+B,EAC/B,WAAkG;QAElG,OAAO,IAAI,+BAA+B,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IACzE,CAAC;CAcJ;AAED;;GAEG;AACH,MAAM,+BAAgC,SAAQ,WAAW;IAGhC;IAFrB,YACI,WAA+B,EACd,WAAkG;QAEnH,KAAK,CAAC,WAAW,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAFjC,gBAAW,GAAX,WAAW,CAAuF;IAGvH,CAAC;IAED,SAAS,CAAC,KAA2D;QACjE,IAAI,CAAC;YACD,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;QACpD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;IACL,CAAC;CACJ"}

package/esm/screenplay/Optional.d.ts

@@ -0,0 +1,26 @@
+import type { Answerable } from './Answerable.js';
+/**
+ * `Optional` is a container object, which holds a value that may or may not be "present",
+ *
+ * The meaning of being "present" depends on the context and typically means a value that:
+ * - is other than `null` or `undefined`
+ * - is retrievable, so retrieving it doesn't throw any errors
+ *
+ * Additionally, `Optional` can also have a context-specific meaning. For example, `Optional#isPresent()`:
+ * - in the context of a `PageElement` means that the element exists in the DOM.
+ * - in the context of a `ModalWindow` means that the modal window is open.
+ * - in the case of a REST API response, `LastResponse.body().books[0].author.name.isPresent()`
+ *   will inform us if a given entry exists (so `books[0].author.name`),
+ *   and if all the links of the property chain leading to the entry of interest exist too
+ *   (so `books` is present, and so is `books[0]`, `books[0].author`, `books[0].author.name`).
+ *
+ * @group Questions
+ */
+export interface Optional {
+    /**
+     * Returns an [`Answerable`](https://serenity-js.org/api/core/#Answerable) that resolves to `true` when the optional value
+     * is present, `false` otherwise.
+     */
+    isPresent(): Answerable<boolean>;
+}
+//# sourceMappingURL=Optional.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Optional.d.ts","sourceRoot":"","sources":["../../src/screenplay/Optional.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,QAAQ;IACrB;;;OAGG;IACH,SAAS,IAAI,UAAU,CAAC,OAAO,CAAC,CAAC;CACpC"}

package/esm/screenplay/Optional.js

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

package/esm/screenplay/Optional.js.map

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

package/esm/screenplay/Question.d.ts

@@ -0,0 +1,349 @@
+import util from 'node:util';
+import type { FileSystemLocation } from '../io/index.js';
+import type { UsesAbilities } from './abilities/index.js';
+import type { Answerable } from './Answerable.js';
+import { Interaction } from './Interaction.js';
+import type { Optional } from './Optional.js';
+import type { AnswersQuestions } from './questions/AnswersQuestions.js';
+import { Describable } from './questions/Describable.js';
+import type { DescriptionFormattingOptions } from './questions/DescriptionFormattingOptions.js';
+import type { MetaQuestion } from './questions/MetaQuestion.js';
+import type { RecursivelyAnswered } from './RecursivelyAnswered.js';
+import type { WithAnswerableProperties } from './WithAnswerableProperties.js';
+/**
+ * **Questions** describe how [actors](https://serenity-js.org/api/core/class/Actor/) should query the system under test or the test environment to retrieve some information.
+ *
+ * Questions are the core building block of the [Screenplay Pattern](https://serenity-js.org/handbook/design/screenplay-pattern),
+ * along with [actors](https://serenity-js.org/api/core/class/Actor/), [abilities](https://serenity-js.org/api/core/class/Ability/),
+ * [interactions](https://serenity-js.org/api/core/class/Interaction/),
+ * and [tasks](https://serenity-js.org/api/core/class/Task/).
+ *
+ * ![Screenplay Pattern](https://serenity-js.org/images/design/serenity-js-screenplay-pattern.png)
+ *
+ * Learn more about:
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ * - [`Ability`](https://serenity-js.org/api/core/class/Ability/)
+ * - [`Interaction`](https://serenity-js.org/api/core/class/Interaction/)
+ * - [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter)
+ *
+ * ## Implementing a basic custom Question
+ *
+ * ```ts
+ *  import { actorCalled, AnswersQuestions, UsesAbilities, Question } from '@serenity-js/core'
+ *  import { Ensure, equals } from '@serenity-js/assertions'
+ *
+ *  const LastItemOf = <T>(list: T[]): Question<T> =>
+ *    Question.about('last item from the list', (actor: AnswersQuestions & UsesAbilities) => {
+ *      return list[list.length - 1]
+ *    });
+ *
+ *  await actorCalled('Quentin').attemptsTo(
+ *    Ensure.that(LastItemOf([1,2,3]), equals(3)),
+ *  )
+ * ```
+ *
+ * ## Implementing a Question that uses an Ability
+ *
+ * Just like the [interactions](https://serenity-js.org/api/core/class/Interaction/), a [`Question`](https://serenity-js.org/api/core/class/Question/)
+ * also can use [actor's](https://serenity-js.org/api/core/class/Actor/) [abilities](https://serenity-js.org/api/core/class/Ability/).
+ *
+ * Here, we use the ability to [`CallAnApi`](https://serenity-js.org/api/rest/class/CallAnApi/) to retrieve a property of
+ * an HTTP response.
+ *
+ * ```ts
+ *  import { AnswersQuestions, UsesAbilities, Question } from '@serenity-js/core'
+ *  import { CallAnApi } from '@serenity-js/rest'
+ *
+ *  const TextOfLastResponseStatus = () =>
+ *    Question.about<number>(`the text of the last response status`, actor => {
+ *      return CallAnApi.as(actor).mapLastResponse(response => response.statusText)
+ *    })
+ * ```
+ *
+ * #### Learn more
+ * - [`CallAnApi`](https://serenity-js.org/api/rest/class/CallAnApi/)
+ * - [`LastResponse`](https://serenity-js.org/api/rest/class/LastResponse/)
+ *
+ * ## Mapping answers to other questions
+ *
+ * Apart from retrieving information, [questions](https://serenity-js.org/api/core/class/Question/) can be used to transform information retrieved by other questions.
+ *
+ * Here, we use the factory method [`Question.about`](https://serenity-js.org/api/core/class/Question/#about) to produce a question that makes the received [actor](https://serenity-js.org/api/core/class/Actor/)
+ * answer [`LastResponse.status`](https://serenity-js.org/api/rest/class/LastResponse/#status) and then compare it against some expected value.
+ *
+ * ```ts
+ * import { actorCalled, AnswersQuestions, UsesAbilities, Question } from '@serenity-js/core'
+ * import { CallAnApi, LastResponse } from '@serenity-js/rest'
+ * import { Ensure, equals } from '@serenity-js/assertions'
+ *
+ * const RequestWasSuccessful = () =>
+ *   Question.about<number>(`the text of the last response status`, async actor => {
+ *     const status = await actor.answer(LastResponse.status());
+ *
+ *     return status === 200;
+ *   })
+ *
+ * await actorCalled('Quentin')
+ *   .whoCan(CallAnApi.at('https://api.example.org/'));
+ *   .attemptsTo(
+ *     Send.a(GetRequest.to('/books/0-688-00230-7')),
+ *     Ensure.that(RequestWasSuccessful(), isTrue()),
+ *   )
+ * ```
+ *
+ * Note that the above example is for demonstration purposes only, Serenity/JS provides an easier way to
+ * verify the response status of the [`LastResponse`](https://serenity-js.org/api/rest/class/LastResponse/):
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { CallAnApi, LastResponse } from '@serenity-js/rest'
+ * import { Ensure, equals } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Quentin')
+ *   .whoCan(CallAnApi.at('https://api.example.org/'));
+ *   .attemptsTo(
+ *     Send.a(GetRequest.to('/books/0-688-00230-7')),
+ *     Ensure.that(LastResponse.status(), equals(200)),
+ *   )
+ * ```
+ *
+ * @group Screenplay Pattern
+ */
+export declare abstract class Question<T> extends Describable {
+    /**
+     * Factory method that simplifies the process of defining custom questions.
+     *
+     * #### Defining a custom question
+     *
+     * ```ts
+     * import { Question } from '@serenity-js/core'
+     *
+     * const EnvVariable = (name: string) =>
+     *   Question.about(`the ${ name } env variable`, actor => process.env[name])
+     * ```
+     *
+     * @param description
+     * @param body
+     * @param [metaQuestionBody]
+     */
+    static about<Answer_Type, Supported_Context_Type>(description: Answerable<string>, body: (actor: AnswersQuestions & UsesAbilities) => Promise<Answer_Type> | Answer_Type, metaQuestionBody: (answerable: Answerable<Supported_Context_Type>) => Question<Promise<Answer_Type>> | Question<Answer_Type>): MetaQuestionAdapter<Supported_Context_Type, Awaited<Answer_Type>>;
+    static about<Answer_Type>(description: Answerable<string>, body: (actor: AnswersQuestions & UsesAbilities) => Promise<Answer_Type> | Answer_Type): QuestionAdapter<Awaited<Answer_Type>>;
+    /**
+     * Generates a [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter) that recursively resolves
+     * any [`Answerable`](https://serenity-js.org/api/core/#Answerable) fields of the provided object,
+     * including [`Answerable`](https://serenity-js.org/api/core/#Answerable) fields
+     * of [nested objects](https://serenity-js.org/api/core/#WithAnswerableProperties).
+     *
+     * Optionally, the method accepts `overrides` to be shallow-merged with the fields of the original `source`,
+     * producing a new merged object.
+     *
+     * Overrides are applied from left to right, with subsequent objects overwriting property assignments of the previous ones.
+     *
+     * #### Resolving an object recursively using `Question.fromObject`
+     *
+     * ```ts
+     * import { actorCalled, Question } from '@serenity-js/core'
+     * import { Send, PostRequest } from '@serenity-js/rest'
+     * import { By, Text, PageElement } from '@serenity-js/web'
+     *
+     * await actorCalled('Daisy')
+     *   .whoCan(CallAnApi.at('https://api.example.org'))
+     *   .attemptsTo(
+     *     Send.a(
+     *       PostRequest.to('/products/2')
+     *         .with(
+     *           Question.fromObject({
+     *             name: Text.of(PageElement.located(By.css('.name'))),
+     *           })
+     *         )
+     *       )
+     *   );
+     * ```
+     *
+     * #### Merging objects using `Question.fromObject`
+     *
+     * ```ts
+     *  import { actorCalled, Question } from '@serenity-js/core'
+     *  import { Send, PostRequest } from '@serenity-js/rest'
+     *  import { By, Text, PageElement } from '@serenity-js/web'
+     *
+     *  await actorCalled('Daisy')
+     *    .whoCan(CallAnApi.at('https://api.example.org'))
+     *    .attemptsTo(
+     *      Send.a(
+     *        PostRequest.to('/products/2')
+     *          .with(
+     *            Question.fromObject({
+     *              name: Text.of(PageElement.located(By.css('.name'))),
+     *              quantity: undefined,
+     *            }, {
+     *              quantity: 2,
+     *            })
+     *          )
+     *        )
+     *    );
+     * ```
+     *
+     * #### Learn more
+     * - [`WithAnswerableProperties`](https://serenity-js.org/api/core/#WithAnswerableProperties)
+     * - [`RecursivelyAnswered`](https://serenity-js.org/api/core/#RecursivelyAnswered)
+     * - [`Answerable`](https://serenity-js.org/api/core/#Answerable)
+     *
+     * @param source
+     * @param overrides
+     */
+    static fromObject<Source_Type extends object>(source: Answerable<WithAnswerableProperties<Source_Type>>, ...overrides: Array<Answerable<Partial<WithAnswerableProperties<Source_Type>>>>): QuestionAdapter<RecursivelyAnswered<Source_Type>>;
+    /**
+     * Generates a [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter) that resolves
+     * any [`Answerable`](https://serenity-js.org/api/core/#Answerable) elements of the provided array.
+     */
+    static fromArray<Source_Type>(source: Array<Answerable<Source_Type>>, options?: DescriptionFormattingOptions): QuestionAdapter<Source_Type[]>;
+    /**
+     * Checks if the value is a [`Question`](https://serenity-js.org/api/core/class/Question/).
+     *
+     * @param maybeQuestion
+     *  The value to check
+     */
+    static isAQuestion<T>(maybeQuestion: unknown): maybeQuestion is Question<T>;
+    /**
+     * Checks if the value is a [`MetaQuestion`](https://serenity-js.org/api/core/interface/MetaQuestion/).
+     *
+     * @param maybeMetaQuestion
+     *  The value to check
+     */
+    static isAMetaQuestion<CT, RQT extends Question<unknown>>(maybeMetaQuestion: unknown): maybeMetaQuestion is MetaQuestion<CT, RQT>;
+    /**
+     * Creates a [`MetaQuestion`](https://serenity-js.org/api/core/interface/MetaQuestion/) that can be composed with any [`Answerable`](https://serenity-js.org/api/core/#Answerable)
+     * to produce a single-line description of its value.
+     *
+     * ```ts
+     * import { actorCalled, Question } from '@serenity-js/core'
+     * import { Ensure, equals } from '@serenity-js/assertions'
+     *
+     * const accountDetails = () =>
+     *   Question.about('account details', actor => ({ name: 'Alice', age: 28 }))
+     *
+     * await actorCalled('Alice').attemptsTo(
+     *   Ensure.that(
+     *     Question.formattedValue().of(accountDetails()),
+     *     equals('{ name: "Alice", age: 28 }'),
+     *   ),
+     * )
+     * ```
+     *
+     * @param options
+     */
+    static formattedValue(options?: DescriptionFormattingOptions): MetaQuestion<any, Question<Promise<string>>>;
+    /**
+     * Creates a [`MetaQuestion`](https://serenity-js.org/api/core/interface/MetaQuestion/) that can be composed with any [`Answerable`](https://serenity-js.org/api/core/#Answerable)
+     * to return its value when the answerable is a [`Question`](https://serenity-js.org/api/core/class/Question/),
+     * or the answerable itself otherwise.
+     *
+     * The description of the resulting question is produced by calling [`Question.describedBy`](https://serenity-js.org/api/core/class/Question/#describedBy) on the
+     * provided answerable.
+     *
+     * ```ts
+     * import { actorCalled, Question } from '@serenity-js/core'
+     * import { Ensure, equals } from '@serenity-js/assertions'
+     *
+     * const accountDetails = () =>
+     *   Question.about('account details', actor => ({ name: 'Alice', age: 28 }))
+     *
+     * await actorCalled('Alice').attemptsTo(
+     *   Ensure.that(
+     *     Question.description().of(accountDetails()),
+     *     equals('account details'),
+     *   ),
+     *   Ensure.that(
+     *     Question.value().of(accountDetails()),
+     *     equals({ name: 'Alice', age: 28 }),
+     *   ),
+     * )
+     * ```
+     */
+    static value<Answer_Type>(): MetaQuestion<Answer_Type, Question<Promise<Answer_Type>>>;
+    protected static createAdapter<AT>(statement: Question<AT>): QuestionAdapter<Awaited<AT>>;
+    private static staticFieldDescription;
+    private static methodDescription;
+    /**
+     * Instructs the provided [`Actor`](https://serenity-js.org/api/core/class/Actor/) to use their [abilities](https://serenity-js.org/api/core/class/Ability/)
+     * to answer this question.
+     */
+    abstract answeredBy(actor: AnswersQuestions & UsesAbilities): T;
+    /**
+     * Changes the description of this object, as returned by [`Describable.describedBy`](https://serenity-js.org/api/core/class/Describable/#describedBy)
+     * and [`Describable.toString`](https://serenity-js.org/api/core/class/Describable/#toString).
+     *
+     * @param description
+     *  Replaces the current description according to the following rules:
+     *  - If `description` is an [`Answerable`](https://serenity-js.org/api/core/#Answerable), it replaces the current description
+     *  - If `description` is a [`MetaQuestion`](https://serenity-js.org/api/core/interface/MetaQuestion/), the current description is passed as `context` to `description.of(context)`, and the result replaces the current description
+     */
+    describedAs(description: Answerable<string> | MetaQuestion<Awaited<T>, Question<Promise<string>>>): this;
+    /**
+     * Maps this question to one of a different type.
+     *
+     * ```ts
+     * Question.about('number returned as string', actor => '42')   // returns: QuestionAdapter<string>
+     *   .as(Number)                                                // returns: QuestionAdapter<number>
+     * ```
+     *
+     * @param mapping
+     */
+    as<O>(mapping: (answer: Awaited<T>) => Promise<O> | O): QuestionAdapter<O>;
+}
+declare global {
+    interface ProxyConstructor {
+        new <Source_Type extends object, Target_Type extends object>(target: Source_Type, handler: ProxyHandler<Source_Type>): Target_Type;
+    }
+}
+/**
+ * Describes an object recursively wrapped in [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter) proxies, so that:
+ * - both methods and fields of the wrapped object can be used as [questions](https://serenity-js.org/api/core/class/Question/) or [interactions](https://serenity-js.org/api/core/class/Interaction/)
+ * - method parameters of the wrapped object will accept [`Answerable<T>`](https://serenity-js.org/api/core/#Answerable)
+ *
+ * @group Questions
+ */
+export type QuestionAdapterFieldDecorator<Original_Type> = {
+    [Field in keyof Omit<Original_Type, keyof QuestionStatement<Original_Type>>]: Original_Type[Field] extends (...args: infer OriginalParameters) => infer OriginalMethodResult ? Field extends 'replace' | 'replaceAll' ? (searchValue: Answerable<string | RegExp>, replaceValue: Answerable<string>) => QuestionAdapter<string> : (...args: {
+        [P in keyof OriginalParameters]: Answerable<Awaited<OriginalParameters[P]>>;
+    }) => QuestionAdapter<Awaited<OriginalMethodResult>> : Original_Type[Field] extends number | bigint | boolean | string | symbol | object ? QuestionAdapter<Awaited<Original_Type[Field]>> : any;
+};
+/**
+ * A union type representing a proxy object returned by [`Question.about`](https://serenity-js.org/api/core/class/Question/#about).
+ *
+ * [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter) proxies the methods and fields of the wrapped object recursively,
+ * allowing them to be used as either a [`Question`](https://serenity-js.org/api/core/class/Question/) or an [`Interaction`](https://serenity-js.org/api/core/class/Interaction/).
+ *
+ * @group Questions
+ */
+export type QuestionAdapter<Answer_Type> = Question<Promise<Answer_Type>> & Interaction & {
+    isPresent(): Question<Promise<boolean>>;
+} & QuestionAdapterFieldDecorator<Answer_Type>;
+/**
+ * An extension of [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter), that in addition to proxying methods and fields
+ * of the wrapped object can also act as a [`MetaQuestion`](https://serenity-js.org/api/core/interface/MetaQuestion/).
+ *
+ * @group Questions
+ */
+export type MetaQuestionAdapter<Context_Type, Answer_Type> = QuestionAdapter<Answer_Type> & MetaQuestion<Context_Type, QuestionAdapter<Answer_Type>>;
+/**
+ * @package
+ */
+declare class QuestionStatement<Answer_Type> extends Interaction implements Question<Promise<Answer_Type>>, Optional {
+    private readonly body;
+    private answer;
+    constructor(subject: Answerable<string>, body: (actor: AnswersQuestions & UsesAbilities, ...Parameters: any[]) => Promise<Answer_Type> | Answer_Type, location?: FileSystemLocation);
+    /**
+     * Returns a Question that resolves to `true` if resolving the `QuestionStatement`
+     * returns a value other than `null` or `undefined`, and doesn't throw errors.
+     */
+    isPresent(): Question<Promise<boolean>>;
+    answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<Answer_Type>;
+    performAs(actor: UsesAbilities & AnswersQuestions): Promise<void>;
+    [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string;
+    describedAs(description: Answerable<string> | MetaQuestion<Answer_Type, Question<Promise<string>>>): this;
+    as<O>(mapping: (answer: Awaited<Answer_Type>) => (Promise<O> | O)): QuestionAdapter<O>;
+}
+export {};
+//# sourceMappingURL=Question.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Question.d.ts","sourceRoot":"","sources":["../../src/screenplay/Question.ts"],"names":[],"mappings":"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"}