@gatling.io/core 0.1.0

package/target/structure/execs.d.ts

@@ -0,0 +1,46 @@
+import "@gatling.io/jvm-types";
+import JvmActionBuilder = io.gatling.javaapi.core.ActionBuilder;
+import JvmExecs = io.gatling.javaapi.core.exec.Execs;
+import JvmExecutable = io.gatling.javaapi.core.exec.Executable;
+import { Wrapper } from "../common";
+import { SessionTransform } from "../session";
+export interface Executable<T extends JvmExecutable> extends Wrapper<T> {
+}
+export interface ActionBuilder extends Executable<JvmActionBuilder> {
+}
+export declare const wrapActionBuilder: (_underlying: JvmActionBuilder) => ActionBuilder;
+export interface ExecFunction<T extends Execs<T>> {
+    /**
+     * Attach some `Executable`s. Chains will be attached sequentially.
+     *
+     * @example
+     * ```ts
+     * const chain1: ChainBuilder = ???
+     * const chain2: ChainBuilder = ???
+     * const chain1ThenChain2 = exec(chain1, chain2)
+     * ```
+     *
+     * @param executable - some `ChainBuilder` or `ActionBuilder`
+     * @param executables - other `ChainBuilder`s or `ActionBuilder`s
+     * @returns a new `StructureBuilder`
+     */
+    (executable: Executable<any>, ...executables: Array<Executable<any>>): T;
+    /**
+     * Attach a new action that will execute a function. Important: the function must only perform
+     * fast in-memory operations. In particular, it mustn't perform any long block I/O operation, or
+     * it will hurt Gatling performance badly.
+     *
+     * @example
+     * ```ts
+     * exec(session => session.set("foo", "bar"))
+     * ```
+     *
+     * @param executable - the function
+     * @returns a new `StructureBuilder`
+     */
+    (executable: SessionTransform): T;
+}
+export interface Execs<T extends Execs<T>> {
+    exec: ExecFunction<T>;
+}
+export declare const execImpl: <J2, J1 extends JvmExecs<J2, any>, T extends Execs<T>>(jvmExecs: J1, wrap: (wrapped: J2) => T) => ExecFunction<T>;

package/target/structure/execs.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execImpl = exports.wrapActionBuilder = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const wrapActionBuilder = (_underlying) => ({
+    _underlying
+});
+exports.wrapActionBuilder = wrapActionBuilder;
+const execImpl = (jvmExecs, wrap) => (arg0, ...arg1) => wrap(typeof arg0 === "function"
+    ? jvmExecs.exec((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTransform)(arg0))) // arg0: SessionTransform
+    : jvmExecs.exec(arg0._underlying, ...arg1.map((e) => e._underlying)) // arg0: Executable, ...arg1: Executable[]
+);
+exports.execImpl = execImpl;

package/target/structure/feeds.d.ts

@@ -0,0 +1,42 @@
+import "@gatling.io/jvm-types";
+import JvmFeeds = io.gatling.javaapi.core.feed.Feeds;
+import { FeederBuilder } from "../feeders";
+import { SessionTo } from "../session";
+export interface FeedFunction<T extends Feeds<T>> {
+    /**
+     * Attach a feed action.
+     *
+     * @param feederBuilder - a source of records
+     * @returns a new StructureBuilder
+     */
+    (feederBuilder: FeederBuilder<unknown>): T;
+    /**
+     * Attach a feed action.
+     *
+     * @param feederBuilder - a source of records
+     * @param numberOfRecords - the number of records to poll from the feeder at once
+     * @returns a new StructureBuilder
+     */
+    (feederBuilder: FeederBuilder<unknown>, numberOfRecords: number): T;
+    /**
+     * Attach a feed action.
+     *
+     * @param feederBuilder - a source of records
+     * @param numberOfRecords - the number of records to poll from the feeder at once, expressed as a Gatling Expression
+     * Language String
+     * @returns a new StructureBuilder
+     */
+    (feederBuilder: FeederBuilder<unknown>, numberOfRecords: string): T;
+    /**
+     * Attach a feed action.
+     *
+     * @param feederBuilder - a source of records
+     * @param numberOfRecords - the number of records to poll from the feeder at once, as a function
+     * @returns a new StructureBuilder
+     */
+    (feederBuilder: FeederBuilder<unknown>, numberOfRecords: SessionTo<number>): T;
+}
+export interface Feeds<T extends Feeds<T>> {
+    feed: FeedFunction<T>;
+}
+export declare const feedImpl: <J2, J1 extends JvmFeeds<J2, any>, T extends Feeds<T>>(jvmFeeds: J1, wrap: (wrapped: J2) => T) => FeedFunction<T>;

package/target/structure/feeds.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feedImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const feedImpl = (jvmFeeds, wrap) => (feederBuilder, numberOfRecords) => {
+    if (typeof numberOfRecords === "number") {
+        return wrap(jvmFeeds.feed(feederBuilder._underlying, numberOfRecords));
+    }
+    else if (typeof numberOfRecords === "string") {
+        return wrap(jvmFeeds.feed(feederBuilder._underlying, numberOfRecords));
+    }
+    else if (typeof numberOfRecords === "function") {
+        return wrap(jvmFeeds.feed(feederBuilder._underlying, (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(numberOfRecords))));
+    }
+    else {
+        return wrap(jvmFeeds.feed(feederBuilder._underlying));
+    }
+};
+exports.feedImpl = feedImpl;

package/target/structure/forEach.d.ts

@@ -0,0 +1,38 @@
+import "@gatling.io/jvm-types";
+import JvmForEach = io.gatling.javaapi.core.loop.ForEach;
+import { SessionTo } from "../session";
+import { On } from "./on";
+export interface ForEachFunction<T extends ForEach<T>> {
+    /**
+     * Define a loop that will iterate over a list of values.
+     *
+     * @param seq - the static list of values to iterate over
+     * @param attributeName - the key to store the current element in the Session
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a DSL component to define the loop content
+     */
+    (seq: unknown[], attributeName: string, counterName?: string): On<T>;
+    /**
+     * Define a loop that will iterate over a list of values.
+     *
+     * @param seq - the list of values to iterate over, expressed as a Gatling Expression Language String, must evaluate
+     * to an array
+     * @param attributeName - the key to store the current element in the Session
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a DSL component to define the loop content
+     */
+    (seq: string, attributeName: string, counterName?: string): On<T>;
+    /**
+     * Define a loop that will iterate over a list of values.
+     *
+     * @param seq - the list of values to iterate over, expressed as a function
+     * @param attributeName - the key to store the current element in the Session
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a DSL component to define the loop content
+     */
+    (seq: SessionTo<Array<unknown>>, attributeName: string, counterName?: string): On<T>;
+}
+export interface ForEach<T extends ForEach<T>> {
+    foreach: ForEachFunction<T>;
+}
+export declare const foreachImpl: <J2, J1 extends JvmForEach<J2, any>, T extends ForEach<T>>(jvmForEach: J1, wrap: (wrapped: J2) => T) => ForEachFunction<T>;

package/target/structure/forEach.js

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

package/target/structure/forever.d.ts

@@ -0,0 +1,16 @@
+import "@gatling.io/jvm-types";
+import JvmForever = io.gatling.javaapi.core.loop.Forever;
+import { On } from "./on";
+export interface ForeverFunction<T extends Forever<T>> {
+    /**
+     * Define a loop that will iterate forever.
+     *
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a DSL component for defining the loop content
+     */
+    (counterName?: string): On<T>;
+}
+export interface Forever<T extends Forever<T>> {
+    forever: ForeverFunction<T>;
+}
+export declare const foreverImpl: <J2, J1 extends JvmForever<J2, any>, T extends Forever<T>>(jvmForever: J1, wrap: (wrapped: J2) => T) => ForeverFunction<T>;

package/target/structure/forever.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foreverImpl = void 0;
+require("@gatling.io/jvm-types");
+const on_1 = require("./on");
+const foreverImpl = (jvmForever, wrap) => (counterName) => (0, on_1.wrapOn)(counterName !== undefined ? jvmForever.forever(counterName) : jvmForever.forever(), wrap);
+exports.foreverImpl = foreverImpl;

package/target/structure/groups.d.ts

@@ -0,0 +1,17 @@
+import "@gatling.io/jvm-types";
+import JvmGroups = io.gatling.javaapi.core.group.Groups;
+import { SessionTo } from "../session";
+import { On } from "./on";
+export interface GroupFunction<T extends Groups<T>> {
+    /**
+     * Define a group
+     *
+     * @param name - the name of the group, expressed as a Gatling Expression Language String or a function
+     * @returns a DSL component for defining the wrapped block
+     */
+    (name: string | SessionTo<string>): On<T>;
+}
+export interface Groups<T extends Groups<T>> {
+    group: GroupFunction<T>;
+}
+export declare const groupImpl: <J2, J1 extends JvmGroups<J2, any>, T extends Groups<T>>(jvmGroups: J1, wrap: (wrapped: J2) => T) => GroupFunction<T>;

package/target/structure/groups.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupImpl = void 0;
+require("@gatling.io/jvm-types");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const on_1 = require("./on");
+const groupImpl = (jvmGroups, wrap) => (group) => (0, on_1.wrapOn)(typeof group === "function" ? jvmGroups.group((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(group))) : jvmGroups.group(group), wrap);
+exports.groupImpl = groupImpl;

package/target/structure/index.d.ts

@@ -0,0 +1,64 @@
+import "@gatling.io/jvm-types";
+import JvmChainBuilder = io.gatling.javaapi.core.ChainBuilder;
+import { JvmStructureBuilderLike } from "./jvmStructureBuilder";
+import { ExecFunction, Execs, Executable } from "./execs";
+import { GroupFunction, Groups } from "./groups";
+import { FeedFunction, Feeds } from "./feeds";
+import { PauseFunction, Pauses } from "./pauses";
+import { Paces } from "./paces";
+import { RendezVous } from "./rendezVous";
+import { Repeat } from "./repeat";
+import { ForEach } from "./forEach";
+import { During } from "./during";
+import { Forever } from "./forever";
+import { AsLongAs } from "./asLongAs";
+import { DoWhile } from "./doWhile";
+import { AsLongAsDuring } from "./asLongAsDuring";
+import { DoWhileDuring } from "./doWhileDuring";
+import { DoIf, DoIfEquals } from "./doIf";
+import { DoIfOrElse, DoIfEqualsOrElse } from "./doIfOrElse";
+import { DoSwitch } from "./doSwitch";
+import { DoSwitchOrElse } from "./doSwitchOrElse";
+import { RandomSwitch } from "./randomSwitch";
+import { RandomSwitchOrElse } from "./randomSwitchOrElse";
+import { UniformRandomSwitch } from "./uniformRandomSwitch";
+import { RoundRobinSwitch } from "./roundRobinSwitch";
+import { Errors } from "./errors";
+export interface StructureBuilder<T extends StructureBuilder<T>> extends Execs<T>, Groups<T>, Feeds<T>, Pauses<T>, Paces<T>, RendezVous<T>, Repeat<T>, ForEach<T>, During<T>, Forever<T>, AsLongAs<T>, DoWhile<T>, AsLongAsDuring<T>, DoWhileDuring<T>, DoIf<T>, DoIfOrElse<T>, DoIfEquals<T>, DoIfEqualsOrElse<T>, DoSwitch<T>, DoSwitchOrElse<T>, RandomSwitch<T>, RandomSwitchOrElse<T>, UniformRandomSwitch<T>, RoundRobinSwitch<T>, Errors<T> {
+}
+export declare const structureBuilderImpl: <J2, J1 extends JvmStructureBuilderLike<J2, any>, T extends StructureBuilder<T>>(jvm: J1, wrap: (wrapped: J2) => T) => StructureBuilder<T>;
+export interface ChainBuilder extends StructureBuilder<ChainBuilder>, Executable<JvmChainBuilder> {
+}
+export { ActionBuilder, wrapActionBuilder } from "./execs";
+export { onCase, percent } from "./choices";
+export declare const exec: ExecFunction<ChainBuilder>;
+export declare const group: GroupFunction<ChainBuilder>;
+export declare const feed: FeedFunction<ChainBuilder>;
+export declare const pause: PauseFunction<ChainBuilder>;
+export declare const pace: import("./paces").PaceFunction<ChainBuilder>;
+export declare const rendezVous: import("./rendezVous").RendezVousFunction<ChainBuilder>;
+export declare const repeat: import("./repeat").RepeatFunction<ChainBuilder>;
+export declare const foreach: import("./forEach").ForEachFunction<ChainBuilder>;
+export declare const during: import("./during").DuringFunction<ChainBuilder>;
+export declare const forever: import("./forever").ForeverFunction<ChainBuilder>;
+export declare const asLongAs: import("./asLongAs").AsLongAsFunction<ChainBuilder>;
+export declare const doWhile: import("./doWhile").DoWhileFunction<ChainBuilder>;
+export declare const asLongAsDuring: import("./asLongAsDuring").AsLongAsDuringFunction<ChainBuilder>;
+export declare const doWhileDuring: import("./doWhileDuring").DoWhileDuringFunction<ChainBuilder>;
+export declare const doIf: import("./doIf").DoIfFunction<ChainBuilder>;
+export declare const doIfOrElse: import("./doIfOrElse").DoIfOrElseFunction<ChainBuilder>;
+export declare const doIfEquals: import("./doIf").DoIfEqualsFunction<ChainBuilder>;
+export declare const doIfEqualsOrElse: import("./doIfOrElse").DoIfEqualsOrElseFunction<ChainBuilder>;
+export declare const doSwitch: import("./doSwitch").DoSwitchFunction<ChainBuilder>;
+export declare const doSwitchOrElse: import("./doSwitchOrElse").DoSwitchOrElseFunction<ChainBuilder>;
+export declare const randomSwitch: import("./randomSwitch").RandomSwitchFunction<ChainBuilder>;
+export declare const randomSwitchOrElse: import("./randomSwitchOrElse").RandomSwitchOrElseFunction<ChainBuilder>;
+export declare const uniformRandomSwitch: import("./uniformRandomSwitch").UniformRandomSwitchFunction<ChainBuilder>;
+export declare const roundRobinSwitch: import("./roundRobinSwitch").RoundRobinSwitchFunction<ChainBuilder>;
+export declare const exitBlockOnFail: import("./errors").ExitBlockOnFailFunction<ChainBuilder>;
+export declare const tryMax: import("./errors").TryMaxFunction<ChainBuilder>;
+export declare const exitHereIf: import("./errors").ExitHereIfFunction<ChainBuilder>;
+export declare const exitHere: import("./errors").ExitHereFunction<ChainBuilder>;
+export declare const exitHereIfFailed: import("./errors").ExitHereIfFailedFunction<ChainBuilder>;
+export declare const stopInjector: import("./errors").StopInjectorFunction<ChainBuilder>;
+export declare const stopInjectorIf: import("./errors").StopInjectorIfFunction<ChainBuilder>;

package/target/structure/index.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopInjectorIf = exports.stopInjector = exports.exitHereIfFailed = exports.exitHere = exports.exitHereIf = exports.tryMax = exports.exitBlockOnFail = exports.roundRobinSwitch = exports.uniformRandomSwitch = exports.randomSwitchOrElse = exports.randomSwitch = exports.doSwitchOrElse = exports.doSwitch = exports.doIfEqualsOrElse = exports.doIfEquals = exports.doIfOrElse = exports.doIf = exports.doWhileDuring = exports.asLongAsDuring = exports.doWhile = exports.asLongAs = exports.forever = exports.during = exports.foreach = exports.repeat = exports.rendezVous = exports.pace = exports.pause = exports.feed = exports.group = exports.exec = exports.percent = exports.onCase = exports.wrapActionBuilder = exports.structureBuilderImpl = void 0;
+require("@gatling.io/jvm-types");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const execs_1 = require("./execs");
+const groups_1 = require("./groups");
+const feeds_1 = require("./feeds");
+const pauses_1 = require("./pauses");
+const paces_1 = require("./paces");
+const rendezVous_1 = require("./rendezVous");
+const repeat_1 = require("./repeat");
+const forEach_1 = require("./forEach");
+const during_1 = require("./during");
+const forever_1 = require("./forever");
+const asLongAs_1 = require("./asLongAs");
+const doWhile_1 = require("./doWhile");
+const asLongAsDuring_1 = require("./asLongAsDuring");
+const doWhileDuring_1 = require("./doWhileDuring");
+const doIf_1 = require("./doIf");
+const doIfOrElse_1 = require("./doIfOrElse");
+const doSwitch_1 = require("./doSwitch");
+const doSwitchOrElse_1 = require("./doSwitchOrElse");
+const randomSwitch_1 = require("./randomSwitch");
+const randomSwitchOrElse_1 = require("./randomSwitchOrElse");
+const uniformRandomSwitch_1 = require("./uniformRandomSwitch");
+const roundRobinSwitch_1 = require("./roundRobinSwitch");
+const errors_1 = require("./errors");
+const structureBuilderImpl = (jvm, wrap) => ({
+    exec: (0, execs_1.execImpl)(jvm, wrap),
+    group: (0, groups_1.groupImpl)(jvm, wrap),
+    feed: (0, feeds_1.feedImpl)(jvm, wrap),
+    pause: (0, pauses_1.pauseImpl)(jvm, wrap),
+    pace: (0, paces_1.paceImpl)(jvm, wrap),
+    rendezVous: (0, rendezVous_1.rendezVousImpl)(jvm, wrap),
+    repeat: (0, repeat_1.repeatImpl)(jvm, wrap),
+    foreach: (0, forEach_1.foreachImpl)(jvm, wrap),
+    during: (0, during_1.duringImpl)(jvm, wrap),
+    forever: (0, forever_1.foreverImpl)(jvm, wrap),
+    asLongAs: (0, asLongAs_1.asLongAsImpl)(jvm, wrap),
+    doWhile: (0, doWhile_1.doWhileImpl)(jvm, wrap),
+    asLongAsDuring: (0, asLongAsDuring_1.asLongAsDuringImpl)(jvm, wrap),
+    doWhileDuring: (0, doWhileDuring_1.doWhileDuringImpl)(jvm, wrap),
+    doIf: (0, doIf_1.doIfImpl)(jvm, wrap),
+    doIfOrElse: (0, doIfOrElse_1.doIfOrElseImpl)(jvm, wrap),
+    doIfEquals: (0, doIf_1.doIfEqualsImpl)(jvm, wrap),
+    doIfEqualsOrElse: (0, doIfOrElse_1.doIfEqualsOrElseImpl)(jvm, wrap),
+    doSwitch: (0, doSwitch_1.doSwitchImpl)(jvm, wrap),
+    doSwitchOrElse: (0, doSwitchOrElse_1.doSwitchOrElseImpl)(jvm, wrap),
+    randomSwitch: (0, randomSwitch_1.randomSwitchImpl)(jvm, wrap),
+    randomSwitchOrElse: (0, randomSwitchOrElse_1.randomSwitchOrElseImpl)(jvm, wrap),
+    uniformRandomSwitch: (0, uniformRandomSwitch_1.uniformRandomSwitchImpl)(jvm, wrap),
+    roundRobinSwitch: (0, roundRobinSwitch_1.roundRobinSwitchImpl)(jvm, wrap),
+    ...(0, errors_1.errorsImpl)(jvm, wrap)
+});
+exports.structureBuilderImpl = structureBuilderImpl;
+const wrapChainBuilder = (_underlying) => ({
+    _underlying,
+    ...(0, exports.structureBuilderImpl)(_underlying, wrapChainBuilder)
+});
+// CoreDsl elements
+var execs_2 = require("./execs");
+Object.defineProperty(exports, "wrapActionBuilder", { enumerable: true, get: function () { return execs_2.wrapActionBuilder; } });
+var choices_1 = require("./choices");
+Object.defineProperty(exports, "onCase", { enumerable: true, get: function () { return choices_1.onCase; } });
+Object.defineProperty(exports, "percent", { enumerable: true, get: function () { return choices_1.percent; } });
+exports.exec = (0, execs_1.execImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.group = (0, groups_1.groupImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.feed = (0, feeds_1.feedImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.pause = (0, pauses_1.pauseImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.pace = (0, paces_1.paceImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.rendezVous = (0, rendezVous_1.rendezVousImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.repeat = (0, repeat_1.repeatImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.foreach = (0, forEach_1.foreachImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.during = (0, during_1.duringImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.forever = (0, forever_1.foreverImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.asLongAs = (0, asLongAs_1.asLongAsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.doWhile = (0, doWhile_1.doWhileImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.asLongAsDuring = (0, asLongAsDuring_1.asLongAsDuringImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.doWhileDuring = (0, doWhileDuring_1.doWhileDuringImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.doIf = (0, doIf_1.doIfImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.doIfOrElse = (0, doIfOrElse_1.doIfOrElseImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.doIfEquals = (0, doIf_1.doIfEqualsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.doIfEqualsOrElse = (0, doIfOrElse_1.doIfEqualsOrElseImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.doSwitch = (0, doSwitch_1.doSwitchImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.doSwitchOrElse = (0, doSwitchOrElse_1.doSwitchOrElseImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.randomSwitch = (0, randomSwitch_1.randomSwitchImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.randomSwitchOrElse = (0, randomSwitchOrElse_1.randomSwitchOrElseImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.uniformRandomSwitch = (0, uniformRandomSwitch_1.uniformRandomSwitchImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.roundRobinSwitch = (0, roundRobinSwitch_1.roundRobinSwitchImpl)(jvm_types_1.CoreDsl, wrapChainBuilder);
+exports.exitBlockOnFail = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).exitBlockOnFail;
+exports.tryMax = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).tryMax;
+exports.exitHereIf = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).exitHereIf;
+exports.exitHere = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).exitHere;
+exports.exitHereIfFailed = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).exitHereIfFailed;
+exports.stopInjector = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).stopInjector;
+exports.stopInjectorIf = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).stopInjectorIf;

package/target/structure/jvmStructureBuilder.d.ts

@@ -0,0 +1,28 @@
+import "@gatling.io/jvm-types";
+import JvmExecs = io.gatling.javaapi.core.exec.Execs;
+import JvmGroups = io.gatling.javaapi.core.group.Groups;
+import JvmFeeds = io.gatling.javaapi.core.feed.Feeds;
+import JvmPauses = io.gatling.javaapi.core.pause.Pauses;
+import JvmPaces = io.gatling.javaapi.core.pause.Paces;
+import JvmRendezVous = io.gatling.javaapi.core.pause.RendezVous;
+import JvmRepeat = io.gatling.javaapi.core.loop.Repeat;
+import JvmForEach = io.gatling.javaapi.core.loop.ForEach;
+import JvmDuring = io.gatling.javaapi.core.loop.During;
+import JvmForever = io.gatling.javaapi.core.loop.Forever;
+import JvmAsLongAs = io.gatling.javaapi.core.loop.AsLongAs;
+import JvmDoWhile = io.gatling.javaapi.core.loop.DoWhile;
+import JvmAsLongAsDuring = io.gatling.javaapi.core.loop.AsLongAsDuring;
+import JvmDoWhileDuring = io.gatling.javaapi.core.loop.DoWhileDuring;
+import JvmDoIf = io.gatling.javaapi.core.condition.DoIf;
+import JvmDoIfOrElse = io.gatling.javaapi.core.condition.DoIfOrElse;
+import JvmDoIfEquals = io.gatling.javaapi.core.condition.DoIfEquals;
+import JvmDoIfEqualsOrElse = io.gatling.javaapi.core.condition.DoIfEqualsOrElse;
+import JvmDoSwitch = io.gatling.javaapi.core.condition.DoSwitch;
+import JvmDoSwitchOrElse = io.gatling.javaapi.core.condition.DoSwitchOrElse;
+import JvmRandomSwitch = io.gatling.javaapi.core.condition.RandomSwitch;
+import JvmRandomSwitchOrElse = io.gatling.javaapi.core.condition.RandomSwitchOrElse;
+import JvmUniformRandomSwitch = io.gatling.javaapi.core.condition.UniformRandomSwitch;
+import JvmRoundRobinSwitch = io.gatling.javaapi.core.condition.RoundRobinSwitch;
+import JvmErrors = io.gatling.javaapi.core.error.Errors;
+export interface JvmStructureBuilderLike<T, W> extends JvmExecs<T, W>, JvmGroups<T, W>, JvmFeeds<T, W>, JvmPauses<T, W>, JvmPaces<T, W>, JvmRendezVous<T, W>, JvmRepeat<T, W>, JvmForEach<T, W>, JvmDuring<T, W>, JvmForever<T, W>, JvmAsLongAs<T, W>, JvmDoWhile<T, W>, JvmAsLongAsDuring<T, W>, JvmDoWhileDuring<T, W>, JvmDoIf<T, W>, JvmDoIfOrElse<T, W>, JvmDoIfEquals<T, W>, JvmDoIfEqualsOrElse<T, W>, JvmDoSwitch<T, W>, JvmDoSwitchOrElse<T, W>, JvmRandomSwitch<T, W>, JvmRandomSwitchOrElse<T, W>, JvmUniformRandomSwitch<T, W>, JvmRoundRobinSwitch<T, W>, JvmErrors<T, W> {
+}

package/target/structure/jvmStructureBuilder.js

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

package/target/structure/on.d.ts

@@ -0,0 +1,12 @@
+import JvmExecutable = io.gatling.javaapi.core.exec.Executable;
+import { Executable } from "./execs";
+interface JvmOn<T> {
+    on(arg0: JvmExecutable, ...arg1: JvmExecutable[]): T;
+    equals(arg0: any): boolean;
+    toString(): string;
+}
+export interface On<T> {
+    on(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+export declare const wrapOn: <J, T>(jvmOn: JvmOn<J>, wrap: (underlying: J) => T) => On<T>;
+export {};

package/target/structure/on.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapOn = void 0;
+const wrapOn = (jvmOn, wrap) => ({
+    on: (executable, ...executables) => wrap(jvmOn.on(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+exports.wrapOn = wrapOn;

package/target/structure/paces.d.ts

@@ -0,0 +1,101 @@
+import "@gatling.io/jvm-types";
+import JvmPaces = io.gatling.javaapi.core.pause.Paces;
+import { Duration } from "../utils/duration";
+import { SessionTo } from "../session";
+export interface PaceFunction<T extends Paces<T>> {
+    /**
+     * Attach a pace action
+     *
+     * @param duration - the duration of the pace, in seconds or with an explicit time unit
+     * @returns a new StructureBuilder
+     */
+    (duration: Duration): T;
+    /**
+     * Attach a pace action where the duration is defined 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 duration of the pace
+     * @returns a new StructureBuilder
+     */
+    (duration: string): T;
+    /**
+     * Attach a pace action
+     *
+     * @param duration - the duration of the pace as a function
+     * @returns a new StructureBuilder
+     */
+    (duration: SessionTo<Duration>): T;
+    /**
+     * Attach a pace action
+     *
+     * @param duration - the duration of the pace, in seconds or with an explicit time unit
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a new StructureBuilder
+     */
+    (duration: Duration, counterName: string): T;
+    /**
+     * Attach a pace action where the duration is defined 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 duration of the pace
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a new StructureBuilder
+     */
+    (duration: string, counterName: string): T;
+    /**
+     * Attach a pace action
+     *
+     * @param duration - the duration of the pace as a function
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a new StructureBuilder
+     */
+    (duration: SessionTo<Duration>, counterName: string): T;
+    /**
+     * Attach a pace action where the duration is random between 2 bounds
+     *
+     * @param min - the duration of the pace, in seconds or with an explicit time unit
+     * @param max - the duration of the pace, in seconds or with an explicit time unit
+     * @returns a new StructureBuilder
+     */
+    (min: Duration, max: Duration): T;
+    /**
+     * Attach a pace action where the duration is random between 2 bounds
+     *
+     * @param min - the duration of the pace as a function
+     * @param max - the duration of the pace as a function
+     * @returns a new StructureBuilder
+     */
+    (min: SessionTo<Duration>, max: SessionTo<Duration>): T;
+    /**
+     * Attach a pace action where the duration is random between 2 bounds
+     *
+     * @param min - the duration of the pace, in seconds or with an explicit time unit
+     * @param max - the duration of the pace, in seconds or with an explicit time unit
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a new StructureBuilder
+     */
+    (min: Duration, max: Duration, counterName: string): T;
+    /**
+     * Attach a pace action where the duration is random between 2 bounds as Gatling Expression Language strings. 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 duration of the pace
+     * @param max - the duration of the pace
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a new StructureBuilder
+     */
+    (min: string, max: string, counterName: string): T;
+    /**
+     * Attach a pace action where the duration is random between 2 bounds
+     *
+     * @param min - the duration of the pace as a function
+     * @param max - the duration of the pace as a function
+     * @param counterName - the name of the loop counter, as stored in the Session
+     * @returns a new StructureBuilder
+     */
+    (min: SessionTo<Duration>, max: SessionTo<Duration>, counterName: string): T;
+}
+export interface Paces<T extends Paces<T>> {
+    pace: PaceFunction<T>;
+}
+export declare const paceImpl: <J2, J1 extends JvmPaces<J2, any>, T extends Paces<T>>(jvmGroups: J1, wrap: (wrapped: J2) => T) => PaceFunction<T>;

package/target/structure/paces.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paceImpl = void 0;
+require("@gatling.io/jvm-types");
+const duration_1 = require("../utils/duration");
+const session_1 = require("../session");
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const paceImpl = (jvmGroups, wrap) => (arg0, arg1, arg2) => {
+    if (arg2 !== undefined) {
+        // pace(min, max, counterName)
+        if (typeof arg0 === "string" && typeof arg1 === "string") {
+            return wrap(jvmGroups.pace(arg0, arg1, arg2));
+        }
+        else if (typeof arg0 === "function" && typeof arg1 === "function") {
+            return wrap(jvmGroups.pace((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg0)), (0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg1)), arg2));
+        }
+        else if ((0, duration_1.isDuration)(arg0) && (0, duration_1.isDuration)(arg1)) {
+            return wrap(jvmGroups.pace((0, duration_1.toJvmDuration)(arg0), (0, duration_1.toJvmDuration)(arg1), arg2));
+        }
+    }
+    else if (arg1 !== undefined) {
+        if (typeof arg1 === "string") {
+            // pace(duration, counterName)
+            if (typeof arg0 === "string") {
+                return wrap(jvmGroups.pace(arg0, arg1));
+            }
+            else if (typeof arg0 === "function") {
+                return wrap(jvmGroups.pace((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg0)), arg1));
+            }
+            else if ((0, duration_1.isDuration)(arg0)) {
+                return wrap(jvmGroups.pace((0, duration_1.toJvmDuration)(arg0), arg1));
+            }
+        }
+        else {
+            // pace(min, max)
+            if (typeof arg0 === "function" && typeof arg1 === "function") {
+                return wrap(jvmGroups.pace((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.pace((0, duration_1.toJvmDuration)(arg0), (0, duration_1.toJvmDuration)(arg1)));
+            }
+        }
+    }
+    else {
+        // pace(duration)
+        if (typeof arg0 === "string") {
+            return wrap(jvmGroups.pace(arg0));
+        }
+        else if (typeof arg0 === "function") {
+            return wrap(jvmGroups.pace((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionToDuration)(arg0))));
+        }
+        else if ((0, duration_1.isDuration)(arg0)) {
+            return wrap(jvmGroups.pace((0, duration_1.toJvmDuration)(arg0)));
+        }
+    }
+    throw Error(`pace() called with invalid arguments ${arg0}, ${arg1}, ${arg2}`);
+};
+exports.paceImpl = paceImpl;