@gatling.io/core 0.1.0

package/target/structure/pauses.d.ts

@@ -0,0 +1,127 @@
+import JvmPauses = io.gatling.javaapi.core.pause.Pauses;
+import JvmPauseType = io.gatling.javaapi.core.PauseType;
+import { Duration } from "../utils/duration";
+import { SessionTo } from "../session";
+export type PauseType = "Disabled" | "Constant" | "Exponential" | {
+    type: "NormalWithPercentageDuration";
+    stdDev: number;
+} | {
+    type: "NormalWithStdDevDuration";
+    stdDev: Duration;
+} | {
+    type: "Custom";
+    f: SessionTo<number>;
+} | {
+    type: "UniformPercentage";
+    plusOrMinus: number;
+} | {
+    type: "UniformDuration";
+    plusOrMinus: Duration;
+};
+export declare const toJvmPauseType: (pauseType: PauseType) => JvmPauseType;
+export interface PauseFunction<T extends Pauses<T>> {
+    /**
+     * Attach a pause
+     *
+     * @param duration - the pause duration, in seconds or with an explicit time unit
+     * @returns a new StructureBuilder
+     */
+    (duration: Duration): T;
+    /**
+     * Attach a pause 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 duration - the pause duration as a Gatling Expression Language string
+     * @returns a new StructureBuilder
+     */
+    (duration: string): T;
+    /**
+     * Attach a pause
+     *
+     * @param duration - the pause duration as a function
+     * @returns a new StructureBuilder
+     */
+    (duration: SessionTo<Duration>): T;
+    /**
+     * Attach a pause
+     *
+     * @param duration - the pause duration, in seconds or with an explicit time unit
+     * @param pauseType - the type of pause
+     * @returns a new StructureBuilder
+     */
+    (duration: Duration, pauseType: PauseType): T;
+    /**
+     * Attach a pause 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 duration - the pause duration as a Gatling Expression Language string
+     * @param pauseType - the type of pause
+     * @returns a new StructureBuilder
+     */
+    (duration: string, pauseType: PauseType): T;
+    /**
+     * Attach a pause
+     *
+     * @param duration - the pause duration as a function
+     * @param pauseType - the type of pause
+     * @returns a new StructureBuilder
+     */
+    (duration: SessionTo<Duration>, pauseType: PauseType): T;
+    /**
+     * Attach a pause computed randomly between 2 values
+     *
+     * @param min the pause minimum, in seconds or with an explicit time unit
+     * @param max the pause maximum, in seconds or with an explicit time unit
+     * @return a new StructureBuilder
+     */
+    (min: Duration, max: Duration): T;
+    /**
+     * Attach a pause computed randomly between 2 values as a Gatling Expression Language string. These expressions must
+     * resolve to either a number, then the unit will be seconds, or an object with an explicit time unit.
+     *
+     * @param min the pause minimum as a Gatling Expression Language string
+     * @param max the pause maximum as a Gatling Expression Language string
+     * @return a new StructureBuilder
+     */
+    (min: string, max: string): T;
+    /**
+     * Attach a pause computed randomly between 2 values
+     *
+     * @param min the pause minimum as a function
+     * @param max the pause maximum as a function
+     * @return a new StructureBuilder
+     */
+    (min: SessionTo<Duration>, max: SessionTo<Duration>): T;
+    /**
+     * Attach a pause computed randomly between 2 values
+     *
+     * @param min the pause minimum, in seconds or with an explicit time unit
+     * @param max the pause maximum, in seconds or with an explicit time unit
+     * @param pauseType - the type of pause
+     * @return a new StructureBuilder
+     */
+    (min: Duration, max: Duration, pauseType: PauseType): T;
+    /**
+     * Attach a pause computed randomly between 2 values as a Gatling Expression Language string. These expressions must
+     * resolve to either a number, then the unit will be seconds, or an object with an explicit time unit.
+     *
+     * @param min the pause minimum as a Gatling Expression Language string
+     * @param max the pause maximum as a Gatling Expression Language string
+     * @param pauseType - the type of pause
+     * @return a new StructureBuilder
+     */
+    (min: string, max: string, pauseType: PauseType): T;
+    /**
+     * Attach a pause computed randomly between 2 values
+     *
+     * @param min the pause minimum as a function
+     * @param max the pause maximum as a function
+     * @param pauseType - the type of pause
+     * @return a new StructureBuilder
+     */
+    (min: SessionTo<Duration>, max: SessionTo<Duration>, pauseType: PauseType): T;
+}
+export interface Pauses<T extends Pauses<T>> {
+    pause: PauseFunction<T>;
+}
+export declare const pauseImpl: <J2, J1 extends JvmPauses<J2, any>, T extends Pauses<T>>(jvmGroups: J1, wrap: (wrapped: J2) => T) => PauseFunction<T>;

package/target/structure/pauses.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pauseImpl = exports.toJvmPauseType = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const duration_1 = require("../utils/duration");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const isPauseType = (x) => x === "Disabled" || x === "Constant" || x === "Exponential" || typeof x.type === "string";
+const toJvmPauseType = (pauseType) => {
+    if (pauseType === "Disabled") {
+        // FIXME find better solution for generating static field definitions in java2typescript (without conflicting
+        //  with methods of the same name, e.g. 'JvmHttpDsl.http' vs. 'JvmHttpDsl.http(String)')
+        return jvm_types_1.CoreDsl.disabledPauses;
+    }
+    else if (pauseType === "Constant") {
+        return jvm_types_1.CoreDsl.constantPauses;
+    }
+    else if (pauseType === "Exponential") {
+        return jvm_types_1.CoreDsl.exponentialPauses;
+    }
+    else if (pauseType.type === "NormalWithPercentageDuration") {
+        return jvm_types_1.CoreDsl.normalPausesWithPercentageDuration(pauseType.stdDev);
+    }
+    else if (pauseType.type === "NormalWithStdDevDuration") {
+        return jvm_types_1.CoreDsl.normalPausesWithStdDevDuration((0, duration_1.toJvmDuration)(pauseType.stdDev));
+    }
+    else if (pauseType.type === "Custom") {
+        return jvm_types_1.CoreDsl.customPauses((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(pauseType.f)));
+    }
+    else if (pauseType.type === "UniformPercentage") {
+        return jvm_types_1.CoreDsl.uniformPausesPlusOrMinusPercentage(pauseType.plusOrMinus);
+    }
+    else if (pauseType.type === "UniformDuration") {
+        return jvm_types_1.CoreDsl.uniformPausesPlusOrMinusDuration((0, duration_1.toJvmDuration)(pauseType.plusOrMinus));
+    }
+    throw Error(`Unhandled pause type ${pauseType}`);
+};
+exports.toJvmPauseType = toJvmPauseType;
+const pauseImpl = (jvmGroups, wrap) => (arg0, arg1, arg2) => {
+    if (arg2 !== undefined) {
+        // pause(min, max, pauseType)
+        if (typeof arg0 === "string" && typeof arg1 === "string") {
+            return wrap(jvmGroups.pause(arg0, arg1, (0, exports.toJvmPauseType)(arg2)));
+        }
+        else if (typeof arg0 === "function" && typeof arg1 === "function") {
+            return wrap(jvmGroups.pause((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg0)), (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg1)), (0, exports.toJvmPauseType)(arg2)));
+        }
+        else if ((0, duration_1.isDuration)(arg0) && (0, duration_1.isDuration)(arg1)) {
+            return wrap(jvmGroups.pause((0, duration_1.toJvmDuration)(arg0), (0, duration_1.toJvmDuration)(arg1), (0, exports.toJvmPauseType)(arg2)));
+        }
+    }
+    else if (arg1 !== undefined) {
+        if (isPauseType(arg1)) {
+            // pause(duration, pauseType)
+            if (typeof arg0 === "string") {
+                return wrap(jvmGroups.pause(arg0, (0, exports.toJvmPauseType)(arg1)));
+            }
+            else if (typeof arg0 === "function") {
+                return wrap(jvmGroups.pause((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg0)), (0, exports.toJvmPauseType)(arg1)));
+            }
+            else if ((0, duration_1.isDuration)(arg0)) {
+                return wrap(jvmGroups.pause((0, duration_1.toJvmDuration)(arg0), (0, exports.toJvmPauseType)(arg1)));
+            }
+        }
+        else {
+            // pause(min, max)
+            if (typeof arg0 === "string" && typeof arg1 === "string") {
+                return wrap(jvmGroups.pause(arg0, arg1));
+            }
+            else if (typeof arg0 === "function" && typeof arg1 === "function") {
+                return wrap(jvmGroups.pause((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg0)), (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg1))));
+            }
+            else if ((0, duration_1.isDuration)(arg0) && (0, duration_1.isDuration)(arg1)) {
+                return wrap(jvmGroups.pause((0, duration_1.toJvmDuration)(arg0), (0, duration_1.toJvmDuration)(arg1)));
+            }
+        }
+    }
+    else {
+        // pause(duration)
+        if (typeof arg0 === "string") {
+            return wrap(jvmGroups.pause(arg0));
+        }
+        else if (typeof arg0 === "function") {
+            return wrap(jvmGroups.pause((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg0))));
+        }
+        else if ((0, duration_1.isDuration)(arg0)) {
+            return wrap(jvmGroups.pause((0, duration_1.toJvmDuration)(arg0)));
+        }
+    }
+    throw Error(`pause() called with invalid arguments ${arg0}, ${arg1}, ${arg2}`);
+};
+exports.pauseImpl = pauseImpl;

package/target/structure/randomSwitch.d.ts

@@ -0,0 +1,19 @@
+import "@gatling.io/jvm-types";
+import JvmRandomSwitch = io.gatling.javaapi.core.condition.RandomSwitch;
+import { ChoiceWithWeight } from "./choices";
+export interface On<T> {
+    on(...choices: ChoiceWithWeight[]): T;
+}
+export interface RandomSwitchFunction<T extends RandomSwitch<T>> {
+    /**
+     * Execute one of the "choices" randomly based on their respective weight. Weights are expressed
+     * in percents so their sum must be <= 100%.
+     *
+     * @returns a DSL component for defining the "choices"
+     */
+    (): On<T>;
+}
+export interface RandomSwitch<T extends RandomSwitch<T>> {
+    randomSwitch: RandomSwitchFunction<T>;
+}
+export declare const randomSwitchImpl: <J2, J1 extends JvmRandomSwitch<J2, any>, T extends RandomSwitch<T>>(jvmRandomSwitch: J1, wrap: (wrapped: J2) => T) => RandomSwitchFunction<T>;

package/target/structure/randomSwitch.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSwitchImpl = void 0;
+require("@gatling.io/jvm-types");
+const wrapOn = (jvmOn, wrap) => ({
+    on: (...choices) => wrap(jvmOn.on(choices.map((c) => c._underlying)))
+});
+const randomSwitchImpl = (jvmRandomSwitch, wrap) => () => wrapOn(jvmRandomSwitch.randomSwitch(), wrap);
+exports.randomSwitchImpl = randomSwitchImpl;

package/target/structure/randomSwitchOrElse.d.ts

@@ -0,0 +1,23 @@
+import "@gatling.io/jvm-types";
+import JvmRandomSwitchOrElse = io.gatling.javaapi.core.condition.RandomSwitchOrElse;
+import { ChoiceWithWeight } from "./choices";
+import { Executable } from "./execs";
+export interface On<T> {
+    on(...choices: ChoiceWithWeight[]): OrElse<T>;
+}
+export interface OrElse<T> {
+    orElse(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+export interface RandomSwitchOrElseFunction<T extends RandomSwitchOrElse<T>> {
+    /**
+     * Execute one of the "choices" randomly based on their respective weight. Weights are expressed
+     * in percents so their sum must be <= 100%.
+     *
+     * @returns the DSL component for defining the "else" block
+     */
+    (): On<T>;
+}
+export interface RandomSwitchOrElse<T extends RandomSwitchOrElse<T>> {
+    randomSwitchOrElse: RandomSwitchOrElseFunction<T>;
+}
+export declare const randomSwitchOrElseImpl: <J2, J1 extends JvmRandomSwitchOrElse<J2, any>, T extends RandomSwitchOrElse<T>>(jvmRandomSwitch: J1, wrap: (wrapped: J2) => T) => RandomSwitchOrElseFunction<T>;

package/target/structure/randomSwitchOrElse.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSwitchOrElseImpl = void 0;
+require("@gatling.io/jvm-types");
+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 randomSwitchOrElseImpl = (jvmRandomSwitch, wrap) => () => wrapOn(jvmRandomSwitch.randomSwitchOrElse(), wrap);
+exports.randomSwitchOrElseImpl = randomSwitchOrElseImpl;

package/target/structure/rendezVous.d.ts

@@ -0,0 +1,15 @@
+import "@gatling.io/jvm-types";
+import JvmRendezVous = io.gatling.javaapi.core.pause.RendezVous;
+export interface RendezVousFunction<T extends RendezVous<T>> {
+    /**
+     * Make virtual users wait until enough of them reach this point
+     *
+     * @param users - the number of virtual users that must reach this point
+     * @returns a new StructureBuilder
+     */
+    (users: number): T;
+}
+export interface RendezVous<T extends RendezVous<T>> {
+    rendezVous: RendezVousFunction<T>;
+}
+export declare const rendezVousImpl: <J2, J1 extends JvmRendezVous<J2, any>, T extends RendezVous<T>>(jvmRendezVous: J1, wrap: (wrapped: J2) => T) => RendezVousFunction<T>;

package/target/structure/rendezVous.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rendezVousImpl = void 0;
+require("@gatling.io/jvm-types");
+const rendezVousImpl = (jvmRendezVous, wrap) => (users) => wrap(jvmRendezVous.rendezVous(users));
+exports.rendezVousImpl = rendezVousImpl;

package/target/structure/repeat.d.ts

@@ -0,0 +1,34 @@
+import "@gatling.io/jvm-types";
+import JvmRepeat = io.gatling.javaapi.core.loop.Repeat;
+import { SessionTo } from "../session";
+import { On } from "./on";
+export interface RepeatFunction<T extends Repeat<T>> {
+    /**
+     * Define a loop that will iterate for a given number of times.
+     *
+     * @param times - the number of iterations
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a DSL component for defining the loop content
+     */
+    (times: number, counterName?: string): On<T>;
+    /**
+     * Define a loop that will iterate for a given number of times.
+     *
+     * @param times - the number of iterations, expressed as a Gatling Expression Language String that must evaluate to an integer
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a DSL component for defining the loop content
+     */
+    (times: string, counterName?: string): On<T>;
+    /**
+     * Define a loop that will iterate for a given number of times.
+     *
+     * @param times - the number of iterations, 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
+     */
+    (times: SessionTo<number>, counterName?: string): On<T>;
+}
+export interface Repeat<T extends Repeat<T>> {
+    repeat: RepeatFunction<T>;
+}
+export declare const repeatImpl: <J2, J1 extends JvmRepeat<J2, any>, T extends Repeat<T>>(jvmRepeat: J1, wrap: (wrapped: J2) => T) => RepeatFunction<T>;

package/target/structure/repeat.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repeatImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const on_1 = require("./on");
+const repeatImpl = (jvmRepeat, wrap) => (times, counterName) => {
+    if (counterName !== undefined) {
+        // repeat(times, counterName
+        if (typeof times === "number") {
+            return (0, on_1.wrapOn)(jvmRepeat.repeat(times, counterName), wrap);
+        }
+        else if (typeof times === "string") {
+            return (0, on_1.wrapOn)(jvmRepeat.repeat(times, counterName), wrap);
+        }
+        else {
+            return (0, on_1.wrapOn)(jvmRepeat.repeat((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(times)), counterName), wrap);
+        }
+    }
+    else {
+        // repeat(times)
+        if (typeof times === "number") {
+            return (0, on_1.wrapOn)(jvmRepeat.repeat(times), wrap);
+        }
+        else if (typeof times === "string") {
+            return (0, on_1.wrapOn)(jvmRepeat.repeat(times), wrap);
+        }
+        else {
+            return (0, on_1.wrapOn)(jvmRepeat.repeat((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(times))), wrap);
+        }
+    }
+};
+exports.repeatImpl = repeatImpl;

package/target/structure/roundRobinSwitch.d.ts

@@ -0,0 +1,18 @@
+import "@gatling.io/jvm-types";
+import JvmRoundRobinSwitch = io.gatling.javaapi.core.condition.RoundRobinSwitch;
+import { Executable } from "./execs";
+export interface On<T> {
+    on(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+export interface RoundRobinSwitchFunction<T extends RoundRobinSwitch<T>> {
+    /**
+     * Execute one of the "choices" in a round-robin fashion. Round-robin is global, not per virtual user.
+     *
+     * @returns a new StructureBuilder
+     */
+    (): On<T>;
+}
+export interface RoundRobinSwitch<T extends RoundRobinSwitch<T>> {
+    roundRobinSwitch: RoundRobinSwitchFunction<T>;
+}
+export declare const roundRobinSwitchImpl: <J2, J1 extends JvmRoundRobinSwitch<J2, any>, T extends RoundRobinSwitch<T>>(jvmRoundRobinSwitch: J1, wrap: (wrapped: J2) => T) => RoundRobinSwitchFunction<T>;

package/target/structure/roundRobinSwitch.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundRobinSwitchImpl = void 0;
+require("@gatling.io/jvm-types");
+const wrapOn = (jvmOn, wrap) => ({
+    on: (executable, ...executables) => wrap(jvmOn.on(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+const roundRobinSwitchImpl = (jvmRoundRobinSwitch, wrap) => () => wrapOn(jvmRoundRobinSwitch.roundRobinSwitch(), wrap);
+exports.roundRobinSwitchImpl = roundRobinSwitchImpl;

package/target/structure/uniformRandomSwitch.d.ts

@@ -0,0 +1,18 @@
+import "@gatling.io/jvm-types";
+import JvmUniformRandomSwitch = io.gatling.javaapi.core.condition.UniformRandomSwitch;
+import { Executable } from "./execs";
+export interface On<T> {
+    on(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+export interface UniformRandomSwitchFunction<T extends UniformRandomSwitch<T>> {
+    /**
+     * Execute one of the "choices" in a random fashion, with each having even weights.
+     *
+     * @returns a DSL component for defining the "choices"
+     */
+    (): On<T>;
+}
+export interface UniformRandomSwitch<T extends UniformRandomSwitch<T>> {
+    uniformRandomSwitch: UniformRandomSwitchFunction<T>;
+}
+export declare const uniformRandomSwitchImpl: <J2, J1 extends JvmUniformRandomSwitch<J2, any>, T extends UniformRandomSwitch<T>>(jvmUniformRandomSwitch: J1, wrap: (wrapped: J2) => T) => UniformRandomSwitchFunction<T>;

package/target/structure/uniformRandomSwitch.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniformRandomSwitchImpl = void 0;
+require("@gatling.io/jvm-types");
+const wrapOn = (jvmOn, wrap) => ({
+    on: (executable, ...executables) => wrap(jvmOn.on(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+const uniformRandomSwitchImpl = (jvmUniformRandomSwitch, wrap) => () => wrapOn(jvmUniformRandomSwitch.uniformRandomSwitch(), wrap);
+exports.uniformRandomSwitchImpl = uniformRandomSwitchImpl;

package/target/throttling.d.ts

@@ -0,0 +1,43 @@
+import JvmThrottleStep = io.gatling.javaapi.core.ThrottleStep;
+import { Wrapper } from "./common";
+import { Duration } from "./utils/duration";
+/**
+ * Bootstrap a new reachRps throttling profile, see {@link ThrottleStepReachIntermediate}
+ *
+ * @param target - the target requests per second
+ * @returns the next DSL step
+ */
+export declare const reachRps: (target: number) => ThrottleStepReachIntermediate;
+/**
+ * Bootstrap a new holdFor throttling profile that limits rps to its current value
+ *
+ * @param duration - the duration of the plateau in seconds
+ * @returns the next DSL step
+ */
+export declare const holdFor: (duration: Duration) => ThrottleStep;
+/**
+ * Bootstrap a new jumpToRps throttling profile that change the rps limit to a new value
+ *
+ * @param target - the new limit
+ * @returns the next DSL step
+ */
+export declare const jumpToRps: (target: number) => ThrottleStep;
+export interface ThrottleStep extends Wrapper<JvmThrottleStep> {
+}
+/** DSL step to define the duration of a throttling ramp. */
+export interface ThrottleStepReachIntermediate {
+    /**
+     * Define the duration of a throttling ramp
+     *
+     * @param duration - the duration
+     * @returns a new ThrottleStep
+     */
+    in(duration: Duration): ThrottleStep;
+    /**
+     * Alias for `in` that's a reserved keyword in Kotlin
+     *
+     * @param duration - the duration
+     * @returns a new ThrottleStep
+     */
+    during(duration: Duration): ThrottleStep;
+}

package/target/throttling.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jumpToRps = exports.holdFor = exports.reachRps = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const duration_1 = require("./utils/duration");
+/**
+ * Bootstrap a new reachRps throttling profile, see {@link ThrottleStepReachIntermediate}
+ *
+ * @param target - the target requests per second
+ * @returns the next DSL step
+ */
+const reachRps = (target) => wrapThrottleStepReachIntermediate(jvm_types_1.CoreDsl.reachRps(target));
+exports.reachRps = reachRps;
+/**
+ * Bootstrap a new holdFor throttling profile that limits rps to its current value
+ *
+ * @param duration - the duration of the plateau in seconds
+ * @returns the next DSL step
+ */
+const holdFor = (duration) => wrapThrottleStep(jvm_types_1.CoreDsl.holdFor((0, duration_1.toJvmDuration)(duration)));
+exports.holdFor = holdFor;
+/**
+ * Bootstrap a new jumpToRps throttling profile that change the rps limit to a new value
+ *
+ * @param target - the new limit
+ * @returns the next DSL step
+ */
+const jumpToRps = (target) => wrapThrottleStep(jvm_types_1.CoreDsl.jumpToRps(target));
+exports.jumpToRps = jumpToRps;
+const wrapThrottleStep = (_underlying) => ({
+    _underlying
+});
+const wrapThrottleStepReachIntermediate = (_underlying) => ({
+    in: (duration) => wrapThrottleStep(_underlying.in((0, duration_1.toJvmDuration)(duration))),
+    during: (duration) => wrapThrottleStep(_underlying.during((0, duration_1.toJvmDuration)(duration)))
+});

package/target/utils/duration.d.ts

@@ -0,0 +1,7 @@
+export type TimeUnit = "milliseconds" | "seconds" | "minutes";
+export type Duration = number | {
+    amount: number;
+    unit: TimeUnit;
+};
+export declare const isDuration: (x: unknown) => x is Duration;
+export declare const toJvmDuration: (duration: Duration) => java.time.Duration;

package/target/utils/duration.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJvmDuration = exports.isDuration = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const isDuration = (x) => typeof x === "number" ||
+    (typeof x === "object" && typeof x.amount === "number" && typeof x.unit === "string");
+exports.isDuration = isDuration;
+const toJvmDuration = (duration) => {
+    const { amount, unit } = typeof duration === "number" ? { amount: duration, unit: "seconds" } : duration;
+    switch (unit) {
+        case "milliseconds":
+            return jvm_types_1.Duration.ofMillis(amount);
+        case "seconds":
+            return jvm_types_1.Duration.ofSeconds(amount);
+        case "minutes":
+            return jvm_types_1.Duration.ofMinutes(amount);
+        default:
+            return jvm_types_1.Duration.ofSeconds(amount);
+    }
+};
+exports.toJvmDuration = toJvmDuration;