@gatling.io/core 0.1.0

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@gatling.io/core",
+  "version": "0.1.0",
+  "main": "target/index.js",
+  "types": "target/index.d.ts",
+  "dependencies": {
+    "@gatling.io/jvm-types": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "29.5.12",
+    "jest": "29.7.0",
+    "prettier": "3.2.5",
+    "rimraf": "5.0.5",
+    "ts-jest": "29.1.2",
+    "ts-node": "10.9.2",
+    "typescript": "5.4.5"
+  },
+  "scripts": {
+    "clean": "rimraf target",
+    "format": "prettier --write '**/*.ts'",
+    "test": "jest",
+    "build": "tsc -p ."
+  }
+}

package/target/assertions.d.ts

@@ -0,0 +1,214 @@
+import JvmAssertion = io.gatling.javaapi.core.Assertion;
+import { Wrapper } from "./common";
+/**
+ * Bootstrap a new global assertion that targets stats aggregated on all requests
+ *
+ * @returns the next DSL step
+ */
+export declare const global: () => AssertionWithPath;
+/**
+ * Bootstrap a new forAll assertion that targets stats on each individual request type
+ *
+ * @returns the next DSL step
+ */
+export declare const forAll: () => AssertionWithPath;
+/**
+ * Bootstrap a new details assertion that targets stats on a specific request type
+ *
+ * @returns the next DSL step
+ */
+export declare const details: (...parts: string[]) => AssertionWithPath;
+/**
+ * Step 2 of the Assertion DSL (path defined). Immutable, so all methods return a new occurrence
+ * and leave the original unmodified.
+ */
+export interface AssertionWithPath {
+    /**
+     * Specify the Assertion targets the response time metric
+     *
+     * @returns the next Assertion DSL step
+     */
+    responseTime(): AssertionWithPathAndTimeMetric;
+    /**
+     * Specify the Assertion targets the all requests count metric
+     *
+     * @returns the next Assertion DSL step
+     */
+    allRequests(): AssertionWithPathAndCountMetric;
+    /**
+     * Specify the Assertion targets the failed requests count metric
+     *
+     * @returns the next Assertion DSL step
+     */
+    failedRequests(): AssertionWithPathAndCountMetric;
+    /**
+     * Specify the Assertion targets the successful requests count metric
+     *
+     * @returns the next Assertion DSL step
+     */
+    successfulRequests(): AssertionWithPathAndCountMetric;
+    /**
+     * Specify the Assertion targets the requests/s metric
+     *
+     * @returns the next Assertion DSL step
+     */
+    requestsPerSec(): AssertionWithPathAndTarget;
+}
+/**
+ * Step 3 of the Assertion DSL (path and time metric defined). Immutable, so all methods return a
+ * new occurrence and leave the original unmodified.
+ */
+export interface AssertionWithPathAndTimeMetric {
+    /**
+     * Specify the Assertion targets the min value metric
+     *
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    min(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the max value metric
+     *
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    max(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the mean value metric
+     *
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    mean(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the standard deviation metric
+     *
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    stdDev(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the percentile1 metric, as defined in gatling.conf
+     *
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    percentile1(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the percentile2 metric, as defined in gatling.conf
+     *
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    percentile2(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the percentile3 metric, as defined in gatling.conf
+     *
+     * @returns the next Assertion DSL step
+     */
+    percentile3(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the percentile4 metric, as defined in gatling.conf
+     *
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    percentile4(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the given percentile metric
+     *
+     * @param value - the value of targeted percentile, between 0 and 100)
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    percentile(value: number): AssertionWithPathAndTarget;
+}
+/**
+ * Step 3 of the Assertion DSL (path and count metric defined). Immutable, so all methods return a
+ * new occurrence and leave the original unmodified.
+ */
+export interface AssertionWithPathAndCountMetric {
+    /**
+     * Specify the Assertion targets the count metric
+     *
+     * @returns the next Assertion DSL step (condition in the next step must be specified with integer values only)
+     */
+    count(): AssertionWithPathAndTarget;
+    /**
+     * Specify the Assertion targets the percentage of total executions metric
+     *
+     * @returns the next Assertion DSL step (condition in the next step can be specified with a floating point value)
+     */
+    percent(): AssertionWithPathAndTarget;
+}
+/**
+ * Step 4 of the Assertion DSL (path and target defined). Immutable, so all methods return a new
+ * occurrence and leave the original unmodified.
+ */
+export interface AssertionWithPathAndTarget {
+    /**
+     * Specify the metric must be strictly less than the expected value
+     *
+     * @param value - the value
+     * @returns a complete Assertion
+     */
+    lt(value: number): Assertion;
+    /**
+     * Specify the metric must be less than or equal to the expected value
+     *
+     * @param value - the value
+     * @returns a complete Assertion
+     */
+    lte(value: number): Assertion;
+    /**
+     * Specify the metric must be strictly greater than the expected value
+     *
+     * @param value - the value
+     * @returns a complete Assertion
+     */
+    gt(value: number): Assertion;
+    /**
+     * Specify the metric must be greater than or equal to the expected value
+     *
+     * @param value - the value
+     * @returns a complete Assertion
+     */
+    gte(value: number): Assertion;
+    /**
+     * Specify the metric must be included in the given range
+     *
+     * @param min - the min, included
+     * @param max - the max, included
+     * @param inclusive - if bounds must be included in the range
+     * @returns a complete Assertion
+     */
+    between(min: number, max: number, inclusive?: boolean): Assertion;
+    /**
+     * Specify the metric must be included in a range defined around a mean value with a half range
+     * expressed as an absolute value
+     *
+     * @param mean - the mean of the range
+     * @param plusOrMinus - the range half width
+     * @param inclusive - if bounds must be included in the range
+     * @returns a complete Assertion
+     */
+    around(mean: number, plusOrMinus: number, inclusive?: boolean): Assertion;
+    /**
+     * Specify the metric must be included in a range defined around a mean value with a half range
+     * expressed as an percentage of the mean value
+     *
+     * @param mean - the mean of the range
+     * @param percentDeviation - the range half width expressed as a percent of the mean
+     * @param inclusive - if bounds must be included in the range
+     * @returns a complete Assertion
+     */
+    deviatesAround(mean: number, percentDeviation: number, inclusive?: boolean): Assertion;
+    /**
+     * Specify the metric must be equal to an expected value
+     *
+     * @param value - the expected value
+     * @returns a complete Assertion
+     */
+    is(value: number): Assertion;
+    /**
+     * Specify the metric must be included in a set of values
+     *
+     * @param values - the expected values
+     * @returns a complete Assertion
+     */
+    in(...values: number[]): Assertion;
+}
+export interface Assertion extends Wrapper<JvmAssertion> {
+}

package/target/assertions.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.details = exports.forAll = exports.global = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+/**
+ * Bootstrap a new global assertion that targets stats aggregated on all requests
+ *
+ * @returns the next DSL step
+ */
+const global = () => wrapAssertionWithPath(jvm_types_1.CoreDsl.global());
+exports.global = global;
+/**
+ * Bootstrap a new forAll assertion that targets stats on each individual request type
+ *
+ * @returns the next DSL step
+ */
+const forAll = () => wrapAssertionWithPath(jvm_types_1.CoreDsl.forAll());
+exports.forAll = forAll;
+/**
+ * Bootstrap a new details assertion that targets stats on a specific request type
+ *
+ * @returns the next DSL step
+ */
+const details = (...parts) => wrapAssertionWithPath(jvm_types_1.CoreDsl.details(...parts));
+exports.details = details;
+const wrapAssertionWithPath = (_underlying) => ({
+    responseTime: () => wrapAssertionWithPathAndTimeMetric(_underlying.responseTime()),
+    allRequests: () => wrapAssertionWithPathAndCountMetric(_underlying.allRequests()),
+    failedRequests: () => wrapAssertionWithPathAndCountMetric(_underlying.failedRequests()),
+    successfulRequests: () => wrapAssertionWithPathAndCountMetric(_underlying.successfulRequests()),
+    requestsPerSec: () => wrapAssertionWithPathAndTarget(_underlying.requestsPerSec())
+});
+const wrapAssertionWithPathAndTimeMetric = (_underlying) => ({
+    min: () => wrapAssertionWithPathAndTarget(_underlying.min()),
+    max: () => wrapAssertionWithPathAndTarget(_underlying.max()),
+    mean: () => wrapAssertionWithPathAndTarget(_underlying.mean()),
+    stdDev: () => wrapAssertionWithPathAndTarget(_underlying.stdDev()),
+    percentile1: () => wrapAssertionWithPathAndTarget(_underlying.percentile1()),
+    percentile2: () => wrapAssertionWithPathAndTarget(_underlying.percentile2()),
+    percentile3: () => wrapAssertionWithPathAndTarget(_underlying.percentile3()),
+    percentile4: () => wrapAssertionWithPathAndTarget(_underlying.percentile4()),
+    percentile: (value) => wrapAssertionWithPathAndTarget(_underlying.percentile(value))
+});
+const wrapAssertionWithPathAndCountMetric = (_underlying) => ({
+    count: () => wrapAssertionWithPathAndTarget(_underlying.count()),
+    percent: () => wrapAssertionWithPathAndTarget(_underlying.percent())
+});
+const wrapAssertionWithPathAndTarget = (_underlying) => ({
+    lt: (value) => wrapAssertion(_underlying.lt(value)),
+    lte: (value) => wrapAssertion(_underlying.lte(value)),
+    gt: (value) => wrapAssertion(_underlying.gt(value)),
+    gte: (value) => wrapAssertion(_underlying.gte(value)),
+    between: (min, max, inclusive) => wrapAssertion(inclusive !== undefined ? _underlying.between(min, max, inclusive) : _underlying.between(min, max)),
+    around: (mean, plusOrMinus, inclusive) => wrapAssertion(inclusive !== undefined ? _underlying.around(mean, plusOrMinus, inclusive) : _underlying.around(mean, plusOrMinus)),
+    deviatesAround: (mean, percentDeviation, inclusive) => wrapAssertion(inclusive !== undefined
+        ? _underlying.deviatesAround(mean, percentDeviation, inclusive)
+        : _underlying.deviatesAround(mean, percentDeviation)),
+    is: (value) => wrapAssertion(_underlying.is(value)),
+    in: (...values) => wrapAssertion(_underlying.in(values))
+});
+const wrapAssertion = (_underlying) => ({
+    _underlying
+});

package/target/body.d.ts

@@ -0,0 +1,150 @@
+import { Wrapper } from "./common";
+import { Session } from "./session";
+import JvmBody = io.gatling.javaapi.core.Body;
+export interface Body extends Wrapper<JvmBody> {
+}
+export declare namespace Body {
+    interface WithBytes extends Body {
+        (session: Session): number[];
+    }
+    interface WithString extends Body {
+        (session: Session): string;
+    }
+}
+export interface StringBodyFunction {
+    /**
+     * Create a body from a String.
+     *
+     * <p>Can also be used as a Function<Session, String> to define the expected value in a check.
+     *
+     * @param string - the body expressed as a gatling Expression Language String
+     * @returns a body
+     */
+    (string: string): Body.WithString;
+    /**
+     * Create a body from a String.
+     *
+     * <p>Can also be used as a Function<Session, String> to define the expected value in a check.
+     *
+     * @param f - the body expressed as a function
+     * @returns a body
+     */
+    (f: (session: Session) => string): Body.WithString;
+}
+export declare const StringBody: StringBodyFunction;
+export interface RawFileBodyFunction {
+    /**
+     * Create a body from a file. Bytes will be sent without any transformation.
+     *
+     * <p>Can also be used as a Function<Session, byte[]> to define the expected value in a check.
+     *
+     * @param filePath - the path of the file, either relative to the root of the classpath, or
+     *     absolute, expressed as a Gatling Expression Language String
+     * @returns a body
+     */
+    (filePath: string): Body.WithBytes;
+    /**
+     * Create a body from a file. Bytes will be sent without any transformation.
+     *
+     * <p>Can also be used as a Function<Session, byte[]> to define the expected value in a check.
+     *
+     * @param filePath - the path of the file, either relative to the root of the classpath, or
+     *     absolute, expressed as a function
+     * @returns a body
+     */
+    (filePath: (session: Session) => string): Body.WithBytes;
+}
+export declare const RawFileBody: RawFileBodyFunction;
+export interface ElFileBodyFunction {
+    /**
+     * Create a body from a file. File text content will be processed as a Gatling Expression Language
+     * String.
+     *
+     * <p>Can also be used as a Function<Session, String> to define the expected value in a check.
+     *
+     * @param filePath - the path of the file, either relative to the root of the classpath, or
+     *     absolute, expressed as a Gatling Expression Language String
+     * @returns a body
+     */
+    (filePath: string): Body.WithString;
+    /**
+     * Create a body from a file. File text content will be processed as a Gatling Expression Language
+     * String.
+     *
+     * <p>Can also be used as a Function<Session, String> to define the expected value in a check.
+     *
+     * @param filePath - the path of the file, either relative to the root of the classpath, or
+     *     absolute, expressed as a function
+     * @returns a body
+     */
+    (filePath: (session: Session) => string): Body.WithString;
+}
+export declare const ElFileBody: ElFileBodyFunction;
+export interface PebbleStringBodyFunction {
+    /**
+     * Create a body from String processed as a <a href="https://pebbletemplates.io/">Pebble
+     * template</a>.
+     *
+     * <p>Can also be used as a Function<Session, String> to define the expected value in a check.
+     *
+     * @param string - the Pebble string
+     * @returns a body
+     */
+    (string: string): Body.WithString;
+}
+export declare const PebbleStringBody: PebbleStringBodyFunction;
+export interface PebbleFileBodyFunction {
+    /**
+     * Create a body from a file. File text content will be processed as a <a
+     * href="https://pebbletemplates.io/">Pebble template</a>.
+     *
+     * <p>Can also be used as a Function<Session, String> to define the expected value in a check.
+     *
+     * @param filePath - the path of the file, either relative to the root of the classpath, or
+     *     absolute, expressed as a Gatling Expression Language String
+     * @returns a body
+     */
+    (filePath: string): Body.WithString;
+    /**
+     * Create a body from a file. File text content will be processed as a <a
+     * href="https://pebbletemplates.io/">Pebble template</a>.
+     *
+     * <p>Can also be used as a Function<Session, String> to define the expected value in a check.
+     *
+     * @param filePath - the path of the file, either relative to the root of the classpath, or
+     *     absolute, expressed as a function
+     * @returns a body
+     */
+    (filePath: (session: Session) => string): Body.WithString;
+}
+export declare const PebbleFileBody: PebbleFileBodyFunction;
+export interface ByteArrayBodyFunction {
+    /**
+     * Create a body from a byte array. Bytes will be sent as is.
+     *
+     * <p>Can also be used as a Function<Session, byte[]> to define the expected value in a check.
+     *
+     * @param bytes - the bytes, expressed as a Gatling Expression Language String
+     * @returns a body
+     */
+    (bytes: string): Body.WithBytes;
+    /**
+     * Create a body from a byte array. Bytes will be sent as is.
+     *
+     * <p>Can also be used as a Function<Session, byte[]> to define the expected value in a check.
+     *
+     * @param bytes - the bytes
+     * @returns a body
+     */
+    (bytes: number[]): Body.WithBytes;
+    /**
+     * Create a body from a byte array. Bytes will be sent as is.
+     *
+     * <p>Can also be used as a Function<Session, byte[]> to define the expected value in a check.
+     *
+     * @param bytes - the bytes, expressed as a function
+     * @returns a body
+     */
+    (bytes: (session: Session) => number[]): Body.WithBytes;
+}
+export declare const ByteArrayBody: ByteArrayBodyFunction;

package/target/body.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteArrayBody = exports.PebbleFileBody = exports.PebbleStringBody = exports.ElFileBody = exports.RawFileBody = exports.StringBody = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const callbacks_1 = require("./gatlingJvm/callbacks");
+const session_1 = require("./session");
+const wrapBodyWithBytes = (_underlying) => Object.assign((session) => _underlying.apply(session._underlying), { _underlying });
+const wrapBodyWithString = (_underlying) => Object.assign((session) => _underlying.apply(session._underlying), { _underlying });
+const StringBody = (string) => wrapBodyWithString(typeof string === "function"
+    ? jvm_types_1.CoreDsl.StringBody((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(string)))
+    : jvm_types_1.CoreDsl.StringBody(string));
+exports.StringBody = StringBody;
+const RawFileBody = (filePath) => wrapBodyWithBytes(typeof filePath === "function"
+    ? jvm_types_1.CoreDsl.RawFileBody((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(filePath)))
+    : jvm_types_1.CoreDsl.RawFileBody(filePath));
+exports.RawFileBody = RawFileBody;
+const ElFileBody = (filePath) => wrapBodyWithString(typeof filePath === "function"
+    ? jvm_types_1.CoreDsl.ElFileBody((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(filePath)))
+    : jvm_types_1.CoreDsl.ElFileBody(filePath));
+exports.ElFileBody = ElFileBody;
+const PebbleStringBody = (string) => wrapBodyWithString(jvm_types_1.CoreDsl.PebbleStringBody(string));
+exports.PebbleStringBody = PebbleStringBody;
+const PebbleFileBody = (filePath) => wrapBodyWithString(typeof filePath === "function"
+    ? jvm_types_1.CoreDsl.PebbleFileBody((0, callbacks_1.wrapCallback)((0, session_1.underlyingSessionTo)(filePath)))
+    : jvm_types_1.CoreDsl.PebbleFileBody(filePath));
+exports.PebbleFileBody = PebbleFileBody;
+const ByteArrayBody = (bytes) => wrapBodyWithBytes(typeof bytes === "function"
+    ? jvm_types_1.CoreDsl.ByteArrayBody((0, callbacks_1.wrapByteArrayCallback)((0, session_1.underlyingSessionTo)(bytes)))
+    : typeof bytes === "string"
+        ? jvm_types_1.CoreDsl.ByteArrayBody(bytes)
+        : jvm_types_1.CoreDsl.ByteArrayBody(bytes));
+exports.ByteArrayBody = ByteArrayBody;
+// TODO registerPebbleExtensions

package/target/checks/builder.d.ts

@@ -0,0 +1,10 @@
+import { Wrapper } from "../common";
+import JvmCheckBuilder = io.gatling.javaapi.core.CheckBuilder;
+/**
+ * Java wrapper of a Scala CheckBuilder. Builder of an Action in a Gatling scenario.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface CheckBuilder extends Wrapper<JvmCheckBuilder> {
+}
+export declare const wrapCheckBuilder: (_underlying: JvmCheckBuilder) => CheckBuilder;

package/target/checks/builder.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCheckBuilder = void 0;
+const wrapCheckBuilder = (_underlying) => ({
+    _underlying
+});
+exports.wrapCheckBuilder = wrapCheckBuilder;

package/target/checks/captureGroup.d.ts

@@ -0,0 +1,15 @@
+import { CheckBuilderMultipleFind } from "./multipleFind";
+import JvmCheckBuilderCaptureGroup = io.gatling.javaapi.core.CheckBuilder$CaptureGroupCheckBuilder;
+/**
+ * A special {@link CheckBuilderMultipleFind<string>} that can define regex capture groups
+ */
+export interface CheckBuilderCaptureGroup extends CheckBuilderMultipleFind<string> {
+    /**
+     * Define that the check extracts an expected number of values from capture groups
+     *
+     * @param count - the number of capture groups in the regular expression pattern
+     * @returns a new MultipleFind
+     */
+    captureGroups(count: number): CheckBuilderMultipleFind<string[]>;
+}
+export declare const wrapCheckBuilderCaptureGroup: (_underlying: JvmCheckBuilderCaptureGroup) => CheckBuilderCaptureGroup;

package/target/checks/captureGroup.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCheckBuilderCaptureGroup = void 0;
+const multipleFind_1 = require("./multipleFind");
+const wrapCheckBuilderCaptureGroup = (_underlying) => ({
+    ...(0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying),
+    captureGroups: (count) => (0, multipleFind_1.wrapCheckBuilderMultipleFind)(_underlying.captureGroups(count))
+});
+exports.wrapCheckBuilderCaptureGroup = wrapCheckBuilderCaptureGroup;

package/target/checks/condition.d.ts

@@ -0,0 +1,19 @@
+import { CheckBuilder } from "../checks";
+import JvmCheckBuilder = io.gatling.javaapi.core.CheckBuilder;
+interface JvmCondition<T> {
+    equals(arg0: any): boolean;
+    then(...arg0: JvmCheckBuilder[]): T;
+    then(arg0: java.util.List<JvmCheckBuilder>): T;
+    toString(): string;
+}
+export interface Condition<T> {
+    /**
+     * Define the checks to apply when the condition holds true.
+     *
+     * @param thenChecks - the checks
+     * @returns a new HttpProtocolBuilder instance
+     */
+    then(...thenChecks: CheckBuilder[]): T;
+}
+export declare const wrapCondition: <J, T>(jvmCondition: JvmCondition<J>, wrap: (underlying: J) => T) => Condition<T>;
+export {};

package/target/checks/condition.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCondition = void 0;
+const wrapCondition = (jvmCondition, wrap) => ({
+    then: (...thenChecks) => wrap(jvmCondition.then(thenChecks.map((c) => c._underlying)))
+});
+exports.wrapCondition = wrapCondition;

package/target/checks/final.d.ts

@@ -0,0 +1,23 @@
+import { CheckBuilder } from "./builder";
+import JvmCheckBuilderFinal = io.gatling.javaapi.core.CheckBuilder$Final;
+/**
+ * Last step of the Check DSL Immutable, so all methods return a new occurrence and leave the
+ * original unmodified.
+ */
+export interface CheckBuilderFinal extends CheckBuilder {
+    /**
+     * Provide a custom name for the check, to be used in case of a failure
+     *
+     * @param n - the name
+     * @returns a new CheckBuilderFinal
+     */
+    name(n: string): CheckBuilderFinal;
+    /**
+     * Save the extracted value in the virtual user's Session
+     *
+     * @param key - the key to store the extracted value in the Session
+     * @returns a new CheckBuilderFinal
+     */
+    saveAs(key: string): CheckBuilderFinal;
+}
+export declare const wrapCheckBuilderFinal: (_underlying: JvmCheckBuilderFinal) => CheckBuilderFinal;

package/target/checks/final.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCheckBuilderFinal = void 0;
+const builder_1 = require("./builder");
+const wrapCheckBuilderFinal = (_underlying) => ({
+    ...(0, builder_1.wrapCheckBuilder)(_underlying),
+    name: (n) => (0, exports.wrapCheckBuilderFinal)(_underlying.name(n)),
+    saveAs: (key) => (0, exports.wrapCheckBuilderFinal)(_underlying.saveAs(key))
+});
+exports.wrapCheckBuilderFinal = wrapCheckBuilderFinal;

package/target/checks/find.d.ts

@@ -0,0 +1,17 @@
+import { CheckBuilderValidate } from "./validate";
+import JvmCheckBuilderFind = io.gatling.javaapi.core.CheckBuilder$Find;
+/**
+ * Step 1 of the Check DSL when the check can only return one single value 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 CheckBuilderFind<X> extends CheckBuilderValidate<X> {
+    /**
+     * Target a single/first value
+     *
+     * @returns the next Check DSL step
+     */
+    find(): CheckBuilderValidate<X>;
+}
+export declare const wrapCheckBuilderFind: <X>(_underlying: JvmCheckBuilderFind<X>) => CheckBuilderFind<X>;

package/target/checks/find.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCheckBuilderFind = void 0;
+const validate_1 = require("./validate");
+const wrapCheckBuilderFind = (_underlying) => ({
+    ...(0, validate_1.wrapCheckBuilderValidate)(_underlying),
+    find: () => (0, validate_1.wrapCheckBuilderValidate)(_underlying.find())
+});
+exports.wrapCheckBuilderFind = wrapCheckBuilderFind;