@gatling.io/core 3.11.7 → 3.12.0

package/src/structure/doIfOrElse.ts

@@ -0,0 +1,160 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { Executable } from "./execs";
+
+import JvmDoIfOrElse = io.gatling.javaapi.core.condition.DoIfOrElse;
+import JvmDoIfEqualsOrElse = io.gatling.javaapi.core.condition.DoIfEqualsOrElse;
+import JvmExecutable = io.gatling.javaapi.core.exec.Executable;
+
+interface JvmThen<T> {
+  then(executable: JvmExecutable, ...executables: JvmExecutable[]): JvmOrElse<T>;
+}
+
+export interface Then<T> {
+  then(executable: Executable<any>, ...executables: Executable<any>[]): OrElse<T>;
+}
+
+const wrapThen = <J, T>(jvmThen: JvmThen<J>, wrap: (underlying: J) => T): Then<T> => ({
+  then: (executable: Executable<any>, ...executables: Executable<any>[]): OrElse<T> =>
+    wrapOrElse(jvmThen.then(executable._underlying, ...executables.map((e) => e._underlying)), wrap)
+});
+
+interface JvmOrElse<T> {
+  orElse(executable: JvmExecutable, ...executables: JvmExecutable[]): T;
+}
+
+export interface OrElse<T> {
+  orElse(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+
+const wrapOrElse = <J, T>(jvmOrElse: JvmOrElse<J>, wrap: (underlying: J) => T): OrElse<T> => ({
+  orElse: (executable: Executable<any>, ...executables: Executable<any>[]): T =>
+    wrap(jvmOrElse.orElse(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+
+export interface DoIfOrElseFunction<T extends DoIfOrElse<T>> {
+  /**
+   * Execute the "then" block only if the condition is true
+   *
+   * @param condition - the condition expressed as a Gatling Expression Language String that must
+   *     evaluate to a Boolean
+   * @returns a DSL component for defining the "then" block
+   */
+  (condition: string): Then<T>;
+
+  /**
+   * Execute the "then" block only if the condition is true
+   *
+   * @param condition - the condition expressed as a function
+   * @returns a DSL component for defining the "then" block
+   */
+  (condition: SessionTo<boolean>): Then<T>;
+}
+
+export interface DoIfOrElse<T extends DoIfOrElse<T>> {
+  doIfOrElse: DoIfOrElseFunction<T>;
+}
+
+export const doIfOrElseImpl =
+  <J2, J1 extends JvmDoIfOrElse<J2, any>, T extends DoIfOrElse<T>>(
+    jvmDoIfOrElse: J1,
+    wrap: (wrapped: J2) => T
+  ): DoIfOrElseFunction<T> =>
+  (condition: string | SessionTo<boolean>) =>
+    wrapThen(
+      typeof condition === "function"
+        ? jvmDoIfOrElse.doIfOrElse(underlyingSessionTo(condition))
+        : jvmDoIfOrElse.doIfOrElse(condition),
+      wrap
+    );
+
+export interface DoIfEqualsOrElseFunction<T extends DoIfEqualsOrElse<T>> {
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a Gatling Expression Language String
+   * @param expected - the expected value expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: string, expected: string): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a Gatling Expression Language String
+   * @param expected - the expected static value
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: string, expected: unknown): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a function
+   * @param expected - the expected value expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: string, expected: SessionTo<unknown>): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a function
+   * @param expected - the expected value expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: SessionTo<unknown>, expected: string): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a function
+   * @param expected - the expected static value
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: SessionTo<unknown>, expected: unknown): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a function
+   * @param expected - the expected value expressed as a function
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: SessionTo<unknown>, expected: SessionTo<unknown>): Then<T>;
+}
+
+export interface DoIfEqualsOrElse<T extends DoIfEqualsOrElse<T>> {
+  doIfEqualsOrElse: DoIfEqualsOrElseFunction<T>;
+}
+
+export const doIfEqualsOrElseImpl =
+  <J2, J1 extends JvmDoIfEqualsOrElse<J2, any>, T extends DoIfEqualsOrElse<T>>(
+    jvmDoIfEqualsOrElse: J1,
+    wrap: (wrapped: J2) => T
+  ): DoIfEqualsOrElseFunction<T> =>
+  (actual: string | SessionTo<unknown>, expected: string | SessionTo<unknown> | unknown) => {
+    if (typeof actual === "function") {
+      const wrappedActual = underlyingSessionTo(actual);
+      if (typeof expected === "function") {
+        return wrapThen(
+          jvmDoIfEqualsOrElse.doIfEqualsOrElse(wrappedActual, underlyingSessionTo(expected as SessionTo<unknown>)),
+          wrap
+        );
+      } else if (typeof expected === "string") {
+        return wrapThen(jvmDoIfEqualsOrElse.doIfEqualsOrElse(wrappedActual, expected), wrap);
+      } else {
+        return wrapThen(jvmDoIfEqualsOrElse.doIfEqualsOrElse(wrappedActual, expected), wrap);
+      }
+    } else {
+      if (typeof expected === "function") {
+        return wrapThen(
+          jvmDoIfEqualsOrElse.doIfEqualsOrElse(actual, underlyingSessionTo(expected as SessionTo<unknown>)),
+          wrap
+        );
+      } else if (typeof expected === "string") {
+        return wrapThen(jvmDoIfEqualsOrElse.doIfEqualsOrElse(actual, expected), wrap);
+      } else {
+        return wrapThen(jvmDoIfEqualsOrElse.doIfEqualsOrElse(actual, expected), wrap);
+      }
+    }
+  };

package/src/structure/doSwitch.ts

@@ -0,0 +1,46 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { ChoiceWithKey } from "./choices";
+
+import JvmDoSwitch = io.gatling.javaapi.core.condition.DoSwitch;
+import JvmOn = io.gatling.javaapi.core.condition.DoSwitch$On;
+
+export interface On<T> {
+  on(...choices: ChoiceWithKey[]): T;
+}
+
+const wrapOn = <J, T>(jvmOn: JvmOn<J>, wrap: (underlying: J) => T): On<T> => ({
+  on: (...choices: ChoiceWithKey[]): T => wrap(jvmOn.on(choices.map((c) => c._underlying)))
+});
+
+export interface DoSwitchFunction<T extends DoSwitch<T>> {
+  /**
+   * Execute one of the "choices" when the actual value is equal to the possibility's one.
+   *
+   * @param actual - the actual value expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the "choices"
+   */
+  (actual: string): On<T>;
+
+  /**
+   * Execute one of the "choices" when the actual value is equal to the possibility's one.
+   *
+   * @param actual - the actual value expressed as a function
+   * @returns a DSL component for defining the "choices"
+   */
+  (actual: SessionTo<unknown>): On<T>;
+}
+
+export interface DoSwitch<T extends DoSwitch<T>> {
+  doSwitch: DoSwitchFunction<T>;
+}
+
+export const doSwitchImpl =
+  <J2, J1 extends JvmDoSwitch<J2, any>, T extends DoSwitch<T>>(
+    jvmDoSwitch: J1,
+    wrap: (wrapped: J2) => T
+  ): DoSwitchFunction<T> =>
+  (actual: string | SessionTo<unknown>) =>
+    wrapOn(
+      typeof actual === "function" ? jvmDoSwitch.doSwitch(underlyingSessionTo(actual)) : jvmDoSwitch.doSwitch(actual),
+      wrap
+    );

package/src/structure/doSwitchOrElse.ts

@@ -0,0 +1,61 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { ChoiceWithKey } from "./choices";
+import { Executable } from "./execs";
+
+import JvmDoSwitchOrElse = io.gatling.javaapi.core.condition.DoSwitchOrElse;
+import JvmOn = io.gatling.javaapi.core.condition.DoSwitchOrElse$On;
+import JvmOrElse = io.gatling.javaapi.core.condition.DoSwitchOrElse$OrElse;
+
+export interface On<T> {
+  on(...choices: ChoiceWithKey[]): OrElse<T>;
+}
+
+const wrapOn = <J, T>(jvmOn: JvmOn<J>, wrap: (underlying: J) => T): On<T> => ({
+  on: (...choices: ChoiceWithKey[]): OrElse<T> => wrapOrElse(jvmOn.on(choices.map((c) => c._underlying)), wrap)
+});
+
+interface OrElse<T> {
+  orElse(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+
+const wrapOrElse = <J, T>(jvmOrElse: JvmOrElse<J>, wrap: (underlying: J) => T): OrElse<T> => ({
+  orElse: (executable: Executable<any>, ...executables: Executable<any>[]): T =>
+    wrap(jvmOrElse.orElse(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+
+export interface DoSwitchOrElseFunction<T extends DoSwitchOrElse<T>> {
+  /**
+   * Execute one of the "choices" when the actual value is equal to the possibility's one, otherwise execute the "else"
+   * block.
+   *
+   * @param actual - the actual value expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the "choices"
+   */
+  (actual: string): On<T>;
+
+  /**
+   * Execute one of the "choices" when the actual value is equal to the possibility's one, otherwise execute the "else"
+   * block.
+   *
+   * @param actual - the actual value expressed as a function
+   * @returns a DSL component for defining the "choices"
+   */
+  (actual: SessionTo<unknown>): On<T>;
+}
+
+export interface DoSwitchOrElse<T extends DoSwitchOrElse<T>> {
+  doSwitchOrElse: DoSwitchOrElseFunction<T>;
+}
+
+export const doSwitchOrElseImpl =
+  <J2, J1 extends JvmDoSwitchOrElse<J2, any>, T extends DoSwitchOrElse<T>>(
+    jvmDoSwitchOrElse: J1,
+    wrap: (wrapped: J2) => T
+  ): DoSwitchOrElseFunction<T> =>
+  (actual: string | SessionTo<unknown>) =>
+    wrapOn(
+      typeof actual === "function"
+        ? jvmDoSwitchOrElse.doSwitchOrElse(underlyingSessionTo(actual))
+        : jvmDoSwitchOrElse.doSwitchOrElse(actual),
+      wrap
+    );

package/src/structure/doWhile.ts

@@ -0,0 +1,53 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { On, wrapOn } from "./on";
+
+import JvmDoWhile = io.gatling.javaapi.core.loop.DoWhile;
+
+export interface DoWhileFunction<T extends DoWhile<T>> {
+  /**
+   * Define a loop that will iterate as long as the condition holds true. The condition is evaluated
+   * at the end of the loop.
+   *
+   * @param condition the condition, expressed as a Gatling Expression Language String
+   * @param counterName the name of the loop counter, as stored in the Session
+   * @return a DSL component for defining the loop content
+   */
+  (condition: string, counterName?: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true. The condition is evaluated
+   * at the end of the loop.
+   *
+   * @param condition the condition, expressed as a function
+   * @param counterName the name of the loop counter, as stored in the Session
+   * @return a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, counterName?: string): On<T>;
+}
+
+export interface DoWhile<T extends DoWhile<T>> {
+  doWhile: DoWhileFunction<T>;
+}
+
+export const doWhileImpl =
+  <J2, J1 extends JvmDoWhile<J2, any>, T extends DoWhile<T>>(
+    jvmDoWhile: J1,
+    wrap: (wrapped: J2) => T
+  ): DoWhileFunction<T> =>
+  (condition: SessionTo<boolean> | string, counterName?: string) => {
+    if (counterName !== undefined) {
+      // doWhile(condition, counterName)
+      if (typeof condition === "function") {
+        return wrapOn(jvmDoWhile.doWhile(underlyingSessionTo(condition), counterName), wrap);
+      } else {
+        return wrapOn(jvmDoWhile.doWhile(condition, counterName), wrap);
+      }
+    } else {
+      // doWhile(condition)
+      if (typeof condition === "function") {
+        return wrapOn(jvmDoWhile.doWhile(underlyingSessionTo(condition)), wrap);
+      } else {
+        return wrapOn(jvmDoWhile.doWhile(condition), wrap);
+      }
+    }
+  };

package/src/structure/doWhileDuring.ts

@@ -0,0 +1,337 @@
+import { Duration, isDuration, toJvmDuration } from "../utils/duration";
+import { SessionTo, underlyingSessionTo, underlyingSessionToDuration } from "../session";
+import { On, wrapOn } from "./on";
+
+import JvmDoWhileDuring = io.gatling.javaapi.core.loop.DoWhileDuring;
+
+export interface DoWhileDuringFunction<T extends DoWhileDuring<T>> {
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, either an integer number of seconds or an object with an explicit time unit
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: Duration): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, either an integer number of seconds or an object with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: Duration, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, either an integer number of seconds or an object with an explicit time unit
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: Duration, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, either an integer number of seconds or an object with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: Duration, counterName: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a function
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: SessionTo<Duration>): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: SessionTo<Duration>, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a function
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: SessionTo<Duration>, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: SessionTo<Duration>, counterName: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a Gatling Expression Language String that
+   *     must either evaluate to an integer number of seconds or an object with an explicit time unit
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a Gatling Expression Language String that
+   *     must either evaluate to an integer number of seconds or an object with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: string, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a Gatling Expression Language String that
+   *     must either evaluate to an integer number of seconds or an object with an explicit time unit
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a Gatling Expression Language String that
+   *     must either evaluate to an integer number of seconds or an object with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: string, counterName: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, either an integer number of seconds or an object with an explicit time unit
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: Duration): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, either an integer number of seconds or an object with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: Duration, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, either an integer number of seconds or an object with an explicit time unit
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: Duration, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, either an integer number of seconds or an object with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: Duration, counterName: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, expressed as a function
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: SessionTo<Duration>): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: SessionTo<Duration>, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, expressed as a function
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: SessionTo<Duration>, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached. The condition is evaluated at the end of the loop.
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: SessionTo<Duration>, counterName: string, exitASAP: boolean): On<T>;
+}
+
+export interface DoWhileDuring<T extends DoWhileDuring<T>> {
+  doWhileDuring: DoWhileDuringFunction<T>;
+}
+
+export const doWhileDuringImpl =
+  <J2, J1 extends JvmDoWhileDuring<J2, any>, T extends DoWhileDuring<T>>(
+    jvmDoWhileDuring: J1,
+    wrap: (wrapped: J2) => T
+  ): DoWhileDuringFunction<T> =>
+  (
+    condition: SessionTo<boolean> | string,
+    duration: Duration | SessionTo<Duration> | string,
+    arg2?: string | boolean,
+    arg3?: boolean
+  ) => {
+    if (arg3 !== undefined && typeof arg2 === "string") {
+      // doWhileDuring(condition, duration, counterName, exitASAP)
+      if (typeof condition === "function") {
+        const wrappedCondition = underlyingSessionTo(condition);
+        if (isDuration(duration)) {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(wrappedCondition, toJvmDuration(duration), arg2, arg3), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmDoWhileDuring.doWhileDuring(wrappedCondition, underlyingSessionToDuration(duration), arg2, arg3),
+            wrap
+          );
+        }
+      } else {
+        if (isDuration(duration)) {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(condition, toJvmDuration(duration), arg2, arg3), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmDoWhileDuring.doWhileDuring(condition, underlyingSessionToDuration(duration), arg2, arg3),
+            wrap
+          );
+        }
+      }
+    } else if (typeof arg2 === "string") {
+      // doWhileDuring(condition, duration, counterName)
+      if (typeof condition === "function") {
+        const wrappedCondition = underlyingSessionTo(condition);
+        if (isDuration(duration)) {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(wrappedCondition, toJvmDuration(duration), arg2), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmDoWhileDuring.doWhileDuring(wrappedCondition, underlyingSessionToDuration(duration), arg2),
+            wrap
+          );
+        }
+      } else {
+        if (isDuration(duration)) {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(condition, toJvmDuration(duration), arg2), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(condition, underlyingSessionToDuration(duration), arg2), wrap);
+        }
+      }
+    } else if (typeof arg2 === "boolean") {
+      // doWhileDuring(condition, duration, exitASAP)
+      if (typeof condition === "function") {
+        const wrappedCondition = underlyingSessionTo(condition);
+        if (isDuration(duration)) {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(wrappedCondition, toJvmDuration(duration), arg2), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmDoWhileDuring.doWhileDuring(wrappedCondition, underlyingSessionToDuration(duration), arg2),
+            wrap
+          );
+        }
+      } else {
+        if (isDuration(duration)) {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(condition, toJvmDuration(duration), arg2), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(condition, underlyingSessionToDuration(duration), arg2), wrap);
+        }
+      }
+    } else if (arg2 === undefined) {
+      // doWhileDuring(condition, duration)
+      if (typeof condition === "function") {
+        const wrappedCondition = underlyingSessionTo(condition);
+        if (isDuration(duration)) {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(wrappedCondition, toJvmDuration(duration)), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(wrappedCondition, underlyingSessionToDuration(duration)), wrap);
+        }
+      } else {
+        if (isDuration(duration)) {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(condition, toJvmDuration(duration)), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(jvmDoWhileDuring.doWhileDuring(condition, underlyingSessionToDuration(duration)), wrap);
+        }
+      }
+    }
+
+    throw Error(`doWhileDuring() called with invalid arguments ${condition}, ${duration}, ${arg2}, ${arg3}`);
+  };