@gatling.io/http 3.14.303 → 3.14.305

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gatling.io/http",
-  "version": "3.14.303",
+  "version": "3.14.305",
   "license": "Apache-2.0",
   "homepage": "https://gatling.io",
   "repository": "github:gatling/gatling-js",
@@ -20,15 +20,15 @@
   "main": "target/index.js",
   "types": "target/index.d.ts",
   "dependencies": {
-    "@gatling.io/jvm-types": "3.14.303",
-    "@gatling.io/core": "3.14.303"
+    "@gatling.io/jvm-types": "3.14.305",
+    "@gatling.io/core": "3.14.305"
   },
   "devDependencies": {
-    "@types/jest": "29.5.14",
-    "jest": "29.7.0",
-    "prettier": "3.5.3",
+    "@types/jest": "30.0.0",
+    "jest": "30.0.4",
+    "prettier": "3.6.2",
     "rimraf": "6.0.1",
-    "ts-jest": "29.3.4",
+    "ts-jest": "29.4.0",
     "ts-node": "10.9.2",
     "typescript": "5.8.3"
   },

package/target/index.d.ts

@@ -13,6 +13,8 @@ export * from "./protocol";
 export * from "./proxy";
 export * from "./request";
 export * from "./response";
+export * from "./ws";
+export * from "./sse";
 import JvmRequest = io.gatling.http.client.Request;
 import JvmResponse = io.gatling.http.response.Response;
 import JvmSession = io.gatling.javaapi.core.Session;

package/target/index.js

@@ -32,6 +32,8 @@ __exportStar(require("./protocol"), exports);
 __exportStar(require("./proxy"), exports);
 __exportStar(require("./request"), exports);
 __exportStar(require("./response"), exports);
+__exportStar(require("./ws"), exports);
+__exportStar(require("./sse"), exports);
 const underlyingRequestTransform = (f) => (jvmRequest, jvmSession) => f((0, request_1.wrapRequest)(jvmRequest), (0, core_1.wrapSession)(jvmSession))._underlying;
 exports.underlyingRequestTransform = underlyingRequestTransform;
 const underlyingResponseTransform = (f) => (jvmResponse, jvmSession) => f((0, response_1.wrapResponse)(jvmResponse), (0, core_1.wrapSession)(jvmSession))._underlying;

package/target/protocol.d.ts

@@ -536,6 +536,63 @@ export interface HttpProtocolBuilder extends ProtocolBuilder {
      * @returns a new HttpProtocolBuilder instance
      */
     nameInferredHtmlResourcesAfterLastPathElement(): HttpProtocolBuilder;
+    /**
+     * Define a baseUrl that will be used as a prefix for all relative WebSocket urls.
+     *
+     * @param url - the base url
+     * @returns a new HttpProtocolBuilder instance
+     */
+    wsBaseUrl(url: string): HttpProtocolBuilder;
+    /**
+     * Define multiple baseUrls that will be used as a prefix for all relative WebSocket urls.
+     * Assigned once per virtual user based on a round-robin strategy.
+     *
+     * @param urls - the base urls
+     * @returns a new HttpProtocolBuilder instance
+     */
+    wsBaseUrls(...urls: string[]): HttpProtocolBuilder;
+    /**
+     * Automatically reconnect disconnected WebSockets
+     *
+     * @returns a new HttpProtocolBuilder instance
+     */
+    wsReconnect(): HttpProtocolBuilder;
+    /**
+     * Define a maximum number of times a WebSocket can be automatically reconnected
+     *
+     * @param max - the limit
+     * @returns a new HttpProtocolBuilder instance
+     */
+    wsMaxReconnects(max: number): HttpProtocolBuilder;
+    /**
+     * Automatically reply to a TEXT frame with another TEXT frame.
+     *
+     * @param f - the function
+     * @returns a new HttpProtocolBuilder instance
+     */
+    wsAutoReplyTextFrame(f: (frame: string) => string | null): HttpProtocolBuilder;
+    /**
+     * Automatically reply to a SocketIo4 ping TEXT frame with the corresponding pong TEXT frame.
+     *
+     * @returns a new HttpProtocolBuilder instance
+     */
+    wsAutoReplySocketIo4(): HttpProtocolBuilder;
+    /**
+     * Set the max size of the buffer for unmatched/unchecked inbound WebSocket messages. 0 by
+     * default, meaning such messages are not buffered.
+     *
+     * @param max - the max size
+     * @returns a new HttpProtocolBuilder instance
+     */
+    wsUnmatchedInboundMessageBufferSize(max: number): HttpProtocolBuilder;
+    /**
+     * Set the max size of the buffer for unmatched/unchecked inbound SSE messages. 0 by default,
+     * meaning such messages are not buffered.
+     *
+     * @param max - the max size
+     * @returns a new HttpProtocolBuilder instance
+     */
+    sseUnmatchedInboundMessageBufferSize(max: number): HttpProtocolBuilder;
     /**
      * Define a Proxy to be used for all requests
      *
@@ -588,8 +645,8 @@ export interface HttpProtocolBuilder extends ProtocolBuilder {
     /**
      * Define some aliases to bypass DNS name resolution
      *
-     * @param aliases the aliases
-     * @return a new HttpProtocolBuilder instance
+     * @param aliases - the aliases
+     * @returns a new HttpProtocolBuilder instance
      */
     hostNameAliases(aliases: Record<string, string[]>): HttpProtocolBuilder;
     /**

package/target/protocol.js

@@ -108,6 +108,16 @@ const wrapHttpProtocolBuilder = (_underlying) => ({
     nameInferredHtmlResourcesAfterRelativeUrl: () => (0, exports.wrapHttpProtocolBuilder)(_underlying.nameInferredHtmlResourcesAfterRelativeUrl()),
     nameInferredHtmlResourcesAfterPath: () => (0, exports.wrapHttpProtocolBuilder)(_underlying.nameInferredHtmlResourcesAfterPath()),
     nameInferredHtmlResourcesAfterLastPathElement: () => (0, exports.wrapHttpProtocolBuilder)(_underlying.nameInferredHtmlResourcesAfterLastPathElement()),
+    // WebSockets part
+    wsBaseUrl: (url) => (0, exports.wrapHttpProtocolBuilder)(_underlying.wsBaseUrl(url)),
+    wsBaseUrls: (...urls) => (0, exports.wrapHttpProtocolBuilder)(_underlying.wsBaseUrls(urls)),
+    wsReconnect: () => (0, exports.wrapHttpProtocolBuilder)(_underlying.wsReconnect()),
+    wsMaxReconnects: (max) => (0, exports.wrapHttpProtocolBuilder)(_underlying.wsMaxReconnects(max)),
+    wsAutoReplyTextFrame: (f) => (0, exports.wrapHttpProtocolBuilder)(_underlying.wsAutoReplyTextFrame(f)),
+    wsAutoReplySocketIo4: () => (0, exports.wrapHttpProtocolBuilder)(_underlying.wsAutoReplySocketIo4()),
+    wsUnmatchedInboundMessageBufferSize: (max) => (0, exports.wrapHttpProtocolBuilder)(_underlying.wsUnmatchedInboundMessageBufferSize(max)),
+    // SSE Part
+    sseUnmatchedInboundMessageBufferSize: (max) => (0, exports.wrapHttpProtocolBuilder)(_underlying.sseUnmatchedInboundMessageBufferSize(max)),
     // Proxy part
     proxy: (proxy) => (0, exports.wrapHttpProtocolBuilder)(_underlying.proxy(proxy._underlying)),
     noProxyFor: (...hosts) => (0, exports.wrapHttpProtocolBuilder)(_underlying.noProxyFor(...hosts)),

package/target/request/index.d.ts

@@ -1,10 +1,12 @@
 import { ActionBuilder, Body, CheckBuilder, Condition, Duration, Session } from "@gatling.io/core";
 import { BodyPart } from "../bodyPart";
 import { Proxy } from "../proxy";
+import JvmRequestActionBuilder = io.gatling.javaapi.http.RequestActionBuilder;
+import JvmRequestWithBodyActionBuilder = io.gatling.javaapi.http.RequestWithBodyActionBuilder;
 import JvmHttpRequestActionBuilder = io.gatling.javaapi.http.HttpRequestActionBuilder;
 export * from "./body";
 export * from "./request";
-export interface RequestWithParamsActionBuilder<T> {
+export interface RequestActionBuilder<T> {
     /**
      * Set some query parameter
      *
@@ -253,6 +255,7 @@ export interface RequestWithParamsActionBuilder<T> {
      */
     signWithOAuth1(consumerKey: (session: Session) => string, clientSharedSecret: (session: Session) => string, token: (session: Session) => string, tokenSecret: (session: Session) => string): T;
 }
+export declare const requestActionBuilderImpl: <T, J extends JvmRequestActionBuilder<J, any>>(jvmBuilder: J, wrap: (_underlying: J) => T) => RequestActionBuilder<T>;
 export interface RequestWithBodyActionBuilder<T> {
     /**
      * Define a request body
@@ -452,53 +455,55 @@ export interface RequestWithBodyActionBuilder<T> {
      */
     asXml(): T;
 }
-export interface RequestActionBuilder<T> {
+export declare const requestWithBodyActionBuilderImpl: <T, J extends JvmRequestWithBodyActionBuilder<J, any>>(jvmBuilder: J, wrap: (_underlying: J) => T) => RequestWithBodyActionBuilder<T>;
+export interface HttpRequestActionBuilder extends RequestWithBodyActionBuilder<HttpRequestActionBuilder>, RequestActionBuilder<HttpRequestActionBuilder>, ActionBuilder {
+    _underlying: JvmHttpRequestActionBuilder;
     /**
      * Apply some checks
      *
      * @param checks - the checks
      * @returns a new HttpRequestActionBuilder instance
      */
-    check(...checks: CheckBuilder[]): T;
+    check(...checks: CheckBuilder[]): HttpRequestActionBuilder;
     /**
      * Apply some checks if some condition holds true
      *
      * @param condition - the condition, expressed as a function
      * @returns the next DSL step
      */
-    checkIf(condition: string): Condition<T>;
+    checkIf(condition: string): Condition<HttpRequestActionBuilder>;
     /**
      * Apply some checks if some condition holds true
      *
      * @param condition - the condition, expressed as a function
      * @returns the next DSL step
      */
-    checkIf(condition: (session: Session) => boolean): Condition<T>;
+    checkIf(condition: (session: Session) => boolean): Condition<HttpRequestActionBuilder>;
     /**
      * Have this request ignore the common checks defined on the HTTP protocol configuration
      *
      * @returns a new HttpRequestActionBuilder instance
      */
-    ignoreProtocolChecks(): T;
+    ignoreProtocolChecks(): HttpRequestActionBuilder;
     /**
      * Have this request ignore the common checks defined on the HTTP protocol configuration
      *
      * @returns a new HttpRequestActionBuilder instance
      */
-    silent(): T;
+    silent(): HttpRequestActionBuilder;
     /**
      * Instruct the reporting engine to forcefully report stats about this request, ignoring HTTP
      * protocol configuration
      *
      * @returns a new HttpRequestActionBuilder instance
      */
-    notSilent(): T;
+    notSilent(): HttpRequestActionBuilder;
     /**
      * Disable automatic redirect following
      *
      * @returns a new HttpRequestActionBuilder instance
      */
-    disableFollowRedirect(): T;
+    disableFollowRedirect(): HttpRequestActionBuilder;
     /**
      * Set some resources to be fetched concurrently after the main request. Next action in the
      * Scenario will be performed once all resources are fetched.
@@ -506,16 +511,13 @@ export interface RequestActionBuilder<T> {
      * @param res - the resources
      * @returns a new HttpRequestActionBuilder instance
      */
-    resources(...res: HttpRequestActionBuilder[]): T;
+    resources(...res: HttpRequestActionBuilder[]): HttpRequestActionBuilder;
     /**
      * Override the default request timeout defined in gatling.conf
      *
      * @param timeout - timeout the timeout
      * @returns a new HttpRequestActionBuilder instance
      */
-    requestTimeout(timeout: Duration): T;
-}
-export interface HttpRequestActionBuilder extends RequestWithParamsActionBuilder<HttpRequestActionBuilder>, RequestWithBodyActionBuilder<HttpRequestActionBuilder>, RequestActionBuilder<HttpRequestActionBuilder>, ActionBuilder {
-    _underlying: JvmHttpRequestActionBuilder;
+    requestTimeout(timeout: Duration): HttpRequestActionBuilder;
 }
 export declare const wrapHttpRequestActionBuilder: (_underlying: JvmHttpRequestActionBuilder) => HttpRequestActionBuilder;

package/target/request/index.js

@@ -14,11 +14,11 @@ 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.wrapHttpRequestActionBuilder = void 0;
+exports.wrapHttpRequestActionBuilder = exports.requestWithBodyActionBuilderImpl = exports.requestActionBuilderImpl = void 0;
 const core_1 = require("@gatling.io/core");
 __exportStar(require("./body"), exports);
 __exportStar(require("./request"), exports);
-const requestWithParamsActionBuilderImpl = (jvmBuilder, wrap) => ({
+const requestActionBuilderImpl = (jvmBuilder, wrap) => ({
     queryParam: (name, value) => {
         if (typeof name === "function") {
             if (typeof value === "function") {
@@ -108,6 +108,7 @@ const requestWithParamsActionBuilderImpl = (jvmBuilder, wrap) => ({
         ? jvmBuilder.signWithOAuth1((0, core_1.underlyingSessionTo)(consumerKey), (0, core_1.underlyingSessionTo)(clientSharedSecret), (0, core_1.underlyingSessionTo)(token), (0, core_1.underlyingSessionTo)(tokenSecret))
         : jvmBuilder.signWithOAuth1(consumerKey, clientSharedSecret, token, tokenSecret))
 });
+exports.requestActionBuilderImpl = requestActionBuilderImpl;
 const requestWithBodyActionBuilderImpl = (jvmBuilder, wrap) => ({
     body: (body) => wrap(jvmBuilder.body(body._underlying)),
     bodyPart: (part) => wrap(jvmBuilder.bodyPart(part._underlying)),
@@ -180,24 +181,22 @@ const requestWithBodyActionBuilderImpl = (jvmBuilder, wrap) => ({
     asJson: () => wrap(jvmBuilder.asJson()),
     asXml: () => wrap(jvmBuilder.asXml())
 });
-const requestActionBuilderImpl = (jvmBuilder, wrap) => ({
-    check: (...checks) => wrap(jvmBuilder.check(checks.map((c) => c._underlying))),
+exports.requestWithBodyActionBuilderImpl = requestWithBodyActionBuilderImpl;
+const wrapHttpRequestActionBuilder = (_underlying) => ({
+    _underlying,
+    ...(0, exports.requestActionBuilderImpl)(_underlying, exports.wrapHttpRequestActionBuilder),
+    ...(0, exports.requestWithBodyActionBuilderImpl)(_underlying, exports.wrapHttpRequestActionBuilder),
+    check: (...checks) => (0, exports.wrapHttpRequestActionBuilder)(_underlying.check(checks.map((c) => c._underlying))),
     checkIf: (condition) => (0, core_1.wrapCondition)(typeof condition === "string"
-        ? jvmBuilder.checkIf(condition)
-        : jvmBuilder.checkIf((0, core_1.underlyingSessionTo)(condition)), wrap),
-    ignoreProtocolChecks: () => wrap(jvmBuilder.ignoreProtocolChecks()),
-    silent: () => wrap(jvmBuilder.silent()),
-    notSilent: () => wrap(jvmBuilder.notSilent()),
-    disableFollowRedirect: () => wrap(jvmBuilder.disableFollowRedirect()),
+        ? _underlying.checkIf(condition)
+        : _underlying.checkIf((0, core_1.underlyingSessionTo)(condition)), exports.wrapHttpRequestActionBuilder),
+    ignoreProtocolChecks: () => (0, exports.wrapHttpRequestActionBuilder)(_underlying.ignoreProtocolChecks()),
+    silent: () => (0, exports.wrapHttpRequestActionBuilder)(_underlying.silent()),
+    notSilent: () => (0, exports.wrapHttpRequestActionBuilder)(_underlying.notSilent()),
+    disableFollowRedirect: () => (0, exports.wrapHttpRequestActionBuilder)(_underlying.disableFollowRedirect()),
     // TODO transformResponse: (f: (response: Response, session: Session) => Response): T =>
     //  wrap(jvmBuilder.transformResponse(wrapBiCallback(underlyingResponseTransform(f))))
-    resources: (...res) => wrap(jvmBuilder.resources(res.map((r) => r._underlying))),
-    requestTimeout: (duration) => wrap(jvmBuilder.requestTimeout((0, core_1.toJvmDuration)(duration)))
-});
-const wrapHttpRequestActionBuilder = (_underlying) => ({
-    _underlying,
-    ...requestWithParamsActionBuilderImpl(_underlying, exports.wrapHttpRequestActionBuilder),
-    ...requestWithBodyActionBuilderImpl(_underlying, exports.wrapHttpRequestActionBuilder),
-    ...requestActionBuilderImpl(_underlying, exports.wrapHttpRequestActionBuilder)
+    resources: (...res) => (0, exports.wrapHttpRequestActionBuilder)(_underlying.resources(res.map((r) => r._underlying))),
+    requestTimeout: (duration) => (0, exports.wrapHttpRequestActionBuilder)(_underlying.requestTimeout((0, core_1.toJvmDuration)(duration)))
 });
 exports.wrapHttpRequestActionBuilder = wrapHttpRequestActionBuilder;

package/target/sse.d.ts

@@ -0,0 +1,214 @@
+import { ActionBuilder, CheckBuilder, Duration, Session, SessionTo, Wrapper } from "@gatling.io/core";
+import { RequestActionBuilder, RequestWithBodyActionBuilder } from "./request";
+import JvmSseConnectActionBuilder = io.gatling.javaapi.http.SseConnectActionBuilder;
+import JvmSseMessageCheck = io.gatling.javaapi.http.SseMessageCheck;
+import JvmSseSetCheckActionBuilder = io.gatling.javaapi.http.SseSetCheckActionBuilder;
+export interface SseUntypedCondition {
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param thenChecks - the checks
+     * @returns a new Text instance
+     */
+    then(...thenChecks: Array<CheckBuilder>): SseMessageCheck;
+}
+export interface SseTypedCondition {
+    /**
+     * Define the checks to apply when the condition holds true.
+     *
+     * @param thenChecks - the checks
+     * @returns a new Text instance
+     */
+    then(...thenChecks: Array<CheckBuilder>): SseMessageCheck;
+}
+export interface SseMessageCheck extends Wrapper<JvmSseMessageCheck> {
+    /**
+     * Define conditions that have to hold true to match inbound messages and apply the checks on them
+     *
+     * @param newMatchConditions - the conditions to match
+     * @returns a new SseMessageCheck instance
+     */
+    matching(...newMatchConditions: Array<CheckBuilder>): SseMessageCheck;
+    /**
+     * Define the checks to apply on inbound messages
+     *
+     * @param checks - the checks
+     * @returns a new SseMessageCheck instance
+     */
+    check(...checks: Array<CheckBuilder>): SseMessageCheck;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a function
+     * @returns the next DSL step
+     */
+    checkIf(condition: (session: Session) => boolean): SseUntypedCondition;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    checkIf(condition: string): SseUntypedCondition;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a function that's aware of the HTTP response and the
+     *     Session
+     * @returns the next DSL step
+     */
+    checkIf(condition: (response: string, session: Session) => boolean): SseTypedCondition;
+}
+export interface SseAwaitActionBuilderOn<T> {
+    /**
+     * Define the checks to wait on
+     *
+     * @param checks - the checks
+     * @returns a usable ActionBuilder
+     */
+    on(...checks: Array<SseMessageCheck>): T;
+}
+export interface SseAwaitActionBuilder<T> {
+    /**
+     * Boostrap a check that waits for a given duration
+     *
+     * @param timeout - the static wait duration
+     * @returns the next DSL step
+     */
+    await(timeout: Duration): SseAwaitActionBuilderOn<T>;
+    /**
+     * Boostrap a check that waits for a given duration
+     *
+     * @param timeout - the wait duration, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    await(timeout: string): SseAwaitActionBuilderOn<T>;
+    /**
+     * Boostrap a check that waits for a given duration
+     *
+     * @param timeout - the wait duration, expressed as a function
+     * @returns the next DSL step
+     */
+    await(timeout: SessionTo<Duration>): SseAwaitActionBuilderOn<T>;
+}
+export interface SseConnectActionBuilder extends SseAwaitActionBuilder<SseConnectActionBuilder>, RequestWithBodyActionBuilder<SseConnectActionBuilder>, RequestActionBuilder<SseConnectActionBuilder>, ActionBuilder {
+    _underlying: JvmSseConnectActionBuilder;
+}
+export declare const wrapSseConnectActionBuilder: (_underlying: JvmSseConnectActionBuilder) => SseConnectActionBuilder;
+export interface SseInboundMessage {
+    message(): string;
+    timestamp(): number;
+}
+export interface SseSetCheckActionBuilder extends SseAwaitActionBuilder<SseSetCheckActionBuilder>, ActionBuilder {
+    _underlying: JvmSseSetCheckActionBuilder;
+}
+export declare const wrapSseSetCheckActionBuilder: (_underlying: JvmSseSetCheckActionBuilder) => SseSetCheckActionBuilder;
+/**
+ * DSL for building <a
+ * href="https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events">SSE</a>
+ * configurations
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface Sse {
+    /**
+     * Define a custom stream name so multiple SSEs for the same virtual users don't conflict
+     *
+     * @param sseName - the name, expressed as a Gatling Expression Language String
+     * @returns a new Sse instance
+     */
+    sseName(sseName: string): Sse;
+    /**
+     * Define a custom stream name so multiple SSEs for the same virtual users don't conflict
+     *
+     * @param sseName - the name, expressed as a function
+     * @returns a new Sse instance
+     */
+    sseName(sseName: (session: Session) => string): Sse;
+    /**
+     * Boostrap an action to connect the SSE with a GET request
+     *
+     * @param url - the url to connect to, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    get(url: string): SseConnectActionBuilder;
+    /**
+     * Boostrap an action to connect the SSE with a POST request
+     *
+     * @param url - the url to connect to, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    post(url: string): SseConnectActionBuilder;
+    /**
+     * Boostrap an action to connect the SSE with a GET request
+     *
+     * @param url - the url to connect to, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    get(url: (session: Session) => string): SseConnectActionBuilder;
+    /**
+     * Boostrap an action to connect the SSE with a POST request
+     *
+     * @param url - the url to connect to, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    post(url: (session: Session) => string): SseConnectActionBuilder;
+    /**
+     * Boostrap an action to set a check
+     *
+     * @returns the next DSL step
+     */
+    setCheck(): SseSetCheckActionBuilder;
+    /**
+     * Create an action to close the stream
+     *
+     * @returns an ActionBuilder
+     */
+    close(): ActionBuilder;
+}
+export interface SseApply {
+    /**
+     * Bootstrap a <a
+     * href="https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events">SSE</a> request
+     * configuration
+     *
+     * @param name - the SSE request name, expressed as a Gatling Expression Language String
+     * @param sseName - the name of the SSE stream so multiple SSE streams for the same virtual users
+     *     don't conflict, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    (name: string, sseName?: string): Sse;
+}
+export interface SsePrefix {
+    /**
+     * Boostrap a SSE check
+     *
+     * @param name - the name of the check
+     * @returns the next DSL step
+     */
+    checkMessage(name: string): SseMessageCheck;
+    /**
+     * Process the currently buffered inbound SSE messages and empty the buffer
+     *
+     * @param f - the function to process the buffered messages
+     * @returns an ActionBuilder
+     */
+    processUnmatchedMessages(f: (messages: Array<SseInboundMessage>, session: Session) => Session): ActionBuilder;
+    /**
+     * Process the currently buffered inbound SSE messages and empty the buffer
+     *
+     * @param sseName - the name of the SSE stream, expressed as a Gatling Expression Language String
+     * @param f - the function to process the buffered messages
+     * @returns an ActionBuilder
+     */
+    processUnmatchedMessages(sseName: string, f: (messages: Array<SseInboundMessage>, session: Session) => Session): ActionBuilder;
+    /**
+     * Process the currently buffered inbound SSE messages and empty the buffer
+     *
+     * @param sseName - the name of the SSE stream, expressed as a function
+     * @param f - the function to process the buffered messages
+     * @returns an ActionBuilder
+     */
+    processUnmatchedMessages(sseName: (session: Session) => string, f: (messages: Array<SseInboundMessage>, session: Session) => Session): ActionBuilder;
+}
+export declare const sse: SseApply & SsePrefix;

package/target/sse.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sse = exports.wrapSseSetCheckActionBuilder = exports.wrapSseConnectActionBuilder = void 0;
+const core_1 = require("@gatling.io/core");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const request_1 = require("./request");
+const wrapUntypedCondition = (_underlying) => ({
+    then: (...thenChecks) => wrapSseMessageCheck(_underlying.then(thenChecks.map((cb) => cb._underlying)))
+});
+const wrapTypedCondition = (_underlying) => ({
+    then: (...thenChecks) => wrapSseMessageCheck(_underlying.then(thenChecks.map((cb) => cb._underlying)))
+});
+const wrapSseMessageCheck = (_underlying) => ({
+    _underlying,
+    matching: (...newMatchConditions) => wrapSseMessageCheck(_underlying.matching(newMatchConditions.map((cb) => cb._underlying))),
+    check: (...checks) => wrapSseMessageCheck(_underlying.check(checks.map((cb) => cb._underlying))),
+    checkIf: (condition) => {
+        if (typeof condition === "string") {
+            return wrapUntypedCondition(_underlying.checkIf(condition));
+        }
+        else if (typeof condition === "function") {
+            if (condition.length === 1) {
+                return wrapUntypedCondition(_underlying.checkIf((0, core_1.underlyingSessionTo)(condition)));
+            }
+            else if (condition.length === 2) {
+                return wrapTypedCondition(_underlying.checkIf((0, core_1.underlyingXWithSessionTo)(condition)));
+            }
+        }
+        throw Error(`checkIf() called with invalid argument ${condition}`);
+    }
+});
+const wrapSseAwaitActionBuilderOn = (jvmOn, wrap) => ({
+    on: (...checks) => wrap(jvmOn.on(checks.map((c) => c._underlying)))
+});
+const sseAwaitActionBuilderImpl = (jvmBuilder, wrap) => ({
+    await: (timeout) => {
+        if (typeof timeout === "string") {
+            return wrapSseAwaitActionBuilderOn(jvmBuilder.await(timeout), wrap);
+        }
+        else if (typeof timeout === "function") {
+            return wrapSseAwaitActionBuilderOn(jvmBuilder.await((0, core_1.underlyingSessionToDuration)(timeout)), wrap);
+        }
+        else if ((0, core_1.isDuration)(timeout)) {
+            return wrapSseAwaitActionBuilderOn(jvmBuilder.await((0, core_1.toJvmDuration)(timeout)), wrap);
+        }
+        throw Error(`await() called with invalid argument ${timeout}`);
+    }
+});
+const wrapSseConnectActionBuilder = (_underlying) => ({
+    _underlying,
+    ...(0, request_1.requestActionBuilderImpl)(_underlying, exports.wrapSseConnectActionBuilder),
+    ...(0, request_1.requestWithBodyActionBuilderImpl)(_underlying, exports.wrapSseConnectActionBuilder),
+    ...sseAwaitActionBuilderImpl(_underlying, exports.wrapSseConnectActionBuilder)
+});
+exports.wrapSseConnectActionBuilder = wrapSseConnectActionBuilder;
+const wrapSseSetCheckActionBuilder = (_underlying) => ({
+    _underlying,
+    ...sseAwaitActionBuilderImpl(_underlying, exports.wrapSseSetCheckActionBuilder)
+});
+exports.wrapSseSetCheckActionBuilder = wrapSseSetCheckActionBuilder;
+const wrapSse = (jvmSse) => ({
+    sseName: (sseName) => wrapSse(typeof sseName === "function" ? jvmSse.sseName((0, core_1.underlyingSessionTo)(sseName)) : jvmSse.sseName(sseName)),
+    get: (url) => (0, exports.wrapSseConnectActionBuilder)(typeof url === "function" ? jvmSse.get((0, core_1.underlyingSessionTo)(url)) : jvmSse.get(url)),
+    post: (url) => (0, exports.wrapSseConnectActionBuilder)(typeof url === "function" ? jvmSse.post((0, core_1.underlyingSessionTo)(url)) : jvmSse.post(url)),
+    setCheck: () => (0, exports.wrapSseSetCheckActionBuilder)(jvmSse.setCheck()),
+    close: () => (0, core_1.wrapActionBuilder)(jvmSse.close())
+});
+const sseApply = (name, sseName) => {
+    // Handle overloading
+    const jvmSse = typeof sseName === "undefined" ? jvm_types_1.HttpDsl.sse(name) : jvm_types_1.HttpDsl.sse(name, sseName);
+    return wrapSse(jvmSse);
+};
+const jvmSsePrefix = jvm_types_1.Sse$Prefix.INSTANCE;
+const ssePrefix = {
+    checkMessage: (name) => wrapSseMessageCheck(jvmSsePrefix.checkMessage(name)),
+    processUnmatchedMessages: (arg0, arg1) => {
+        if (arg1 !== undefined) {
+            // arg1 is the SseProcessUnmatchedMessagesCallback if it is defined
+            // arg0 is the sseName
+            const f = arg1;
+            if (typeof arg0 === "string") {
+                const sseName = arg0;
+                return (0, core_1.wrapActionBuilder)(jvmSsePrefix.processUnmatchedMessages(sseName, (0, core_1.underlyingXWithSessionToSession)(f)));
+            }
+            else if (typeof arg0 === "function") {
+                const sseName = arg0;
+                return (0, core_1.wrapActionBuilder)(jvmSsePrefix.processUnmatchedMessages((0, core_1.underlyingSessionTo)(sseName), (0, core_1.underlyingXWithSessionToSession)(f)));
+            }
+        }
+        else if (typeof arg0 === "function") {
+            // arg0 is the SseProcessUnmatchedMessagesCallback is arg1 is undefined
+            const f = arg0;
+            return (0, core_1.wrapActionBuilder)(jvmSsePrefix.processUnmatchedMessages((0, core_1.underlyingXWithSessionToSession)(f)));
+        }
+        throw Error(`processUnmatchedMessages() called with invalid arguments ${arg0}, ${arg1}`);
+    }
+};
+exports.sse = Object.assign(sseApply, ssePrefix);

package/target/ws.d.ts

@@ -0,0 +1,377 @@
+import { ActionBuilder, ChainBuilder, CheckBuilder, Duration, Session, Wrapper } from "@gatling.io/core";
+import { RequestActionBuilder } from "./request";
+import JvmWsFrameCheckBinary = io.gatling.javaapi.http.WsFrameCheck$Binary;
+import JvmWsFrameCheckText = io.gatling.javaapi.http.WsFrameCheck$Text;
+/**
+ * DSL for building WebSocket configurations
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface Ws {
+    /**
+     * Define a custom WebSocket name so multiple WebSockets for the same virtual users don't conflict
+     *
+     * @param wsName - the name, expressed as a Gatling Expression Language String
+     * @returns a new Ws instance
+     */
+    wsName(wsName: string): Ws;
+    /**
+     * Define a custom WebSocket name so multiple WebSockets for the same virtual users don't conflict
+     *
+     * @param wsName - the name, expressed as a function
+     * @returns a new Ws instance
+     */
+    wsName(wsName: (session: Session) => string): Ws;
+    /**
+     * Boostrap an action to connect the WebSocket
+     *
+     * @param url - the url to connect to, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    connect(url: string): WsConnectActionBuilder;
+    /**
+     * Boostrap an action to connect the WebSocket
+     *
+     * @param url - the url to connect to, expressed as a function
+     * @returns the next DSL step
+     */
+    connect(url: (session: Session) => string): WsConnectActionBuilder;
+    /**
+     * Boostrap an action to send a TEXT frame
+     *
+     * @param text - the text to send, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    sendText(text: string): WsSendTextActionBuilder;
+    /**
+     * Boostrap an action to send a TEXT frame
+     *
+     * @param text - the text to send, expressed as a function
+     * @returns the next DSL step
+     */
+    sendText(text: (session: Session) => string): WsSendTextActionBuilder;
+    /**
+     * Boostrap an action to send a BINARY frame
+     *
+     * @param bytes - the static bytes to send
+     * @returns the next DSL step
+     */
+    sendBytes(bytes: number[]): WsSendBinaryActionBuilder;
+    /**
+     * Boostrap an action to send a BINARY frame
+     *
+     * @param bytes - the bytes to send, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    sendBytes(bytes: string): WsSendBinaryActionBuilder;
+    /**
+     * Boostrap an action to send a BINARY frame
+     *
+     * @param bytes - the bytes to send, expressed as a function
+     * @returns the next DSL step
+     */
+    sendBytes(bytes: (session: Session) => number[]): WsSendBinaryActionBuilder;
+    /**
+     * Boostrap an action to send a CLOSE frame with the default 1000 status code
+     *
+     * @returns the next DSL step
+     */
+    close(): ActionBuilder;
+    /**
+     * Boostrap an action to send a CLOSE frame with specified status and reason
+     *
+     * @param statusCode - the close frame status code
+     * @param reason - the close frame reason
+     * @returns the next DSL step
+     */
+    close(statusCode: number, reason: string): ActionBuilder;
+}
+type WsProcessUnmatchedMessagesCallback = (messages: WsInboundMessage[], session: Session) => Session;
+export interface WsPrefix {
+    /**
+     * Bootstrap a check on inbound TEXT frames
+     *
+     * @param name - the name of the check, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    checkTextMessage(name: string): WsFrameCheckText;
+    /**
+     * Bootstrap a check on inbound TEXT frames
+     *
+     * @param name - the name of the check, expressed as a function
+     * @returns the next DSL step
+     */
+    checkTextMessage(name: (session: Session) => string): WsFrameCheckText;
+    /**
+     * Bootstrap a check on inbound BINARY frames
+     *
+     * @param name - the name of the check, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    checkBinaryMessage(name: string): WsFrameCheckBinary;
+    /**
+     * Bootstrap a check on inbound BINARY frames
+     *
+     * @param name - the name of the check, expressed as a function
+     * @returns the next DSL step
+     */
+    checkBinaryMessage(name: (session: Session) => string): WsFrameCheckBinary;
+    /**
+     * Process the currently buffered inbound WebSocket messages and empty the buffer
+     *
+     * @param f - the function to process the buffered messages
+     * @returns an ActionBuilder
+     */
+    processUnmatchedMessages(f: WsProcessUnmatchedMessagesCallback): ActionBuilder;
+    /**
+     * Process the currently buffered inbound WebSocket messages and empty the buffer
+     *
+     * @param wsName - the name of the WebSocket, expressed as a Gatling Expression Language String
+     * @param f - the function to process the buffered messages
+     * @returns an ActionBuilder
+     */
+    processUnmatchedMessages(wsName: string, f: WsProcessUnmatchedMessagesCallback): ActionBuilder;
+    /**
+     * Process the currently buffered inbound WebSocket messages and empty the buffer
+     *
+     * @param wsName - the name of the WebSocket, expressed as a function
+     * @param f - the function to process the buffered messages
+     * @returns an ActionBuilder
+     */
+    processUnmatchedMessages(wsName: (session: Session) => string, f: WsProcessUnmatchedMessagesCallback): ActionBuilder;
+}
+export interface WsAwaitActionBuilder<T> {
+    /**
+     * Boostrap a check that waits for a given duration
+     *
+     * @param timeout - the static wait duration
+     * @returns the next DSL step
+     */
+    await(timeout: Duration): WsAwaitActionBuilderOn<T>;
+    /**
+     * Boostrap a check that waits for a given duration
+     *
+     * @param timeout - the wait duration, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    await(timeout: string): WsAwaitActionBuilderOn<T>;
+    /**
+     * Boostrap a check that waits for a given duration
+     *
+     * @param timeout - the wait duration, expressed as a function
+     * @returns the next DSL step
+     */
+    await(timeout: (session: Session) => Duration): WsAwaitActionBuilderOn<T>;
+}
+export interface WsAwaitActionBuilderOn<T> {
+    /**
+     * Define the checks to wait on
+     *
+     * @param checks - the checks
+     * @returns a usable ActionBuilder
+     */
+    on(...checks: WsFrameCheck[]): T;
+}
+/**
+ * DSL for building WebSocket connect actions
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface WsConnectActionBuilder extends RequestActionBuilder<WsConnectActionBuilder>, WsAwaitActionBuilder<WsConnectActionBuilder>, ActionBuilder {
+    /**
+     * Define a WebSocket subprotocol
+     *
+     * @param sub - the subprotocol, expressed as a Gatling Expression Language String
+     * @returns a new WsConnectActionBuilder instance
+     */
+    subprotocol(sub: string): WsConnectActionBuilder;
+    /**
+     * Define a WebSocket subprotocol
+     *
+     * @param sub - the subprotocol, expressed as a function
+     * @returns a new WsConnectActionBuilder instance
+     */
+    subprotocol(sub: (session: Session) => string): WsConnectActionBuilder;
+    /**
+     * Define a chain to execute when the WebSocket gets connected or re-connected
+     *
+     * @param chain - the chain
+     * @returns a new WsConnectActionBuilder instance
+     */
+    onConnected(chain: ChainBuilder): WsConnectActionBuilder;
+}
+/**
+ * DSL for building actions to send TEXT frames
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface WsSendTextActionBuilder extends WsAwaitActionBuilder<WsSendTextActionBuilder>, ActionBuilder {
+}
+/**
+ * DSL for building actions to send BINARY frames
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface WsSendBinaryActionBuilder extends WsAwaitActionBuilder<WsSendBinaryActionBuilder>, ActionBuilder {
+}
+export type WsFrameCheck = WsFrameCheckBinary | WsFrameCheckText;
+/**
+ * DSL for building WebSocket BINARY frames checks
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface WsFrameCheckBinary extends Wrapper<JvmWsFrameCheckBinary> {
+    /**
+     * Define conditions that have to hold true to match inbound messages and apply the checks on
+     * them
+     *
+     * @param newMatchConditions - the conditions to match
+     * @returns a new Binary instance
+     */
+    matching(...newMatchConditions: CheckBuilder[]): WsFrameCheckBinary;
+    /**
+     * Define the checks to apply on inbound messages
+     *
+     * @param checks - the checks
+     * @returns a new Binary instance
+     */
+    check(...checks: CheckBuilder[]): WsFrameCheckBinary;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a function
+     * @returns the next DSL step
+     */
+    checkIf(condition: (session: Session) => boolean): WsFrameCheckBinaryUntypedCondition;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    checkIf(condition: string): WsFrameCheckBinaryUntypedCondition;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a function that's aware of the HTTP response and
+     *     the Session
+     * @returns the next DSL step
+     */
+    checkIf(condition: (response: number[], session: Session) => boolean): WsFrameCheckBinaryTypedCondition;
+    /**
+     * Make the check silent, not logged by the reporting engine
+     *
+     * @returns a new Binary instance
+     */
+    silent(): WsFrameCheckBinary;
+}
+export interface WsFrameCheckBinaryUntypedCondition {
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param thenChecks - the checks
+     * @returns a new Binary instance
+     */
+    then(...thenChecks: CheckBuilder[]): WsFrameCheckBinary;
+}
+export interface WsFrameCheckBinaryTypedCondition {
+    /**
+     * Define the checks to apply when the condition holds true.
+     *
+     * @param thenChecks - the checks
+     * @returns a new Binary instance
+     */
+    then(...thenChecks: CheckBuilder[]): WsFrameCheckBinary;
+}
+/**
+ * DSL for building WebSocket TEXT frames checks
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface WsFrameCheckText extends Wrapper<JvmWsFrameCheckText> {
+    /**
+     * Define conditions that have to hold true to match inbound messages and apply the checks on
+     * them
+     *
+     * @param newMatchConditions - the conditions to match
+     * @returns a new Text instance
+     */
+    matching(...newMatchConditions: CheckBuilder[]): WsFrameCheckText;
+    /**
+     * Define the checks to apply on inbound messages
+     *
+     * @param checks - the checks
+     * @returns a new Text instance
+     */
+    check(...checks: CheckBuilder[]): WsFrameCheckText;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a function
+     * @returns the next DSL step
+     */
+    checkIf(condition: (session: Session) => boolean): WsFrameCheckTextUntypedCondition;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    checkIf(condition: string): WsFrameCheckTextUntypedCondition;
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param condition - a condition, expressed as a function that's aware of the HTTP response and
+     *     the Session
+     * @returns the next DSL step
+     */
+    checkIf(condition: (response: string, session: Session) => boolean): WsFrameCheckTextTypedCondition;
+    /**
+     * Make the check silent, not logged by the reporting engine
+     *
+     * @returns a new Text instance
+     */
+    silent(): WsFrameCheckText;
+}
+export interface WsFrameCheckTextUntypedCondition {
+    /**
+     * Define the checks to apply on inbound messages when a condition holds true.
+     *
+     * @param thenChecks - the checks
+     * @returns a new Text instance
+     */
+    then(...thenChecks: CheckBuilder[]): WsFrameCheckText;
+}
+export interface WsFrameCheckTextTypedCondition {
+    /**
+     * Define the checks to apply when the condition holds true.
+     *
+     * @param thenChecks - the checks
+     * @returns a new Text instance
+     */
+    then(...thenChecks: CheckBuilder[]): WsFrameCheckText;
+}
+export type WsInboundMessage = WsInboundMessageBinary | WsInboundMessageText;
+export interface WsInboundMessageBinary {
+    timestamp(): number;
+    message(): number[];
+}
+export declare const isWsInboundMessageBinary: (message: WsInboundMessage) => message is WsInboundMessageBinary;
+export interface WsInboundMessageText {
+    timestamp(): number;
+    message(): string;
+}
+export declare const isWsInboundMessageText: (message: WsInboundMessage) => message is WsInboundMessageText;
+export interface WsApply {
+    /**
+     * Bootstrap a WebSocket request configuration
+     *
+     * @param name - the WebSocket request name, expressed as a Gatling Expression Language String
+     * @param wsName - the name of the WebSocket so multiple WebSockets for the same virtual users don't
+     *     conflict, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    (name: string, wsName?: string): Ws;
+}
+export declare const ws: WsApply & WsPrefix;
+export {};

package/target/ws.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ws = exports.isWsInboundMessageText = exports.isWsInboundMessageBinary = void 0;
+const core_1 = require("@gatling.io/core");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const request_1 = require("./request");
+const jvmWsPrefix = jvm_types_1.Ws$Prefix.INSTANCE;
+const wsPrefix = {
+    checkBinaryMessage: (name) => wrapWsFrameCheckBinary(typeof name === "function"
+        ? jvmWsPrefix.checkBinaryMessage((0, core_1.underlyingSessionTo)(name))
+        : jvmWsPrefix.checkBinaryMessage(name)),
+    checkTextMessage: (name) => wrapWsFrameCheckText(typeof name === "function"
+        ? jvmWsPrefix.checkTextMessage((0, core_1.underlyingSessionTo)(name))
+        : jvmWsPrefix.checkTextMessage(name)),
+    processUnmatchedMessages: (arg0, arg1) => {
+        if (arg1 !== undefined) {
+            // arg1 is the WsProcessUnmatchedMessagesCallback if it is defined
+            // arg0 is the sseName
+            const f = arg1;
+            if (typeof arg0 === "string") {
+                const sseName = arg0;
+                return (0, core_1.wrapActionBuilder)(jvmWsPrefix.processUnmatchedMessages(sseName, (0, core_1.underlyingXWithSessionToSession)(f)));
+            }
+            else if (typeof arg0 === "function") {
+                const sseName = arg0;
+                return (0, core_1.wrapActionBuilder)(jvmWsPrefix.processUnmatchedMessages((0, core_1.underlyingSessionTo)(sseName), (0, core_1.underlyingXWithSessionToSession)(f)));
+            }
+        }
+        else if (typeof arg0 === "function") {
+            // arg0 is the SseProcessUnmatchedMessagesCallback if arg1 is undefined
+            const f = arg0;
+            return (0, core_1.wrapActionBuilder)(jvmWsPrefix.processUnmatchedMessages((0, core_1.underlyingXWithSessionToSession)(f)));
+        }
+        throw Error(`processUnmatchedMessages() called with invalid arguments ${arg0}, ${arg1}`);
+    }
+};
+const wsAwaitActionBuilderImpl = (jvmBuilder, wrap) => ({
+    await: (timeout) => wrapWsAwaitActionBuilderOn((0, core_1.isDuration)(timeout)
+        ? jvmBuilder.await((0, core_1.toJvmDuration)(timeout))
+        : typeof timeout === "function"
+            ? jvmBuilder.await((0, core_1.underlyingSessionToDuration)(timeout))
+            : jvmBuilder.await(timeout), wrap)
+});
+const wrapWsAwaitActionBuilderOn = (jvmOn, wrap) => ({
+    on: (...checks) => wrap(jvmOn.on(checks.map((c) => c._underlying)))
+});
+const wrapWsConnectActionBuilder = (_underlying) => ({
+    _underlying,
+    subprotocol: (sub) => wrapWsConnectActionBuilder(typeof sub === "function" ? _underlying.subprotocol((0, core_1.underlyingSessionTo)(sub)) : _underlying.subprotocol(sub)),
+    onConnected: (chain) => wrapWsConnectActionBuilder(_underlying.onConnected(chain._underlying)),
+    ...(0, request_1.requestActionBuilderImpl)(_underlying, wrapWsConnectActionBuilder),
+    ...wsAwaitActionBuilderImpl(_underlying, wrapWsConnectActionBuilder)
+});
+const wrapWsSendTextActionBuilder = (_underlying) => ({
+    _underlying,
+    ...wsAwaitActionBuilderImpl(_underlying, wrapWsSendTextActionBuilder)
+});
+const wrapWsSendBinaryActionBuilder = (_underlying) => ({
+    _underlying,
+    ...wsAwaitActionBuilderImpl(_underlying, wrapWsSendBinaryActionBuilder)
+});
+const wrapWsFrameCheckBinary = (_underlying) => ({
+    _underlying,
+    matching: (...newMatchConditions) => wrapWsFrameCheckBinary(_underlying.check(newMatchConditions.map((cb) => cb._underlying))),
+    check: (...checks) => wrapWsFrameCheckBinary(_underlying.check(checks.map((cb) => cb._underlying))),
+    checkIf: (condition) => {
+        if (typeof condition === "function") {
+            if (condition.length === 1) {
+                return wrapWsFrameCheckBinaryUntypedCondition(_underlying.checkIf((0, core_1.underlyingSessionTo)(condition)));
+            }
+            else {
+                return wrapWsFrameCheckBinaryTypedCondition(_underlying.checkIf((0, core_1.underlyingXWithSessionTo)(condition)));
+            }
+        }
+        else {
+            return wrapWsFrameCheckBinaryUntypedCondition(_underlying.checkIf(condition));
+        }
+    },
+    silent: () => wrapWsFrameCheckBinary(_underlying.silent())
+});
+const wrapWsFrameCheckBinaryUntypedCondition = (_underlying) => ({
+    then: (...thenChecks) => wrapWsFrameCheckBinary(_underlying.then(thenChecks.map((cb) => cb._underlying)))
+});
+const wrapWsFrameCheckBinaryTypedCondition = (_underlying) => ({
+    then: (...thenChecks) => wrapWsFrameCheckBinary(_underlying.then(thenChecks.map((cb) => cb._underlying)))
+});
+const wrapWsFrameCheckText = (_underlying) => ({
+    _underlying,
+    matching: (...newMatchConditions) => wrapWsFrameCheckText(_underlying.check(newMatchConditions.map((cb) => cb._underlying))),
+    check: (...checks) => wrapWsFrameCheckText(_underlying.check(checks.map((cb) => cb._underlying))),
+    checkIf: (condition) => {
+        if (typeof condition === "function") {
+            if (condition.length === 1) {
+                return wrapWsFrameCheckTextUntypedCondition(_underlying.checkIf((0, core_1.underlyingSessionTo)(condition)));
+            }
+            else {
+                return wrapWsFrameCheckTextTypedCondition(_underlying.checkIf((0, core_1.underlyingXWithSessionTo)(condition)));
+            }
+        }
+        else {
+            return wrapWsFrameCheckTextUntypedCondition(_underlying.checkIf(condition));
+        }
+    },
+    silent: () => wrapWsFrameCheckText(_underlying.silent())
+});
+const wrapWsFrameCheckTextUntypedCondition = (_underlying) => ({
+    then: (...thenChecks) => wrapWsFrameCheckText(_underlying.then(thenChecks.map((cb) => cb._underlying)))
+});
+const wrapWsFrameCheckTextTypedCondition = (_underlying) => ({
+    then: (...thenChecks) => wrapWsFrameCheckText(_underlying.then(thenChecks.map((cb) => cb._underlying)))
+});
+const isWsInboundMessageBinary = (message) => typeof message.message() !== "string";
+exports.isWsInboundMessageBinary = isWsInboundMessageBinary;
+const isWsInboundMessageText = (message) => typeof message.message() === "string";
+exports.isWsInboundMessageText = isWsInboundMessageText;
+const wrapWs = (jvmWs) => ({
+    wsName: (wsName) => wrapWs(typeof wsName === "function" ? jvmWs.wsName((0, core_1.underlyingSessionTo)(wsName)) : jvmWs.wsName(wsName)),
+    connect: (url) => wrapWsConnectActionBuilder(typeof url === "function" ? jvmWs.connect((0, core_1.underlyingSessionTo)(url)) : jvmWs.connect(url)),
+    sendText: (text) => wrapWsSendTextActionBuilder(typeof text === "function" ? jvmWs.sendText((0, core_1.underlyingSessionTo)(text)) : jvmWs.sendText(text)),
+    sendBytes: (bytes) => wrapWsSendBinaryActionBuilder(typeof bytes === "function"
+        ? jvmWs.sendBytes((0, core_1.underlyingSessionTo)(bytes))
+        : typeof bytes === "string"
+            ? jvmWs.sendBytes(bytes)
+            : jvmWs.sendBytes(bytes)),
+    close: () => (0, core_1.wrapActionBuilder)(jvmWs.close())
+});
+const wsApply = (name, wsName) => {
+    const jvmWs = wsName === undefined ? jvm_types_1.HttpDsl.ws(name) : jvm_types_1.HttpDsl.ws(name, wsName);
+    return wrapWs(jvmWs);
+};
+exports.ws = Object.assign(wsApply, wsPrefix);