@gatling.io/core 0.1.0

package/target/feeders.d.ts

@@ -0,0 +1,203 @@
+import JvmFeederBuilder = io.gatling.javaapi.core.FeederBuilder;
+import JvmFeederBuilderFileBased = io.gatling.javaapi.core.FeederBuilder$FileBased;
+import { Wrapper } from "./common";
+export interface FeederBuilder<T> extends Wrapper<JvmFeederBuilder<T>> {
+    /**
+     * Set a queue strategy. Records will be provided in the same order as defined in the underlying
+     * source. A given record will only be provided once. The run will be immediately stopped if the
+     * feeder runs out of records.
+     *
+     * @returns a new FeederBuilder
+     */
+    queue(): FeederBuilder<T>;
+    /**
+     * Set a random strategy. Records will be provided in a random order, unrelated to the order in
+     * the underlying source. A given record can be provided multiple times. Such feeder will never
+     * run out of records.
+     *
+     * @returns a new FeederBuilder
+     */
+    random(): FeederBuilder<T>;
+    /**
+     * Set a shuffle strategy. Records will be provided in a random order, unrelated to the order in
+     * the underlying source. A given record will only be provided once. The run will be immediately
+     * stopped if the feeder runs out of records.
+     *
+     * @returns a new FeederBuilder
+     */
+    shuffle(): FeederBuilder<T>;
+    /**
+     * Set a circular strategy. Records will be provided in the same order as defined in the
+     * underlying source. Once the last record of the underlying source is reached, the feeder will go
+     * back to the first record. A given record can be provided multiple times. Such feeder will never
+     * run out of records.
+     *
+     * @returns a new FeederBuilder
+     */
+    circular(): FeederBuilder<T>;
+    /**
+     * Provide a function to transform records as defined in the underlying source
+     *
+     * @param f - the transformation function
+     * @returns a new FeederBuilder
+     */
+    transform(f: (name: string, value: T) => unknown): FeederBuilder<unknown>;
+    /**
+     * Return the number of records more efficiantly than readRecords().size().
+     *
+     * @returns the number of recordss
+     */
+    recordsCount(): number;
+    /**
+     * Distribute data evenly amongst all the injectors of a Gatling Enterprise cluster. Only
+     * effective when the test is running with Gatling Enterprise, noop otherwise.
+     *
+     * @returns a new FeederBuilder
+     */
+    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
+     *
+     * @returns a new FileBased
+     */
+    unzip(): FileBasedFeederBuilder<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.
+     *
+     * @returns a new Batchable
+     */
+    eager(): BatchableFeederBuilder<T>;
+    /**
+     * Force loading small chunks of data from the underlying source one by one. Slower runtime but
+     * faster boot time and lower memory consumption.
+     *
+     * @returns a new Batchable
+     */
+    batch(): BatchableFeederBuilder<T>;
+    /**
+     * Force loading small chunks of data from the underlying source one by one Slower runtime but
+     * faster boot time and lower memory consumption.
+     *
+     * @param lines - the number of buffered lines
+     * @returns a new Batchable
+     */
+    batch(lines: number): BatchableFeederBuilder<T>;
+}
+export interface CsvFunction {
+    /**
+     * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder
+     *
+     * @param filePath - the path of the file, relative to the root of the resources folder
+     * @returns a new feeder
+     */
+    (filePath: string): BatchableFeederBuilder<string>;
+    /**
+     * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder
+     *
+     * @param filePath - the path of the file, relative to the root of the resources folder
+     * @param quoteChar - the quote char to wrap values containing special characters
+     * @returns a new feeder
+     */
+    (filePath: string, quoteChar: string): BatchableFeederBuilder<string>;
+}
+export declare const csv: CsvFunction;
+export interface SsvFunction {
+    /**
+     * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+     * is a semi-colon
+     *
+     * @param filePath - the path of the file, relative to the root of the resources folder
+     * @returns a new feeder
+     */
+    (filePath: string): BatchableFeederBuilder<string>;
+    /**
+     * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+     * is a semi-colon
+     *
+     * @param filePath - the path of the file, relative to the root of the resources folder
+     * @param quoteChar - the quote char to wrap values containing special characters (must be a single character)
+     * @returns a new feeder
+     */
+    (filePath: string, quoteChar: string): BatchableFeederBuilder<string>;
+}
+export declare const ssv: SsvFunction;
+export interface TsvFunction {
+    /**
+     * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+     * is a tab
+     *
+     * @param filePath - the path of the file, relative to the root of the resources folder
+     * @returns a new feeder
+     */
+    (filePath: string): BatchableFeederBuilder<string>;
+    /**
+     * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+     * is a tab
+     *
+     * @param filePath - the path of the file, relative to the root of the resources folder
+     * @param quoteChar - the quote char to wrap values containing special characters (must be a single character)
+     * @returns a new feeder
+     */
+    (filePath: string, quoteChar: string): BatchableFeederBuilder<string>;
+}
+export declare const tsv: TsvFunction;
+export interface SeparatedValuesFunction {
+    /**
+     * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+     * is a tab
+     *
+     * @param filePath - the path of the file, relative to the root of the resources folder
+     * @param separator - the provided separator char (must be a single character)
+     * @returns a new feeder
+     */
+    (filePath: string, separator: string): BatchableFeederBuilder<string>;
+    /**
+     * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+     * is a tab
+     *
+     * @param filePath - the path of the file, relative to the root of the resources folder
+     * @param separator - the provided separator char (must be a single character)
+     * @param quoteChar - the quote char to wrap values containing special characters (must be a single character)
+     * @returns a new feeder
+     */
+    (filePath: string, separator: string, quoteChar: string): BatchableFeederBuilder<string>;
+}
+export declare const separatedValues: SeparatedValuesFunction;
+/**
+ * Bootstrap a new JSON file based feeder
+ *
+ * @param filePath - the path of the file, relative to the root of the resources folder
+ * @returns a new feeder
+ */
+export declare const jsonFile: (filePath: string) => FileBasedFeederBuilder<any>;
+/**
+ * Bootstrap a new JSON API based feeder
+ *
+ * @param url - the url of the API
+ * @returns a new feeder
+ */
+export declare const jsonUrl: (url: string) => FeederBuilder<any>;
+/**
+ * Bootstrap a new in-memory array of Maps based feeder
+ *
+ * @param data - the in-memory data
+ * @returns a new feeder
+ */
+export declare const arrayFeeder: (data: Array<Record<string, unknown>>) => FeederBuilder<unknown>;

package/target/feeders.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayFeeder = exports.jsonUrl = exports.jsonFile = exports.separatedValues = exports.tsv = exports.ssv = exports.csv = exports.wrapFileBasedFeederBuilder = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const callbacks_1 = require("./gatlingJvm/callbacks");
+const wrapFeederBuilder = (_underlying) => ({
+    _underlying,
+    queue: () => wrapFeederBuilder(_underlying.queue()),
+    random: () => wrapFeederBuilder(_underlying.random()),
+    shuffle: () => wrapFeederBuilder(_underlying.shuffle()),
+    circular: () => wrapFeederBuilder(_underlying.circular()),
+    transform: (f) => wrapFeederBuilder(_underlying.transform((0, callbacks_1.wrapBiCallback)(f))),
+    recordsCount: () => _underlying.recordsCount(),
+    shard: () => wrapFeederBuilder(_underlying.shard())
+});
+const wrapFileBasedFeederBuilder = (_underlying) => ({
+    _underlying,
+    queue: () => (0, exports.wrapFileBasedFeederBuilder)(_underlying.queue()),
+    random: () => (0, exports.wrapFileBasedFeederBuilder)(_underlying.random()),
+    shuffle: () => (0, exports.wrapFileBasedFeederBuilder)(_underlying.shuffle()),
+    circular: () => (0, exports.wrapFileBasedFeederBuilder)(_underlying.circular()),
+    transform: (f) => wrapFeederBuilder(_underlying.transform((0, callbacks_1.wrapBiCallback)(f))),
+    recordsCount: () => _underlying.recordsCount(),
+    shard: () => (0, exports.wrapFileBasedFeederBuilder)(_underlying.shard()),
+    unzip: () => (0, exports.wrapFileBasedFeederBuilder)(_underlying.unzip())
+});
+exports.wrapFileBasedFeederBuilder = wrapFileBasedFeederBuilder;
+const wrapBatchableFeederBuilder = (_underlying) => ({
+    _underlying,
+    queue: () => wrapBatchableFeederBuilder(_underlying.queue()),
+    random: () => wrapBatchableFeederBuilder(_underlying.random()),
+    shuffle: () => wrapBatchableFeederBuilder(_underlying.shuffle()),
+    circular: () => wrapBatchableFeederBuilder(_underlying.circular()),
+    transform: (f) => wrapFeederBuilder(_underlying.transform((0, callbacks_1.wrapBiCallback)(f))),
+    recordsCount: () => _underlying.recordsCount(),
+    shard: () => wrapBatchableFeederBuilder(_underlying.shard()),
+    unzip: () => wrapBatchableFeederBuilder(_underlying.unzip()),
+    eager: () => wrapBatchableFeederBuilder(_underlying.eager()),
+    batch: (lines) => wrapBatchableFeederBuilder(lines !== undefined ? _underlying.batch(lines) : _underlying.batch())
+});
+const csv = (filePath, quoteChar) => wrapBatchableFeederBuilder(quoteChar !== undefined ? jvm_types_1.CoreDsl.csv(filePath, quoteChar) : jvm_types_1.CoreDsl.csv(filePath));
+exports.csv = csv;
+const ssv = (filePath, quoteChar) => wrapBatchableFeederBuilder(quoteChar !== undefined ? jvm_types_1.CoreDsl.ssv(filePath, quoteChar) : jvm_types_1.CoreDsl.ssv(filePath));
+exports.ssv = ssv;
+const tsv = (filePath, quoteChar) => wrapBatchableFeederBuilder(quoteChar !== undefined ? jvm_types_1.CoreDsl.tsv(filePath, quoteChar) : jvm_types_1.CoreDsl.tsv(filePath));
+exports.tsv = tsv;
+const separatedValues = (filePath, separator, quoteChar) => wrapBatchableFeederBuilder(quoteChar !== undefined
+    ? jvm_types_1.CoreDsl.separatedValues(filePath, separator, quoteChar)
+    : jvm_types_1.CoreDsl.separatedValues(filePath, separator));
+exports.separatedValues = separatedValues;
+/**
+ * Bootstrap a new JSON file based feeder
+ *
+ * @param filePath - the path of the file, relative to the root of the resources folder
+ * @returns a new feeder
+ */
+const jsonFile = (filePath) => (0, exports.wrapFileBasedFeederBuilder)(jvm_types_1.CoreDsl.jsonFile(filePath));
+exports.jsonFile = jsonFile;
+/**
+ * Bootstrap a new JSON API based feeder
+ *
+ * @param url - the url of the API
+ * @returns a new feeder
+ */
+const jsonUrl = (url) => wrapFeederBuilder(jvm_types_1.CoreDsl.jsonUrl(url));
+exports.jsonUrl = jsonUrl;
+/**
+ * Bootstrap a new in-memory array of Maps based feeder
+ *
+ * @param data - the in-memory data
+ * @returns a new feeder
+ */
+const arrayFeeder = (data) => wrapFeederBuilder(jvm_types_1.CoreDsl.arrayFeeder(data));
+exports.arrayFeeder = arrayFeeder;

package/target/filters.d.ts

@@ -0,0 +1,31 @@
+import JvmFilter = io.gatling.javaapi.core.Filter;
+import JvmFilterAllowList = io.gatling.javaapi.core.Filter$AllowList;
+import JvmFilterDenyList = io.gatling.javaapi.core.Filter$DenyList;
+import { Wrapper } from "./common";
+export interface Filter<T extends JvmFilter<unknown>> extends Wrapper<T> {
+    type: "allow" | "deny";
+}
+export interface AllowListFilter extends Filter<JvmFilterAllowList> {
+    type: "allow";
+}
+export interface DenyListFilter extends Filter<JvmFilterDenyList> {
+    type: "deny";
+}
+/**
+ * Create a new AllowList based on some <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java regular
+ * expression patterns</a>. Typically used to filter HTTP resources.
+ *
+ * @param patterns some Java regex patterns
+ * @return a new AllowList
+ */
+export declare const AllowList: (...patterns: string[]) => AllowListFilter;
+/**
+ * Create a new DenyList based on some <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java regular
+ * expression patterns</a> Typically used to filter HTTP resources.
+ *
+ * @param patterns some Java regex patterns
+ * @return a new DenyList
+ */
+export declare const DenyList: (...patterns: string[]) => DenyListFilter;

package/target/filters.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DenyList = exports.AllowList = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const wrapAllowListFilter = (_underlying) => ({
+    _underlying,
+    type: "allow"
+});
+const wrapDenyListFilter = (_underlying) => ({
+    _underlying,
+    type: "deny"
+});
+/**
+ * Create a new AllowList based on some <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java regular
+ * expression patterns</a>. Typically used to filter HTTP resources.
+ *
+ * @param patterns some Java regex patterns
+ * @return a new AllowList
+ */
+const AllowList = (...patterns) => wrapAllowListFilter(jvm_types_1.CoreDsl.AllowList(patterns));
+exports.AllowList = AllowList;
+/**
+ * Create a new DenyList based on some <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java regular
+ * expression patterns</a> Typically used to filter HTTP resources.
+ *
+ * @param patterns some Java regex patterns
+ * @return a new DenyList
+ */
+const DenyList = (...patterns) => wrapDenyListFilter(jvm_types_1.CoreDsl.DenyList(patterns));
+exports.DenyList = DenyList;

package/target/gatlingJvm/app.d.ts

@@ -0,0 +1,4 @@
+import JvmPopulationBuilder = io.gatling.javaapi.core.PopulationBuilder;
+import JvmSetUp = io.gatling.javaapi.core.Simulation$SetUp;
+export type SetUpFunction = (populationBuilders: JvmPopulationBuilder[]) => JvmSetUp;
+export type Simulation = (setUp: SetUpFunction) => void;

package/target/gatlingJvm/app.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/target/gatlingJvm/callbacks.d.ts

@@ -0,0 +1,9 @@
+import JvmSession = io.gatling.javaapi.core.Session;
+type JvmExpression<T> = (arg: JvmSession) => T;
+type Callback<T, R> = (arg: T) => R;
+type BiCallback<T, U, R> = (arg0: T, arg1: U) => R;
+export declare const wrapByteArray: (v: number[]) => number[];
+export declare const wrapByteArrayCallback: (f: JvmExpression<number[]>) => JvmExpression<number[]>;
+export declare const wrapCallback: <T, R>(f: Callback<T, R>) => Callback<T, R>;
+export declare const wrapBiCallback: <T, U, R>(f: BiCallback<T, U, R>) => BiCallback<T, U, R>;
+export {};

package/target/gatlingJvm/callbacks.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapBiCallback = exports.wrapCallback = exports.wrapByteArrayCallback = exports.wrapByteArray = void 0;
+const CallbackWrapper = Java.type("io.gatling.js.callbacks.CallbackWrapper");
+// Byte arrays
+const wrapByteArray = (v) => CallbackWrapper.wrapByteArray(v);
+exports.wrapByteArray = wrapByteArray;
+const wrapByteArrayCallback = (f) => CallbackWrapper.wrapByteArrayFunction(f);
+exports.wrapByteArrayCallback = wrapByteArrayCallback;
+// Generic functions
+const wrapCallback = (f) => CallbackWrapper.wrapFunction(f);
+exports.wrapCallback = wrapCallback;
+const wrapBiCallback = (f) => CallbackWrapper.wrapBiFunction(f);
+exports.wrapBiCallback = wrapBiCallback;

package/target/gatlingJvm/collections.d.ts

@@ -0,0 +1 @@
+export declare const asJava: (value: unknown) => unknown;

package/target/gatlingJvm/collections.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asJava = void 0;
+const ArrayList = Java.type("java.util.ArrayList");
+const HashMap = Java.type("java.util.HashMap");
+const asJavaList = (elements) => {
+    const javaList = new ArrayList();
+    for (let i = 0; i < elements.length; i++) {
+        javaList.add((0, exports.asJava)(elements[i]));
+    }
+    return javaList;
+};
+const asJavaMap = (records) => {
+    const javaMap = new HashMap();
+    Object.entries(records).forEach(([key, value]) => {
+        javaMap.put(key, (0, exports.asJava)(value));
+    });
+    return javaMap;
+};
+const asJava = (value) => {
+    if (Array.isArray(value)) {
+        return asJavaList(value);
+    }
+    else if (typeof value === "object" && value !== null) {
+        return asJavaMap(value);
+    }
+    else {
+        return value;
+    }
+};
+exports.asJava = asJava;

package/target/index.d.ts

@@ -0,0 +1,115 @@
+import * as jvm from "./gatlingJvm/app";
+import { PauseType } from "./structure/pauses";
+import { Duration } from "./utils/duration";
+import { SessionTo } from "./session";
+import { Assertion } from "./assertions";
+import { PopulationBuilder } from "./population";
+import { ProtocolBuilder } from "./protocol";
+import { ThrottleStep } from "./throttling";
+export * from "./gatlingJvm/callbacks";
+export * from "./utils/duration";
+export * from "./assertions";
+export * from "./body";
+export * from "./checks";
+export * from "./closedInjection";
+export * from "./common";
+export * from "./feeders";
+export * from "./filters";
+export * from "./openInjection";
+export * from "./population";
+export * from "./protocol";
+export * from "./scenario";
+export * from "./session";
+export * from "./structure";
+export * from "./throttling";
+export interface SetUp {
+    /**
+     * Define the desired protocol configurations
+     *
+     * @param protocols - the protocols
+     * @returns the same mutated setup instance
+     */
+    protocols(...protocols: ProtocolBuilder[]): SetUp;
+    /**
+     * Define the desired assertions
+     *
+     * @param assertions - the assertions
+     * @returns the same mutated setup instance
+     */
+    assertions(...assertions: Assertion[]): SetUp;
+    /**
+     * Define the run max duration
+     *
+     * @param duration - the max duration
+     * @returns the same mutated setup instance
+     */
+    maxDuration(duration: Duration): SetUp;
+    /**
+     * Define the throttling, meaning a maximum throughput over time
+     *
+     * @param throttleSteps - the throttling DSL steps
+     * @returns the same mutated setup instance
+     */
+    throttle(...throttleSteps: ThrottleStep[]): SetUp;
+    /**
+     * Disable the pauses
+     *
+     *  @returns the same mutated setup instance
+     */
+    disablePauses(): SetUp;
+    /**
+     * Apply constant pauses
+     *
+     * @returns the same mutated setup instance
+     */
+    constantPauses(): SetUp;
+    /**
+     * Apply exponential pauses
+     *
+     * @returns the same mutated setup instance
+     */
+    exponentialPauses(): SetUp;
+    /**
+     * Apply custom pauses
+     *
+     * @returns the same mutated setup instance
+     */
+    customPauses(f: SessionTo<number>): SetUp;
+    /**
+     * Apply uniform pauses with half-width defined as a percentage
+     *
+     * @returns the same mutated setup instance
+     */
+    uniformPauses(plusOrMinus: number): SetUp;
+    /**
+     * Apply uniform pauses with half-width defined as an absolute value
+     *
+     * @returns the same mutated setup instance
+     */
+    uniformPauses(plusOrMinus: Duration): SetUp;
+    /**
+     * Apply normal distribution pauses with the standard deviation defined as an absolute value
+     *
+     * @param stdDevDuration - the standard deviation of the distribution.
+     * @returns the same mutated setup instance
+     */
+    normalPausesWithStdDevDuration(stdDevDuration: Duration): SetUp;
+    /**
+     * Apply normal distribution pauses with the standard deviation defined as a percentage of the
+     * value defined in the scenario
+     *
+     * @param stdDevPercent - the standard deviation of the distribution in percents.
+     * @returns the same mutated setup instance
+     */
+    normalPausesWithPercentageDuration(stdDevPercent: number): SetUp;
+    /**
+     * Apply uniform pauses with a given strategy
+     *
+     * @param pauseType - the pause type
+     * @returns the same mutated setup instance
+     */
+    pauses(pauseType: PauseType): SetUp;
+}
+export type SetUpFunction = (...populationBuilders: PopulationBuilder[]) => SetUp;
+export type Simulation = (setUp: SetUpFunction) => void;
+export declare const runSimulation: (simulation: Simulation) => jvm.Simulation;

package/target/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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;
+const callbacks_1 = require("./gatlingJvm/callbacks");
+const pauses_1 = require("./structure/pauses");
+const duration_1 = require("./utils/duration");
+const session_1 = require("./session");
+// FIXME no export *
+__exportStar(require("./gatlingJvm/callbacks"), exports);
+__exportStar(require("./utils/duration"), exports);
+__exportStar(require("./assertions"), exports);
+__exportStar(require("./body"), exports);
+__exportStar(require("./checks"), exports);
+__exportStar(require("./closedInjection"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./feeders"), exports);
+__exportStar(require("./filters"), exports);
+__exportStar(require("./openInjection"), exports);
+__exportStar(require("./population"), exports);
+__exportStar(require("./protocol"), exports);
+__exportStar(require("./scenario"), exports);
+__exportStar(require("./session"), exports);
+__exportStar(require("./structure"), exports);
+__exportStar(require("./throttling"), exports);
+const wrapSetUp = (jvmSetUp) => ({
+    protocols: (...protocols) => wrapSetUp(jvmSetUp.protocols(protocols.map((p) => p._underlying))),
+    assertions: (...assertions) => wrapSetUp(jvmSetUp.assertions(assertions.map((p) => p._underlying))),
+    maxDuration: (duration) => wrapSetUp(jvmSetUp.maxDuration((0, duration_1.toJvmDuration)(duration))),
+    throttle: (...throttleSteps) => wrapSetUp(jvmSetUp.throttle(throttleSteps.map((t) => t._underlying))),
+    disablePauses: () => wrapSetUp(jvmSetUp.disablePauses()),
+    constantPauses: () => wrapSetUp(jvmSetUp.constantPauses()),
+    exponentialPauses: () => wrapSetUp(jvmSetUp.exponentialPauses()),
+    customPauses: (f) => wrapSetUp(jvmSetUp.customPauses((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(f)))),
+    uniformPauses: (plusOrMinus) => wrapSetUp(jvmSetUp.uniformPauses((0, duration_1.toJvmDuration)(plusOrMinus))),
+    normalPausesWithStdDevDuration: (stdDevDuration) => wrapSetUp(jvmSetUp.normalPausesWithStdDevDuration((0, duration_1.toJvmDuration)(stdDevDuration))),
+    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))));
+};
+exports.runSimulation = runSimulation;

package/target/openInjection.d.ts

@@ -0,0 +1,51 @@
+import "@gatling.io/jvm-types";
+import { Wrapper } from "./common";
+import { Duration } from "./utils/duration";
+import JvmOpenInjectionStep = io.gatling.javaapi.core.OpenInjectionStep;
+import JvmOpenInjectionStepRamp = io.gatling.javaapi.core.OpenInjectionStep$Ramp;
+import JvmOpenInjectionStepStressPeak = io.gatling.javaapi.core.OpenInjectionStep$StressPeak;
+import JvmOpenInjectionStepConstantRate = io.gatling.javaapi.core.OpenInjectionStep$ConstantRate;
+import JvmOpenInjectionStepRampRate = io.gatling.javaapi.core.OpenInjectionStep$RampRate;
+import JvmOpenInjectionStepRampRateDuring = io.gatling.javaapi.core.RampRate$During;
+import JvmOpenInjectionStepStairs = io.gatling.javaapi.core.OpenInjectionStep$Stairs;
+import JvmOpenInjectionStepStairsTimes = io.gatling.javaapi.core.Stairs$Times;
+export interface OpenInjectionStep extends Wrapper<JvmOpenInjectionStep> {
+}
+export interface ConstantRateOpenInjectionStep extends OpenInjectionStep {
+    randomized(): OpenInjectionStep;
+}
+export interface OpenInjectionStepRamp extends Wrapper<JvmOpenInjectionStepRamp> {
+    during(duration: Duration): OpenInjectionStep;
+}
+export interface OpenInjectionStepStressPeak extends Wrapper<JvmOpenInjectionStepStressPeak> {
+    during(duration: Duration): OpenInjectionStep;
+}
+export interface OpenInjectionStepConstantRate extends Wrapper<JvmOpenInjectionStepConstantRate> {
+    during(duration: Duration): ConstantRateOpenInjectionStep;
+}
+export interface OpenInjectionStepRampRate extends Wrapper<JvmOpenInjectionStepRampRate> {
+    to(to: number): OpenInjectionStepRampRateDuring;
+}
+export interface OpenInjectionStepRampRateDuring extends Wrapper<JvmOpenInjectionStepRampRateDuring> {
+    during(duration: Duration): RampRateOpenInjectionStep;
+}
+export interface RampRateOpenInjectionStep extends OpenInjectionStep {
+    randomized(): OpenInjectionStep;
+}
+export interface OpenInjectionStepStairs extends Wrapper<JvmOpenInjectionStepStairs> {
+    times(levels: number): OpenInjectionStepStairsTimes;
+}
+export interface OpenInjectionStepStairsTimes extends Wrapper<JvmOpenInjectionStepStairsTimes> {
+    eachLevelLasting(duration: Duration): OpenInjectionStepStairsComposite;
+}
+export interface OpenInjectionStepStairsComposite extends OpenInjectionStep {
+    startingFrom(startingRate: number): OpenInjectionStepStairsComposite;
+    separatedByRampsLasting(duration: Duration): OpenInjectionStepStairsComposite;
+}
+export declare const rampUsers: (users: number) => OpenInjectionStepRamp;
+export declare const stressPeakUsers: (users: number) => OpenInjectionStepStressPeak;
+export declare const atOnceUsers: (users: number) => OpenInjectionStep;
+export declare const constantUsersPerSec: (rate: number) => OpenInjectionStepConstantRate;
+export declare const rampUsersPerSec: (rate: number) => OpenInjectionStepRampRate;
+export declare const nothingFor: (duration: Duration) => OpenInjectionStep;
+export declare const incrementUsersPerSec: (rateIncrement: number) => OpenInjectionStepStairs;