@gatling.io/core 0.1.0 → 0.1.2

package/target/openInjection.d.ts

@@ -1,6 +1,5 @@
-import "@gatling.io/jvm-types";
-import { Wrapper } from "./common";
 import { Duration } from "./utils/duration";
+import { Wrapper } from "./common";
 import JvmOpenInjectionStep = io.gatling.javaapi.core.OpenInjectionStep;
 import JvmOpenInjectionStepRamp = io.gatling.javaapi.core.OpenInjectionStep$Ramp;
 import JvmOpenInjectionStepStressPeak = io.gatling.javaapi.core.OpenInjectionStep$StressPeak;
@@ -9,43 +8,182 @@ import JvmOpenInjectionStepRampRate = io.gatling.javaapi.core.OpenInjectionStep$
 import JvmOpenInjectionStepRampRateDuring = io.gatling.javaapi.core.RampRate$During;
 import JvmOpenInjectionStepStairs = io.gatling.javaapi.core.OpenInjectionStep$Stairs;
 import JvmOpenInjectionStepStairsTimes = io.gatling.javaapi.core.Stairs$Times;
+/**
+ * An injection profile step for using an open workload model where you control the arrival rate of
+ * new users. In 99.99% of the cases, the right choice, over closed workload model.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
 export interface OpenInjectionStep extends Wrapper<JvmOpenInjectionStep> {
 }
 export interface ConstantRateOpenInjectionStep extends OpenInjectionStep {
     randomized(): OpenInjectionStep;
 }
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject a stock of users distributed
+ * evenly on a given period of time. Strictly equivalent to {@link ConstantRateOpenInjectionStep}
+ */
 export interface OpenInjectionStepRamp extends Wrapper<JvmOpenInjectionStepRamp> {
+    /**
+     * Define the duration of the ramp
+     *
+     * @param duration - the ramp duration
+     * @returns a new OpenInjectionStep
+     */
     during(duration: Duration): OpenInjectionStep;
 }
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject a stock of users distributed
+ * with a <a hreh="https://en.wikipedia.org/wiki/Heaviside_step_function">Heaviside</a>
+ * distribution on a given period of time. Strictly equivalent to {@link OpenInjectionStepConstantRate}
+ */
 export interface OpenInjectionStepStressPeak extends Wrapper<JvmOpenInjectionStepStressPeak> {
+    /**
+     * Define the duration of the Heaviside distribution
+     *
+     * @param duration - the duration
+     * @returns a new OpenInjectionStep
+     */
     during(duration: Duration): OpenInjectionStep;
 }
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users at a constant rate for a
+ * given duration.
+ */
 export interface OpenInjectionStepConstantRate extends Wrapper<JvmOpenInjectionStepConstantRate> {
+    /**
+     * Define the duration of the step
+     *
+     * @param duration - the duration
+     * @returns a new OpenInjectionStep
+     */
     during(duration: Duration): ConstantRateOpenInjectionStep;
 }
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users at a rate that will
+ * increase linearly for a given duration.
+ */
 export interface OpenInjectionStepRampRate extends Wrapper<JvmOpenInjectionStepRampRate> {
+    /**
+     * Define the target rate at the end of the ramp
+     *
+     * @param to - the target rate
+     * @returns the next DSL step
+     */
     to(to: number): OpenInjectionStepRampRateDuring;
 }
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users at a rate that will
+ * increase linearly for a given duration.
+ */
 export interface OpenInjectionStepRampRateDuring extends Wrapper<JvmOpenInjectionStepRampRateDuring> {
+    /**
+     * Define the duration of the ramp
+     *
+     * @param duration - the duration
+     * @returns a new OpenInjectionStep
+     */
     during(duration: Duration): RampRateOpenInjectionStep;
 }
+/**
+ * A special {@link OpenInjectionStep} that supports "randomized".
+ */
 export interface RampRateOpenInjectionStep extends OpenInjectionStep {
     randomized(): OpenInjectionStep;
 }
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users with stairs rates.
+ */
 export interface OpenInjectionStepStairs extends Wrapper<JvmOpenInjectionStepStairs> {
+    /**
+     * Define the number of levels
+     *
+     * @param levels - the number of levels in the stairs
+     * @returns the next DSL step
+     */
     times(levels: number): OpenInjectionStepStairsTimes;
 }
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users with stairs rates.
+ */
 export interface OpenInjectionStepStairsTimes extends Wrapper<JvmOpenInjectionStepStairsTimes> {
+    /**
+     * Define the duration of each level
+     *
+     * @param duration - the duration
+     * @returns the next DSL step
+     */
     eachLevelLasting(duration: Duration): OpenInjectionStepStairsComposite;
 }
+/**
+ * A DSL for creating a {@link OpenInjectionStep} that will inject users with stairs rates.
+ */
 export interface OpenInjectionStepStairsComposite extends OpenInjectionStep {
+    /**
+     * Define the initial number of users per second rate (optional)
+     *
+     * @param startingRate - the initial rate
+     * @returns a usable {@link OpenInjectionStep}
+     */
     startingFrom(startingRate: number): OpenInjectionStepStairsComposite;
+    /**
+     * Define ramps separating levels (optional)
+     *
+     * @param duration - the duration
+     * @returns a usable {@link OpenInjectionStep}
+     */
     separatedByRampsLasting(duration: Duration): OpenInjectionStepStairsComposite;
 }
+/**
+ * Bootstrap a new open workload rampUsers injection profile, see {@link OpenInjectionStepRamp}
+ *
+ * @param users - the total number of users to inject
+ * @returns the next DSL step
+ */
 export declare const rampUsers: (users: number) => OpenInjectionStepRamp;
+/**
+ * Bootstrap a new open workload stress peak injection profile, see {@link
+ * OpenInjectionStepStressPeak}
+ *
+ * @param users - the total number of users to inject
+ * @returns the next DSL step
+ */
 export declare const stressPeakUsers: (users: number) => OpenInjectionStepStressPeak;
+/**
+ * Inject a bunch of users at the same time.
+ *
+ * @param users - the number of users to inject
+ * @returns a new OpenInjectionStep
+ */
 export declare const atOnceUsers: (users: number) => OpenInjectionStep;
+/**
+ * Bootstrap a new open workload constantUsersPerSec injection profile, see {@link
+ * OpenInjectionStepConstantRate}
+ *
+ * @param rate - the users per second rate
+ * @returns the next DSL step
+ */
 export declare const constantUsersPerSec: (rate: number) => OpenInjectionStepConstantRate;
+/**
+ * Bootstrap a new open workload rampUsersPerSec injection profile, see {@link
+ * OpenInjectionStepRampRate}
+ *
+ * @param rate - the users per second start rate
+ * @returns the next DSL step
+ */
 export declare const rampUsersPerSec: (rate: number) => OpenInjectionStepRampRate;
+/**
+ * Don't inject any new user for a given duration
+ *
+ * @param duration - the duration
+ * @returns a new OpenInjectionStep
+ */
 export declare const nothingFor: (duration: Duration) => OpenInjectionStep;
+/**
+ * Bootstrap a new open workload incrementUsersPerSec injection profile, see {@link
+ * OpenInjectionStepStairs}
+ *
+ * @param rateIncrement - the difference of users per second rate between levels of the stairs
+ * @returns the next DSL step
+ */
 export declare const incrementUsersPerSec: (rateIncrement: number) => OpenInjectionStepStairs;

package/target/openInjection.js

@@ -1,7 +1,6 @@
 "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 });
@@ -46,17 +45,63 @@ const wrapOpenInjectionStepStairsComposite = (_underlying) => ({
     startingFrom: (startingRate) => wrapOpenInjectionStepStairsComposite(_underlying.startingFrom(startingRate)),
     separatedByRampsLasting: (duration) => wrapOpenInjectionStepStairsComposite(_underlying.separatedByRampsLasting((0, duration_1.toJvmDuration)(duration)))
 });
+/**
+ * Bootstrap a new open workload rampUsers injection profile, see {@link OpenInjectionStepRamp}
+ *
+ * @param users - the total number of users to inject
+ * @returns the next DSL step
+ */
 const rampUsers = (users) => wrapOpenInjectionStepRamp(jvm_types_1.CoreDsl.rampUsers(users));
 exports.rampUsers = rampUsers;
+/**
+ * Bootstrap a new open workload stress peak injection profile, see {@link
+ * OpenInjectionStepStressPeak}
+ *
+ * @param users - the total number of users to inject
+ * @returns the next DSL step
+ */
 const stressPeakUsers = (users) => wrapOpenInjectionStepStressPeak(jvm_types_1.CoreDsl.stressPeakUsers(users));
 exports.stressPeakUsers = stressPeakUsers;
+/**
+ * Inject a bunch of users at the same time.
+ *
+ * @param users - the number of users to inject
+ * @returns a new OpenInjectionStep
+ */
 const atOnceUsers = (users) => wrapOpenInjectionStep(jvm_types_1.CoreDsl.atOnceUsers(users));
 exports.atOnceUsers = atOnceUsers;
+/**
+ * Bootstrap a new open workload constantUsersPerSec injection profile, see {@link
+ * OpenInjectionStepConstantRate}
+ *
+ * @param rate - the users per second rate
+ * @returns the next DSL step
+ */
 const constantUsersPerSec = (rate) => wrapOpenInjectionStepConstantRate(jvm_types_1.CoreDsl.constantUsersPerSec(rate));
 exports.constantUsersPerSec = constantUsersPerSec;
+/**
+ * Bootstrap a new open workload rampUsersPerSec injection profile, see {@link
+ * OpenInjectionStepRampRate}
+ *
+ * @param rate - the users per second start rate
+ * @returns the next DSL step
+ */
 const rampUsersPerSec = (rate) => wrapOpenInjectionStepRampRate(jvm_types_1.CoreDsl.rampUsersPerSec(rate));
 exports.rampUsersPerSec = rampUsersPerSec;
+/**
+ * Don't inject any new user for a given duration
+ *
+ * @param duration - the duration
+ * @returns a new OpenInjectionStep
+ */
 const nothingFor = (duration) => wrapOpenInjectionStep(jvm_types_1.CoreDsl.nothingFor((0, duration_1.toJvmDuration)(duration)));
 exports.nothingFor = nothingFor;
+/**
+ * Bootstrap a new open workload incrementUsersPerSec injection profile, see {@link
+ * OpenInjectionStepStairs}
+ *
+ * @param rateIncrement - the difference of users per second rate between levels of the stairs
+ * @returns the next DSL step
+ */
 const incrementUsersPerSec = (rateIncrement) => wrapOpenInjectionStepStairs(jvm_types_1.CoreDsl.incrementUsersPerSec(rateIncrement));
 exports.incrementUsersPerSec = incrementUsersPerSec;

package/target/population.d.ts

@@ -1,11 +1,10 @@
-import "@gatling.io/jvm-types";
-import JvmPopulationBuilder = io.gatling.javaapi.core.PopulationBuilder;
+import { Duration } from "./utils/duration";
+import { PauseType } from "./structure/pauses";
 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";
+import JvmPopulationBuilder = io.gatling.javaapi.core.PopulationBuilder;
 /**
  * A builder for a Population = a Scenario + an injection profile.
  *

package/target/population.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapPopulationBuilder = void 0;
-require("@gatling.io/jvm-types");
-const session_1 = require("./session");
+const callbacks_1 = require("./gatlingJvm/callbacks");
 const duration_1 = require("./utils/duration");
 const pauses_1 = require("./structure/pauses");
-const callbacks_1 = require("./gatlingJvm/callbacks");
+const session_1 = require("./session");
 const wrapPopulationBuilder = (_underlying) => ({
     _underlying,
     protocols: (...protocols) => (0, exports.wrapPopulationBuilder)(_underlying.protocols(protocols.map((p) => p._underlying))),

package/target/protocol.d.ts

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

package/target/protocol.js

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

package/target/scenario.d.ts

@@ -1,10 +1,20 @@
-import "@gatling.io/jvm-types";
-import { StructureBuilder } from "./structure";
 import { ClosedInjectionStep } from "./closedInjection";
 import { OpenInjectionStep } from "./openInjection";
 import { PopulationBuilder } from "./population";
+import { StructureBuilder } from "./structure";
+/**
+ * Javascript wrapper of a Java ScenarioBuilder.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
 export interface ScenarioBuilder extends StructureBuilder<ScenarioBuilder> {
     injectOpen(...steps: OpenInjectionStep[]): PopulationBuilder;
     injectClosed(...steps: ClosedInjectionStep[]): PopulationBuilder;
 }
+/**
+ * Create a new immutable Scenario builder
+ *
+ * @param name - the scenario name
+ * @returns a new Scenario builder
+ */
 export declare const scenario: (name: string) => ScenarioBuilder;

package/target/scenario.js

@@ -1,15 +1,20 @@
 "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 structure_1 = require("./structure");
 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)
 });
+/**
+ * Create a new immutable Scenario builder
+ *
+ * @param name - the scenario name
+ * @returns a new Scenario builder
+ */
 const scenario = (name) => {
     const jvmScenarioBuilder = jvm_types_1.CoreDsl.scenario(name);
     return wrapScenarioBuilder(jvmScenarioBuilder);

package/target/session.d.ts

@@ -1,21 +1,110 @@
 import { Duration } from "./utils/duration";
 import { Wrapper } from "./common";
 import JvmSession = io.gatling.javaapi.core.Session;
+/**
+ * The state of a given virtual user.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
 export interface Session extends Wrapper<JvmSession> {
+    /**
+     * Get a stored value by its key
+     *
+     * @param key - the storage key
+     * @typeParam T - the type of the desired value
+     * @returns the value if it exists, null otherwise
+     */
     get<T>(key: string): T;
+    /**
+     * Create a new instance updated with a given attribute, possibly overriding an existing one
+     *
+     * @param key - the attribute key
+     * @param value - the attribute value
+     * @returns a new instance with the new stored attribute
+     */
     set(key: string, value: any): Session;
+    /**
+     * Create a new instance updated with a given byte array (number[]), possibly overriding an existing one
+     *
+     * @param key - the attribute key
+     * @param value - the attribute value
+     * @returns a new instance with the new stored attribute
+     */
     setByteArray(key: string, value: number[]): Session;
+    /**
+     * Create a new instance updated with multiple attributes, possibly overriding existing ones
+     *
+     * @param newAttributes - the new attributes
+     * @returns a new instance with the new stored attributes
+     */
     setAll(newAttributes: Record<string, any>): Session;
+    /**
+     * Create a new instance updated with an attribute removed
+     *
+     * @param key - the key of the attribute to remove
+     * @returns a new instance with the attribute removed
+     */
     remove(key: string): Session;
+    /**
+     * Create a new instance updated with all attributes removed except Gatling internal ones
+     *
+     * @returns a new instance with a reset user state
+     */
     reset(): Session;
+    /**
+     * Create a new instance updated with multiple attributes removed
+     *
+     * @param keys - the keys of the attributes to remove
+     * @returns a new instance with the attributes removed
+     */
     removeAll(...keys: string[]): Session;
+    /**
+     * Check if the Session contains a given attribute key
+     *
+     * @param key - the attribute key
+     * @returns true is the key is defined
+     */
     contains(key: string): boolean;
+    /**
+     * @returns if the Session's status is failure
+     */
     isFailed(): boolean;
+    /**
+     * Create a new instance with the status forced to "succeeded"
+     *
+     * @returns a new instance with the new status
+     */
     markAsSucceeded(): Session;
+    /**
+     * Create a new instance with the status forced to "failed"
+     *
+     * @returns a new instance with the new status
+     */
     markAsFailed(): Session;
+    /**
+     * Provide the name of the scenario of the virtual user
+     *
+     * @returns the virtual user's scenario name
+     */
     scenario(): string;
+    /**
+     * Provide the list of groups at the current position for the virtual user
+     *
+     * @returns the list of groups, from shallowest to deepest
+     */
     groups(): string[];
+    /**
+     * Provide the unique (for this injector) id of the virtual user
+     *
+     * @returns the virtual user's id
+     */
     userId(): number;
+    /**
+     * Provide a representation of the Session content
+     *
+     * @returns the Session content as a pretty printed string
+     */
+    toString(): string;
 }
 export declare const wrapSession: (_underlying: JvmSession) => Session;
 export type Expression<T> = T | ((session: Session) => T);

package/target/session.js

@@ -27,7 +27,8 @@ const wrapSession = (_underlying) => ({
     markAsFailed: () => (0, exports.wrapSession)(_underlying.markAsFailed()),
     scenario: () => _underlying.scenario(),
     groups: () => _underlying.groups(),
-    userId: () => _underlying.userId()
+    userId: () => _underlying.userId(),
+    toString: () => _underlying.toString()
 });
 exports.wrapSession = wrapSession;
 const underlyingSessionTransform = (f) => (jvmSession) => f((0, exports.wrapSession)(jvmSession))._underlying;

package/target/structure/asLongAs.d.ts

@@ -1,7 +1,6 @@
-import "@gatling.io/jvm-types";
-import JvmAsLongAs = io.gatling.javaapi.core.loop.AsLongAs;
 import { SessionTo } from "../session";
 import { On } from "./on";
+import JvmAsLongAs = io.gatling.javaapi.core.loop.AsLongAs;
 export interface AsLongAsFunction<T extends AsLongAs<T>> {
     /**
      * Define a loop that will iterate as long as the condition holds true

package/target/structure/asLongAs.js

@@ -1,9 +1,8 @@
 "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 session_1 = require("../session");
 const on_1 = require("./on");
 const asLongAsImpl = (jvmAsLongAs, wrap) => (condition, arg1, arg2) => {
     if (arg2 !== undefined && typeof arg1 === "string") {

package/target/structure/asLongAsDuring.d.ts

@@ -1,8 +1,7 @@
-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";
+import JvmAsLongAsDuring = io.gatling.javaapi.core.loop.AsLongAsDuring;
 export interface AsLongAsDuringFunction<T extends AsLongAsDuring<T>> {
     /**
      * Define a loop that will iterate as long as the condition holds true and a maximum duration

package/target/structure/asLongAsDuring.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asLongAsDuringImpl = void 0;
-require("@gatling.io/jvm-types");
+const callbacks_1 = require("../gatlingJvm/callbacks");
 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") {

package/target/structure/choices.d.ts

@@ -1,8 +1,7 @@
-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";
+import JvmChoiceWithKey = io.gatling.javaapi.core.Choice$WithKey;
+import JvmChoiceWithWeight = io.gatling.javaapi.core.Choice$WithWeight;
 export interface ChoiceWithKey extends Wrapper<JvmChoiceWithKey> {
 }
 interface ChoiceWithKeyThen {

package/target/structure/choices.js

@@ -1,7 +1,6 @@
 "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

package/target/structure/doIf.d.ts

@@ -1,8 +1,7 @@
-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";
+import JvmDoIf = io.gatling.javaapi.core.condition.DoIf;
+import JvmDoIfEquals = io.gatling.javaapi.core.condition.DoIfEquals;
 export interface Then<T> {
     then(executable: Executable<any>, ...executables: Executable<any>[]): T;
 }

package/target/structure/doIf.js

@@ -1,9 +1,8 @@
 "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 session_1 = require("../session");
 const wrapThen = (jvmThen, wrap) => ({
     then: (executable, ...executables) => wrap(jvmThen.then(executable._underlying, ...executables.map((e) => e._underlying)))
 });

package/target/structure/doIfOrElse.d.ts

@@ -1,8 +1,7 @@
-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";
+import JvmDoIfOrElse = io.gatling.javaapi.core.condition.DoIfOrElse;
+import JvmDoIfEqualsOrElse = io.gatling.javaapi.core.condition.DoIfEqualsOrElse;
 export interface Then<T> {
     then(executable: Executable<any>, ...executables: Executable<any>[]): OrElse<T>;
 }

package/target/structure/doIfOrElse.js

@@ -1,9 +1,8 @@
 "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 session_1 = require("../session");
 const wrapThen = (jvmThen, wrap) => ({
     then: (executable, ...executables) => wrapOrElse(jvmThen.then(executable._underlying, ...executables.map((e) => e._underlying)), wrap)
 });

package/target/structure/doSwitch.d.ts

@@ -1,7 +1,6 @@
-import "@gatling.io/jvm-types";
-import JvmDoSwitch = io.gatling.javaapi.core.condition.DoSwitch;
 import { SessionTo } from "../session";
 import { ChoiceWithKey } from "./choices";
+import JvmDoSwitch = io.gatling.javaapi.core.condition.DoSwitch;
 export interface On<T> {
     on(...choices: ChoiceWithKey[]): T;
 }

package/target/structure/doSwitch.js

@@ -1,9 +1,8 @@
 "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 session_1 = require("../session");
 const wrapOn = (jvmOn, wrap) => ({
     on: (...choices) => wrap(jvmOn.on(choices.map((c) => c._underlying)))
 });

package/target/structure/doSwitchOrElse.d.ts

@@ -1,8 +1,7 @@
-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";
+import JvmDoSwitchOrElse = io.gatling.javaapi.core.condition.DoSwitchOrElse;
 export interface On<T> {
     on(...choices: ChoiceWithKey[]): OrElse<T>;
 }

package/target/structure/doSwitchOrElse.js

@@ -1,9 +1,8 @@
 "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 session_1 = require("../session");
 const wrapOn = (jvmOn, wrap) => ({
     on: (...choices) => wrapOrElse(jvmOn.on(choices.map((c) => c._underlying)), wrap)
 });

package/target/structure/doWhile.d.ts

@@ -1,7 +1,6 @@
-import "@gatling.io/jvm-types";
-import JvmDoWhile = io.gatling.javaapi.core.loop.DoWhile;
 import { SessionTo } from "../session";
 import { On } from "./on";
+import JvmDoWhile = io.gatling.javaapi.core.loop.DoWhile;
 export interface DoWhileFunction<T extends DoWhile<T>> {
     /**
      * Define a loop that will iterate as long as the condition holds true. The condition is evaluated

package/target/structure/doWhile.js

@@ -1,9 +1,8 @@
 "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 session_1 = require("../session");
 const on_1 = require("./on");
 const doWhileImpl = (jvmDoWhile, wrap) => (condition, counterName) => {
     if (counterName !== undefined) {