@gatling.io/core 3.13.2 → 3.13.104-M10

package/package.json

@@ -1,20 +1,35 @@
 {
   "name": "@gatling.io/core",
-  "version": "3.13.2",
+  "version": "3.13.104-M10",
   "license": "Apache-2.0",
+  "homepage": "https://gatling.io",
+  "repository": "github:gatling/gatling-js",
+  "bugs": "https://github.com/gatling/gatling/issues",
+  "keywords": [
+    "gatling",
+    "typescript",
+    "test",
+    "testing",
+    "loadtest",
+    "loadtesting",
+    "load test",
+    "load testing",
+    "performance test",
+    "performance testing"
+  ],
   "main": "target/index.js",
   "types": "target/index.d.ts",
   "dependencies": {
-    "@gatling.io/jvm-types": "3.13.2"
+    "@gatling.io/jvm-types": "3.13.104-M10"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",
     "jest": "29.7.0",
-    "prettier": "3.3.3",
+    "prettier": "3.4.1",
     "rimraf": "6.0.1",
     "ts-jest": "29.2.5",
     "ts-node": "10.9.2",
-    "typescript": "5.6.3"
+    "typescript": "5.7.2"
   },
   "scripts": {
     "clean": "rimraf target",

package/jest.config.js

@@ -1,5 +0,0 @@
-/** @type {import('ts-jest').JestConfigWithTsJest} */
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-};

package/src/assertions.ts

@@ -1,305 +0,0 @@
-import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
-
-import { Wrapper } from "./common";
-
-import JvmAssertion = io.gatling.javaapi.core.Assertion;
-import JvmAssertionWithPath = io.gatling.javaapi.core.Assertion$WithPath;
-import JvmAssertionWithPathAndTarget = io.gatling.javaapi.core.Assertion$WithPathAndTarget;
-import JvmAssertionWithPathAndCountMetric = io.gatling.javaapi.core.Assertion$WithPathAndCountMetric;
-import JvmAssertionWithPathAndTimeMetric = io.gatling.javaapi.core.Assertion$WithPathAndTimeMetric;
-
-/**
- * Bootstrap a new global assertion that targets stats aggregated on all requests
- *
- * @returns the next DSL step
- */
-export const global = (): AssertionWithPath => wrapAssertionWithPath(JvmCoreDsl.global());
-
-/**
- * Bootstrap a new forAll assertion that targets stats on each individual request type
- *
- * @returns the next DSL step
- */
-export const forAll = (): AssertionWithPath => wrapAssertionWithPath(JvmCoreDsl.forAll());
-
-/**
- * Bootstrap a new details assertion that targets stats on a specific request type
- *
- * @returns the next DSL step
- */
-export const details = (...parts: string[]): AssertionWithPath => wrapAssertionWithPath(JvmCoreDsl.details(...parts));
-
-/**
- * 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;
-}
-
-const wrapAssertionWithPath = (_underlying: JvmAssertionWithPath): AssertionWithPath => ({
-  responseTime: () => wrapAssertionWithPathAndTimeMetric(_underlying.responseTime()),
-  allRequests: () => wrapAssertionWithPathAndCountMetric(_underlying.allRequests()),
-  failedRequests: () => wrapAssertionWithPathAndCountMetric(_underlying.failedRequests()),
-  successfulRequests: () => wrapAssertionWithPathAndCountMetric(_underlying.successfulRequests()),
-  requestsPerSec: () => wrapAssertionWithPathAndTarget(_underlying.requestsPerSec())
-});
-
-/**
- * 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;
-}
-
-const wrapAssertionWithPathAndTimeMetric = (
-  _underlying: JvmAssertionWithPathAndTimeMetric
-): AssertionWithPathAndTimeMetric => ({
-  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: number) => wrapAssertionWithPathAndTarget(_underlying.percentile(value))
-});
-
-/**
- * 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;
-}
-
-const wrapAssertionWithPathAndCountMetric = (
-  _underlying: JvmAssertionWithPathAndCountMetric
-): AssertionWithPathAndCountMetric => ({
-  count: () => wrapAssertionWithPathAndTarget(_underlying.count()),
-  percent: () => wrapAssertionWithPathAndTarget(_underlying.percent())
-});
-
-/**
- * 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;
-}
-
-const wrapAssertionWithPathAndTarget = (
-  _underlying: JvmAssertionWithPathAndTarget<unknown>
-): AssertionWithPathAndTarget => ({
-  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))
-});
-
-export interface Assertion extends Wrapper<JvmAssertion> {}
-
-const wrapAssertion = (_underlying: JvmAssertion): Assertion => ({
-  _underlying
-});

package/src/body.ts

@@ -1,211 +0,0 @@
-import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
-
-import { Wrapper } from "./common";
-import { asByteArrayFunction } from "./gatlingJvm/byteArrays";
-import { Expression, Session, underlyingSessionTo } from "./session";
-
-import JvmBody = io.gatling.javaapi.core.Body;
-import JvmBodyWithBytes = io.gatling.javaapi.core.Body$WithBytes;
-import JvmBodyWithString = io.gatling.javaapi.core.Body$WithString;
-
-export interface Body extends Wrapper<JvmBody> {}
-
-export namespace Body {
-  export interface WithBytes extends Body {
-    (session: Session): number[];
-  }
-  export interface WithString extends Body {
-    (session: Session): string;
-  }
-}
-
-const wrapBodyWithBytes = (_underlying: JvmBodyWithBytes): Body.WithBytes =>
-  Object.assign((session: Session): number[] => _underlying.apply(session._underlying), { _underlying });
-
-const wrapBodyWithString = (_underlying: JvmBodyWithString): Body.WithString =>
-  Object.assign((session: Session): string => _underlying.apply(session._underlying), { _underlying });
-
-// TODO gzipBody
-
-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 const StringBody: StringBodyFunction = (string: Expression<string>): Body.WithString =>
-  wrapBodyWithString(
-    typeof string === "function" ? JvmCoreDsl.StringBody(underlyingSessionTo(string)) : JvmCoreDsl.StringBody(string)
-  );
-
-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 const RawFileBody: RawFileBodyFunction = (filePath: Expression<string>): Body.WithBytes =>
-  wrapBodyWithBytes(
-    typeof filePath === "function"
-      ? JvmCoreDsl.RawFileBody(underlyingSessionTo(filePath))
-      : JvmCoreDsl.RawFileBody(filePath)
-  );
-
-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 const ElFileBody: ElFileBodyFunction = (filePath: Expression<string>): Body.WithString =>
-  wrapBodyWithString(
-    typeof filePath === "function"
-      ? JvmCoreDsl.ElFileBody(underlyingSessionTo(filePath))
-      : JvmCoreDsl.ElFileBody(filePath)
-  );
-
-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 const PebbleStringBody: PebbleStringBodyFunction = (string: string): Body.WithString =>
-  wrapBodyWithString(JvmCoreDsl.PebbleStringBody(string));
-
-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 const PebbleFileBody: PebbleFileBodyFunction = (filePath: Expression<string>): Body.WithString =>
-  wrapBodyWithString(
-    typeof filePath === "function"
-      ? JvmCoreDsl.PebbleFileBody(underlyingSessionTo(filePath))
-      : JvmCoreDsl.PebbleFileBody(filePath)
-  );
-
-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 const ByteArrayBody: ByteArrayBodyFunction = (bytes: string | Expression<number[]>): Body.WithBytes =>
-  wrapBodyWithBytes(
-    typeof bytes === "function"
-      ? JvmCoreDsl.ByteArrayBody(asByteArrayFunction(underlyingSessionTo(bytes)))
-      : typeof bytes === "string"
-        ? JvmCoreDsl.ByteArrayBody(bytes)
-        : JvmCoreDsl.ByteArrayBody(bytes)
-  );
-
-// TODO registerPebbleExtensions

package/src/checks/builder.ts

@@ -1,14 +0,0 @@
-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 const wrapCheckBuilder = (_underlying: JvmCheckBuilder): CheckBuilder => ({
-  _underlying
-});

package/src/checks/captureGroup.ts

@@ -1,22 +0,0 @@
-import { CheckBuilderMultipleFind, wrapCheckBuilderMultipleFind } 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 const wrapCheckBuilderCaptureGroup = (_underlying: JvmCheckBuilderCaptureGroup): CheckBuilderCaptureGroup => ({
-  ...wrapCheckBuilderMultipleFind<string>(_underlying),
-  captureGroups: (count: number): CheckBuilderMultipleFind<string[]> =>
-    wrapCheckBuilderMultipleFind(_underlying.captureGroups(count))
-});

package/src/checks/condition.ts

@@ -1,24 +0,0 @@
-import { CheckBuilder } from "../checks";
-
-import JvmCheckBuilder = io.gatling.javaapi.core.CheckBuilder;
-
-interface JvmCondition<T> {
-  equals(arg0: any /*java.lang.Object*/): 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 const wrapCondition = <J, T>(jvmCondition: JvmCondition<J>, wrap: (underlying: J) => T): Condition<T> => ({
-  then: (...thenChecks: CheckBuilder[]): T => wrap(jvmCondition.then(thenChecks.map((c) => c._underlying)))
-});

package/src/checks/final.ts

@@ -1,31 +0,0 @@
-import { CheckBuilder, wrapCheckBuilder } 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 const wrapCheckBuilderFinal = (_underlying: JvmCheckBuilderFinal): CheckBuilderFinal => ({
-  ...wrapCheckBuilder(_underlying),
-  name: (n: string) => wrapCheckBuilderFinal(_underlying.name(n)),
-  saveAs: (key: string) => wrapCheckBuilderFinal(_underlying.saveAs(key))
-});

package/src/checks/find.ts

@@ -1,23 +0,0 @@
-import { CheckBuilderValidate, wrapCheckBuilderValidate } 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 const wrapCheckBuilderFind = <X>(_underlying: JvmCheckBuilderFind<X>): CheckBuilderFind<X> => ({
-  ...wrapCheckBuilderValidate<X>(_underlying),
-  find: () => wrapCheckBuilderValidate(_underlying.find())
-});