@serenity-js/core 3.25.0 → 3.25.2

package/src/model/artifacts/HTTPRequestResponse.ts

@@ -3,7 +3,7 @@ import type { JSONObject } from 'tiny-types';
 import { JSONData } from './JSONData';
 
 /**
- * The value of the {@apilink HTTPRequestResponse} {@apilink Artifact} describing an HTTP request/response pair.
+ * The value of the `HTTPRequestResponse` artifact describing an HTTP request/response pair.
  */
 export interface RequestAndResponse extends JSONObject {
     request: {
@@ -22,7 +22,7 @@ export interface RequestAndResponse extends JSONObject {
 }
 
 /**
- * An {@apilink Artifact} describing a HTTP request/response pair.
+ * An artifact describing a HTTP request/response pair.
  */
 export class HTTPRequestResponse extends JSONData {
     static fromJSON(value: RequestAndResponse): HTTPRequestResponse {

package/src/screenplay/Activity.ts

@@ -9,12 +9,12 @@ import type { AnswersQuestions } from './questions/AnswersQuestions';
 import { Describable } from './questions/Describable';
 
 /**
- * **Activities** represents {@apilink Task|tasks} and {@apilink Interaction|interactions} to be performed by an {@apilink Actor|actor}.
+ * **Activities** represents [tasks](https://serenity-js.org/api/core/class/Task/) and [interactions](https://serenity-js.org/api/core/class/Interaction/) to be performed by an [actor](https://serenity-js.org/api/core/class/Actor/).
  *
  * Learn more about:
- * - [Performing activities at multiple levels](/handbook/design/screenplay-pattern#performing-activities-at-multiple-levels)
- * - {@apilink Actor}
- * - {@apilink PerformsActivities}
+ * - [Performing activities at multiple levels](https://serenity-js.org/handbook/design/screenplay-pattern#performing-activities-at-multiple-levels)
+ * - [`Actor`](https://serenity-js.org/api/core/class/Actor/)
+ * - [`PerformsActivities`](https://serenity-js.org/api/core/interface/PerformsActivities/)
  * - [Command design pattern on Wikipedia](https://en.wikipedia.org/wiki/Command_pattern)
  *
  * @group Screenplay Pattern
@@ -33,22 +33,22 @@ export abstract class Activity extends Describable {
     }
 
     /**
-     * Returns the location where this {@apilink Activity} was instantiated.
+     * Returns the location where this [`Activity`](https://serenity-js.org/api/core/class/Activity/) was instantiated.
      */
     instantiationLocation(): FileSystemLocation {
         return this.#location;
     }
 
     /**
-     * Instructs the provided {@apilink Actor} to perform this {@apilink Activity}.
+     * Instructs the provided [`Actor`](https://serenity-js.org/api/core/class/Actor/) to perform this [`Activity`](https://serenity-js.org/api/core/class/Activity/).
      *
      * @param actor
      *
      * #### Learn more
-     * - {@apilink Actor}
-     * - {@apilink PerformsActivities}
-     * - {@apilink UsesAbilities}
-     * - {@apilink AnswersQuestions}
+     * - [`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/)
      */
     abstract performAs(actor: PerformsActivities | UsesAbilities | AnswersQuestions): Promise<any>;
 

package/src/screenplay/Actor.ts

@@ -25,26 +25,26 @@ import type { TellsTime, Timestamp } from './time';
 
 /**
  * **Actors** represent **people** and **external systems** interacting with the system under test.
- * Their role is to perform {@apilink Activity|activities} that demonstrate how to accomplish a given goal.
+ * Their role is to perform [activities](https://serenity-js.org/api/core/class/Activity/) that demonstrate how to accomplish a given goal.
  *
- * Actors are the core building block of the [Screenplay Pattern](/handbook/design/screenplay-pattern),
- * along with {@apilink Ability|Abilities}, {@apilink Interaction|Interactions}, {@apilink Task|Tasks}, and {@apilink Question|Questions}.
+ * Actors are the core building block of the [Screenplay Pattern](https://serenity-js.org/handbook/design/screenplay-pattern),
+ * along with [abilities](https://serenity-js.org/api/core/class/Ability/), [interactions](https://serenity-js.org/api/core/class/Interaction/), [tasks](https://serenity-js.org/api/core/class/Task/), and [questions](https://serenity-js.org/api/core/class/Question/).
  * Actors are also the first thing you see in a typical Serenity/JS test scenario.
  *
- * ![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 Cast}
- * - {@apilink Stage}
- * - {@apilink Ability|Abilities}
- * - {@apilink Activity|Activities}
- * - {@apilink Interaction|Interactions}
- * - {@apilink Task|Tasks}
- * - {@apilink Question|Questions}
+ * - [`Cast`](https://serenity-js.org/api/core/class/Cast/)
+ * - [`Stage`](https://serenity-js.org/api/core/class/Stage/)
+ * - [`Ability`](https://serenity-js.org/api/core/class/Ability/)
+ * - [`Activity`](https://serenity-js.org/api/core/class/Activity/)
+ * - [`Interaction`](https://serenity-js.org/api/core/class/Interaction/)
+ * - [`Task`](https://serenity-js.org/api/core/class/Task/)
+ * - [`Question`](https://serenity-js.org/api/core/class/Question/)
  *
  * ## Representing people and systems as actors
  *
- * To use a Serenity/JS {@apilink Actor}, all you need is to say their name:
+ * To use a Serenity/JS [`Actor`](https://serenity-js.org/api/core/class/Actor/), all you need is to say their name:
  *
  * ```typescript
  * import { actorCalled } from '@serenity-js/core'
@@ -53,8 +53,8 @@ import type { TellsTime, Timestamp } from './time';
  * // returns: Actor
  * ```
  *
- * Serenity/JS actors perform within the scope of a test scenario, so the first time you invoke {@apilink actorCalled},
- * Serenity/JS instantiates a new actor from the default {@apilink Cast} of actors (or any custom cast you might have {@apilink configured|configured}).
+ * Serenity/JS actors perform within the scope of a test scenario, so the first time you invoke [`actorCalled`](https://serenity-js.org/api/core/function/actorCalled/),
+ * Serenity/JS instantiates a new actor from the default [cast](https://serenity-js.org/api/core/class/Cast/) of actors (or any custom cast you might have [configured](https://serenity-js.org/api/core/function/configure/)).
  * Any subsequent invocations of this function within the scope of the same test scenario retrieve the already instantiated actor, identified by their name.
  *
  * ```typescript
@@ -104,12 +104,12 @@ export class Actor implements PerformsActivities,
     }
 
     /**
-     * Retrieves actor's {@apilink Ability} of `abilityType`, or one that extends `abilityType`.
+     * Retrieves actor's [`Ability`](https://serenity-js.org/api/core/class/Ability/) of `abilityType`, or one that extends `abilityType`.
      *
-     * Please note that this method performs an {@apilink instanceof} check against abilities
-     * given to this actor via {@apilink Actor.whoCan}.
+     * Please note that this method performs an [`instanceof`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof) check against abilities
+     * given to this actor via [`Actor.whoCan`](https://serenity-js.org/api/core/class/Actor/#whoCan).
      *
-     * Please also note that {@apilink Actor.whoCan} performs the same check when abilities are assigned to the actor
+     * Please also note that [`Actor.whoCan`](https://serenity-js.org/api/core/class/Actor/#whoCan) performs the same check when abilities are assigned to the actor
      * to ensure the actor has at most one instance of a given ability type.
      *
      * @param abilityType
@@ -129,8 +129,8 @@ export class Actor implements PerformsActivities,
     }
 
     /**
-     * Instructs the actor to attempt to perform a number of {@apilink Activity|activities},
-     * so either {@apilink Task|Tasks} or {@apilink Interaction|Interactions}),
+     * Instructs the actor to attempt to perform a number of [activities](https://serenity-js.org/api/core/class/Activity/),
+     * so either [tasks](https://serenity-js.org/api/core/class/Task/) or [interactions](https://serenity-js.org/api/core/class/Interaction/)),
      * one by one.
      *
      * @param {...activities: Activity[]} activities
@@ -144,7 +144,7 @@ export class Actor implements PerformsActivities,
     }
 
     /**
-     * Gives this Actor a list of {@apilink Ability|abilities} they can use
+     * Gives this Actor a list of [abilities](https://serenity-js.org/api/core/class/Ability/) they can use
      * to interact with the system under test or the test environment.
      *
      * @param abilities
@@ -153,7 +153,7 @@ export class Actor implements PerformsActivities,
      * @returns
      *  The actor with newly gained abilities
      *
-     * @throws {@apilink ConfigurationError}
+     * @throws [`ConfigurationError`](https://serenity-js.org/api/core/class/ConfigurationError/)
      *  Throws a ConfigurationError if the actor already has an ability of this type.
      */
     whoCan(...abilities: Ability[]): Actor {
@@ -164,7 +164,7 @@ export class Actor implements PerformsActivities,
 
     /**
      * @param answerable -
-     *  An {@apilink Answerable} to answer (resolve the value of).
+     *  An [`Answerable`](https://serenity-js.org/api/core/#Answerable) to answer (resolve the value of).
      *
      * @returns
      *  The answer to the Answerable
@@ -194,8 +194,8 @@ export class Actor implements PerformsActivities,
     }
 
     /**
-     * Instructs the actor to invoke {@apilink Discardable.discard} method on any
-     * {@apilink Discardable} {@apilink Ability} it's been configured with.
+     * Instructs the actor to invoke [`Discardable.discard`](https://serenity-js.org/api/core/interface/Discardable/#discard) method on any
+     * [discardable](https://serenity-js.org/api/core/interface/Discardable/) [ability](https://serenity-js.org/api/core/class/Ability/) it's been configured with.
      */
     dismiss(): Promise<void> {
         return this.findAbilitiesOfType<Discardable>('discard')
@@ -209,7 +209,7 @@ export class Actor implements PerformsActivities,
     /**
      * Returns a human-readable, string representation of this actor and their abilities.
      *
-     * **PRO TIP:** To get the name of the actor, use {@apilink Actor.name}
+     * **PRO TIP:** To get the name of the actor, use [`Actor.name`](https://serenity-js.org/api/core/class/Actor/#name)
      */
     toString(): string {
         const abilities = Array.from(this.abilities.values()).map(ability => ability.constructor.name);
@@ -268,8 +268,8 @@ export class Actor implements PerformsActivities,
     }
 
     /**
-     * Instantiates a {@apilink Name} based on the string value of the parameter,
-     * or returns the argument if it's already an instance of {@apilink Name}.
+     * Instantiates a `Name` based on the string value of the parameter,
+     * or returns the argument if it's already an instance of `Name`.
      *
      * @param maybeName
      */

package/src/screenplay/Answerable.ts

@@ -2,7 +2,7 @@ import type { Question } from './Question';
 
 /**
  * A union type that provides a convenient way to represent any value
- * that can be resolved by {@apilink Actor.answer}.
+ * that can be resolved by [`Actor.answer`](https://serenity-js.org/api/core/class/Actor/#answer).
  *
  * @group Questions
  */

package/src/screenplay/Answered.ts

@@ -1,8 +1,8 @@
 import type { Question } from './Question';
 
 /**
- * Describes the type of answer a given {@apilink Answerable} would
- * resolve to when given to {@apilink Actor.answer}.
+ * 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

package/src/screenplay/Interaction.ts

@@ -5,34 +5,34 @@ import type { CollectsArtifacts } from './artifacts';
 import type { AnswersQuestions } from './questions';
 
 /**
- * **Interactions** are low-level {@apilink Activity|activities} that encapsulate
- * a handful of instructions for an {@apilink Actor|actor} on how to use their {@apilink Ability|abilities}
+ * **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. {@apilink Click}, {@apilink Enter}, or {@apilink Send}.
+ * 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 {@apilink Task|task}.
+ * 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](/handbook/design/screenplay-pattern),
- * along with {@apilink Actor|Actors}, {@apilink Ability|Abilities}, {@apilink Question|Questions}, and {@apilink Task|Tasks}.
+ * 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](/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|Actor}
- * - {@apilink Ability|Abilities}
- * - {@apilink Activity|Activities}
+ * - [`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](/handbook/about/architecture) ship with dozens of interactions to help you compose your test scenarios.
+ * [Serenity/JS modules](https://serenity-js.org/handbook/getting-started/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 {@apilink Interaction.where} factory method.
+ * 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'
@@ -84,13 +84,13 @@ export abstract class Interaction extends Activity {
     }
 
     /**
-     * Instructs the provided {@apilink Actor} to perform this {@apilink 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
-     * - {@apilink Actor}
-     * - {@apilink PerformsActivities}
-     * - {@apilink UsesAbilities}
-     * - {@apilink AnswersQuestions}
+     * - [`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
      */

package/src/screenplay/Optional.ts

@@ -19,7 +19,7 @@ import type { Answerable } from './Answerable';
  */
 export interface Optional {
     /**
-     * Returns an {@apilink Answerable} that resolves to `true` when the optional value
+     * 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>;

package/src/screenplay/Question.ts

@@ -18,18 +18,20 @@ import type { RecursivelyAnswered } from './RecursivelyAnswered';
 import type { WithAnswerableProperties } from './WithAnswerableProperties';
 
 /**
- * **Questions** describe how {@apilink Actor|actors} should query the system under test or the test environment to retrieve some information.
+ * **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](/handbook/design/screenplay-pattern),
- * along with {@apilink Actor|Actors}, {@apilink Ability|Abilities}, {@apilink Interaction|Interactions}, and {@apilink Task|Tasks}.
+ * 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](/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}
- * - {@apilink Ability|Abilities}
- * - {@apilink Interaction}
- * - {@apilink QuestionAdapter}
+ * - [`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
  *
@@ -49,10 +51,10 @@ import type { WithAnswerableProperties } from './WithAnswerableProperties';
  *
  * ## Implementing a Question that uses an Ability
  *
- * Just like the {@apilink Interaction|interactions}, a {@apilink Question}
- * also can use {@apilink Actor|actor's} {@apilink Ability|abilities}.
+ * 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 {@apilink CallAnApi} to retrieve a property of
+ * Here, we use the ability to [`CallAnApi`](https://serenity-js.org/api/rest/class/CallAnApi/) to retrieve a property of
  * an HTTP response.
  *
  * ```ts
@@ -66,15 +68,15 @@ import type { WithAnswerableProperties } from './WithAnswerableProperties';
  * ```
  *
  * #### Learn more
- * - {@apilink CallAnApi}
- * - {@apilink LastResponse}
+ * - [`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, {@apilink Question|questions} can be used to transform information retrieved by 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 {@apilink Question.about} to produce a question that makes the received {@apilink Actor|actor}
- * answer {@apilink LastResponse.status} and then compare it against some expected value.
+ * 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'
@@ -97,7 +99,7 @@ import type { WithAnswerableProperties } from './WithAnswerableProperties';
  * ```
  *
  * Note that the above example is for demonstration purposes only, Serenity/JS provides an easier way to
- * verify the response status of the {@apilink LastResponse}:
+ * verify the response status of the [`LastResponse`](https://serenity-js.org/api/rest/class/LastResponse/):
  *
  * ```ts
  * import { actorCalled } from '@serenity-js/core'
@@ -157,9 +159,10 @@ export abstract class Question<T> extends Describable {
     }
 
     /**
-     * Generates a {@apilink QuestionAdapter} that recursively resolves
-     * any {@apilink Answerable} fields of the provided object,
-     * including {@apilink Answerable} fields of {@apilink WithAnswerableProperties|nested objects}.
+     * 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.
@@ -212,9 +215,9 @@ export abstract class Question<T> extends Describable {
      * ```
      *
      * #### Learn more
-     * - {@apilink WithAnswerableProperties}
-     * - {@apilink RecursivelyAnswered}
-     * - {@apilink Answerable}
+     * - [`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
@@ -241,8 +244,8 @@ export abstract class Question<T> extends Describable {
     }
 
     /**
-     * Generates a {@apilink QuestionAdapter} that resolves
-     * any {@apilink Answerable} elements of the provided array.
+     * 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[]> {
         const formatter = new ValueFormatter(ValueFormatter.defaultOptions);
@@ -265,7 +268,7 @@ export abstract class Question<T> extends Describable {
     }
 
     /**
-     * Checks if the value is a {@apilink Question}.
+     * Checks if the value is a [`Question`](https://serenity-js.org/api/core/class/Question/).
      *
      * @param maybeQuestion
      *  The value to check
@@ -276,7 +279,7 @@ export abstract class Question<T> extends Describable {
     }
 
     /**
-     * Checks if the value is a {@apilink MetaQuestion}.
+     * Checks if the value is a [`MetaQuestion`](https://serenity-js.org/api/core/interface/MetaQuestion/).
      *
      * @param maybeMetaQuestion
      *  The value to check
@@ -288,7 +291,7 @@ export abstract class Question<T> extends Describable {
     }
 
     /**
-     * Creates a {@apilink MetaQuestion} that can be composed with any {@apilink Answerable}
+     * 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
@@ -313,11 +316,11 @@ export abstract class Question<T> extends Describable {
     }
 
     /**
-     * Creates a {@apilink MetaQuestion} that can be composed with any {@apilink Answerable}
-     * to return its value when the answerable is a {@apilink Question},
+     * 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 {@apilink Question.description} on the
+     * 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
@@ -474,19 +477,19 @@ export abstract class Question<T> extends Describable {
     }
 
     /**
-     * Instructs the provided {@apilink Actor} to use their {@apilink Ability|abilities}
+     * 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 {@apilink Describable.describedBy}
-     * and {@apilink Describable.toString}.
+     * 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 {@apilink Answerable}, it replaces the current description
-     *  - If `description` is a {@apilink MetaQuestion}, the current description is passed as `context` to `description.of(context)`, and the result replaces the current description
+     *  - 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 {
         super.setDescription(
@@ -525,9 +528,9 @@ declare global {
 /* eslint-disable @typescript-eslint/indent */
 
 /**
- * Describes an object recursively wrapped in {@apilink QuestionAdapter} proxies, so that:
- * - both methods and fields of the wrapped object can be used as {@apilink Question|questions} or {@apilink Interactions|interactions}
- * - method parameters of the wrapped object will accept {@apilink Answerable|Answerable<T>}
+ * 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
  */
@@ -548,10 +551,10 @@ export type QuestionAdapterFieldDecorator<Original_Type> = {
 /* eslint-enable @typescript-eslint/indent */
 
 /**
- * A union type representing a proxy object returned by {@apilink Question.about}.
+ * A union type representing a proxy object returned by [`Question.about`](https://serenity-js.org/api/core/class/Question/#about).
  *
- * {@apilink QuestionAdapter} proxies the methods and fields of the wrapped object recursively,
- * allowing them to be used as either a {@apilink Question} or an {@apilink Interaction}.
+ * [`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
  */
@@ -562,8 +565,8 @@ export type QuestionAdapter<Answer_Type> =
     & QuestionAdapterFieldDecorator<Answer_Type>;
 
 /**
- * An extension of {@apilink QuestionAdapter}, that in addition to proxying methods and fields
- * of the wrapped object can also act as a {@apilink MetaQuestion}.
+ * 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
  */
@@ -587,7 +590,7 @@ class QuestionStatement<Answer_Type> extends Interaction implements Question<Pro
     }
 
     /**
-     * Returns a Question that resolves to `true` if resolving the {@apilink QuestionStatement}
+     * 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>> {

package/src/screenplay/RecursivelyAnswered.ts

@@ -1,9 +1,9 @@
 import type { Question } from './Question';
 
 /**
- * Describes a recursively resolved plain JavaScript {@apilink WithAnswerableProperties}.
+ * Describes a recursively resolved plain JavaScript object with [answerable properties](https://serenity-js.org/api/core/#WithAnswerableProperties).
  *
- * Typically, used in conjunction with {@apilink Question.fromObject}.
+ * Typically, used in conjunction with [`Question.fromObject`](https://serenity-js.org/api/core/class/Question/#fromObject).
  *
  * ## Using `RecursivelyAnswered`
  *