@serenity-js/core 3.25.0 → 3.25.2

package/lib/screenplay/abilities/Ability.d.ts

@@ -1,37 +1,38 @@
 import type { AbilityType } from './AbilityType';
 import type { UsesAbilities } from './UsesAbilities';
 /**
- * **Abilities** enable {@apilink Actor|actors}
- * to perform {@apilink Interaction|interactions} with the system under test
- * and answer {@apilink Question|questions} about its state.
+ * **Abilities** enable [actors](https://serenity-js.org/api/core/class/Actor/)
+ * to perform [interactions](https://serenity-js.org/api/core/class/Interaction/) with the system under test
+ * and answer [questions](https://serenity-js.org/api/core/class/Question/) about its state.
  *
  * From the technical perspective, **abilities** act as **wrappers** around any **integration libraries** required
  * to communicate with the external interfaces of system under test,
- * such as {@apilink BrowseTheWeb|web browser drivers} or an {@apilink CallAnApi|HTTP client}.
- * They also enable [portability](/handbook/design/portable-test-code)
+ * such as [web browser drivers](https://serenity-js.org/api/web/class/BrowseTheWeb/) or an [HTTP client](https://serenity-js.org/api/rest/class/CallAnApi/).
+ * They also enable [portability](https://serenity-js.org/handbook/design/portable-test-code)
  * of your test code across such integration libraries.
  *
- * Abilities are the core building block of the [Screenplay Pattern](/handbook/design/screenplay-pattern),
- * along with {@apilink Actor|Actors}, {@apilink Interaction|Interactions}, {@apilink Question|Questions}, and {@apilink Task|Tasks}.
+ * Abilities 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/), [interactions](https://serenity-js.org/api/core/class/Interaction/),
+ * [questions](https://serenity-js.org/api/core/class/Question/), and [tasks](https://serenity-js.org/api/core/class/Task/).
  *
- * ![Screenplay Pattern](/images/design/serenity-js-screenplay-pattern.png)
+ * ![Screenplay Pattern](https://serenity-js.org/images/design/serenity-js-screenplay-pattern.png)
  *
  * Learn more about:
- * - {@apilink Actor|Actors}
- * - {@apilink Cast|Configuring actors using Casts}
- * - {@apilink Interaction|Interactions}
- * - {@apilink Question|Questions}
- * - [Web testing](/handbook/web-testing/)
- * - [API testing](/handbook/api-testing/)
- * - [Mobile testing](/handbook/mobile-testing/)
+ * - [Actors](https://serenity-js.org/api/core/class/Actor/)
+ * - [Configuring actors using Casts](https://serenity-js.org/api/core/class/Cast/)
+ * - [Interactions](https://serenity-js.org/api/core/class/Interaction/)
+ * - [Questions](https://serenity-js.org/api/core/class/Question/)
+ * - [Web testing](https://serenity-js.org/handbook/web-testing/)
+ * - [API testing](https://serenity-js.org/handbook/api-testing/)
+ * - [Mobile testing](https://serenity-js.org/handbook/mobile-testing/)
  *
  * ## Giving actors the abilities to interact
  *
  * Serenity/JS actors are capable of interacting with **any interface** of the system under test,
- * be it a [web UI](/handbook/web-testing/), a [mobile app](/handbook/mobile-testing/), a [web service](/handbook/api-testing/),
- * or {@apilink Ability|anything else} that a Node.js program can talk to.
+ * be it a [web UI](https://serenity-js.org/handbook/web-testing/), a [mobile app](https://serenity-js.org/handbook/mobile-testing/), a [web service](https://serenity-js.org/handbook/api-testing/),
+ * or [anything else](https://serenity-js.org/api/core/class/Ability/) that a Node.js program can talk to.
  * This flexibility is enabled by a mechanism called _**abilities**_
- * and achieved without introducing any unnecessary dependencies to your code base thanks to the [modular architecture](/handbook/about/architecture) of Serenity/JS.
+ * and achieved without introducing any unnecessary dependencies to your code base thanks to the [modular architecture](https://serenity-js.org/handbook/getting-started/architecture) of Serenity/JS.
  *
  * :::tip Remember
  * **Actors** have **abilities** that enable them to **perform interactions** and **answer questions**.
@@ -40,18 +41,18 @@ import type { UsesAbilities } from './UsesAbilities';
  * From the technical perspective, an **ability** is an [adapter](https://en.wikipedia.org/wiki/Adapter_pattern)
  * around an interface-specific integration library, such as a web browser driver, an HTTP client, a database client, and so on.
  * You give an actor an ability, and it's the ability's responsibility to provide a consistent API around the integration library and deal with any of its quirks.
- * Abilities **encapsulate integration libraries** and handle their {@apilink Initialisable|configuration and initialisation},
- * the process of {@apilink Discardable|freeing up any resources} they hold,
+ * Abilities **encapsulate integration libraries** and handle their [configuration and initialisation](https://serenity-js.org/api/core/interface/Initialisable/),
+ * the process of [freeing up any resources](https://serenity-js.org/api/core/interface/Discardable/) they hold,
  * as well as managing any state associated with the library.
  *
  * ### Portable interactions with web interfaces
  *
  * To make your Serenity/JS actors interact with web interfaces,
- * you call the [`Actor.whoCan`](/api/core/class/Actor#whoCan) method and give them an implementation of the ability to [`BrowseTheWeb`](/api/web/class/BrowseTheWeb),
+ * you call the [`Actor.whoCan`](https://serenity-js.org/api/core/class/Actor#whoCan) method and give them an implementation of the ability to [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb),
  * specific to your web integration tool of choice.
  *
- * Note how {@apilink BrowseTheWebWithPlaywright}, {@apilink BrowseTheWebWithWebdriverIO}, and {@apilink BrowseTheWebWithProtractor}
- * all **extend** the base ability to {@apilink BrowseTheWeb}.
+ * Note how [`BrowseTheWebWithPlaywright`](https://serenity-js.org/api/playwright/class/BrowseTheWebWithPlaywright/), [`BrowseTheWebWithWebdriverIO`](https://serenity-js.org/api/webdriverio/class/BrowseTheWebWithWebdriverIO/), and [`BrowseTheWebWithProtractor`](https://serenity-js.org/api/protractor/class/BrowseTheWebWithProtractor/)
+ * all **extend** the base ability to [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb/).
  *
  * #### Playwright
  *
@@ -89,10 +90,10 @@ import type { UsesAbilities } from './UsesAbilities';
  *
  * ### Retrieving an ability
  *
- * Use {@apilink Ability.as} to retrieve an ability in a custom {@apilink Interaction} or {@apilink Question} implementation.
+ * Use [`PerformActivities`](https://serenity-js.org/api/core/class/PerformActivities/)} to retrieve an ability in a custom [`Interaction`](https://serenity-js.org/api/core/class/Interaction/) or [`Question`](https://serenity-js.org/api/core/class/Question/) implementation.
  *
- * Here, `Ability` can be the integration library-specific class, for example {@apilink BrowseTheWebWithPlaywright},
- * or its library-agnostic parent class, like {@apilink BrowseTheWeb}.
+ * Here, `Ability` can be the integration library-specific class, for example [`BrowseTheWebWithPlaywright`](https://serenity-js.org/api/playwright/class/BrowseTheWebWithPlaywright/),
+ * or its library-agnostic parent class, like [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb/).
  *
  * To make your code portable across the various integration libraries, retrieve the ability
  * using the library-agnostic parent class:
@@ -109,15 +110,15 @@ import type { UsesAbilities } from './UsesAbilities';
  *
  * Another reason is that the Serenity/JS implementation of the Screenplay Pattern lets you **completely decouple the actor from the integration libraries**
  * and make the abilities of the same type **interchangeable**.
- * For example, [Serenity/JS web modules](/handbook/web-testing/serenity-js-web-modules) offer an abstraction that lets you switch between web integration libraries
+ * For example, [Serenity/JS web modules](https://serenity-js.org/handbook/web-testing/serenity-js-web-modules) offer an abstraction that lets you switch between web integration libraries
  * as vastly different as Selenium, WebdriverIO, or Playwright without having to change _anything whatsoever_ in your test scenarios.
  *
- * What this means is that your test code can become [portable and reusable across projects and teams](/handbook/design/portable-test-code),
+ * What this means is that your test code can become [portable and reusable across projects and teams](https://serenity-js.org/handbook/design/portable-test-code),
  * even if they don't use the same low-level integration tools. It also helps you to **avoid vendor lock-in**, as you can wrap any third-party integration library
  * into an ability and swap it out for another implementation if you need to.
  *
  * However, Serenity/JS **doesn't prevent you** from using the integration libraries directly.
- * When you need to, you can use a library-specific ability like {@apilink BrowseTheWebWithPlaywright}
+ * When you need to, you can use a library-specific ability like [`BrowseTheWebWithPlaywright`](https://serenity-js.org/api/playwright/class/BrowseTheWebWithPlaywright/)
  * to trade portability for access to library-specific low-level methods:
  *
  * ```typescript
@@ -140,7 +141,7 @@ import type { UsesAbilities } from './UsesAbilities';
  * ## Associating actors with data
  *
  * One more reason to use abilities is that abilities can also help you to **associate actors with data** they need to perform their activities.
- * For example, a commonly used ability is one to [`TakeNotes`](/api/core/class/TakeNotes), which allows your actors to start the test scenario
+ * For example, a commonly used ability is one to [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes), which allows your actors to start the test scenario
  * equipped with some data set, or record information about what they see in the test scenario so that they can act upon it later:
  *
  * ```typescript
@@ -165,7 +166,7 @@ import type { UsesAbilities } from './UsesAbilities';
  * ## Actors with multiple abilities
  *
  * Of course, an actor can have **any number of abilities** they need to play their role.
- * For example, it is quite common for an actor to be able to [`BrowseTheWeb`](/api/web/class/BrowseTheWeb), [`TakeNotes`](/api/core/class/TakeNotes), and [`CallAnApi`](/api/rest/class/CallAnApi):
+ * For example, it is quite common for an actor to be able to [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb), [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes), and [`CallAnApi`](https://serenity-js.org/api/rest/class/CallAnApi):
  *
  * ```typescript
  * import { actorCalled, Notepad, TakeNotes } from '@serenity-js/core'
@@ -197,17 +198,17 @@ import type { UsesAbilities } from './UsesAbilities';
  * ## Writing custom abilities
  *
  * If your system under test provides a type of interface that Serenity/JS doesn't support yet,
- * you might want to implement a custom {@apilink Ability}, as well as {@apilink Interaction|interactions}
- * and {@apilink Question|questions} to interact with it.
+ * you might want to implement a custom [`Ability`](https://serenity-js.org/api/core/class/Ability/), as well as [interactions](https://serenity-js.org/api/core/class/Interaction/)
+ * and [questions](https://serenity-js.org/api/core/class/Question/) to interact with it.
  *
- * The best way to start with that is for you to review the examples in the {@apilink Ability|Screenplay Pattern API docs},
+ * The best way to start with that is for you to review the examples in the [Screenplay Pattern API docs](https://serenity-js.org/api/core/class/Ability/),
  * as well as the [Serenity/JS code base on GitHub](https://github.com/serenity-js/serenity-js/tree/main/packages).
- * Also note that all the [Serenity/JS modules](/handbook/about/architecture)
+ * Also note that all the [Serenity/JS modules](https://serenity-js.org/handbook/getting-started/architecture)
  * have their automated tests written in such a way to not only provide an **extremely high test coverage** for the framework itself,
  * but to be **accessible** and act as a **reference implementation for you** to create your own integrations.
  *
  * If you believe that the custom integration you've developed could benefit the wider Serenity/JS community,
- * please consider open-sourcing it yourself, or [contributing it](/contributing) to the main framework.
+ * please consider open-sourcing it yourself, or [contributing it](https://serenity-js.org/community/contributing/) to the main framework.
  *
  * [![Join Serenity/JS Community Chat](https://img.shields.io/badge/Chat-Serenity%2FJS%20Community-FBD30B?logo=matrix)](https://matrix.to/#/#serenity-js:gitter.im)
  *
@@ -265,8 +266,9 @@ import type { UsesAbilities } from './UsesAbilities';
  * ## Using auto-initialisable and auto-discardable abilities
  *
  * Abilities that rely on resources that need to be initialised before they can be used,
- * or discarded before the actor is dismissed can implement the {@apilink Initialisable}
- * or {@apilink Discardable} interfaces, respectively.
+ * or discarded before the actor is dismissed can implement
+ * the [`Initialisable`](https://serenity-js.org/api/core/interface/Initialisable/)
+ * or [`Discardable`](https://serenity-js.org/api/core/interface/Discardable/) interfaces, respectively.
  *
  * ### Defining a custom ability to `QueryPostgresDB`
  *
@@ -347,19 +349,19 @@ import type { UsesAbilities } from './UsesAbilities';
  * ```
  *
  * ## Learn more
- * - {@apilink AbilityType}
- * - {@apilink Initialisable}
- * - {@apilink Discardable}
- * - {@apilink BrowseTheWeb}
- * - {@apilink CallAnApi}
- * - {@apilink TakeNotes}
+ * - [`AbilityType`](https://serenity-js.org/api/core/#AbilityType)
+ * - [`Initialisable`](https://serenity-js.org/api/core/interface/Initialisable/)
+ * - [`Discardable`](https://serenity-js.org/api/core/interface/Discardable/)
+ * - [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb/)
+ * - [`CallAnApi`](https://serenity-js.org/api/rest/class/CallAnApi/)
+ * - [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes/)
  *
  * @group Screenplay Pattern
  */
 export declare abstract class Ability {
     /**
-     * Used to access an {@apilink Actor|actor's} {@apilink Ability|ability} of the given type
-     * from within the {@apilink Interaction} and {@apilink Question} classes.
+     * Used to access an [actor's](https://serenity-js.org/api/core/class/Actor/) [ability](https://serenity-js.org/api/core/class/Ability/) of the given type
+     * from within the [`Interaction`](https://serenity-js.org/api/core/class/Interaction/) and [`Question`](https://serenity-js.org/api/core/class/Question/) classes.
      *
      * #### Retrieving an ability in an interaction definition
      *

package/lib/screenplay/abilities/Ability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ability.d.ts","sourceRoot":"","sources":["../../../src/screenplay/abilities/Ability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmWG;AACH,8BAAsB,OAAO;IAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,OAAO,EACvB,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,aAAa,GACrB,CAAC;CAGP"}
+{"version":3,"file":"Ability.d.ts","sourceRoot":"","sources":["../../../src/screenplay/abilities/Ability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqWG;AACH,8BAAsB,OAAO;IAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,OAAO,EACvB,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,aAAa,GACrB,CAAC;CAGP"}

package/lib/screenplay/abilities/Ability.js

@@ -2,37 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ability = void 0;
 /**
- * **Abilities** enable {@apilink Actor|actors}
- * to perform {@apilink Interaction|interactions} with the system under test
- * and answer {@apilink Question|questions} about its state.
+ * **Abilities** enable [actors](https://serenity-js.org/api/core/class/Actor/)
+ * to perform [interactions](https://serenity-js.org/api/core/class/Interaction/) with the system under test
+ * and answer [questions](https://serenity-js.org/api/core/class/Question/) about its state.
  *
  * From the technical perspective, **abilities** act as **wrappers** around any **integration libraries** required
  * to communicate with the external interfaces of system under test,
- * such as {@apilink BrowseTheWeb|web browser drivers} or an {@apilink CallAnApi|HTTP client}.
- * They also enable [portability](/handbook/design/portable-test-code)
+ * such as [web browser drivers](https://serenity-js.org/api/web/class/BrowseTheWeb/) or an [HTTP client](https://serenity-js.org/api/rest/class/CallAnApi/).
+ * They also enable [portability](https://serenity-js.org/handbook/design/portable-test-code)
  * of your test code across such integration libraries.
  *
- * Abilities are the core building block of the [Screenplay Pattern](/handbook/design/screenplay-pattern),
- * along with {@apilink Actor|Actors}, {@apilink Interaction|Interactions}, {@apilink Question|Questions}, and {@apilink Task|Tasks}.
+ * Abilities 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/), [interactions](https://serenity-js.org/api/core/class/Interaction/),
+ * [questions](https://serenity-js.org/api/core/class/Question/), and [tasks](https://serenity-js.org/api/core/class/Task/).
  *
- * ![Screenplay Pattern](/images/design/serenity-js-screenplay-pattern.png)
+ * ![Screenplay Pattern](https://serenity-js.org/images/design/serenity-js-screenplay-pattern.png)
  *
  * Learn more about:
- * - {@apilink Actor|Actors}
- * - {@apilink Cast|Configuring actors using Casts}
- * - {@apilink Interaction|Interactions}
- * - {@apilink Question|Questions}
- * - [Web testing](/handbook/web-testing/)
- * - [API testing](/handbook/api-testing/)
- * - [Mobile testing](/handbook/mobile-testing/)
+ * - [Actors](https://serenity-js.org/api/core/class/Actor/)
+ * - [Configuring actors using Casts](https://serenity-js.org/api/core/class/Cast/)
+ * - [Interactions](https://serenity-js.org/api/core/class/Interaction/)
+ * - [Questions](https://serenity-js.org/api/core/class/Question/)
+ * - [Web testing](https://serenity-js.org/handbook/web-testing/)
+ * - [API testing](https://serenity-js.org/handbook/api-testing/)
+ * - [Mobile testing](https://serenity-js.org/handbook/mobile-testing/)
  *
  * ## Giving actors the abilities to interact
  *
  * Serenity/JS actors are capable of interacting with **any interface** of the system under test,
- * be it a [web UI](/handbook/web-testing/), a [mobile app](/handbook/mobile-testing/), a [web service](/handbook/api-testing/),
- * or {@apilink Ability|anything else} that a Node.js program can talk to.
+ * be it a [web UI](https://serenity-js.org/handbook/web-testing/), a [mobile app](https://serenity-js.org/handbook/mobile-testing/), a [web service](https://serenity-js.org/handbook/api-testing/),
+ * or [anything else](https://serenity-js.org/api/core/class/Ability/) that a Node.js program can talk to.
  * This flexibility is enabled by a mechanism called _**abilities**_
- * and achieved without introducing any unnecessary dependencies to your code base thanks to the [modular architecture](/handbook/about/architecture) of Serenity/JS.
+ * and achieved without introducing any unnecessary dependencies to your code base thanks to the [modular architecture](https://serenity-js.org/handbook/getting-started/architecture) of Serenity/JS.
  *
  * :::tip Remember
  * **Actors** have **abilities** that enable them to **perform interactions** and **answer questions**.
@@ -41,18 +42,18 @@ exports.Ability = void 0;
  * From the technical perspective, an **ability** is an [adapter](https://en.wikipedia.org/wiki/Adapter_pattern)
  * around an interface-specific integration library, such as a web browser driver, an HTTP client, a database client, and so on.
  * You give an actor an ability, and it's the ability's responsibility to provide a consistent API around the integration library and deal with any of its quirks.
- * Abilities **encapsulate integration libraries** and handle their {@apilink Initialisable|configuration and initialisation},
- * the process of {@apilink Discardable|freeing up any resources} they hold,
+ * Abilities **encapsulate integration libraries** and handle their [configuration and initialisation](https://serenity-js.org/api/core/interface/Initialisable/),
+ * the process of [freeing up any resources](https://serenity-js.org/api/core/interface/Discardable/) they hold,
  * as well as managing any state associated with the library.
  *
  * ### Portable interactions with web interfaces
  *
  * To make your Serenity/JS actors interact with web interfaces,
- * you call the [`Actor.whoCan`](/api/core/class/Actor#whoCan) method and give them an implementation of the ability to [`BrowseTheWeb`](/api/web/class/BrowseTheWeb),
+ * you call the [`Actor.whoCan`](https://serenity-js.org/api/core/class/Actor#whoCan) method and give them an implementation of the ability to [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb),
  * specific to your web integration tool of choice.
  *
- * Note how {@apilink BrowseTheWebWithPlaywright}, {@apilink BrowseTheWebWithWebdriverIO}, and {@apilink BrowseTheWebWithProtractor}
- * all **extend** the base ability to {@apilink BrowseTheWeb}.
+ * Note how [`BrowseTheWebWithPlaywright`](https://serenity-js.org/api/playwright/class/BrowseTheWebWithPlaywright/), [`BrowseTheWebWithWebdriverIO`](https://serenity-js.org/api/webdriverio/class/BrowseTheWebWithWebdriverIO/), and [`BrowseTheWebWithProtractor`](https://serenity-js.org/api/protractor/class/BrowseTheWebWithProtractor/)
+ * all **extend** the base ability to [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb/).
  *
  * #### Playwright
  *
@@ -90,10 +91,10 @@ exports.Ability = void 0;
  *
  * ### Retrieving an ability
  *
- * Use {@apilink Ability.as} to retrieve an ability in a custom {@apilink Interaction} or {@apilink Question} implementation.
+ * Use [`PerformActivities`](https://serenity-js.org/api/core/class/PerformActivities/)} to retrieve an ability in a custom [`Interaction`](https://serenity-js.org/api/core/class/Interaction/) or [`Question`](https://serenity-js.org/api/core/class/Question/) implementation.
  *
- * Here, `Ability` can be the integration library-specific class, for example {@apilink BrowseTheWebWithPlaywright},
- * or its library-agnostic parent class, like {@apilink BrowseTheWeb}.
+ * Here, `Ability` can be the integration library-specific class, for example [`BrowseTheWebWithPlaywright`](https://serenity-js.org/api/playwright/class/BrowseTheWebWithPlaywright/),
+ * or its library-agnostic parent class, like [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb/).
  *
  * To make your code portable across the various integration libraries, retrieve the ability
  * using the library-agnostic parent class:
@@ -110,15 +111,15 @@ exports.Ability = void 0;
  *
  * Another reason is that the Serenity/JS implementation of the Screenplay Pattern lets you **completely decouple the actor from the integration libraries**
  * and make the abilities of the same type **interchangeable**.
- * For example, [Serenity/JS web modules](/handbook/web-testing/serenity-js-web-modules) offer an abstraction that lets you switch between web integration libraries
+ * For example, [Serenity/JS web modules](https://serenity-js.org/handbook/web-testing/serenity-js-web-modules) offer an abstraction that lets you switch between web integration libraries
  * as vastly different as Selenium, WebdriverIO, or Playwright without having to change _anything whatsoever_ in your test scenarios.
  *
- * What this means is that your test code can become [portable and reusable across projects and teams](/handbook/design/portable-test-code),
+ * What this means is that your test code can become [portable and reusable across projects and teams](https://serenity-js.org/handbook/design/portable-test-code),
  * even if they don't use the same low-level integration tools. It also helps you to **avoid vendor lock-in**, as you can wrap any third-party integration library
  * into an ability and swap it out for another implementation if you need to.
  *
  * However, Serenity/JS **doesn't prevent you** from using the integration libraries directly.
- * When you need to, you can use a library-specific ability like {@apilink BrowseTheWebWithPlaywright}
+ * When you need to, you can use a library-specific ability like [`BrowseTheWebWithPlaywright`](https://serenity-js.org/api/playwright/class/BrowseTheWebWithPlaywright/)
  * to trade portability for access to library-specific low-level methods:
  *
  * ```typescript
@@ -141,7 +142,7 @@ exports.Ability = void 0;
  * ## Associating actors with data
  *
  * One more reason to use abilities is that abilities can also help you to **associate actors with data** they need to perform their activities.
- * For example, a commonly used ability is one to [`TakeNotes`](/api/core/class/TakeNotes), which allows your actors to start the test scenario
+ * For example, a commonly used ability is one to [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes), which allows your actors to start the test scenario
  * equipped with some data set, or record information about what they see in the test scenario so that they can act upon it later:
  *
  * ```typescript
@@ -166,7 +167,7 @@ exports.Ability = void 0;
  * ## Actors with multiple abilities
  *
  * Of course, an actor can have **any number of abilities** they need to play their role.
- * For example, it is quite common for an actor to be able to [`BrowseTheWeb`](/api/web/class/BrowseTheWeb), [`TakeNotes`](/api/core/class/TakeNotes), and [`CallAnApi`](/api/rest/class/CallAnApi):
+ * For example, it is quite common for an actor to be able to [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb), [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes), and [`CallAnApi`](https://serenity-js.org/api/rest/class/CallAnApi):
  *
  * ```typescript
  * import { actorCalled, Notepad, TakeNotes } from '@serenity-js/core'
@@ -198,17 +199,17 @@ exports.Ability = void 0;
  * ## Writing custom abilities
  *
  * If your system under test provides a type of interface that Serenity/JS doesn't support yet,
- * you might want to implement a custom {@apilink Ability}, as well as {@apilink Interaction|interactions}
- * and {@apilink Question|questions} to interact with it.
+ * you might want to implement a custom [`Ability`](https://serenity-js.org/api/core/class/Ability/), as well as [interactions](https://serenity-js.org/api/core/class/Interaction/)
+ * and [questions](https://serenity-js.org/api/core/class/Question/) to interact with it.
  *
- * The best way to start with that is for you to review the examples in the {@apilink Ability|Screenplay Pattern API docs},
+ * The best way to start with that is for you to review the examples in the [Screenplay Pattern API docs](https://serenity-js.org/api/core/class/Ability/),
  * as well as the [Serenity/JS code base on GitHub](https://github.com/serenity-js/serenity-js/tree/main/packages).
- * Also note that all the [Serenity/JS modules](/handbook/about/architecture)
+ * Also note that all the [Serenity/JS modules](https://serenity-js.org/handbook/getting-started/architecture)
  * have their automated tests written in such a way to not only provide an **extremely high test coverage** for the framework itself,
  * but to be **accessible** and act as a **reference implementation for you** to create your own integrations.
  *
  * If you believe that the custom integration you've developed could benefit the wider Serenity/JS community,
- * please consider open-sourcing it yourself, or [contributing it](/contributing) to the main framework.
+ * please consider open-sourcing it yourself, or [contributing it](https://serenity-js.org/community/contributing/) to the main framework.
  *
  * [![Join Serenity/JS Community Chat](https://img.shields.io/badge/Chat-Serenity%2FJS%20Community-FBD30B?logo=matrix)](https://matrix.to/#/#serenity-js:gitter.im)
  *
@@ -266,8 +267,9 @@ exports.Ability = void 0;
  * ## Using auto-initialisable and auto-discardable abilities
  *
  * Abilities that rely on resources that need to be initialised before they can be used,
- * or discarded before the actor is dismissed can implement the {@apilink Initialisable}
- * or {@apilink Discardable} interfaces, respectively.
+ * or discarded before the actor is dismissed can implement
+ * the [`Initialisable`](https://serenity-js.org/api/core/interface/Initialisable/)
+ * or [`Discardable`](https://serenity-js.org/api/core/interface/Discardable/) interfaces, respectively.
  *
  * ### Defining a custom ability to `QueryPostgresDB`
  *
@@ -348,19 +350,19 @@ exports.Ability = void 0;
  * ```
  *
  * ## Learn more
- * - {@apilink AbilityType}
- * - {@apilink Initialisable}
- * - {@apilink Discardable}
- * - {@apilink BrowseTheWeb}
- * - {@apilink CallAnApi}
- * - {@apilink TakeNotes}
+ * - [`AbilityType`](https://serenity-js.org/api/core/#AbilityType)
+ * - [`Initialisable`](https://serenity-js.org/api/core/interface/Initialisable/)
+ * - [`Discardable`](https://serenity-js.org/api/core/interface/Discardable/)
+ * - [`BrowseTheWeb`](https://serenity-js.org/api/web/class/BrowseTheWeb/)
+ * - [`CallAnApi`](https://serenity-js.org/api/rest/class/CallAnApi/)
+ * - [`TakeNotes`](https://serenity-js.org/api/core/class/TakeNotes/)
  *
  * @group Screenplay Pattern
  */
 class Ability {
     /**
-     * Used to access an {@apilink Actor|actor's} {@apilink Ability|ability} of the given type
-     * from within the {@apilink Interaction} and {@apilink Question} classes.
+     * Used to access an [actor's](https://serenity-js.org/api/core/class/Actor/) [ability](https://serenity-js.org/api/core/class/Ability/) of the given type
+     * from within the [`Interaction`](https://serenity-js.org/api/core/class/Interaction/) and [`Question`](https://serenity-js.org/api/core/class/Question/) classes.
      *
      * #### Retrieving an ability in an interaction definition
      *

package/lib/screenplay/abilities/Ability.js.map

@@ -1 +1 @@
-{"version":3,"file":"Ability.js","sourceRoot":"","sources":["../../../src/screenplay/abilities/Ability.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmWG;AACH,MAAsB,OAAO;IAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,MAAM,CAAC,EAAE,CAEL,KAAoB;QAEpB,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,CAAM,CAAC;IACtC,CAAC;CACJ;AA7CD,0BA6CC"}
+{"version":3,"file":"Ability.js","sourceRoot":"","sources":["../../../src/screenplay/abilities/Ability.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqWG;AACH,MAAsB,OAAO;IAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,MAAM,CAAC,EAAE,CAEL,KAAoB;QAEpB,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,CAAM,CAAC;IACtC,CAAC;CACJ;AA7CD,0BA6CC"}

package/lib/screenplay/abilities/AbilityType.d.ts

@@ -1,7 +1,7 @@
 import type { Ability } from './Ability';
 /**
- * An interface describing the static access method that every {@apilink Ability} class
- * needs to provide in order to be accessible from within the {@apilink Interaction|interactions}.
+ * An interface describing the static access method that every [`Ability`](https://serenity-js.org/api/core/class/Ability/) class
+ * needs to provide in order to be accessible from within the [interactions](https://serenity-js.org/api/core/class/Interaction/).
  *
  * #### Retrieving an ability from an interaction
  *
@@ -35,9 +35,9 @@ import type { Ability } from './Ability';
  * ```
  *
  * ## Learn more
- * - {@apilink Ability}
- * - {@apilink Actor}
- * - {@apilink Interaction}
+ * - [`Ability`](https://serenity-js.org/api/core/class/Ability/)
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ * - [`Interaction`](https://serenity-js.org/api/core/class/Interaction/)
  *
  * @group Abilities
  */

package/lib/screenplay/abilities/AnswerQuestions.d.ts

@@ -3,11 +3,11 @@ import type { AnswersQuestions } from '../questions';
 import { Ability } from './Ability';
 import type { UsesAbilities } from './UsesAbilities';
 /**
- * This {@apilink Ability} enables an {@apilink Actor} to resolve the value of a given {@apilink Answerable}.
+ * This [`Ability`](https://serenity-js.org/api/core/class/Ability/) enables an [`Actor`](https://serenity-js.org/api/core/class/Actor/) to resolve the value of a given [`Answerable`](https://serenity-js.org/api/core/#Answerable).
  *
- * {@apilink AnswerQuestions} is used internally by {@apilink Actor.answer}, and it is unlikely you'll ever need to use it directly in your code.
+ * `AnswerQuestions` is used internally by [`Actor.answer`](https://serenity-js.org/api/core/class/Actor/#answer), and it is unlikely you'll ever need to use it directly in your code.
  * That is, unless you're building a custom Serenity/JS extension and want to override the default behaviour of the framework,
- * in which case you should check out the [Contributor's Guide](/contributing).
+ * in which case you should check out the [Contributor's Guide](https://serenity-js.org/community/contributing/).
  *
  * @group Abilities
  */

package/lib/screenplay/abilities/AnswerQuestions.js

@@ -5,11 +5,11 @@ const io_1 = require("../../io");
 const Question_1 = require("../Question");
 const Ability_1 = require("./Ability");
 /**
- * This {@apilink Ability} enables an {@apilink Actor} to resolve the value of a given {@apilink Answerable}.
+ * This [`Ability`](https://serenity-js.org/api/core/class/Ability/) enables an [`Actor`](https://serenity-js.org/api/core/class/Actor/) to resolve the value of a given [`Answerable`](https://serenity-js.org/api/core/#Answerable).
  *
- * {@apilink AnswerQuestions} is used internally by {@apilink Actor.answer}, and it is unlikely you'll ever need to use it directly in your code.
+ * `AnswerQuestions` is used internally by [`Actor.answer`](https://serenity-js.org/api/core/class/Actor/#answer), and it is unlikely you'll ever need to use it directly in your code.
  * That is, unless you're building a custom Serenity/JS extension and want to override the default behaviour of the framework,
- * in which case you should check out the [Contributor's Guide](/contributing).
+ * in which case you should check out the [Contributor's Guide](https://serenity-js.org/community/contributing/).
  *
  * @group Abilities
  */

package/lib/screenplay/abilities/CanHaveAbilities.d.ts

@@ -1,18 +1,18 @@
 import type { Ability } from './Ability';
 import type { UsesAbilities } from './UsesAbilities';
 /**
- * Describes an {@apilink Actor} who can have an {@apilink Ability} to perform some {@apilink Activity}.
+ * Describes an [`Actor`](https://serenity-js.org/api/core/class/Actor/) who can have an [`Ability`](https://serenity-js.org/api/core/class/Ability/) to perform some [`Activity`](https://serenity-js.org/api/core/class/Activity/).
  *
  * ## Learn more
  *
- * - {@apilink Ability}
- * - {@apilink Actor}
+ * - [`Ability`](https://serenity-js.org/api/core/class/Ability/)
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
  *
  * @group Actors
  */
 export interface CanHaveAbilities<Returned_Type = UsesAbilities> {
     /**
-     * Assigns an {@apilink Ability} or several abilities to the {@apilink Actor}
+     * Assigns an [`Ability`](https://serenity-js.org/api/core/class/Ability/) or several abilities to the [`Actor`](https://serenity-js.org/api/core/class/Actor/)
      */
     whoCan(...abilities: Ability[]): Returned_Type;
 }

package/lib/screenplay/abilities/Discardable.d.ts

@@ -1,19 +1,19 @@
 /**
- * An interface to be implemented by any {@apilink Ability} that needs to free up
+ * An interface to be implemented by any [`Ability`](https://serenity-js.org/api/core/class/Ability/) that needs to free up
  * the resources it uses, e.g. disconnect from a database.
  *
- * This {@apilink Discardable.discard} method is invoked directly by the {@apilink Actor}, and indirectly by {@apilink Stage}:
- * - when {@apilink SceneFinishes}, for actors instantiated after {@apilink SceneStarts} - e.g. within a test scenario or in a "before each" hook
- * - when {@apilink TestRunFinishes}, for actors instantiated before {@apilink SceneStarts} - e.g. in a "before all" hook
+ * This [`Discardable.discard`](https://serenity-js.org/api/core/interface/Discardable/#discard) method is invoked directly by the [actor](https://serenity-js.org/api/core/class/Actor/), and indirectly by the [stage](https://serenity-js.org/api/core/class/Stage/):
+ * - when [SceneFinishes](https://serenity-js.org/api/core-events/class/SceneFinishes/), for actors instantiated after [SceneStarts](https://serenity-js.org/api/core-events/class/SceneStarts/) - e.g. within a test scenario or in a "before each" hook
+ * - when [`TestRunFinishes`](https://serenity-js.org/api/core-events/class/TestRunFinishes/), for actors instantiated before [SceneStarts](https://serenity-js.org/api/core-events/class/SceneStarts/) - e.g. in a "before all" hook
  *
- * Note that events such as {@apilink SceneFinishes} and {@apilink TestRunFinishes} are emitted by Serenity/JS test runner adapters,
+ * Note that events such as [SceneFinishes](https://serenity-js.org/api/core-events/class/SceneFinishes/) and [`TestRunFinishes`](https://serenity-js.org/api/core-events/class/TestRunFinishes/) are emitted by Serenity/JS test runner adapters,
  * such as `@serenity-js/cucumber`, `@serenity-js/mocha`, `@serenity-js/jasmine`, and so on.
  * Consult their respective readmes to learn how to register them with your test runner of choice.
  *
  * ## Learn more
- * - {@apilink Ability}
- * - {@apilink AbilityType}
- * - {@apilink Initialisable}
+ * - [`Ability`](https://serenity-js.org/api/core/class/Ability/)
+ * - [`AbilityType`](https://serenity-js.org/api/core/#AbilityType)
+ * - [`Initialisable`](https://serenity-js.org/api/core/interface/Initialisable/)
  *
  * @group Abilities
  */

package/lib/screenplay/abilities/Initialisable.d.ts

@@ -1,30 +1,30 @@
 /**
- * An interface to be implemented by any {@apilink Ability} that needs to initialise
+ * An interface to be implemented by any [`Ability`](https://serenity-js.org/api/core/class/Ability/) that needs to initialise
  * the resources it uses, e.g. establish a database connection.
  *
- * The {@apilink Initialisable.initialise} method is invoked whenever {@apilink Actor.attemptsTo} method is called,
- * but **only when** {@apilink Initialisable.isInitialised} returns false. This is to avoid initialising abilities more than once.
+ * The [`Initialisable.initialise`](https://serenity-js.org/api/core/interface/Initialisable/#initialise) method is invoked whenever [`Actor.attemptsTo`](https://serenity-js.org/api/core/class/Actor/#attemptsTo) method is called,
+ * but **only when** [`Initialisable.isInitialised`](https://serenity-js.org/api/core/interface/Initialisable/#isInitialised) returns false. This is to avoid initialising abilities more than once.
  *
  * ## Learn more
- * - {@apilink Ability}
- * - {@apilink AbilityType}
- * - {@apilink Discardable}
+ * - [`Ability`](https://serenity-js.org/api/core/class/Ability/)
+ * - [`AbilityType`](https://serenity-js.org/api/core/#AbilityType)
+ * - [`Discardable`](https://serenity-js.org/api/core/interface/Discardable/)
  *
  * @group Abilities
  */
 export interface Initialisable {
     /**
-     * Initialises the ability. Invoked whenever {@apilink Actor.attemptsTo} method is called,
-     * but **only when** {@apilink Initialisable.isInitialised} returns false.
+     * Initialises the ability. Invoked whenever [`Actor.attemptsTo`](https://serenity-js.org/api/core/class/Actor/#attemptsTo) method is called,
+     * but **only when** [`Initialisable.isInitialised`](https://serenity-js.org/api/core/interface/Initialisable/#isInitialised) returns false.
      *
-     * Make sure to implement {@apilink Initialisable.isInitialised} so that it returns `true`
+     * Make sure to implement [`Initialisable.isInitialised`](https://serenity-js.org/api/core/interface/Initialisable/#isInitialised) so that it returns `true`
      * when the ability has been successfully initialised.
      */
     initialise(): Promise<void> | void;
     /**
      * Should return `true` when all the resources that the given ability needs
-     * have been initialised. Should return `false` if the {@apilink Actor} should
-     * initialise them again when {@apilink Actor.attemptsTo} is called.
+     * have been initialised. Should return `false` if the [`Actor`](https://serenity-js.org/api/core/class/Actor/) should
+     * initialise them again when [`Actor.attemptsTo`](https://serenity-js.org/api/core/class/Actor/#attemptsTo) is called.
      *
      * @returns {boolean}
      */

package/lib/screenplay/abilities/PerformActivities.d.ts

@@ -6,11 +6,11 @@ import type { AnswersQuestions } from '../questions';
 import { Ability } from './Ability';
 import type { UsesAbilities } from './UsesAbilities';
 /**
- * An {@apilink Ability} that enables an {@apilink Actor} to perform a given {@apilink Activity}.
+ * An [`Ability`](https://serenity-js.org/api/core/class/Ability/) that enables an [`Actor`](https://serenity-js.org/api/core/class/Actor/) to perform a given [`Activity`](https://serenity-js.org/api/core/class/Activity/).
  *
- * {@apilink PerformActivities} is used internally by {@apilink Actor.perform}, and it is unlikely you'll ever need to use it directly in your code.
+ * [`PerformActivities`](https://serenity-js.org/api/core/class/PerformActivities/) is used internally by [`Actor.attemptsTo`](https://serenity-js.org/api/core/class/Actor/#attemptsTo), and it is unlikely you'll ever need to use it directly in your code.
  * That is, unless you're building a custom Serenity/JS extension and want to override the default behaviour of the framework,
- * in which case you should check out the [Contributor's Guide](/contributing).
+ * in which case you should check out the [Contributor's Guide](https://serenity-js.org/community/contributing).
  *
  * @group Abilities
  */

package/lib/screenplay/abilities/PerformActivities.js

@@ -9,11 +9,11 @@ const model_1 = require("../../model");
 const Interaction_1 = require("../Interaction");
 const Ability_1 = require("./Ability");
 /**
- * An {@apilink Ability} that enables an {@apilink Actor} to perform a given {@apilink Activity}.
+ * An [`Ability`](https://serenity-js.org/api/core/class/Ability/) that enables an [`Actor`](https://serenity-js.org/api/core/class/Actor/) to perform a given [`Activity`](https://serenity-js.org/api/core/class/Activity/).
  *
- * {@apilink PerformActivities} is used internally by {@apilink Actor.perform}, and it is unlikely you'll ever need to use it directly in your code.
+ * [`PerformActivities`](https://serenity-js.org/api/core/class/PerformActivities/) is used internally by [`Actor.attemptsTo`](https://serenity-js.org/api/core/class/Actor/#attemptsTo), and it is unlikely you'll ever need to use it directly in your code.
  * That is, unless you're building a custom Serenity/JS extension and want to override the default behaviour of the framework,
- * in which case you should check out the [Contributor's Guide](/contributing).
+ * in which case you should check out the [Contributor's Guide](https://serenity-js.org/community/contributing).
  *
  * @group Abilities
  */