@gatling.io/core 0.1.0

package/target/checks/jsonOfTypeMultipleFind.d.ts

@@ -0,0 +1,56 @@
+import { CheckBuilderMultipleFind } from "./multipleFind";
+import JvmCheckBuilderJsonOfTypeMultipleFind = io.gatling.javaapi.core.CheckBuilder$JsonOfTypeMultipleFind;
+/**
+ * A special {@link CheckBuilderFind<string>} that works on JSON
+ */
+export interface CheckBuilderJsonOfTypeMultipleFind extends CheckBuilderMultipleFind<string> {
+    /**
+     * Define that the extracted value is a String
+     *
+     * @returns a new MultipleFind
+     */
+    ofString(): CheckBuilderMultipleFind<string>;
+    /**
+     * Define that the extracted value is a Boolean
+     *
+     * @returns a new MultipleFind
+     */
+    ofBoolean(): CheckBuilderMultipleFind<boolean>;
+    /**
+     * Define that the extracted value is an Integer
+     *
+     * @returns a new MultipleFind
+     */
+    ofInt(): CheckBuilderMultipleFind<number>;
+    /**
+     * Define that the extracted value is a Long
+     *
+     * @returns a new MultipleFind
+     */
+    ofLong(): CheckBuilderMultipleFind<number>;
+    /**
+     * Define that the extracted value is a Double
+     *
+     * @returns a new MultipleFind
+     */
+    ofDouble(): CheckBuilderMultipleFind<number>;
+    /**
+     * Define that the extracted value is a List (a JSON array)
+     *
+     * @returns a new MultipleFind
+     */
+    ofList(): CheckBuilderMultipleFind<unknown[]>;
+    /**
+     * Define that the extracted value is a Map (a JSON object)
+     *
+     * @returns a new MultipleFind
+     */
+    ofMap(): CheckBuilderMultipleFind<Record<string, unknown>>;
+    /**
+     * Define that the extracted value is an untyped object
+     *
+     * @returns a new MultipleFind
+     */
+    ofObject(): CheckBuilderMultipleFind<unknown>;
+}
+export declare const wrapCheckBuilderJsonOfTypeMultipleFind: (_underlying: JvmCheckBuilderJsonOfTypeMultipleFind) => CheckBuilderJsonOfTypeMultipleFind;

package/target/checks/jsonOfTypeMultipleFind.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCheckBuilderJsonOfTypeMultipleFind = void 0;
+const multipleFind_1 = require("./multipleFind");
+const wrapCheckBuilderJsonOfTypeMultipleFind = (_underlying) => ({
+    ...(0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying),
+    ofString: () => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.ofString()),
+    ofBoolean: () => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.ofBoolean()),
+    ofInt: () => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.ofInt()),
+    ofLong: () => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.ofLong()),
+    ofDouble: () => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.ofDouble()),
+    ofList: () => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.ofList()),
+    ofMap: () => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.ofMap()),
+    ofObject: () => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.ofObject())
+});
+exports.wrapCheckBuilderJsonOfTypeMultipleFind = wrapCheckBuilderJsonOfTypeMultipleFind;

package/target/checks/multipleFind.d.ts

@@ -0,0 +1,57 @@
+import { CheckBuilderValidate } from "./validate";
+import JvmCheckBuilderMultipleFind = io.gatling.javaapi.core.CheckBuilder$MultipleFind;
+/**
+ * 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
+ */
+export interface CheckBuilderMultipleFind<X> extends CheckBuilderValidate<X> {
+    /**
+     * Target a single/first value
+     *
+     * @returns the next Check DSL step
+     */
+    find(): CheckBuilderValidate<X>;
+    /**
+     * Target the occurrence-th occurrence in the extracted values
+     *
+     * @param occurrence - the rank of the target value in the extracted values list
+     * @returns the next Check DSL step
+     */
+    find(occurrence: number): CheckBuilderValidate<X>;
+    /**
+     * Target all the occurrences of the extracted values
+     *
+     * @returns the next Check DSL step
+     */
+    findAll(): CheckBuilderValidate<X[]>;
+    /**
+     * Target a random occurrence in the extracted values
+     *
+     * @returns the next Check DSL step
+     */
+    findRandom(): CheckBuilderValidate<X>;
+    /**
+     * Target multiple random occurrences in the extracted values
+     *
+     * @param num - the number of occurrences to collect
+     * @returns the next Check DSL step
+     */
+    findRandom(num: number): CheckBuilderValidate<X[]>;
+    /**
+     * Target multiple random occurrences in the extracted values
+     *
+     * @param num - the number of occurrences to collect
+     * @param failIfLess - fail if num is greater than the number of extracted values
+     * @returns the next Check DSL step
+     */
+    findRandom(num: number, failIfLess: boolean): CheckBuilderValidate<X[]>;
+    /**
+     * Target the count of extracted values
+     *
+     * @returns the next Check DSL step
+     */
+    count(): CheckBuilderValidate<number>;
+}
+export declare const wrapCheckBuilderMultipleFind: <X>(_underlying: JvmCheckBuilderMultipleFind<X>) => CheckBuilderMultipleFind<X>;

package/target/checks/multipleFind.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCheckBuilderMultipleFind = void 0;
+const validate_1 = require("./validate");
+const wrapCheckBuilderMultipleFind = (_underlying) => ({
+    ...(0, validate_1.wrapCheckBuilderValidate)(_underlying),
+    find: (occurrence) => (0, validate_1.wrapCheckBuilderValidate)(occurrence !== undefined ? _underlying.find(occurrence) : _underlying.find()),
+    findAll: () => (0, validate_1.wrapCheckBuilderValidate)(_underlying.findAll()),
+    findRandom: (num, failIfLess) => {
+        if (num !== undefined) {
+            if (failIfLess !== undefined) {
+                return (0, validate_1.wrapCheckBuilderValidate)(_underlying.findRandom(num, failIfLess));
+            }
+            else {
+                return (0, validate_1.wrapCheckBuilderValidate)(_underlying.findRandom(num));
+            }
+        }
+        else {
+            return (0, validate_1.wrapCheckBuilderValidate)(_underlying.findRandom());
+        }
+    },
+    count: function () {
+        throw new Error("Function not implemented.");
+    }
+});
+exports.wrapCheckBuilderMultipleFind = wrapCheckBuilderMultipleFind;

package/target/checks/validate.d.ts

@@ -0,0 +1,242 @@
+import { Session, SessionTo } from "../session";
+import { CheckBuilderFinal } from "./final";
+import JvmCheckBuilderValidate = io.gatling.javaapi.core.CheckBuilder$Validate;
+/**
+ * Step 2 of the Check DSL where we define how to validate the extracted value. Immutable, so all
+ * methods return a new occurrence and leave the original unmodified.
+ *
+ * @typeParam X - the type of the extracted value
+ */
+export interface CheckBuilderValidate<X> extends CheckBuilderFinal {
+    /**
+     * Transform the extracted value
+     *
+     * @param f - the transformation function
+     * @typeParam X2 - the transformed value
+     * @returns a new CheckBuilderValidate
+     */
+    transform<X2>(f: (x: X) => X2): CheckBuilderValidate<X2>;
+    /**
+     * Transform the extracted value, whith access to the current Session
+     *
+     * @param f - the transformation function
+     * @typeParam X2 - the transformed value
+     * @returns a new CheckBuilderValidate
+     */
+    transformWithSession<X2>(f: (x: X, session: Session) => X2): CheckBuilderValidate<X2>;
+    /**
+     * Provide a default value if the check wasn't able to extract anything
+     *
+     * @param value - the default value
+     * @returns a new Validate
+     */
+    withDefault(value: X): CheckBuilderValidate<X>;
+    /**
+     * Provide a default Gatling Expression Language value if the check wasn't able to extract
+     * anything
+     *
+     * @param value - the default value as a Gatling Expression Language String
+     * @returns a new Validate
+     */
+    withDefaultEL(value: string): CheckBuilderValidate<X>;
+    /**
+     * Provide a default value if the check wasn't able to extract anything
+     *
+     * @param value - the default value as a function
+     * @returns a new Validate
+     */
+    withDefault(value: SessionTo<X>): CheckBuilderValidate<X>;
+    /**
+     * Provide a custom validation strategy
+     *
+     * @param name - the name of the validation, in case of a failure
+     * @param f - the custom validation function, must throw to trigger a failure
+     * @returns a new CheckBuilderFinal
+     */
+    validate(name: string, f: (x: X, session: Session) => X): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is equal to an expected value
+     *
+     * @param expected - the expected value
+     * @returns a new CheckBuilderFinal
+     */
+    is(expected: X): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is equal to an expected value, passed as a Gatling Expression
+     * Language String
+     *
+     * @param expected - the expected value as a Gatling Expression Language String
+     * @returns a new CheckBuilderFinal
+     */
+    isEL(expected: string): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is equal to an expected value, passed as a function
+     *
+     * @param expected - the expected value as a function
+     * @returns a new CheckBuilderFinal
+     */
+    is(expected: SessionTo<X>): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is null
+     *
+     * @returns a new CheckBuilderFinal
+     */
+    isNull(): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is not an expected value
+     *
+     * @param expected - the unexpected value
+     * @returns a new CheckBuilderFinal
+     */
+    not(expected: X): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is not an expected value, passed as a Gatling Expression
+     * Language String
+     *
+     * @param expected - the unexpected value as a Gatling Expression Language String
+     * @returns a new CheckBuilderFinal
+     */
+    notEL(expected: string): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is not an expected value, passed as a function
+     *
+     * @param expected - the unexpected value as a function
+     * @returns a new CheckBuilderFinal
+     */
+    not(expected: SessionTo<X>): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is not null
+     *
+     * @returns a new CheckBuilderFinal
+     */
+    notNull(): CheckBuilderFinal;
+    /**
+     * Validate the extracted value belongs to an expected set
+     *
+     * @param expected - the set of possible values
+     * @returns a new Final
+     */
+    in(...expected: X[]): CheckBuilderFinal;
+    /**
+     * Validate the extracted value belongs to an expected set, passed as a Gatling Expression
+     * Language String
+     *
+     * @param expected - the set of possible values, as a Gatling Expression Language String
+     * @returns a new CheckBuilderFinal
+     */
+    inEL(expected: string): CheckBuilderFinal;
+    /**
+     * Validate the extracted value belongs to an expected set, passed as a function
+     *
+     * @param expected - the set of possible values, as a function
+     * @returns a new CheckBuilderFinal
+     */
+    in(expected: SessionTo<X[]>): CheckBuilderFinal;
+    /**
+     * Validate the check was able to extract any value
+     *
+     * @returns a new CheckBuilderFinal
+     */
+    exists(): CheckBuilderFinal;
+    /**
+     * Validate the check was not able to extract any value
+     *
+     * @returns a new CheckBuilderFinal
+     */
+    notExists(): CheckBuilderFinal;
+    /**
+     * Make the check is successful whenever it was able to extract something or not
+     *
+     * @returns a new CheckBuilderFinal
+     */
+    optional(): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is less than a given value
+     *
+     * @param value - the value
+     * @returns a new CheckBuilderFinal
+     */
+    lt(value: X): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is less than a given value, passed as a Gatling Expression
+     * Language String
+     *
+     * @param value - the value, as a Gatling Expression Language String
+     * @returns a new CheckBuilderFinal
+     */
+    ltEL(value: string): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is less than a given value, passed as a function
+     *
+     * @param value - the value, as a function
+     * @returns a new CheckBuilderFinal
+     */
+    lt(value: SessionTo<X>): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is less than or equal to a given value
+     *
+     * @param value - the value
+     * @returns a new CheckBuilderFinal
+     */
+    lte(value: X): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is less than or equal to a given value, passed as a Gatling
+     * Expression Language String
+     *
+     * @param value - the value, as a Gatling Expression Language String
+     * @returns a new CheckBuilderFinal
+     */
+    lteEL(value: string): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is less than or equal to a given value, passed as a function
+     *
+     * @param value - the value, as a function
+     * @returns a new CheckBuilderFinal
+     */
+    lte(value: SessionTo<X>): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is greater than a given value
+     *
+     * @param value - the value
+     * @returns a new CheckBuilderFinal
+     */
+    gt(value: X): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is greater than a given value, passed as a Gatling Expression
+     * Language String
+     *
+     * @param value - the value, as a Gatling Expression Language String
+     * @returns a new CheckBuilderFinal
+     */
+    gtEL(value: string): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is greater than a given value, passed as a function
+     *
+     * @param value - the value, as a function
+     * @returns a new CheckBuilderFinal
+     */
+    gt(value: SessionTo<X>): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is greater than or equal to a given value
+     *
+     * @param value - the value
+     * @returns a new CheckBuilderFinal
+     */
+    gte(value: X): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is greater than or equal to a given value, passed as a Gatling
+     * Expression Language String
+     *
+     * @param value - the value, as a Gatling Expression Language String
+     * @returns a new CheckBuilderFinal
+     */
+    gteEL(value: string): CheckBuilderFinal;
+    /**
+     * Validate the extracted value is greater than or equal to a given value, passed as a function
+     *
+     * @param value - the value, as a function
+     * @returns a new CheckBuilderFinal
+     */
+    gte(value: SessionTo<X>): CheckBuilderFinal;
+}
+export declare const wrapCheckBuilderValidate: <X>(_underlying: JvmCheckBuilderValidate<X>) => CheckBuilderValidate<X>;

package/target/checks/validate.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCheckBuilderValidate = void 0;
+const callbacks_1 = require("../gatlingJvm/callbacks");
+const session_1 = require("../session");
+const final_1 = require("./final");
+const wrapCheckBuilderValidate = (_underlying) => ({
+    ...(0, final_1.wrapCheckBuilderFinal)(_underlying),
+    transform: (f) => (0, exports.wrapCheckBuilderValidate)(_underlying.transform((0, callbacks_1.wrapCallback)(f))),
+    transformWithSession: (f) => (0, exports.wrapCheckBuilderValidate)(_underlying.transformWithSession((0, callbacks_1.wrapBiCallback)((0, session_1.underlyingXWithSessionTo)(f)))),
+    withDefault: (value) => (0, exports.wrapCheckBuilderValidate)(typeof value === "function"
+        ? _underlying.withDefault((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(value)))
+        : _underlying.withDefault(value)),
+    withDefaultEL: (value) => (0, exports.wrapCheckBuilderValidate)(_underlying.withDefaultEl(value)),
+    validate: (name, f) => (0, final_1.wrapCheckBuilderFinal)(_underlying.validate(name, (0, callbacks_1.wrapBiCallback)((0, session_1.underlyingXWithSessionTo)(f)))),
+    is: (expected) => (0, final_1.wrapCheckBuilderFinal)(typeof expected === "function"
+        ? _underlying.is((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(expected)))
+        : _underlying.is(expected)),
+    isEL: (expected) => (0, final_1.wrapCheckBuilderFinal)(_underlying.isEL(expected)),
+    isNull: () => (0, final_1.wrapCheckBuilderFinal)(_underlying.isNull()),
+    not: (expected) => (0, final_1.wrapCheckBuilderFinal)(typeof expected === "function"
+        ? _underlying.not((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(expected)))
+        : _underlying.not(expected)),
+    notEL: (expected) => (0, final_1.wrapCheckBuilderFinal)(_underlying.notEL(expected)),
+    notNull: () => (0, final_1.wrapCheckBuilderFinal)(_underlying.notNull()),
+    in: (expected, ...rest) => (0, final_1.wrapCheckBuilderFinal)(typeof expected === "function"
+        ? _underlying.in((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(expected)))
+        : _underlying.in([expected, ...rest])),
+    inEL: (expected) => (0, final_1.wrapCheckBuilderFinal)(_underlying.inEL(expected)),
+    exists: () => (0, final_1.wrapCheckBuilderFinal)(_underlying.exists()),
+    notExists: () => (0, final_1.wrapCheckBuilderFinal)(_underlying.notExists()),
+    optional: () => (0, final_1.wrapCheckBuilderFinal)(_underlying.optional()),
+    lt: (value) => (0, final_1.wrapCheckBuilderFinal)(typeof value === "function"
+        ? _underlying.lt((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(value)))
+        : _underlying.lt(value)),
+    ltEL: (value) => (0, final_1.wrapCheckBuilderFinal)(_underlying.ltEL(value)),
+    lte: (value) => (0, final_1.wrapCheckBuilderFinal)(typeof value === "function"
+        ? _underlying.lte((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(value)))
+        : _underlying.lte(value)),
+    lteEL: (value) => (0, final_1.wrapCheckBuilderFinal)(_underlying.lteEL(value)),
+    gt: (value) => (0, final_1.wrapCheckBuilderFinal)(typeof value === "function"
+        ? _underlying.gt((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(value)))
+        : _underlying.gt(value)),
+    gtEL: (value) => (0, final_1.wrapCheckBuilderFinal)(_underlying.gtEL(value)),
+    gte: (value) => (0, final_1.wrapCheckBuilderFinal)(typeof value === "function"
+        ? _underlying.gte((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(value)))
+        : _underlying.gte(value)),
+    gteEL: (value) => (0, final_1.wrapCheckBuilderFinal)(_underlying.gteEL(value))
+});
+exports.wrapCheckBuilderValidate = wrapCheckBuilderValidate;

package/target/closedInjection.d.ts

@@ -0,0 +1,33 @@
+import "@gatling.io/jvm-types";
+import { Wrapper } from "./common";
+import { Duration } from "./utils/duration";
+import JvmClosedInjectionStep = io.gatling.javaapi.core.ClosedInjectionStep;
+import JvmClosedInjectionStepConstant = io.gatling.javaapi.core.ClosedInjectionStep$Constant;
+import JvmClosedInjectionStepRamp = io.gatling.javaapi.core.ClosedInjectionStep$Ramp;
+import JvmClosedInjectionStepRampTo = io.gatling.javaapi.core.ClosedInjectionStep$RampTo;
+import JvmClosedInjectionStepStairs = io.gatling.javaapi.core.ClosedInjectionStep$Stairs;
+import JvmClosedInjectionStepStairsWithTime = io.gatling.javaapi.core.ClosedInjectionStep$StairsWithTime;
+export interface ClosedInjectionStep extends Wrapper<JvmClosedInjectionStep> {
+}
+export interface ClosedInjectionStepConstant extends Wrapper<JvmClosedInjectionStepConstant> {
+    during(duration: Duration): ClosedInjectionStep;
+}
+export interface ClosedInjectionStepRamp extends Wrapper<JvmClosedInjectionStepRamp> {
+    to(t: number): ClosedInjectionStepRampTo;
+}
+export interface ClosedInjectionStepRampTo extends Wrapper<JvmClosedInjectionStepRampTo> {
+    during(duration: Duration): ClosedInjectionStep;
+}
+export interface ClosedInjectionStepStairs extends Wrapper<JvmClosedInjectionStepStairs> {
+    times(levels: number): ClosedInjectionStepStairsWithTime;
+}
+export interface ClosedInjectionStepStairsWithTime extends Wrapper<JvmClosedInjectionStepStairsWithTime> {
+    eachLevelLasting(duration: Duration): ClosedInjectionStepComposite;
+}
+export interface ClosedInjectionStepComposite extends ClosedInjectionStep {
+    startingFrom(startingUsers: number): ClosedInjectionStepComposite;
+    separatedByRampsLasting(duration: Duration): ClosedInjectionStepComposite;
+}
+export declare const constantConcurrentUsers: (users: number) => ClosedInjectionStepConstant;
+export declare const rampConcurrentUsers: (from: number) => ClosedInjectionStepRamp;
+export declare const incrementConcurrentUsers: (usersIncrement: number) => ClosedInjectionStepStairs;

package/target/closedInjection.js

@@ -0,0 +1,38 @@
+"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 });
+const wrapClosedInjectionStepConstant = (_underlying) => ({
+    _underlying,
+    during: (duration) => wrapClosedInjectionStep(_underlying.during((0, duration_1.toJvmDuration)(duration)))
+});
+const wrapClosedInjectionStepRamp = (_underlying) => ({
+    _underlying,
+    to: (t) => wrapClosedInjectionStepRampTo(_underlying.to(t))
+});
+const wrapClosedInjectionStepRampTo = (_underlying) => ({
+    _underlying,
+    during: (duration) => wrapClosedInjectionStep(_underlying.during((0, duration_1.toJvmDuration)(duration)))
+});
+const wrapClosedInjectionStepStairs = (_underlying) => ({
+    _underlying,
+    times: (levels) => wrapClosedInjectionStepStairsWithTime(_underlying.times(levels))
+});
+const wrapClosedInjectionStepStairsWithTime = (_underlying) => ({
+    _underlying,
+    eachLevelLasting: (duration) => wrapClosedInjectionStepComposite(_underlying.eachLevelLasting((0, duration_1.toJvmDuration)(duration)))
+});
+const wrapClosedInjectionStepComposite = (_underlying) => ({
+    _underlying,
+    startingFrom: (startingUsers) => wrapClosedInjectionStepComposite(_underlying.startingFrom(startingUsers)),
+    separatedByRampsLasting: (duration) => wrapClosedInjectionStepComposite(_underlying.separatedByRampsLasting((0, duration_1.toJvmDuration)(duration)))
+});
+const constantConcurrentUsers = (users) => wrapClosedInjectionStepConstant(jvm_types_1.CoreDsl.constantConcurrentUsers(users));
+exports.constantConcurrentUsers = constantConcurrentUsers;
+const rampConcurrentUsers = (from) => wrapClosedInjectionStepRamp(jvm_types_1.CoreDsl.rampConcurrentUsers(from));
+exports.rampConcurrentUsers = rampConcurrentUsers;
+const incrementConcurrentUsers = (usersIncrement) => wrapClosedInjectionStepStairs(jvm_types_1.CoreDsl.incrementConcurrentUsers(usersIncrement));
+exports.incrementConcurrentUsers = incrementConcurrentUsers;

package/target/common.d.ts

@@ -0,0 +1,3 @@
+export interface Wrapper<T> {
+    _underlying: T;
+}

package/target/common.js

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