@gatling.io/core 0.1.0

package/target/openInjection.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incrementUsersPerSec = exports.nothingFor = exports.rampUsersPerSec = exports.constantUsersPerSec = exports.atOnceUsers = exports.stressPeakUsers = exports.rampUsers = void 0;
+require("@gatling.io/jvm-types");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const duration_1 = require("./utils/duration");
+const wrapOpenInjectionStep = (_underlying) => ({ _underlying });
+const wrapConstantRateOpenInjectionStep = (_underlying) => ({
+    _underlying,
+    randomized: () => wrapOpenInjectionStep(_underlying.randomized())
+});
+const wrapOpenInjectionStepRamp = (_underlying) => ({
+    _underlying,
+    during: (duration) => wrapOpenInjectionStep(_underlying.during((0, duration_1.toJvmDuration)(duration)))
+});
+const wrapOpenInjectionStepStressPeak = (_underlying) => ({
+    _underlying,
+    during: (duration) => wrapOpenInjectionStep(_underlying.during((0, duration_1.toJvmDuration)(duration)))
+});
+const wrapOpenInjectionStepConstantRate = (_underlying) => ({
+    _underlying,
+    during: (duration) => wrapConstantRateOpenInjectionStep(_underlying.during((0, duration_1.toJvmDuration)(duration)))
+});
+const wrapOpenInjectionStepRampRate = (_underlying) => ({
+    _underlying,
+    to: (to) => wrapOpenInjectionStepRampRateDuring(_underlying.to(to))
+});
+const wrapOpenInjectionStepRampRateDuring = (_underlying) => ({
+    _underlying,
+    during: (duration) => wrapRampRateOpenInjectionStep(_underlying.during((0, duration_1.toJvmDuration)(duration)))
+});
+const wrapRampRateOpenInjectionStep = (_underlying) => ({
+    _underlying,
+    randomized: () => wrapOpenInjectionStep(_underlying.randomized())
+});
+const wrapOpenInjectionStepStairs = (_underlying) => ({
+    _underlying,
+    times: (levels) => wrapOpenInjectionStepStairsTimes(_underlying.times(levels))
+});
+const wrapOpenInjectionStepStairsTimes = (_underlying) => ({
+    _underlying,
+    eachLevelLasting: (duration) => wrapOpenInjectionStepStairsComposite(_underlying.eachLevelLasting((0, duration_1.toJvmDuration)(duration)))
+});
+const wrapOpenInjectionStepStairsComposite = (_underlying) => ({
+    _underlying,
+    startingFrom: (startingRate) => wrapOpenInjectionStepStairsComposite(_underlying.startingFrom(startingRate)),
+    separatedByRampsLasting: (duration) => wrapOpenInjectionStepStairsComposite(_underlying.separatedByRampsLasting((0, duration_1.toJvmDuration)(duration)))
+});
+const rampUsers = (users) => wrapOpenInjectionStepRamp(jvm_types_1.CoreDsl.rampUsers(users));
+exports.rampUsers = rampUsers;
+const stressPeakUsers = (users) => wrapOpenInjectionStepStressPeak(jvm_types_1.CoreDsl.stressPeakUsers(users));
+exports.stressPeakUsers = stressPeakUsers;
+const atOnceUsers = (users) => wrapOpenInjectionStep(jvm_types_1.CoreDsl.atOnceUsers(users));
+exports.atOnceUsers = atOnceUsers;
+const constantUsersPerSec = (rate) => wrapOpenInjectionStepConstantRate(jvm_types_1.CoreDsl.constantUsersPerSec(rate));
+exports.constantUsersPerSec = constantUsersPerSec;
+const rampUsersPerSec = (rate) => wrapOpenInjectionStepRampRate(jvm_types_1.CoreDsl.rampUsersPerSec(rate));
+exports.rampUsersPerSec = rampUsersPerSec;
+const nothingFor = (duration) => wrapOpenInjectionStep(jvm_types_1.CoreDsl.nothingFor((0, duration_1.toJvmDuration)(duration)));
+exports.nothingFor = nothingFor;
+const incrementUsersPerSec = (rateIncrement) => wrapOpenInjectionStepStairs(jvm_types_1.CoreDsl.incrementUsersPerSec(rateIncrement));
+exports.incrementUsersPerSec = incrementUsersPerSec;

package/target/population.d.ts

@@ -0,0 +1,82 @@
+import "@gatling.io/jvm-types";
+import JvmPopulationBuilder = io.gatling.javaapi.core.PopulationBuilder;
+import { Wrapper } from "./common";
+import { ProtocolBuilder } from "./protocol";
+import { SessionTo } from "./session";
+import { Duration } from "./utils/duration";
+import { PauseType } from "./structure/pauses";
+import { ThrottleStep } from "./throttling";
+/**
+ * A builder for a Population = a Scenario + an injection profile.
+ *
+ * Immutable, meaning each method doesn't mutate the current instance but return a new one.
+ */
+export interface PopulationBuilder extends Wrapper<JvmPopulationBuilder> {
+    /**
+     * Define the optional protocols for this PopulationBuilder
+     *
+     * @param protocols - the protocols
+     * @returns a new PopulationBuilder
+     */
+    protocols(...protocols: ProtocolBuilder[]): PopulationBuilder;
+    /**
+     * Define some other PopulationBuilder to be executed once all the users of this PopulationBuilder
+     * complete their Scenario.
+     *
+     * @param children - the children PopulationBuilder
+     * @returns a new PopulationBuilder
+     */
+    andThen(...children: PopulationBuilder[]): PopulationBuilder;
+    /**
+     * Disable the pauses
+     *
+     * @return a new PopulationBuilder
+     */
+    disablePauses(): PopulationBuilder;
+    /**
+     * Use constant pauses
+     *
+     * @return a new PopulationBuilder
+     */
+    constantPauses(): PopulationBuilder;
+    /**
+     * Use exponential pauses
+     *
+     * @return a new PopulationBuilder
+     */
+    exponentialPauses(): PopulationBuilder;
+    /**
+     * Use custom pauses
+     *
+     * @return a new PopulationBuilder
+     */
+    customPauses(f: SessionTo<number>): PopulationBuilder;
+    /**
+     * Use uniform pauses with a standard deviation percentage
+     *
+     * @return a new PopulationBuilder
+     */
+    uniformPauses(plusOrMinus: Duration): PopulationBuilder;
+    /**
+     * Use pauses configured with a given strategy
+     *
+     * @param pauseType the pause type
+     * @return a new PopulationBuilder
+     */
+    pauses(pauseType: PauseType): PopulationBuilder;
+    /**
+     * Define the optional throttling profile
+     *
+     * @param throttleSteps the throttling profile steps
+     * @return a new PopulationBuilder
+     */
+    throttle(...throttleSteps: ThrottleStep[]): PopulationBuilder;
+    /**
+     * Disable the injection profile sharding that happens normally when running with Gatling
+     * Enterprise. Only effective when the test is running with Gatling Enterprise, noop otherwise.
+     *
+     * @return a new PopulationBuilder
+     */
+    noShard(): PopulationBuilder;
+}
+export declare const wrapPopulationBuilder: (_underlying: JvmPopulationBuilder) => PopulationBuilder;

package/target/population.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapPopulationBuilder = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("./session");
+const duration_1 = require("./utils/duration");
+const pauses_1 = require("./structure/pauses");
+const callbacks_1 = require("./gatlingJvm/callbacks");
+const wrapPopulationBuilder = (_underlying) => ({
+    _underlying,
+    protocols: (...protocols) => (0, exports.wrapPopulationBuilder)(_underlying.protocols(protocols.map((p) => p._underlying))),
+    andThen: (...children) => (0, exports.wrapPopulationBuilder)(_underlying.andThen(children.map((c) => c._underlying))),
+    disablePauses: () => (0, exports.wrapPopulationBuilder)(_underlying.disablePauses()),
+    constantPauses: () => (0, exports.wrapPopulationBuilder)(_underlying.constantPauses()),
+    exponentialPauses: () => (0, exports.wrapPopulationBuilder)(_underlying.exponentialPauses()),
+    customPauses: (f) => (0, exports.wrapPopulationBuilder)(_underlying.customPauses((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(f)))),
+    uniformPauses: (plusOrMinus) => (0, exports.wrapPopulationBuilder)(_underlying.uniformPauses((0, duration_1.toJvmDuration)(plusOrMinus))),
+    pauses: (pauseType) => (0, exports.wrapPopulationBuilder)(_underlying.pauses((0, pauses_1.toJvmPauseType)(pauseType))),
+    throttle: (...throttleSteps) => (0, exports.wrapPopulationBuilder)(_underlying.throttle(throttleSteps.map((t) => t._underlying))),
+    noShard: () => (0, exports.wrapPopulationBuilder)(_underlying.noShard())
+});
+exports.wrapPopulationBuilder = wrapPopulationBuilder;

package/target/protocol.d.ts

@@ -0,0 +1,5 @@
+import "@gatling.io/jvm-types";
+import JvmProtocolBuilder = io.gatling.javaapi.core.ProtocolBuilder;
+import { Wrapper } from "./common";
+export interface ProtocolBuilder extends Wrapper<JvmProtocolBuilder> {
+}

package/target/protocol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@gatling.io/jvm-types");

package/target/scenario.d.ts

@@ -0,0 +1,10 @@
+import "@gatling.io/jvm-types";
+import { StructureBuilder } from "./structure";
+import { ClosedInjectionStep } from "./closedInjection";
+import { OpenInjectionStep } from "./openInjection";
+import { PopulationBuilder } from "./population";
+export interface ScenarioBuilder extends StructureBuilder<ScenarioBuilder> {
+    injectOpen(...steps: OpenInjectionStep[]): PopulationBuilder;
+    injectClosed(...steps: ClosedInjectionStep[]): PopulationBuilder;
+}
+export declare const scenario: (name: string) => ScenarioBuilder;

package/target/scenario.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scenario = void 0;
+require("@gatling.io/jvm-types");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const structure_1 = require("./structure");
+const population_1 = require("./population");
+const wrapScenarioBuilder = (jvmScenarioBuilder) => ({
+    injectOpen: (...steps) => (0, population_1.wrapPopulationBuilder)(jvmScenarioBuilder.injectOpen(steps.map((s) => s._underlying))),
+    injectClosed: (...steps) => (0, population_1.wrapPopulationBuilder)(jvmScenarioBuilder.injectClosed(steps.map((s) => s._underlying))),
+    ...(0, structure_1.structureBuilderImpl)(jvmScenarioBuilder, wrapScenarioBuilder)
+});
+const scenario = (name) => {
+    const jvmScenarioBuilder = jvm_types_1.CoreDsl.scenario(name);
+    return wrapScenarioBuilder(jvmScenarioBuilder);
+};
+exports.scenario = scenario;

package/target/session.d.ts

@@ -0,0 +1,28 @@
+import { Duration } from "./utils/duration";
+import { Wrapper } from "./common";
+import JvmSession = io.gatling.javaapi.core.Session;
+export interface Session extends Wrapper<JvmSession> {
+    get<T>(key: string): T;
+    set(key: string, value: any): Session;
+    setByteArray(key: string, value: number[]): Session;
+    setAll(newAttributes: Record<string, any>): Session;
+    remove(key: string): Session;
+    reset(): Session;
+    removeAll(...keys: string[]): Session;
+    contains(key: string): boolean;
+    isFailed(): boolean;
+    markAsSucceeded(): Session;
+    markAsFailed(): Session;
+    scenario(): string;
+    groups(): string[];
+    userId(): number;
+}
+export declare const wrapSession: (_underlying: JvmSession) => Session;
+export type Expression<T> = T | ((session: Session) => T);
+export type SessionTransform = (session: Session) => Session;
+export declare const underlyingSessionTransform: (f: SessionTransform) => ((jvmSession: JvmSession) => JvmSession);
+export type SessionTo<T> = (session: Session) => T;
+export declare const underlyingSessionTo: <T>(f: SessionTo<T>) => ((jvmSession: JvmSession) => T);
+export declare const underlyingSessionToJava: <T>(f: SessionTo<T>) => ((jvmSession: JvmSession) => unknown);
+export declare const underlyingSessionToDuration: (f: SessionTo<Duration>) => ((jvmSession: JvmSession) => java.time.Duration);
+export declare const underlyingXWithSessionTo: <X, X2>(f: (x: X, session: Session) => X2) => ((x: X, jvmSession: JvmSession) => X2);

package/target/session.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.underlyingXWithSessionTo = exports.underlyingSessionToDuration = exports.underlyingSessionToJava = exports.underlyingSessionTo = exports.underlyingSessionTransform = exports.wrapSession = void 0;
+const callbacks_1 = require("./gatlingJvm/callbacks");
+const collections_1 = require("./gatlingJvm/collections");
+const duration_1 = require("./utils/duration");
+const wrapSession = (_underlying) => ({
+    _underlying,
+    get: (key) => _underlying.get(key),
+    set: (key, value) => {
+        return (0, exports.wrapSession)(_underlying.set(key, (0, collections_1.asJava)(value)));
+    },
+    setByteArray: (key, value) => (0, exports.wrapSession)(_underlying.set(key, (0, callbacks_1.wrapByteArray)(value))),
+    setAll: (newAttributes) => {
+        let session = _underlying;
+        for (const key in newAttributes) {
+            session = session.set(key, (0, collections_1.asJava)(newAttributes[key]));
+        }
+        return (0, exports.wrapSession)(session);
+    },
+    remove: (key) => (0, exports.wrapSession)(_underlying.remove(key)),
+    reset: () => (0, exports.wrapSession)(_underlying.reset()),
+    removeAll: (...keys) => (0, exports.wrapSession)(_underlying.removeAll(...keys)),
+    contains: (key) => _underlying.contains(key),
+    isFailed: () => _underlying.isFailed(),
+    markAsSucceeded: () => (0, exports.wrapSession)(_underlying.markAsSucceeded()),
+    markAsFailed: () => (0, exports.wrapSession)(_underlying.markAsFailed()),
+    scenario: () => _underlying.scenario(),
+    groups: () => _underlying.groups(),
+    userId: () => _underlying.userId()
+});
+exports.wrapSession = wrapSession;
+const underlyingSessionTransform = (f) => (jvmSession) => f((0, exports.wrapSession)(jvmSession))._underlying;
+exports.underlyingSessionTransform = underlyingSessionTransform;
+const underlyingSessionTo = (f) => (jvmSession) => f((0, exports.wrapSession)(jvmSession));
+exports.underlyingSessionTo = underlyingSessionTo;
+const underlyingSessionToJava = (f) => (jvmSession) => (0, collections_1.asJava)(f((0, exports.wrapSession)(jvmSession)));
+exports.underlyingSessionToJava = underlyingSessionToJava;
+const underlyingSessionToDuration = (f) => (jvmSession) => (0, duration_1.toJvmDuration)(f((0, exports.wrapSession)(jvmSession)));
+exports.underlyingSessionToDuration = underlyingSessionToDuration;
+const underlyingXWithSessionTo = (f) => (x, jvmSession) => f(x, (0, exports.wrapSession)(jvmSession));
+exports.underlyingXWithSessionTo = underlyingXWithSessionTo;

package/target/structure/asLongAs.d.ts

@@ -0,0 +1,74 @@
+import "@gatling.io/jvm-types";
+import JvmAsLongAs = io.gatling.javaapi.core.loop.AsLongAs;
+import { SessionTo } from "../session";
+import { On } from "./on";
+export interface AsLongAsFunction<T extends AsLongAs<T>> {
+    /**
+     * Define a loop that will iterate as long as the condition holds true
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @returns a DSL component for defining the loop content
+     */
+    (condition: string): On<T>;
+    /**
+     * Define a loop that will iterate as long as the condition holds true
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @param exitASAP - if the loop must be interrupted if the condition becomes false inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (condition: string, exitASAP: boolean): On<T>;
+    /**
+     * Define a loop that will iterate as long as the condition holds true
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns 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
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @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 inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (condition: string, counterName: string, exitASAP: boolean): On<T>;
+    /**
+     * Define a loop that will iterate as long as the condition holds true
+     *
+     * @param condition - the condition, expressed as a function
+     * @returns a DSL component for defining the loop content
+     */
+    (condition: SessionTo<boolean>): On<T>;
+    /**
+     * Define a loop that will iterate as long as the condition holds true
+     *
+     * @param condition - the condition, expressed as a function
+     * @param exitASAP - if the loop must be interrupted if the condition becomes false inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (condition: SessionTo<boolean>, exitASAP: boolean): On<T>;
+    /**
+     * Define a loop that will iterate as long as the condition holds true
+     *
+     * @param condition - the condition, 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>, counterName: string): On<T>;
+    /**
+     * Define a loop that will iterate as long as the condition holds true
+     *
+     * @param condition - the condition, 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 inside the loop
+     * @returns a DSL component for defining the loop content
+     */
+    (condition: SessionTo<boolean>, counterName: string, exitASAP: boolean): On<T>;
+}
+export interface AsLongAs<T extends AsLongAs<T>> {
+    asLongAs: AsLongAsFunction<T>;
+}
+export declare const asLongAsImpl: <J2, J1 extends JvmAsLongAs<J2, any>, T extends AsLongAs<T>>(jvmAsLongAs: J1, wrap: (wrapped: J2) => T) => AsLongAsFunction<T>;

package/target/structure/asLongAs.js

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

package/target/structure/asLongAsDuring.d.ts

@@ -0,0 +1,221 @@
+import "@gatling.io/jvm-types";
+import JvmAsLongAsDuring = io.gatling.javaapi.core.loop.AsLongAsDuring;
+import { Duration } from "../utils/duration";
+import { SessionTo } from "../session";
+import { On } from "./on";
+export interface AsLongAsDuringFunction<T extends AsLongAsDuring<T>> {
+    /**
+     * Define a loop that will iterate as long as the condition holds true and a maximum duration
+     * isn't reached
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @param duration - the maximum duration, in seconds or 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
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @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
+     */
+    (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
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @param duration - the maximum duration, in seconds or 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
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @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 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
+     *
+     * @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
+     *
+     * @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
+     *
+     * @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
+     *
+     * @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
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @param duration - the maximum duration, expressed as a Gatling Expression Language String
+     * @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
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @param duration - the maximum duration, expressed as a Gatling Expression Language String
+     * @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
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @param duration - the maximum duration, expressed as a Gatling Expression Language String
+     * @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
+     *
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @param duration - the maximum duration, expressed as a Gatling Expression Language String
+     * @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
+     *
+     * @param condition - the condition, expressed as a function
+     * @param duration - the maximum duration, in seconds or 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
+     *
+     * @param condition - the condition, expressed as a function
+     * @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
+     */
+    (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
+     *
+     * @param condition - the condition, expressed as a function
+     * @param duration - the maximum duration, in seconds or 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
+     *
+     * @param condition - the condition, expressed as a function
+     * @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 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
+     *
+     * @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
+     *
+     * @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
+     *
+     * @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
+     *
+     * @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 AsLongAsDuring<T extends AsLongAsDuring<T>> {
+    asLongAsDuring: AsLongAsDuringFunction<T>;
+}
+export declare const asLongAsDuringImpl: <J2, J1 extends JvmAsLongAsDuring<J2, any>, T extends AsLongAsDuring<T>>(jvmAsLongAsDuring: J1, wrap: (wrapped: J2) => T) => AsLongAsDuringFunction<T>;