@serenity-js/core 3.25.0 → 3.25.2

package/src/screenplay/questions/tag-functions.ts

@@ -9,12 +9,13 @@ import type { DescriptionFormattingOptions } from './DescriptionFormattingOption
 import type { MetaQuestion } from './MetaQuestion';
 
 /**
- * Creates a single-line description of an {@apilink Activity} by transforming
+ * Creates a single-line description of an [`Activity`](https://serenity-js.org/api/core/class/Activity/) by transforming
  * a [template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates),
  * parameterised with [primitive data types](https://developer.mozilla.org/en-US/docs/Glossary/Primitive),
  * [complex data structures](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#objects),
- * or any other {@apilink Answerable|Answerables}, into a {@link QuestionAdapter|`QuestionAdapter<string>`}
- * that can be used with {@apilink Task.where} and {@apilink Interaction.where} methods.
+ * or any other [answerables](https://serenity-js.org/api/core/#Answerable),
+ * into a [`QuestionAdapter<string>`](https://serenity-js.org/api/core/#QuestionAdapter)
+ * that can be used with [`Task.where`](https://serenity-js.org/api/core/class/Task/#where) and [`Interaction.where`](https://serenity-js.org/api/core/class/Interaction/#where) methods.
  *
  * ```ts
  * const dial = (phoneNumber: Answerable<string>) =>
@@ -28,7 +29,8 @@ import type { MetaQuestion } from './MetaQuestion';
  *
  * ## Trimming the output
  *
- * Use {@apilink DescriptionFormattingOptions} to trim the descriptions of template parameters.
+ * Use [`DescriptionFormattingOptions`](http://serenity-js.org/api/core/interface/DescriptionFormattingOptions/)
+ * to trim the descriptions of template parameters.
  * By default, the output is displayed in full.
  *
  * ```ts
@@ -45,9 +47,9 @@ import type { MetaQuestion } from './MetaQuestion';
  *
  * ## Using with Questions
  *
- * When `the` is parameterised with {@apilink Question|Questions},
- * it retrieves their description by calling {@apilink Question.describedBy}
- * in the context of the {@apilink Actor} performing the {@apilink Activity}.
+ * When `the` is parameterised with [questions](https://serenity-js.org/api/core/class/Question/),
+ * it retrieves their description by calling [`Question.describedBy`](https://serenity-js.org/api/core/class/Question/#describedBy)
+ * in the context of the [`Actor`](https://serenity-js.org/api/core/class/Actor/) performing the [`Activity`](https://serenity-js.org/api/core/class/Activity/).
  * 
  * ```ts
  * import { actorCalled, Question, Task, the } from '@serenity-js/core'
@@ -66,7 +68,7 @@ import type { MetaQuestion } from './MetaQuestion';
  * )
  * ```
  * 
- * If you'd like the question to be described using its formatted value instead of its description, use {@apilink Question.formattedValue}.
+ * If you'd like the question to be described using its formatted value instead of its description, use [`Question.formattedValue`](https://serenity-js.org/api/core/class/Question/#formattedValue).
  *
  * ```ts
  * import { actorCalled, Question, Task, the } from '@serenity-js/core'
@@ -89,7 +91,7 @@ import type { MetaQuestion } from './MetaQuestion';
  *
  * When `the` is parameterised with objects that have
  * a custom [`toString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString) method,
- * or {@link Answerable|Answerables} resolving to such objects, the `toString()` method is called to produce the resulting description.
+ * or [answerables](https://serenity-js.org/api/core/#Answerable) resolving to such objects, the `toString()` method is called to produce the resulting description.
  *
  * ```ts
  * import { actorCalled, description, Task } from '@serenity-js/core'
@@ -118,7 +120,7 @@ import type { MetaQuestion } from './MetaQuestion';
  * ## Using with objects without a custom `toString` method
  *
  * When `the` is parameterised with complex objects that don't have a custom `toString()` method,
- * or {@link Answerable}s resolving to such objects,
+ * or [`Answerable`](https://serenity-js.org/api/core/#Answerable)s resolving to such objects,
  * the resulting description will contain a JSON-like string representation of the object.
  *
  * ```ts
@@ -141,7 +143,7 @@ import type { MetaQuestion } from './MetaQuestion';
  *
  * ## Using with masked values
  *
- * When `the` is parameterised with {@apilink Masked} values,
+ * When `the` is parameterised with [masked values](https://serenity-js.org/api/core/class/Masked/),
  * the resulting description will contain a masked representation of the values.
  *
  * ```ts
@@ -158,11 +160,11 @@ import type { MetaQuestion } from './MetaQuestion';
  *
  * ## Learn more
  *
- * - {@apilink Answerable}
- * - {@apilink Question}
- * - {@apilink Question.describedAs}
- * - {@apilink QuestionAdapter}
- * - {@apilink Masked}
+ * - [`Answerable`](https://serenity-js.org/api/core/#Answerable)
+ * - [`Question`](https://serenity-js.org/api/core/class/Question/)
+ * - [`Question.describedAs`](https://serenity-js.org/api/core/class/Question/#describedAs)
+ * - [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter)
+ * - [`Masked`](https://serenity-js.org/api/core/class/Masked/)
  *
  * @group Questions
  */
@@ -216,7 +218,7 @@ export function the(...args: any[]): any {
  *
  * ## Transforming the interpolated string
  *
- * The mechanism presented below relies on {@apilink QuestionAdapter}.
+ * The mechanism presented below relies on [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter).
  *
  * ```ts
  * import { q, actorCalled } from '@serenity-js/core'
@@ -231,10 +233,10 @@ export function the(...args: any[]): any {
  *
  * ## Learn more
  *
- * - {@apilink Answerable}
- * - {@apilink Question}
- * - {@apilink Question.describedAs}
- * - {@apilink QuestionAdapter}
+ * - [`Answerable`](https://serenity-js.org/api/core/#Answerable)
+ * - [`Question`](https://serenity-js.org/api/core/class/Question/)
+ * - [`Question.describedAs`](https://serenity-js.org/api/core/class/Question/#describedAs)
+ * - [`QuestionAdapter`](https://serenity-js.org/api/core/#QuestionAdapter)
  *
  * @group Questions
  *

package/src/screenplay/time/TellsTime.ts

@@ -1,13 +1,13 @@
 import type { Timestamp } from './models';
 
 /**
- * Describes an {@apilink Actor} or a supporting class capable of telling
+ * Describes an [`Actor`](https://serenity-js.org/api/core/class/Actor/) or a supporting class capable of telling
  * the current wall clock time.
  *
  * ## Learn more
- * - {@apilink Actor}
- * - {@apilink Serenity}
- * - {@apilink Stage}
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ * - [`Serenity`](https://serenity-js.org/api/core/class/Serenity/)
+ * - [`Stage`](https://serenity-js.org/api/core/class/Stage/)
  *
  * @group Time
  */

package/src/screenplay/time/abilities/ScheduleWork.ts

@@ -4,10 +4,10 @@ import type { Clock, DelayedCallback, Duration, RepeatUntilLimits} from '../mode
 import { Scheduler } from '../models';
 
 /**
- * An {@apilink Ability} that enables an {@apilink Actor} to schedule a callback function
+ * An [`Ability`](https://serenity-js.org/api/core/class/Ability/) that enables an [`Actor`](https://serenity-js.org/api/core/class/Actor/) to schedule a callback function
  * to be executed with a delay, or until some condition is met.
  *
- * Used internally by the {@apilink Interaction|interaction} to {@apilink Wait}.
+ * Used internally by the [interaction](https://serenity-js.org/api/core/class/Interaction/) to [`Wait`](https://serenity-js.org/api/core/class/Wait/).
  *
  * @experimental
  *

package/src/screenplay/time/activities/Wait.ts

@@ -12,13 +12,13 @@ import { ScheduleWork } from '../abilities';
 import { Duration } from '../models';
 
 /**
- * `Wait` is a synchronisation statement that instructs the {@apilink Actor|actor}
- * to wait before proceeding with their next {@apilink Activity|activity},
- * either for a set {@apilink Duration|duration}, or until a given {@apilink Expectation|expectation} is met.
+ * `Wait` is a synchronisation statement that instructs the [actor](https://serenity-js.org/api/core/class/Actor/)
+ * to wait before proceeding with their next [activity](https://serenity-js.org/api/core/class/Activity/),
+ * either for a set [duration](https://serenity-js.org/api/core/class/Duration/), or until a given [expectation](https://serenity-js.org/api/core/class/Expectation/) is met.
  *
- * You can configure the timeout of the interaction to {@apilink Wait.until}:
- * - globally, using {@apilink SerenityConfig.interactionTimeout}
- * - locally, on a per-interaction basis using {@apilink Wait.upTo}
+ * You can configure the timeout of the interaction to [`Wait.until`](https://serenity-js.org/api/core/class/Wait/#until):
+ * - globally, using [`SerenityConfig.interactionTimeout`](https://serenity-js.org/api/core/class/SerenityConfig/#interactionTimeout)
+ * - locally, on a per-interaction basis using [`Wait.upTo`](https://serenity-js.org/api/core/class/Wait/#upTo)
  *
  * :::tip Portable waiting
  * Serenity/JS implements `Wait` from scratch, so that the behaviour is consistent no matter the integration tool you use (Playwright, WebdriverIO, Selenium, etc.)
@@ -98,7 +98,8 @@ import { Duration } from '../models';
  *     );
  * ```
  *
- * `Wait.until` makes the {@apilink Actor} keep asking the {@apilink Question},
+ * `Wait.until` makes the [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ * keep asking the [`Question`](https://serenity-js.org/api/core/class/Question/),
  * in this case `Text.of(App.status)`, until the answer meets
  * the expectation, or a timeout expires (default: 5s).
  *
@@ -125,53 +126,53 @@ import { Duration } from '../models';
  * ```
  *
  * ## Learn more
- * - {@apilink SerenityConfig.interactionTimeout}
- * - {@apilink Duration}
- * - {@apilink Expectation}
+ * - [`SerenityConfig.interactionTimeout`](https://serenity-js.org/api/core/class/SerenityConfig/#interactionTimeout)
+ * - [`Duration`](https://serenity-js.org/api/core/class/Duration/)
+ * - [`Expectation`](https://serenity-js.org/api/core/class/Expectation/)
  *
  * @group Time
  */
 export class Wait {
 
     /**
-     * Minimum timeout that can be used with {@apilink Wait.until},
+     * Minimum timeout that can be used with [`Wait.until`](https://serenity-js.org/api/core/class/Wait/#until),
      * defaults to 250 milliseconds,
      */
     static readonly minimumTimeout = Duration.ofMilliseconds(250);
 
     /**
-     * The amount of time {@apilink Wait.until} should wait between condition checks,
+     * The amount of time [`Wait.until`](https://serenity-js.org/api/core/class/Wait/#until) should wait between condition checks,
      * defaults to 500ms.
      *
-     * Use {@apilink WaitUntil.pollingEvery} to override it for a given interaction.
+     * Use [`WaitUntil.pollingEvery`](https://serenity-js.org/api/core/class/WaitUntil/#pollingEvery) to override it for a given interaction.
      *
      * @type {Duration}
      */
     static readonly defaultPollingInterval = Duration.ofMilliseconds(500);
 
     /**
-     * Minimum polling interval of 50ms between condition checks, used with {@apilink Wait.until}.
+     * Minimum polling interval of 50ms between condition checks, used with [`Wait.until`](https://serenity-js.org/api/core/class/Wait/#until).
      */
     static readonly minimumPollingInterval = Duration.ofMilliseconds(50);
 
     /**
-     * Instantiates a version of this {@apilink Interaction}
+     * Instantiates a version of this [`Interaction`](https://serenity-js.org/api/core/class/Interaction/)
      * configured to wait for a set duration.
      *
      * @param duration
-     *  A set duration the {@apilink Actor} should wait for before proceeding.
+     *  A set duration the [`Actor`](https://serenity-js.org/api/core/class/Actor/) should wait for before proceeding.
      */
     static for(duration: Answerable<Duration>): Interaction {
         return new WaitFor(duration);
     }
 
     /**
-     * Instantiates a version of this {@apilink Interaction}
+     * Instantiates a version of this [`Interaction`](https://serenity-js.org/api/core/class/Interaction/)
      * configured to wait until the answer to the question `actual` meets the `expectation`,
      * or the `timeout` expires.
      *
      * @param timeout
-     *  Custom timeout to override {@apilink SerenityConfig.interactionTimeout}
+     *  Custom timeout to override [`SerenityConfig.interactionTimeout`](https://serenity-js.org/api/core/class/SerenityConfig/#interactionTimeout)
      */
     static upTo(timeout: Duration): { until: <Actual>(actual: Answerable<Actual>, expectation: Expectation<Actual>) => WaitUntil<Actual> } {
         return {
@@ -181,17 +182,17 @@ export class Wait {
     }
 
     /**
-     * Instantiates a version of this {@apilink Interaction} configured to
-     * poll every {@apilink Wait.defaultPollingInterval} for the result of the provided
+     * Instantiates a version of this [`Interaction`](https://serenity-js.org/api/core/class/Interaction/) configured to
+     * poll every [`Wait.defaultPollingInterval`](https://serenity-js.org/api/core/class/Wait/#defaultPollingInterval) for the result of the provided
      * question (`actual`) until it meets the `expectation`,
      * or the timeout expires.
      *
      * @param actual
-     *  An {@apilink Answerable} that the {@apilink Actor} will keep answering
-     *  until the answer meets the {@apilink Expectation} provided, or the timeout expires.
+     *  An [`Answerable`](https://serenity-js.org/api/core/#Answerable) that the [`Actor`](https://serenity-js.org/api/core/class/Actor/) will keep answering
+     *  until the answer meets the [`Expectation`](https://serenity-js.org/api/core/class/Expectation/) provided, or the timeout expires.
      *
      * @param expectation
-     *  An {@apilink Expectation} to be met before proceeding
+     *  An [`Expectation`](https://serenity-js.org/api/core/class/Expectation/) to be met before proceeding
      */
     static until<Actual>(actual: Answerable<Actual>, expectation: Expectation<Actual>): WaitUntil<Actual> {
         return new WaitUntil(actual, expectation, Wait.defaultPollingInterval);
@@ -214,14 +215,15 @@ class WaitFor extends Interaction {
 }
 
 /**
- * Synchronisation statement that instructs the {@apilink Actor} to wait before proceeding until a given {@apilink Expectation} is met.
+ * Synchronisation statement that instructs the [`Actor`](https://serenity-js.org/api/core/class/Actor/) to wait before proceeding until a given [`Expectation`](https://serenity-js.org/api/core/class/Expectation/) is met.
  *
  * :::tip
- * To instantiate {@apilink Interaction|interaction} to {@apilink WaitUntil}, use the factory method {@apilink Wait.until}.
+ * To instantiate the [interaction](https://serenity-js.org/api/core/class/Interaction/) to [`WaitUntil`](https://serenity-js.org/api/core/class/WaitUntil/),
+ * use the factory method [`Wait.until`](https://serenity-js.org/api/core/class/Wait/#until).
  * :::
  *
  * ## Learn more
- * * {@apilink Wait.until}
+ * * [`Wait.until`](https://serenity-js.org/api/core/class/Wait/#until)
  *
  * @group Time
  */
@@ -243,7 +245,7 @@ export class WaitUntil<Actual> extends Interaction {
     }
 
     /**
-     * Configure how frequently the {@apilink Actor} should check if the answer meets the expectation.
+     * Configure how frequently the [`Actor`](https://serenity-js.org/api/core/class/Actor/) should check if the answer meets the expectation.
      *
      * Note that the polling interval defines the delay between subsequent attempts
      * to evaluate the expected value, and doesn't include the amount of time

package/src/screenplay/time/models/Clock.ts

@@ -4,7 +4,7 @@ import { Duration } from './Duration';
 import { Timestamp } from './Timestamp';
 
 /**
- * A {@apilink Clock} tells the time. This abstraction allows Serenity/JS to have a single place
+ * A [`Clock`](https://serenity-js.org/api/core/class/Clock/) tells the time. This abstraction allows Serenity/JS to have a single place
  * in the framework responsible for telling the time, and one that can be easily mocked for internal testing.
  *
  * ```ts
@@ -12,8 +12,8 @@ import { Timestamp } from './Timestamp';
  * ```
  *
  * ## Learn more
- * - {@apilink Timestamp}
- * - {@apilink Duration}
+ * - [`Timestamp`](https://serenity-js.org/api/core/class/Timestamp/)
+ * - [`Duration`](https://serenity-js.org/api/core/class/Duration/)
  *
  * @group Time
  */
@@ -26,7 +26,7 @@ export class Clock {
 
     /**
      * Sets the clock ahead to force early resolution of promises
-     * returned by {@apilink Clock.waitFor};
+     * returned by [`Clock.waitFor`](https://serenity-js.org/api/core/class/Clock/#waitFor).
      *
      * Useful for test purposes to avoid unnecessary delays.
      *

package/src/screenplay/time/models/Duration.ts

@@ -2,7 +2,7 @@ import type { JSONObject} from 'tiny-types';
 import { ensure, isGreaterThanOrEqualTo, isInteger, TinyType } from 'tiny-types';
 
 /**
- * Represents a duration in milliseconds between two {@apilink Timestamp|timestamps}.
+ * Represents a duration in milliseconds between two [timestamps](https://serenity-js.org/api/core/class/Timestamp/).
  *
  * @group Time
  */

package/src/screenplay/time/models/Timestamp.ts

@@ -6,10 +6,10 @@ import { Duration } from './Duration';
 /**
  * Represents a point in time.
  *
- * `Timestamp` makes it easier for you to work with information related to time, like {@apilink DomainEvent|domain events}.
+ * `Timestamp` makes it easier for you to work with information related to time, like [Serenity/JS domain events](https://serenity-js.org/api/core-events/class/DomainEvent/).
  *
  * ## Learn more
- * - {@apilink Duration}
+ * - [`Duration`](https://serenity-js.org/api/core/class/Duration/)
  * - [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
  *
  * @group Time

package/src/stage/Cast.ts

@@ -1,11 +1,11 @@
 import type { Actor } from '../screenplay';
 
 /**
- * Serenity/JS uses the concept of a _**cast of actors**_ to centralise the process of configuring the {@apilink Actor|actors} and assigning their {@apilink Ability|abilities}.
+ * Serenity/JS uses the concept of a _**cast of actors**_ to centralise the process of configuring the [actors](https://serenity-js.org/api/core/class/Actor/) and assigning their [abilities](https://serenity-js.org/api/core/class/Ability/).
  *
- * When you invoke {@apilink actorCalled} for the first time in a test scenario,
- * Serenity/JS {@apilink Actor|instantiates a new actor}
- * and passes it through the {@apilink Cast.prepare} method.
+ * When you invoke [`actorCalled`](https://serenity-js.org/api/core/function/actorCalled/) for the first time in a test scenario,
+ * Serenity/JS [instantiates a new actor](https://serenity-js.org/api/core/class/Actor/)
+ * and passes it through the [`Cast.prepare`](https://serenity-js.org/api/core/class/Cast/#prepare) method.
  * Specifying a **custom cast** gives you an opportunity to configure the actor with the abilities
  * they need before it's returned to the caller,
  * or configure the actors differently **depending on their name**.
@@ -18,7 +18,7 @@ import type { Actor } from '../screenplay';
  * ## Configuring a cast of actors for the entire test suite
  *
  * When working with relatively **simple scenarios** where all the actors should always receive the same set of abilities,
- * you can {@apilink configure} Serenity/JS to use a generic {@apilink Cast.where}:
+ * you can [`engage`](https://serenity-js.org/api/core/function/engage/) Serenity/JS to use a generic [`Cast.where`](https://serenity-js.org/api/core/class/Cast/#where):
  *
  * ```typescript
  * import { Cast, configure } from '@serenity-js/core'
@@ -32,28 +32,28 @@ import type { Actor } from '../screenplay';
  * })
  * ```
  *
- * If you're using Serenity/JS with one of the [supported test runners](/handbook/test-runners/),
+ * If you're using Serenity/JS with one of the [supported test runners](https://serenity-js.org/handbook/test-runners/),
  * you might prefer to use your test runner's native configuration mechanism
- * instead of invoking {@apilink configure} explicitly.
+ * instead of invoking [`engage`](https://serenity-js.org/api/core/function/engage/) explicitly.
  *
  * :::tip configure vs engage
- * Calling {@apilink configure} resets the entire Serenity/JS configuration
+ * Calling [`configure`](https://serenity-js.org/api/core/function/configure/) resets the entire Serenity/JS configuration
  * and should be done exactly once in your entire test suite.
- * If you want to retain the configuration but reset the cast, use {@apilink engage} instead.
+ * If you want to retain the configuration but reset the cast, use [`engage`](https://serenity-js.org/api/core/function/engage/) instead.
  * :::
  *
  * Learn more about configuring Serenity/JS with:
- * - [Cucumber.js](/handbook/test-runners/cucumber)
- * - [Jasmine](/handbook/test-runners/jasmine)
- * - [Mocha](/handbook/test-runners/mocha)
- * - [Playwright Test](/handbook/test-runners/playwright-test)
- * - [Protractor](/handbook/test-runners/protractor)
- * - [WebdriverIO](/handbook/test-runners/webdriverio)
+ * - [Cucumber.js](https://serenity-js.org/handbook/test-runners/cucumber)
+ * - [Jasmine](https://serenity-js.org/handbook/test-runners/jasmine)
+ * - [Mocha](https://serenity-js.org/handbook/test-runners/mocha)
+ * - [Playwright Test](https://serenity-js.org/handbook/test-runners/playwright-test)
+ * - [Protractor](https://serenity-js.org/handbook/test-runners/protractor)
+ * - [WebdriverIO](https://serenity-js.org/handbook/test-runners/webdriverio)
  *
  * ## Engaging a cast of actors for the specific scenario
  *
- * If you want to retain Serenity/JS configuration, but set a different {@apilink Cast}
- * for the given test scenario you should use {@apilink engage} instead of {@apilink configure}.
+ * If you want to retain Serenity/JS configuration, but set a different [cast](https://serenity-js.org/api/core/class/Cast/)
+ * for the given test scenario you should use [`engage`](https://serenity-js.org/api/core/function/engage/) instead of [`configure`](https://serenity-js.org/api/core/function/configure/).
  *
  * This approach is useful for example when your entire test suite is dedicated to interacting with the system
  * under test via its REST APIs, and you have a handful of scenarios that need a web browser.
@@ -77,10 +77,10 @@ import type { Actor } from '../screenplay';
  * ## Writing custom casts for complex scenarios
  *
  * In **complex scenarios** that involve multiple **actors with different abilities**,
- * you should create a custom implementation of the {@apilink Cast}.
+ * you should create a custom implementation of the [cast](https://serenity-js.org/api/core/class/Cast/).
  *
  * Examples of such scenarios include those where actors use separate browser instances, interact with different REST APIs,
- * or start with different data in their {@apilink Notepad|notepads}.
+ * or start with different data in their [notepads](https://serenity-js.org/api/core/class/Notepad/).
  *
  * ### Defining a custom cast of actors interacting with a Web UI
  *
@@ -164,12 +164,12 @@ export abstract class Cast {
     }
 
     /**
-     * Configures an {@apilink Actor} instantiated when {@apilink Stage.actor} is invoked.
+     * Configures an [`Actor`](https://serenity-js.org/api/core/class/Actor/) instantiated when [`Stage.actor`](https://serenity-js.org/api/core/class/Stage/#actor) is invoked.
      *
      * @param actor
      *
      * #### Learn more
-     * - {@apilink engage}
+     * - [`engage`](https://serenity-js.org/api/core/function/engage/)
      */
     abstract prepare(actor: Actor): Actor;
 }

package/src/stage/Extras.ts

@@ -2,7 +2,7 @@ import type { Actor } from '../screenplay';
 import type { Cast } from './Cast';
 
 /**
- * Produces no-op actors with no special {@apilink Ability}
+ * Produces no-op actors with no special [`Ability`](https://serenity-js.org/api/core/class/Ability/)
  */
 export class Extras implements Cast {
     prepare(actor: Actor): Actor {

package/src/stage/ListensToDomainEvents.ts

@@ -1,22 +1,22 @@
 import type { DomainEvent } from '../events';
 
 /**
- * A {@apilink StageCrewMember} that can listen and react to {@apilink DomainEvent|DomainEvents}
+ * A [`StageCrewMember`](https://serenity-js.org/api/core/interface/StageCrewMember/) that can listen and react to [Serenity/JS domain events](https://serenity-js.org/api/core-events/class/DomainEvent/)
  *
  * ## Learn more
  *
- * - {@apilink StageCrewMember}
- * - {@apilink StageCrewMemberBuilder}
- * - {@apilink configure}
- * - {@apilink SerenityConfig.crew}
+ * - [`StageCrewMember`](https://serenity-js.org/api/core/interface/StageCrewMember/)
+ * - [`StageCrewMember`](https://serenity-js.org/api/core/interface/StageCrewMemberBuilder/)
+ * - [`engage`](https://serenity-js.org/api/core/function/engage/)
+ * - [`SerenityConfig.crew`](https://serenity-js.org/api/core/class/SerenityConfig/#crew)
  *
  * @group Stage
  */
 export interface ListensToDomainEvents {
 
     /**
-     * Handles {@apilink DomainEvent} objects emitted by the {@apilink Stage}
-     * that this {@apilink StageCrewMember} is assigned to.
+     * Handles [`DomainEvent`](https://serenity-js.org/api/core-events/class/DomainEvent/) objects emitted by the [`Stage`](https://serenity-js.org/api/core/class/Stage/)
+     * that this [`StageCrewMember`](https://serenity-js.org/api/core/interface/StageCrewMember/) is assigned to.
      *
      * @param event
      */