@gatling.io/core 0.1.0

package/target/structure/doWhileDuring.d.ts

@@ -0,0 +1,225 @@
+import "@gatling.io/jvm-types";
+import JvmDoWhileDuring = io.gatling.javaapi.core.loop.DoWhileDuring;
+import { Duration } from "../utils/duration";
+import { SessionTo } from "../session";
+import { On } from "./on";
+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 declare const doWhileDuringImpl: <J2, J1 extends JvmDoWhileDuring<J2, any>, T extends DoWhileDuring<T>>(jvmDoWhileDuring: J1, wrap: (wrapped: J2) => T) => DoWhileDuringFunction<T>;

package/target/structure/doWhileDuring.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doWhileDuringImpl = void 0;
+require("@gatling.io/jvm-types");
+const duration_1 = require("../utils/duration");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const on_1 = require("./on");
+const doWhileDuringImpl = (jvmDoWhileDuring, wrap) => (condition, duration, arg2, arg3) => {
+    if (arg3 !== undefined && typeof arg2 === "string") {
+        // doWhileDuring(condition, duration, counterName, exitASAP)
+        if (typeof condition === "function") {
+            const wrappedCondition = (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition));
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(wrappedCondition, (0, duration_1.toJvmDuration)(duration), arg2, arg3), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(wrappedCondition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2, arg3), wrap);
+            }
+        }
+        else {
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(condition, (0, duration_1.toJvmDuration)(duration), arg2, arg3), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(condition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2, arg3), wrap);
+            }
+        }
+    }
+    else if (typeof arg2 === "string") {
+        // doWhileDuring(condition, duration, counterName)
+        if (typeof condition === "function") {
+            const wrappedCondition = (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition));
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(wrappedCondition, (0, duration_1.toJvmDuration)(duration), arg2), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(wrappedCondition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2), wrap);
+            }
+        }
+        else {
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(condition, (0, duration_1.toJvmDuration)(duration), arg2), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(condition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2), wrap);
+            }
+        }
+    }
+    else if (typeof arg2 === "boolean") {
+        // doWhileDuring(condition, duration, exitASAP)
+        if (typeof condition === "function") {
+            const wrappedCondition = (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition));
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(wrappedCondition, (0, duration_1.toJvmDuration)(duration), arg2), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(wrappedCondition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2), wrap);
+            }
+        }
+        else {
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(condition, (0, duration_1.toJvmDuration)(duration), arg2), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(condition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2), wrap);
+            }
+        }
+    }
+    else if (arg2 === undefined) {
+        // doWhileDuring(condition, duration)
+        if (typeof condition === "function") {
+            const wrappedCondition = (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition));
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(wrappedCondition, (0, duration_1.toJvmDuration)(duration)), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(wrappedCondition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration))), wrap);
+            }
+        }
+        else {
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(condition, (0, duration_1.toJvmDuration)(duration)), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmDoWhileDuring.doWhileDuring(condition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration))), wrap);
+            }
+        }
+    }
+    throw Error(`doWhileDuring() called with invalid arguments ${condition}, ${duration}, ${arg2}, ${arg3}`);
+};
+exports.doWhileDuringImpl = doWhileDuringImpl;

package/target/structure/during.d.ts

@@ -0,0 +1,123 @@
+import "@gatling.io/jvm-types";
+import JvmDuring = io.gatling.javaapi.core.loop.During;
+import { Duration } from "../utils/duration";
+import { SessionTo } from "../session";
+import { On } from "./on";
+export interface DuringFunction<T extends During<T>> {
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration, in seconds or with an explicit time unit
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: Duration): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration, in seconds or with an explicit time unit
+     * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: Duration, exitASAP: boolean): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration, in seconds or 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
+     */
+    (duration: Duration, counterName: string): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration, in seconds or 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 max duration is reached inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: Duration, counterName: string, exitASAP: boolean): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration as a Gatling Expression Language string. This expression must resolve to
+     * either a number, then the unit will be seconds, or an object with an explicit time unit.
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: string): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration as a Gatling Expression Language string. This expression must resolve to
+     * either a number, then the unit will be seconds, or an object with an explicit time unit.
+     * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: string, exitASAP: boolean): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration as a Gatling Expression Language string. This expression must resolve to
+     * either a number, then the unit will be 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
+     */
+    (duration: string, counterName: string): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration as a Gatling Expression Language string. This expression must resolve to
+     * either a number, then the unit will be 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 max duration is reached inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: string, counterName: string, exitASAP: boolean): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration as a function
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: SessionTo<Duration>): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration as a function
+     * @param exitASAP - if the loop must be interrupted if the max duration is reached inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: SessionTo<Duration>, exitASAP: boolean): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration 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
+     */
+    (duration: SessionTo<Duration>, counterName: string): On<T>;
+    /**
+     * Define a loop that will iterate for a given duration. The condition is evaluated at the end of
+     * the loop.
+     *
+     * @param duration - the maximum duration 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 max duration is reached inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (duration: SessionTo<Duration>, counterName: string, exitASAP: boolean): On<T>;
+}
+export interface During<T extends During<T>> {
+    during: DuringFunction<T>;
+}
+export declare const duringImpl: <J2, J1 extends JvmDuring<J2, any>, T extends During<T>>(jvmDuring: J1, wrap: (wrapped: J2) => T) => DuringFunction<T>;

package/target/structure/during.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duringImpl = void 0;
+require("@gatling.io/jvm-types");
+const duration_1 = require("../utils/duration");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const on_1 = require("./on");
+const duringImpl = (jvmDuring, wrap) => (duration, arg1, arg2) => {
+    if (arg2 !== undefined && typeof arg1 === "string") {
+        // during(duration, counterName, exitASAP)
+        if ((0, duration_1.isDuration)(duration)) {
+            return (0, on_1.wrapOn)(jvmDuring.during((0, duration_1.toJvmDuration)(duration), arg1, arg2), wrap);
+        }
+        else if (typeof duration === "function") {
+            return (0, on_1.wrapOn)(jvmDuring.during((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg1, arg2), wrap);
+        }
+        else {
+            return (0, on_1.wrapOn)(jvmDuring.during(duration, arg1, arg2), wrap);
+        }
+    }
+    else if (typeof arg1 === "string") {
+        // during(duration, counterName)
+        if ((0, duration_1.isDuration)(duration)) {
+            return (0, on_1.wrapOn)(jvmDuring.during((0, duration_1.toJvmDuration)(duration), arg1), wrap);
+        }
+        else if (typeof duration === "function") {
+            return (0, on_1.wrapOn)(jvmDuring.during((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg1), wrap);
+        }
+        else {
+            return (0, on_1.wrapOn)(jvmDuring.during(duration, arg1), wrap);
+        }
+    }
+    else if (typeof arg1 === "boolean") {
+        // during(duration, exitASAP)
+        if ((0, duration_1.isDuration)(duration)) {
+            return (0, on_1.wrapOn)(jvmDuring.during((0, duration_1.toJvmDuration)(duration), arg1), wrap);
+        }
+        else if (typeof duration === "function") {
+            return (0, on_1.wrapOn)(jvmDuring.during((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg1), wrap);
+        }
+        else {
+            return (0, on_1.wrapOn)(jvmDuring.during(duration, arg1), wrap);
+        }
+    }
+    else if (arg1 === undefined) {
+        // during(duration)
+        if ((0, duration_1.isDuration)(duration)) {
+            return (0, on_1.wrapOn)(jvmDuring.during((0, duration_1.toJvmDuration)(duration)), wrap);
+        }
+        else if (typeof duration === "function") {
+            return (0, on_1.wrapOn)(jvmDuring.during((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration))), wrap);
+        }
+        else {
+            return (0, on_1.wrapOn)(jvmDuring.during(duration), wrap);
+        }
+    }
+    throw Error(`during() called with invalid arguments ${duration}, ${arg1}, ${arg2}`);
+};
+exports.duringImpl = duringImpl;

package/target/structure/errors.d.ts

@@ -0,0 +1,121 @@
+import "@gatling.io/jvm-types";
+import JvmErrors = io.gatling.javaapi.core.error.Errors;
+import { SessionTo } from "../session";
+import { On } from "./on";
+export interface ExitBlockOnFailFunction<T extends Errors<T>> {
+    /**
+     * Define a block that is interrupted for a given virtual user if it experiences a failure.
+     *
+     * @returns a DSL component for defining the tried block
+     */
+    (): On<T>;
+}
+export interface TryMaxFunction<T extends Errors<T>> {
+    /**
+     * Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
+     *
+     * @param times - the maximum number of tries, including the first one (hence number of retries + 1)
+     * @returns a DSL component for defining the tried block
+     */
+    (times: number | string | SessionTo<number>): On<T>;
+    /**
+     * Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
+     *
+     * @param times - the maximum number of tries, including the first one (hence number of retries + 1)
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a DSL component for defining the tried block
+     */
+    (times: number | string | SessionTo<number>, counterName: string): On<T>;
+}
+export interface ExitHereIfFunction<T extends Errors<T>> {
+    /**
+     * Have the virtual user exit here if the condition holds true
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @returns a new StructureBuilder
+     */
+    (condition: string): T;
+    /**
+     * Have the virtual user exit here if the condition holds true
+     *
+     * @param condition - the condition, expressed as a function
+     * @returns a new StructureBuilder
+     */
+    (condition: SessionTo<boolean>): T;
+}
+export interface ExitHereFunction<T extends Errors<T>> {
+    /**
+     * Have the virtual user exit here
+     *
+     * @returns a new StructureBuilder
+     */
+    (): T;
+}
+export interface ExitHereIfFailedFunction<T extends Errors<T>> {
+    /**
+     * Have the virtual user exit here if the state of its Session is failed
+     *
+     * @returns a new StructureBuilder
+     */
+    (): T;
+}
+export interface StopInjectorFunction<T extends Errors<T>> {
+    /**
+     * Have the virtual user abruptly stop the injector
+     *
+     * @param message - the message, expressed as a Gatling Expression Language String
+     * @returns a new StructureBuilder
+     */
+    (message: string): T;
+    /**
+     * Have the virtual user abruptly stop the injector
+     *
+     * @param message - the message, expressed as a function
+     * @returns a new StructureBuilder
+     */
+    (message: SessionTo<string>): T;
+}
+export interface StopInjectorIfFunction<T extends Errors<T>> {
+    /**
+     * Have the virtual user abruptly stop the injector if a condition is met
+     *
+     * @param message - the message, expressed as a Gatling Expression Language String
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @returns a new StructureBuilder
+     */
+    (message: string, condition: string): T;
+    /**
+     * Have the virtual user abruptly stop the injector if a condition is met
+     *
+     * @param message - the message, expressed as a Gatling Expression Language String
+     * @param condition - the condition, expressed as a function
+     * @returns a new StructureBuilder
+     */
+    (message: string, condition: SessionTo<boolean>): T;
+    /**
+     * Have the virtual user abruptly stop the injector if a condition is met
+     *
+     * @param message - the message, expressed as a function
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @returns a new StructureBuilder
+     */
+    (message: SessionTo<string>, condition: string): T;
+    /**
+     * Have the virtual user abruptly stop the injector if a condition is met
+     *
+     * @param message - the message, expressed as a function
+     * @param condition - the condition, expressed as a function
+     * @returns a new StructureBuilder
+     */
+    (message: SessionTo<string>, condition: SessionTo<boolean>): T;
+}
+export interface Errors<T extends Errors<T>> {
+    exitBlockOnFail: ExitBlockOnFailFunction<T>;
+    tryMax: TryMaxFunction<T>;
+    exitHereIf: ExitHereIfFunction<T>;
+    exitHere: ExitHereFunction<T>;
+    exitHereIfFailed: ExitHereIfFailedFunction<T>;
+    stopInjector: StopInjectorFunction<T>;
+    stopInjectorIf: StopInjectorIfFunction<T>;
+}
+export declare const errorsImpl: <J2, J1 extends JvmErrors<J2, any>, T extends Errors<T>>(jvmErrors: J1, wrap: (wrapped: J2) => T) => Errors<T>;

package/target/structure/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorsImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const on_1 = require("./on");
+const errorsImpl = (jvmErrors, wrap) => ({
+    exitBlockOnFail: () => (0, on_1.wrapOn)(jvmErrors.exitBlockOnFail(), wrap),
+    tryMax: (times) => (0, on_1.wrapOn)(typeof times === "function"
+        ? jvmErrors.tryMax((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(times)))
+        : typeof times === "string"
+            ? jvmErrors.tryMax(times)
+            : jvmErrors.tryMax(times), wrap),
+    exitHereIf: (condition) => wrap(typeof condition === "function"
+        ? jvmErrors.exitHereIf((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition)))
+        : jvmErrors.exitHereIf(condition)),
+    exitHere: () => wrap(jvmErrors.exitHere()),
+    exitHereIfFailed: () => wrap(jvmErrors.exitHereIfFailed()),
+    stopInjector: (message) => wrap(typeof message === "function"
+        ? jvmErrors.stopInjector((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(message)))
+        : jvmErrors.stopInjector(message)),
+    stopInjectorIf: (message, condition) => {
+        if (typeof message === "function") {
+            if (typeof condition === "function") {
+                return wrap(jvmErrors.stopInjectorIf((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(message)), (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition))));
+            }
+            else {
+                return wrap(jvmErrors.stopInjectorIf((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(message)), condition));
+            }
+        }
+        else {
+            if (typeof condition === "function") {
+                return wrap(jvmErrors.stopInjectorIf(message, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition))));
+            }
+            else {
+                return wrap(jvmErrors.stopInjectorIf(message, condition));
+            }
+        }
+    }
+});
+exports.errorsImpl = errorsImpl;