@gatling.io/core 0.1.1 → 3.11.2

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@gatling.io/core",
-  "version": "0.1.1",
+  "version": "3.11.2",
   "license": "Apache-2.0",
   "main": "target/index.js",
   "types": "target/index.d.ts",
   "dependencies": {
-    "@gatling.io/jvm-types": "0.1.1"
+    "@gatling.io/jvm-types": "3.11.2"
   },
   "devDependencies": {
     "@types/jest": "29.5.12",
     "jest": "29.7.0",
     "prettier": "3.2.5",
-    "rimraf": "5.0.5",
+    "rimraf": "5.0.7",
     "ts-jest": "29.1.2",
     "ts-node": "10.9.2",
     "typescript": "5.4.5"

package/target/assertions.d.ts

@@ -1,5 +1,5 @@
-import JvmAssertion = io.gatling.javaapi.core.Assertion;
 import { Wrapper } from "./common";
+import JvmAssertion = io.gatling.javaapi.core.Assertion;
 /**
  * Bootstrap a new global assertion that targets stats aggregated on all requests
  *

package/target/checks/multipleFind.d.ts

@@ -4,7 +4,7 @@ import JvmCheckBuilderMultipleFind = io.gatling.javaapi.core.CheckBuilder$Multip
  * Step 1 of the Check DSL when the check can return multiple values Immutable, so all methods
  * return a new occurrence and leave the original unmodified.
  *
- * @typeParam <X> - the type of Java values the check can extract
+ * @typeParam X - the type of Java values the check can extract
  */
 export interface CheckBuilderMultipleFind<X> extends CheckBuilderValidate<X> {
     /**

package/target/closedInjection.d.ts

@@ -1,4 +1,3 @@
-import "@gatling.io/jvm-types";
 import { Wrapper } from "./common";
 import { Duration } from "./utils/duration";
 import JvmClosedInjectionStep = io.gatling.javaapi.core.ClosedInjectionStep;
@@ -7,27 +6,121 @@ import JvmClosedInjectionStepRamp = io.gatling.javaapi.core.ClosedInjectionStep$
 import JvmClosedInjectionStepRampTo = io.gatling.javaapi.core.ClosedInjectionStep$RampTo;
 import JvmClosedInjectionStepStairs = io.gatling.javaapi.core.ClosedInjectionStep$Stairs;
 import JvmClosedInjectionStepStairsWithTime = io.gatling.javaapi.core.ClosedInjectionStep$StairsWithTime;
+/**
+ * An injection profile step for using a closed workload model where you control the concurrent
+ * number of users. Only use if your system has a queue limiting entry. Don't use otherwise or your
+ * test will not match any production use case.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
 export interface ClosedInjectionStep extends Wrapper<JvmClosedInjectionStep> {
 }
+/**
+ * DSL component for building a {@link ClosedInjectionStep} that will inject new users in a way to
+ * maintain a constant number of concurrent users for a given duration.
+ */
 export interface ClosedInjectionStepConstant extends Wrapper<JvmClosedInjectionStepConstant> {
+    /**
+     * Define the duration of the step
+     *
+     * @param duration - the duration
+     * @returns a new ClosedInjectionStep
+     */
     during(duration: Duration): ClosedInjectionStep;
 }
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users for a given duration.
+ */
 export interface ClosedInjectionStepRamp extends Wrapper<JvmClosedInjectionStepRamp> {
+    /**
+     * Define the target number of concurrent users at the end of the ramp.
+     *
+     * @param t - the target number
+     * @returns a RampConcurrentUsersInjectionTo
+     */
     to(t: number): ClosedInjectionStepRampTo;
 }
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users for a given duration.
+ */
 export interface ClosedInjectionStepRampTo extends Wrapper<JvmClosedInjectionStepRampTo> {
+    /**
+     * Define the duration of the ramp.
+     *
+     * @param duration - the duration
+     * @returns a complete ClosedInjectionStep
+     */
     during(duration: Duration): ClosedInjectionStep;
 }
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users in a stairs fashion
+ */
 export interface ClosedInjectionStepStairs extends Wrapper<JvmClosedInjectionStepStairs> {
+    /**
+     * Define the number of levels
+     *
+     * @param levels - the number of levels in the stairs
+     * @returns the next DSL step
+     */
     times(levels: number): ClosedInjectionStepStairsWithTime;
 }
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users in a stairs fashion
+ */
 export interface ClosedInjectionStepStairsWithTime extends Wrapper<JvmClosedInjectionStepStairsWithTime> {
+    /**
+     * Define the duration of each level
+     *
+     * @param duration - the duration
+     * @returns the next DSL step
+     */
     eachLevelLasting(duration: Duration): ClosedInjectionStepComposite;
 }
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users in a stairs fashion
+ */
 export interface ClosedInjectionStepComposite extends ClosedInjectionStep {
+    /**
+     * Define the initial number of concurrent users (optional)
+     *
+     * @param startingUsers - the initial number of concurrent users
+     * @returns a usable {@link ClosedInjectionStep}
+     */
     startingFrom(startingUsers: number): ClosedInjectionStepComposite;
+    /**
+     * Define ramps separating levels (optional)
+     *
+     * @param duration - the duration of the ramps
+     * @returns a usable {@link ClosedInjectionStep}
+     */
     separatedByRampsLasting(duration: Duration): ClosedInjectionStepComposite;
 }
+/**
+ * Bootstrap a new closed workload constantConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepConstant}
+ *
+ * @param users - the number of concurrent users
+ * @returns the next DSL step
+ */
 export declare const constantConcurrentUsers: (users: number) => ClosedInjectionStepConstant;
+/**
+ * Bootstrap a new closed workload rampConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepRamp}
+ *
+ * @param from - the number of concurrent users at the start of the ramp
+ * @returns the next DSL step
+ */
 export declare const rampConcurrentUsers: (from: number) => ClosedInjectionStepRamp;
+/**
+ * Bootstrap a new closed workload incrementConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepStairs}
+ *
+ * @param usersIncrement - the difference of concurrent users between levels of the stairs
+ * @returns the next DSL step
+ */
 export declare const incrementConcurrentUsers: (usersIncrement: number) => ClosedInjectionStepStairs;

package/target/closedInjection.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.incrementConcurrentUsers = exports.rampConcurrentUsers = exports.constantConcurrentUsers = void 0;
-require("@gatling.io/jvm-types");
 const jvm_types_1 = require("@gatling.io/jvm-types");
 const duration_1 = require("./utils/duration");
 const wrapClosedInjectionStep = (_underlying) => ({ _underlying });
@@ -30,9 +29,30 @@ const wrapClosedInjectionStepComposite = (_underlying) => ({
     startingFrom: (startingUsers) => wrapClosedInjectionStepComposite(_underlying.startingFrom(startingUsers)),
     separatedByRampsLasting: (duration) => wrapClosedInjectionStepComposite(_underlying.separatedByRampsLasting((0, duration_1.toJvmDuration)(duration)))
 });
+/**
+ * Bootstrap a new closed workload constantConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepConstant}
+ *
+ * @param users - the number of concurrent users
+ * @returns the next DSL step
+ */
 const constantConcurrentUsers = (users) => wrapClosedInjectionStepConstant(jvm_types_1.CoreDsl.constantConcurrentUsers(users));
 exports.constantConcurrentUsers = constantConcurrentUsers;
+/**
+ * Bootstrap a new closed workload rampConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepRamp}
+ *
+ * @param from - the number of concurrent users at the start of the ramp
+ * @returns the next DSL step
+ */
 const rampConcurrentUsers = (from) => wrapClosedInjectionStepRamp(jvm_types_1.CoreDsl.rampConcurrentUsers(from));
 exports.rampConcurrentUsers = rampConcurrentUsers;
+/**
+ * Bootstrap a new closed workload incrementConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepStairs}
+ *
+ * @param usersIncrement - the difference of concurrent users between levels of the stairs
+ * @returns the next DSL step
+ */
 const incrementConcurrentUsers = (usersIncrement) => wrapClosedInjectionStepStairs(jvm_types_1.CoreDsl.incrementConcurrentUsers(usersIncrement));
 exports.incrementConcurrentUsers = incrementConcurrentUsers;

package/target/feeders.d.ts

@@ -57,11 +57,6 @@ export interface FeederBuilder<T> extends Wrapper<JvmFeederBuilder<T>> {
     shard(): FeederBuilder<T>;
 }
 export interface FileBasedFeederBuilder<T> extends FeederBuilder<T> {
-    queue(): FileBasedFeederBuilder<T>;
-    random(): FileBasedFeederBuilder<T>;
-    shuffle(): FileBasedFeederBuilder<T>;
-    circular(): FileBasedFeederBuilder<T>;
-    shard(): FileBasedFeederBuilder<T>;
     /**
      * Advice to unzip the underlying source because it's a zip or tar file
      *
@@ -71,12 +66,6 @@ export interface FileBasedFeederBuilder<T> extends FeederBuilder<T> {
 }
 export declare const wrapFileBasedFeederBuilder: <T>(_underlying: JvmFeederBuilderFileBased<T>) => FileBasedFeederBuilder<T>;
 export interface BatchableFeederBuilder<T> extends FileBasedFeederBuilder<T> {
-    queue(): BatchableFeederBuilder<T>;
-    random(): BatchableFeederBuilder<T>;
-    shuffle(): BatchableFeederBuilder<T>;
-    circular(): BatchableFeederBuilder<T>;
-    shard(): BatchableFeederBuilder<T>;
-    unzip(): BatchableFeederBuilder<T>;
     /**
      * Force loading the whole data in memory from the underlying source at once. Faster runtime but
      * slower boot time and higher heap usage.

package/target/index.d.ts

@@ -1,4 +1,4 @@
-import * as jvm from "./gatlingJvm/app";
+import "@gatling.io/jvm-types";
 import { PauseType } from "./structure/pauses";
 import { Duration } from "./utils/duration";
 import { SessionTo } from "./session";
@@ -112,4 +112,19 @@ export interface SetUp {
 }
 export type SetUpFunction = (...populationBuilders: PopulationBuilder[]) => SetUp;
 export type Simulation = (setUp: SetUpFunction) => void;
-export declare const runSimulation: (simulation: Simulation) => jvm.Simulation;
+export interface SimulationFunction {
+    /**
+     * Register a Gatling simulation, with the default name (which is "default")
+     *
+     * @param simulationSetUp - The function setting up the simulation
+     */
+    (simulationSetUp: Simulation): void;
+    /**
+     * Register a Gatling simulation
+     *
+     * @param simulationName - The simulation name (max 100 characters)
+     * @param simulationSetUp - The function setting up the simulation
+     */
+    (simulationName: string, simulationSetUp: Simulation): void;
+}
+export declare const simulation: SimulationFunction;

package/target/index.js

@@ -14,7 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSimulation = void 0;
+exports.simulation = void 0;
+require("@gatling.io/jvm-types");
 const callbacks_1 = require("./gatlingJvm/callbacks");
 const pauses_1 = require("./structure/pauses");
 const duration_1 = require("./utils/duration");
@@ -50,7 +51,18 @@ const wrapSetUp = (jvmSetUp) => ({
     normalPausesWithPercentageDuration: (stdDevPercent) => wrapSetUp(jvmSetUp.normalPausesWithPercentageDuration(stdDevPercent)),
     pauses: (pauseType) => wrapSetUp(jvmSetUp.pauses((0, pauses_1.toJvmPauseType)(pauseType)))
 });
-const runSimulation = (simulation) => (jvmSetUp) => {
-    simulation((...populationBuilders) => wrapSetUp(jvmSetUp(populationBuilders.map((p) => p._underlying))));
+const simulation = (arg0, arg1) => {
+    const [simulationName, simulationSetUp] = arg1 !== undefined ? [arg0.trim(), arg1] : ["default", arg0];
+    if (simulationName.length === 0) {
+        throw Error("simulationName must not be empty");
+    }
+    if ([...simulationName].length > 100) {
+        // Count actual characters, not UTF-16 code units as with simulationName.length
+        throw Error("simulationName must not exceed 100 characters");
+    }
+    const JsSimulation = Java.type("io.gatling.js.JsSimulation");
+    JsSimulation.registerJsSimulation(simulationName, (jvmSetUp) => {
+        simulationSetUp((...populationBuilders) => wrapSetUp(jvmSetUp(populationBuilders.map((p) => p._underlying))));
+    });
 };
-exports.runSimulation = runSimulation;
+exports.simulation = simulation;

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);