@gatling.io/core 0.1.0

package/target/structure/asLongAsDuring.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asLongAsDuringImpl = 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 asLongAsDuringImpl = (jvmAsLongAsDuring, wrap) => (condition, duration, arg2, arg3) => {
+    if (arg3 !== undefined && typeof arg2 === "string") {
+        // asLongAsDuring(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)(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, (0, duration_1.toJvmDuration)(duration), arg2, arg3), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(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)(jvmAsLongAsDuring.asLongAsDuring(condition, (0, duration_1.toJvmDuration)(duration), arg2, arg3), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(condition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2, arg3), wrap);
+            }
+        }
+    }
+    else if (typeof arg2 === "string") {
+        // asLongAsDuring(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)(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, (0, duration_1.toJvmDuration)(duration), arg2), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2), wrap);
+            }
+        }
+        else {
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(condition, (0, duration_1.toJvmDuration)(duration), arg2), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(condition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2), wrap);
+            }
+        }
+    }
+    else if (typeof arg2 === "boolean") {
+        // asLongAsDuring(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)(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, (0, duration_1.toJvmDuration)(duration), arg2), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2), wrap);
+            }
+        }
+        else {
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(condition, (0, duration_1.toJvmDuration)(duration), arg2), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(condition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration)), arg2), wrap);
+            }
+        }
+    }
+    else if (arg2 === undefined) {
+        // asLongAsDuring(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)(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, (0, duration_1.toJvmDuration)(duration)), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration))), wrap);
+            }
+        }
+        else {
+            if ((0, duration_1.isDuration)(duration)) {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(condition, (0, duration_1.toJvmDuration)(duration)), wrap);
+            }
+            else if (typeof duration === "function") {
+                return (0, on_1.wrapOn)(jvmAsLongAsDuring.asLongAsDuring(condition, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(duration))), wrap);
+            }
+        }
+    }
+    throw Error(`asLongAsDuring() called with invalid arguments ${condition}, ${duration}, ${arg2}, ${arg3}`);
+};
+exports.asLongAsDuringImpl = asLongAsDuringImpl;

package/target/structure/choices.d.ts

@@ -0,0 +1,18 @@
+import "@gatling.io/jvm-types";
+import JvmChoiceWithKey = io.gatling.javaapi.core.Choice$WithKey;
+import JvmChoiceWithWeight = io.gatling.javaapi.core.Choice$WithWeight;
+import { Wrapper } from "../common";
+import { Executable } from "./execs";
+export interface ChoiceWithKey extends Wrapper<JvmChoiceWithKey> {
+}
+interface ChoiceWithKeyThen {
+    then(executable: Executable<any>, ...executables: Executable<any>[]): ChoiceWithKey;
+}
+export declare const onCase: (key: unknown) => ChoiceWithKeyThen;
+export interface ChoiceWithWeight extends Wrapper<JvmChoiceWithWeight> {
+}
+interface ChoiceWithWeightThen {
+    then(executable: Executable<any>, ...executables: Executable<any>[]): ChoiceWithWeight;
+}
+export declare const percent: (percent: number) => ChoiceWithWeightThen;
+export {};

package/target/structure/choices.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.percent = exports.onCase = void 0;
+require("@gatling.io/jvm-types");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const wrapChoiceWithKey = (_underlying) => ({
+    _underlying
+});
+const wrapChoiceWithKeyThen = (jvmChoiceWithKeyThen) => ({
+    then: (executable, ...executables) => wrapChoiceWithKey(jvmChoiceWithKeyThen.then(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+const onCase = (key) => wrapChoiceWithKeyThen(jvm_types_1.CoreDsl.onCase(key));
+exports.onCase = onCase;
+const wrapChoiceWithWeight = (_underlying) => ({
+    _underlying
+});
+const wrapChoiceWithWeightThen = (jvmChoiceWithWeightThen) => ({
+    then: (executable, ...executables) => wrapChoiceWithWeight(jvmChoiceWithWeightThen.then(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+const percent = (percent) => wrapChoiceWithWeightThen(jvm_types_1.CoreDsl.percent(percent));
+exports.percent = percent;

package/target/structure/doIf.d.ts

@@ -0,0 +1,83 @@
+import "@gatling.io/jvm-types";
+import JvmDoIf = io.gatling.javaapi.core.condition.DoIf;
+import JvmDoIfEquals = io.gatling.javaapi.core.condition.DoIfEquals;
+import { SessionTo } from "../session";
+import { Executable } from "./execs";
+export interface Then<T> {
+    then(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+export interface DoIfFunction<T extends DoIf<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 DoIf<T extends DoIf<T>> {
+    doIf: DoIfFunction<T>;
+}
+export declare const doIfImpl: <J2, J1 extends JvmDoIf<J2, any>, T extends DoIf<T>>(jvmDoIf: J1, wrap: (wrapped: J2) => T) => DoIfFunction<T>;
+export interface DoIfEqualsFunction<T extends DoIfEquals<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 Gatling Expression Language String
+     * @param expected - the expected value expressed as a function
+     * @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 DoIfEquals<T extends DoIfEquals<T>> {
+    doIfEquals: DoIfEqualsFunction<T>;
+}
+export declare const doIfEqualsImpl: <J2, J1 extends JvmDoIfEquals<J2, any>, T extends DoIfEquals<T>>(jvmDoIfEquals: J1, wrap: (wrapped: J2) => T) => DoIfEqualsFunction<T>;

package/target/structure/doIf.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doIfEqualsImpl = exports.doIfImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const wrapThen = (jvmThen, wrap) => ({
+    then: (executable, ...executables) => wrap(jvmThen.then(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+const doIfImpl = (jvmDoIf, wrap) => (condition) => wrapThen(typeof condition === "function"
+    ? jvmDoIf.doIf((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition)))
+    : jvmDoIf.doIf(condition), wrap);
+exports.doIfImpl = doIfImpl;
+const doIfEqualsImpl = (jvmDoIfEquals, wrap) => (actual, expected) => {
+    if (typeof actual === "function") {
+        const wrappedActual = (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(actual));
+        if (typeof expected === "function") {
+            return wrapThen(jvmDoIfEquals.doIfEquals(wrappedActual, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(expected))), wrap);
+        }
+        else if (typeof expected === "string") {
+            return wrapThen(jvmDoIfEquals.doIfEquals(wrappedActual, expected), wrap);
+        }
+        else {
+            return wrapThen(jvmDoIfEquals.doIfEquals(wrappedActual, expected), wrap);
+        }
+    }
+    else {
+        if (typeof expected === "function") {
+            return wrapThen(jvmDoIfEquals.doIfEquals(actual, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(expected))), wrap);
+        }
+        else if (typeof expected === "string") {
+            return wrapThen(jvmDoIfEquals.doIfEquals(actual, expected), wrap);
+        }
+        else {
+            return wrapThen(jvmDoIfEquals.doIfEquals(actual, expected), wrap);
+        }
+    }
+};
+exports.doIfEqualsImpl = doIfEqualsImpl;

package/target/structure/doIfOrElse.d.ts

@@ -0,0 +1,86 @@
+import "@gatling.io/jvm-types";
+import JvmDoIfOrElse = io.gatling.javaapi.core.condition.DoIfOrElse;
+import JvmDoIfEqualsOrElse = io.gatling.javaapi.core.condition.DoIfEqualsOrElse;
+import { SessionTo } from "../session";
+import { Executable } from "./execs";
+export interface Then<T> {
+    then(executable: Executable<any>, ...executables: Executable<any>[]): OrElse<T>;
+}
+export interface OrElse<T> {
+    orElse(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+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 declare const doIfOrElseImpl: <J2, J1 extends JvmDoIfOrElse<J2, any>, T extends DoIfOrElse<T>>(jvmDoIfOrElse: J1, wrap: (wrapped: J2) => T) => DoIfOrElseFunction<T>;
+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 declare const doIfEqualsOrElseImpl: <J2, J1 extends JvmDoIfEqualsOrElse<J2, any>, T extends DoIfEqualsOrElse<T>>(jvmDoIfEqualsOrElse: J1, wrap: (wrapped: J2) => T) => DoIfEqualsOrElseFunction<T>;

package/target/structure/doIfOrElse.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doIfEqualsOrElseImpl = exports.doIfOrElseImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const wrapThen = (jvmThen, wrap) => ({
+    then: (executable, ...executables) => wrapOrElse(jvmThen.then(executable._underlying, ...executables.map((e) => e._underlying)), wrap)
+});
+const wrapOrElse = (jvmOrElse, wrap) => ({
+    orElse: (executable, ...executables) => wrap(jvmOrElse.orElse(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+const doIfOrElseImpl = (jvmDoIfOrElse, wrap) => (condition) => wrapThen(typeof condition === "function"
+    ? jvmDoIfOrElse.doIfOrElse((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition)))
+    : jvmDoIfOrElse.doIfOrElse(condition), wrap);
+exports.doIfOrElseImpl = doIfOrElseImpl;
+const doIfEqualsOrElseImpl = (jvmDoIfEqualsOrElse, wrap) => (actual, expected) => {
+    if (typeof actual === "function") {
+        const wrappedActual = (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(actual));
+        if (typeof expected === "function") {
+            return wrapThen(jvmDoIfEqualsOrElse.doIfEqualsOrElse(wrappedActual, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(expected))), 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, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(expected))), wrap);
+        }
+        else if (typeof expected === "string") {
+            return wrapThen(jvmDoIfEqualsOrElse.doIfEqualsOrElse(actual, expected), wrap);
+        }
+        else {
+            return wrapThen(jvmDoIfEqualsOrElse.doIfEqualsOrElse(actual, expected), wrap);
+        }
+    }
+};
+exports.doIfEqualsOrElseImpl = doIfEqualsOrElseImpl;

package/target/structure/doSwitch.d.ts

@@ -0,0 +1,27 @@
+import "@gatling.io/jvm-types";
+import JvmDoSwitch = io.gatling.javaapi.core.condition.DoSwitch;
+import { SessionTo } from "../session";
+import { ChoiceWithKey } from "./choices";
+export interface On<T> {
+    on(...choices: ChoiceWithKey[]): T;
+}
+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 declare const doSwitchImpl: <J2, J1 extends JvmDoSwitch<J2, any>, T extends DoSwitch<T>>(jvmDoSwitch: J1, wrap: (wrapped: J2) => T) => DoSwitchFunction<T>;

package/target/structure/doSwitch.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doSwitchImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const wrapOn = (jvmOn, wrap) => ({
+    on: (...choices) => wrap(jvmOn.on(choices.map((c) => c._underlying)))
+});
+const doSwitchImpl = (jvmDoSwitch, wrap) => (actual) => wrapOn(typeof actual === "function"
+    ? jvmDoSwitch.doSwitch((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(actual)))
+    : jvmDoSwitch.doSwitch(actual), wrap);
+exports.doSwitchImpl = doSwitchImpl;

package/target/structure/doSwitchOrElse.d.ts

@@ -0,0 +1,34 @@
+import "@gatling.io/jvm-types";
+import JvmDoSwitchOrElse = io.gatling.javaapi.core.condition.DoSwitchOrElse;
+import { SessionTo } from "../session";
+import { ChoiceWithKey } from "./choices";
+import { Executable } from "./execs";
+export interface On<T> {
+    on(...choices: ChoiceWithKey[]): OrElse<T>;
+}
+interface OrElse<T> {
+    orElse(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+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 declare const doSwitchOrElseImpl: <J2, J1 extends JvmDoSwitchOrElse<J2, any>, T extends DoSwitchOrElse<T>>(jvmDoSwitchOrElse: J1, wrap: (wrapped: J2) => T) => DoSwitchOrElseFunction<T>;
+export {};

package/target/structure/doSwitchOrElse.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doSwitchOrElseImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const wrapOn = (jvmOn, wrap) => ({
+    on: (...choices) => wrapOrElse(jvmOn.on(choices.map((c) => c._underlying)), wrap)
+});
+const wrapOrElse = (jvmOrElse, wrap) => ({
+    orElse: (executable, ...executables) => wrap(jvmOrElse.orElse(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+const doSwitchOrElseImpl = (jvmDoSwitchOrElse, wrap) => (actual) => wrapOn(typeof actual === "function"
+    ? jvmDoSwitchOrElse.doSwitchOrElse((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(actual)))
+    : jvmDoSwitchOrElse.doSwitchOrElse(actual), wrap);
+exports.doSwitchOrElseImpl = doSwitchOrElseImpl;

package/target/structure/doWhile.d.ts

@@ -0,0 +1,28 @@
+import "@gatling.io/jvm-types";
+import JvmDoWhile = io.gatling.javaapi.core.loop.DoWhile;
+import { SessionTo } from "../session";
+import { On } from "./on";
+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 declare const doWhileImpl: <J2, J1 extends JvmDoWhile<J2, any>, T extends DoWhile<T>>(jvmDoWhile: J1, wrap: (wrapped: J2) => T) => DoWhileFunction<T>;

package/target/structure/doWhile.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doWhileImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const on_1 = require("./on");
+const doWhileImpl = (jvmDoWhile, wrap) => (condition, counterName) => {
+    if (counterName !== undefined) {
+        // doWhile(condition, counterName)
+        if (typeof condition === "function") {
+            return (0, on_1.wrapOn)(jvmDoWhile.doWhile((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition)), counterName), wrap);
+        }
+        else {
+            return (0, on_1.wrapOn)(jvmDoWhile.doWhile(condition, counterName), wrap);
+        }
+    }
+    else {
+        // doWhile(condition)
+        if (typeof condition === "function") {
+            return (0, on_1.wrapOn)(jvmDoWhile.doWhile((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(condition))), wrap);
+        }
+        else {
+            return (0, on_1.wrapOn)(jvmDoWhile.doWhile(condition), wrap);
+        }
+    }
+};
+exports.doWhileImpl = doWhileImpl;