@serenity-js/webdriverio 2.32.3 → 3.0.0-rc.1

package/src/screenplay/interactions/Wait.ts

@@ -1,267 +0,0 @@
-import { Answerable, AnswersQuestions, AssertionError, Duration, Expectation, ExpectationMet, ExpectationOutcome, Interaction, UsesAbilities } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-
-import { BrowseTheWeb } from '../abilities';
-import { WaitBuilder } from './WaitBuilder';
-
-/**
- * @desc
- *  Instructs the {@link @serenity-js/core/lib/screenplay/actor~Actor} to
- *  wait before proceeding either for a set {@link @serenity-js/core/lib/model~Duration}
- *  or until a given {@link @serenity-js/core/lib/screenplay/questions~Expectation} is met.
- *
- *  Under the hood, `Wait` uses WebdriverIO ["explicit waiting"](https://webdriver.io/docs/autowait/)
- *  mechanism.
- *
- * @example <caption>Example widget</caption>
- *  <!--
- *      After about 1 second, the text will change from 'Loading...' to 'Ready!'
- *  -->
- *  <h1 id="status">Loading...</h1>
- *  <script>
- *      (function () {
- *          setTimeout(function () {
- *              document.getElementById('status').textContent = 'Ready!'
- *          }, 1000);
- *      })();
- *  </script>
- *
- * @example <caption>Lean Page Object describing the widget</caption>
- *  import { by, Target } from '@serenity-js/webdriverio';
- *
- *  class App {
- *      static status = Target.the('status widget')
- *          .located(by.id('status'));
- *  }
- *
- * @example <caption>Waiting for a set amount of time</caption>
- *  import { actorCalled, Duration } from '@serenity-js/core';
- *  import { BrowseTheWeb, Wait } from '@serenity-js/webdriverio';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *
- *  actorCalled('Wendy')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Wait.for(Duration.ofSeconds(1.5)),
- *          Ensure.that(App.status, equals('Ready!')),
- *      );
- *
- *  // Please note that while the above implementation works,
- *  // this approach is inefficient because at best
- *  // the actor might wait too long and at worst the test
- *  // might become "flaky" if any external interference
- *  // (like network glitches, animations taking a bit too long etc.)
- *  // makes the actor wait not long enough.
- *
- * @example <caption>Waiting until a condition is met</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { BrowseTheWeb, Wait, Text } from '@serenity-js/webdriverio';
- *  import { equals } from '@serenity-js/assertions';
- *
- *  actorCalled('Wendy')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Wait.until(Text.of(App.status), equals('Ready!')),
- *          // app is ready, proceed with the scenario
- *      );
- *
- *  // Wait.until makes the Actor keep asking a Question,
- *  // in this case Text.of(App.status), until the answer meets
- *  // the expectation, or a timeout expires (default: 5s).
- *  //
- *  // Please note that both Ensure and Wait can be used with
- *  // the same expectations, like `equals`.
- *
- * @example <caption>Changing the default timeout</caption>
- *  import { actorCalled, Duration } from '@serenity-js/core';
- *  import { BrowseTheWeb, Wait, Text } from '@serenity-js/webdriverio';
- *  import { equals } from '@serenity-js/assertions';
- *
- *  actorCalled('Wendy')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Wait.upTo(Duration.ofSeconds(3))
- *              .until(Text.of(App.status), equals('Ready!')),
- *          // app is ready, proceed with the scenario
- *      );
- *
- * @see {@link BrowseTheWeb}
- * @see {@link Target}
- * @see {@link Text}
- * @see {@link @serenity-js/assertions~Ensure}
- * @see {@link @serenity-js/assertions/lib/expectations~equals}
- * @see {@link @serenity-js/core/lib/model~Duration}
- *
- * @see {@link @serenity-js/core/lib/screenplay~Interaction}
- */
-export class Wait {
-
-    /**
-     * @desc
-     *  Default timeout of 5 seconds used with {@link Wait.until}.
-     *
-     * @type {@serenity-js/core~Duration}
-     */
-    static readonly Default_Timeout = Duration.ofSeconds(5);
-
-    /**
-     * @desc
-     *  Instantiates a version of this {@link @serenity-js/core/lib/screenplay~Interaction}
-     *  configured to wait for a set duration.
-     *
-     * @param {Answerable<Duration>} duration
-     *  A set duration the {@link @serenity-js/core/lib/screenplay/actor~Actor} should wait for
-     *  before proceeding
-     *
-     * @returns {@serenity-js/core/lib/screenplay~Interaction}
-     */
-    static for(duration: Answerable<Duration>): Interaction {
-        return new WaitFor(duration);
-    }
-
-    /**
-     * @desc
-     *  Instantiates a version of this {@link @serenity-js/core/lib/screenplay~Interaction}
-     *  configured to wait until the answer to the question (`actual`) meets the `expectation`,
-     *  or a custom timeout expires.
-     *
-     * @param {Duration} duration
-     *  Custom timeout to override {@link Wait.Default_Timeout}
-     *
-     * @returns {WaitBuilder}
-     */
-    static upTo(duration: Duration): WaitBuilder {
-        return {
-            until: <Actual>(actual: Answerable<Actual>, expectation: Expectation<any, Actual>): Interaction =>
-                new WaitUntil(actual, expectation, duration),
-        };
-    }
-
-    /**
-     * @desc
-     *  Instantiates a version of this {@link @serenity-js/core/lib/screenplay~Interaction}
-     *  configured to wait until the answer to the question (`actual`) meets the `expectation`,
-     *  or a {@link Wait.Default_Timeout} expires.
-     *
-     * @param {Answerable<Actual>} actual
-     *  A {@link @serenity-js/core/lib/screenplay~Question}
-     *  that the {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  will keep asking until the answer meets
-     *  the {@link @serenity-js/core/lib/screenplay/questions~Expectation} provided
-     *
-     * @param {@serenity-js/core/lib/screenplay/questions~<any,Actual>} expectation
-     *  An {@link @serenity-js/core/lib/screenplay/questions~Expectation} to be met before proceeding
-     *
-     * @returns {@serenity-js/core/lib/screenplay~Interaction}
-     */
-    static until<Actual>(actual: Answerable<Actual>, expectation: Expectation<any, Actual>): Interaction {
-        return new WaitUntil(actual, expectation, Wait.Default_Timeout);
-    }
-}
-
-/**
- * @package
- */
-class WaitFor extends Interaction {
-    constructor(private readonly duration: Answerable<Duration>) {
-        super();
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  perform this {@link @serenity-js/core/lib/screenplay~Interaction}.
-     *
-     * @param {UsesAbilities & AnswersQuestions} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     */
-    async performAs(actor: UsesAbilities & AnswersQuestions): Promise<void> {
-        return actor.answer(this.duration)
-            .then(duration => BrowseTheWeb.as(actor).browser.pause(duration.inMilliseconds()) as Promise<void>);
-    }
-
-    /**
-     * @desc
-     *  Generates a description to be used when reporting this {@link @serenity-js/core/lib/screenplay~Activity}.
-     *
-     * @returns {string}
-     */
-    toString(): string {
-        return formatted`#actor waits for ${ this.duration }`;
-    }
-}
-
-/**
- * @package
- */
-class WaitUntil<Actual> extends Interaction {
-    constructor(
-        private readonly actual: Answerable<Actual>,
-        private readonly expectation: Expectation<any, Actual>,
-        private readonly timeout: Duration,
-    ) {
-        super();
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  perform this {@link @serenity-js/core/lib/screenplay~Interaction}.
-     *
-     * @param {UsesAbilities & AnswersQuestions} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     */
-    performAs(actor: UsesAbilities & AnswersQuestions): PromiseLike<void> {
-        const
-            actual      = this.actual,
-            expectation = this.expectation.answeredBy(actor);
-
-        let expectationOutcome: ExpectationOutcome<any, Actual>;
-
-        return BrowseTheWeb.as(actor)
-            .browser
-            .waitUntil(function () {
-                return actor.answer(actual)
-                    .then(act => expectation(act))
-                    .then(outcome => {
-                        expectationOutcome = outcome;
-
-                        return outcome instanceof ExpectationMet;
-                    });
-            }, {
-                timeout:    this.timeout.inMilliseconds(),
-                timeoutMsg: `Wait timed out after ${ this.timeout }`,
-            })
-            .then(_ => void 0)
-            .catch(error => {
-                if (expectationOutcome) {
-                    throw new AssertionError(
-                        `Waited ${ this.timeout.toString() } for ${ formatted `${ this.actual }` } to ${ this.expectation.toString() }`,
-                        expectationOutcome.expected,
-                        expectationOutcome.actual,
-                        error,
-                    );
-                }
-
-                throw error;
-            });
-    }
-
-    /**
-     * @desc
-     *  Generates a description to be used when reporting this {@link @serenity-js/core/lib/screenplay~Activity}.
-     *
-     * @returns {string}
-     */
-    toString(): string {
-        return formatted`#actor waits up to ${ this.timeout } until ${ this.actual } does ${ this.expectation }`;
-    }
-}

package/src/screenplay/interactions/WaitBuilder.ts

@@ -1,34 +0,0 @@
-/**
- * @desc
- *  Fluent interface to make the instantiation of
- *  the {@link @serenity-js/core/lib/screenplay~Interaction}
- *  to {@link Wait} more readable.
- *
- * @see {@link Wait}
- *
- * @interface
- */
-import { Answerable, Expectation, Interaction } from '@serenity-js/core';
-
-export interface WaitBuilder {
-
-    /**
-     * @desc
-     *  Instantiates an {@link @serenity-js/core/lib/screenplay~Interaction}
-     *  to {@link Wait}.
-     *
-     * @param {Answerable<Actual>} actual
-     *  A {@link @serenity-js/core/lib/screenplay~Question}
-     *  that the {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  will keep asking until the answer meets
-     *  the {@link @serenity-js/core/lib/screenplay/questions~Expectation} provided
-     *
-     * @param {@serenity-js/core/lib/screenplay/questions~Expectation<any,Actual>} expectation
-     *  An {@link @serenity-js/assertions~Expectation} to be met before proceeding
-     *
-     * @returns {Interaction}
-     *
-     * @see {@link Target}
-     */
-    until: <Actual>(actual: Answerable<Actual>, expectation: Expectation<any, Actual>) => Interaction;
-}

package/src/screenplay/interactions/WebElementInteraction.ts

@@ -1,56 +0,0 @@
-import { Answerable, AnswersQuestions, Interaction, LogicError } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-import { Element } from 'webdriverio';
-
-/**
- * @desc
- *  A base class for WebdriverIO-specific interactions
- *
- * @extends {@serenity-js/core/lib/screenplay~Interaction}
- */
-export abstract class WebElementInteraction extends Interaction {
-
-    /**
-     * @param {string} description
-     *  A human-readable description to be used when reporting
-     *  this {@link @serenity-js/core/lib/screenplay~Interaction}.
-     */
-    constructor(private readonly description: string) {
-        super();
-    }
-
-    /**
-     * @desc
-     *  Returns the resolved {@link @wdio/types~Element}, or throws a {@link @serenity-js/core/lib/errors~LogicError}
-     *  if the element is `undefined`.
-     *
-     * @param {@serenity-js/core/lib/screenplay/actor~AnswersQuestions} actor
-     * @param {@serenity-js/core/lib/screenplay~Answerable<Element<'async'>>} element
-     *
-     * @returns {Promise<Element<'async'>>}
-     *
-     * @protected
-     */
-    protected async resolve(
-        actor: AnswersQuestions,
-        element: Answerable<Element<'async'>>,
-    ): Promise<Element<'async'>> {
-        const resolved = await actor.answer(element);
-
-        if (! resolved) {
-            throw new LogicError(formatted `Couldn't find ${ element }`);
-        }
-
-        return resolved;
-    }
-
-    /**
-     * @desc
-     *  Generates a description to be used when reporting this {@link @serenity-js/core/lib/screenplay~Activity}.
-     *
-     * @returns {string}
-     */
-    toString(): string {
-        return this.description;
-    }
-}

package/src/screenplay/interactions/index.ts

@@ -1,13 +0,0 @@
-export * from './Clear';
-export * from './Click';
-export * from './DoubleClick';
-export * from './Enter';
-export * from './ExecuteScript';
-export * from './Hover';
-export * from './Navigate';
-export * from './Press';
-export * from './PressBuilder';
-export * from './RightClick';
-export * from './Scroll';
-export * from './Wait';
-export * from './WebElementInteraction';

package/src/screenplay/questions/Attribute.ts

@@ -1,112 +0,0 @@
-import { Answerable, AnswersQuestions, LogicError, MetaQuestion, Question, UsesAbilities } from '@serenity-js/core';
-import { Element } from 'webdriverio';
-
-import { TargetNestedElement } from './targets';
-
-/**
- * @desc
- *  Returns the value of the given HTML attribute of a given {@link WebElement},
- *  represented by Answerable<{@link @wdio/types~Element}>
- *
- * @example <caption>Example widget</caption>
- *  <ul id="shopping-list" data-items-left="2">
- *    <li data-state="bought">Coffee<li>
- *    <li data-state="buy">Honey<li>
- *    <li data-state="buy">Chocolate<li>
- *  </ul>
- *
- * @example <caption>Retrieve a HTML attribute of a given WebElement</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *  import { Attribute, by, BrowseTheWeb, Target } from '@serenity-js/webdriverio';
- *
- *  const shoppingList = () =>
- *      Target.the('shopping list').located(by.id('shopping-list'))
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Ensure.that(Attribute.called('data-items-left').of(shoppingList()), equals('2')),
- *      )
- *
- * @example <caption>Find WebElements with a given attribute</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, includes } from '@serenity-js/assertions';
- *  import { Attribute, BrowseTheWeb, by, Target } from '@serenity-js/webdriverio';
- *
- *  class ShoppingList {
- *      static items = () =>
- *          Target.all('items')
- *              .located(by.css('#shopping-list li'))
- *
- *      static outstandingItems = () =>
- *          ShoppingList.items
- *              .where(Attribute.called('data-state'), includes('buy'))
- *  }
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Ensure.that(
- *              Text.ofAll(ShoppingList.outstandingItems()),
- *              equals([ 'Honey', 'Chocolate' ])
- *          ),
- *      )
- *
- * @extends {@serenity-js/core/lib/screenplay~Question}
- * @implements {@serenity-js/core/lib/screenplay/questions~MetaQuestion}
- */
-export class Attribute
-    extends Question<Promise<string>>
-    implements MetaQuestion<Answerable<Element<'async'>>, Promise<string>>
-{
-    /**
-     * @param {Answerable<string>} name
-     * @returns {Attribute}
-     */
-    static called(name: Answerable<string>): Attribute {
-        return new Attribute(name);
-    }
-
-    /**
-     * @param {Answerable<string>} name
-     * @param {@serenity-js/core/lib/screenplay~Answerable<Element<'async'>>} [element]
-     */
-    constructor(
-        private readonly name: Answerable<string>,
-        private readonly element?: Answerable<Element<'async'>>,
-    ) {
-        super(`"${ name }" attribute of ${ element }`);
-    }
-
-    /**
-     * @desc
-     *  Resolves to the value of a HTML attribute of the `target` element,
-     *  located in the context of a `parent` element.
-     *
-     * @param {Answerable<Element<'async'>>} parent
-     * @returns {Question<Promise<string[]>>}
-     *
-     * @see {@link Target.all}
-     * @see {@link @serenity-js/core/lib/screenplay/questions~MetaQuestion}
-     */
-    of(parent: Answerable<Element<'async'>>): Question<Promise<string>> {
-        return new Attribute(
-            this.name,
-            this.element
-                ? new TargetNestedElement(parent, this.element)
-                : parent
-        );
-    }
-
-    async answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<string> {
-        if (! this.element) {
-            throw new LogicError(`Target not specified`);   // todo: better error message?
-        }
-
-        const element = await actor.answer(this.element);
-        const name    = await actor.answer(this.name);
-
-        return element.getAttribute(name);
-    }
-}

package/src/screenplay/questions/CSSClasses.ts

@@ -1,116 +0,0 @@
-import { Answerable, AnswersQuestions, MetaQuestion, Question, UsesAbilities } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-import { Element } from 'webdriverio';
-
-import { Attribute } from './Attribute';
-import { TargetNestedElement } from './targets';
-
-/**
- * @desc
- *  Resolves to an array of [CSS classes](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes#attr-class)
- *  of a given {@link WebElement}, represented by Answerable<{@link @wdio/types~Element}>.
- *
- * @example <caption>Example widget</caption>
- *  <ul id="shopping-list" class="active favourite">
- *    <li class="bought">Coffee<li>
- *    <li class="buy">Honey<li>
- *    <li class="buy">Chocolate<li>
- *  </ul>
- *
- * @example <caption>Retrieve CSS classes of a given WebElement</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *  import { BrowseTheWeb, by, CSSClasses, Target } from '@serenity-js/webdriverio';
- *
- *  const shoppingList = () =>
- *      Target.the('shopping list').located(by.id('shopping-list'))
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Ensure.that(CSSClasses.of(shoppingList()), equals([ 'active', 'favourite' ])),
- *      )
- *
- * @example <caption>Find WebElements with a given class</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, contain } from '@serenity-js/assertions';
- *  import { BrowseTheWeb, by, CSSClasses, Target } from '@serenity-js/webdriverio';
- *
- *  class ShoppingList {
- *      static items = () =>
- *          Target.all('items')
- *              .located(by.css('#shopping-list li'))
- *
- *      static outstandingItems = () =>
- *          ShoppingList.items
- *              .where(CSSClasses, contain('buy'))
- *  }
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Ensure.that(
- *              Text.ofAll(ShoppingList.outstandingItems()),
- *              equals([ 'Honey', 'Chocolate' ])
- *          ),
- *      )
- *
- * @extends {@serenity-js/core/lib/screenplay~Question}
- * @implements {@serenity-js/core/lib/screenplay/questions~MetaQuestion}
- */
-export class CSSClasses
-    extends Question<Promise<string[]>>
-    implements MetaQuestion<Answerable<Element<'async'>>, Promise<string[]>>
-{
-    /**
-     * @param {Question<Element<'async'>> | Element<'async'>} target
-     * @returns {CSSClasses}
-     */
-    static of(target: Answerable<Element<'async'>>): CSSClasses {
-        return new CSSClasses(target);
-    }
-
-    /**
-     * @param {Question<Element<'async'>> | Element<'async'>} target
-     */
-    constructor(private readonly target: Answerable<Element<'async'>>) {
-        super(formatted `CSS classes of ${ target}`);
-    }
-
-    /**
-     * @desc
-     *  Resolves to an array of CSS classes of the `target` element,
-     *  located in the context of a `parent` element.
-     *
-     * @param {@serenity-js/core/lib/screenplay~Answerable<Element<'async'>>} parent
-     * @returns {Question<Promise<string[]>>}
-     *
-     * @see {@link Target.all}
-     * @see {@link @serenity-js/core/lib/screenplay/questions~MetaQuestion}
-     */
-    of(parent: Answerable<Element<'async'>>): Question<Promise<string[]>> {
-        return new CSSClasses(new TargetNestedElement(parent, this.target));
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  answer this {@link @serenity-js/core/lib/screenplay~Question}.
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     */
-    answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<string[]> {
-        return Attribute.called('class').of(this.target).answeredBy(actor)
-            .then(attribute => attribute
-                .replace(/\s+/, ' ')
-                .trim()
-                .split(' ')
-                .filter(cssClass => !! cssClass),
-            );
-    }
-}

package/src/screenplay/questions/LastScriptExecution.ts

@@ -1,21 +0,0 @@
-import { Question } from '@serenity-js/core';
-
-import { BrowseTheWeb } from '../abilities';
-
-/**
- * @desc
- *  Returns the result of last script executed via {@link ExecuteScript}
- */
-export class LastScriptExecution {
-
-    /**
-     * @desc
-     *  Enables asserting on the result of a function executed via {@link ExecuteScript}.
-     *
-     * @returns {Question<R>}
-     */
-    static result<R>(): Question<R> {
-        return Question.about(`last script execution result`, actor =>
-            BrowseTheWeb.as(actor).getLastScriptExecutionResult());
-    }
-}

package/src/screenplay/questions/NestedTargetBuilder.ts

@@ -1,30 +0,0 @@
-import { Answerable } from '@serenity-js/core';
-import type { Element } from 'webdriverio';
-
-import { TargetBuilder } from './TargetBuilder';
-
-/**
- * @desc
- *  Fluent interface to make the instantiation of
- *  the {@link @serenity-js/core/lib/screenplay~Question}
- *  about a nested {@link Target} more readable.
- *
- * @see {@link Target}
- *
- * @interface
- */
-export interface NestedTargetBuilder<T> {
-
-    /**
-     * @desc
-     *  Instantiates a {@link @serenity-js/core/lib/screenplay~Question}
-     *  about a {@link Target}.
-     *
-     * @param {@serenity-js/core/lib/screenplay~Answerable<Element<'async'>>} parent
-     * @returns {TargetBuilder}
-     *
-     * @see {@link Target}
-     * @see {@link TargetBuilder}
-     */
-    of: (parent: Answerable<Element<'async'>>) => TargetBuilder<T>;
-}

package/src/screenplay/questions/TargetBuilder.ts

@@ -1,27 +0,0 @@
-import { Locator } from './locators';
-
-/**
- * @desc
- *  Fluent interface to make the instantiation of
- *  the {@link @serenity-js/core/lib/screenplay~Question}
- *  about a {@link Target} more readable.
- *
- * @see {@link Target}
- *
- * @interface
- */
-export interface TargetBuilder<T> {
-
-    /**
-     * @desc
-     *  Instantiates a {@link @serenity-js/core/lib/screenplay~Question}
-     *  about a {@link Target}.
-     *
-     * @param {Locator} locator
-     * @returns {@serenity-js/core/lib/screenplay~Question}
-     *
-     * @see {@link Target}
-     * @see {@link Locator}
-     */
-    located: (locator: Locator) => T;
-}