@gatling.io/grpc 3.14.600

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,19 @@
+# Gatling JS - gRPC module
+
+Gatling JS is a JavaScript/TypeScript interface for the [Gatling load testing tool](https://gatling.io/).
+
+This package contains the Gatling JS DSL for [the gRPC protocol](https://docs.gatling.io/reference/script/grpc/protocol/).
+
+To get started with Gatling JS, see our [introduction to JavaScript scripting](https://docs.gatling.io/tutorials/scripting-intro-js);
+or simply have a look at our demo projects:
+
+- https://github.com/gatling/gatling-js-demo
+- https://github.com/gatling/gatling-grpc-demo
+
+## Questions, help?
+
+Read the [documentation](https://docs.gatling.io).
+
+Join the [Gatling Community Forum](https://community.gatling.io).
+
+Found a real bug? Raise an [issue](https://github.com/gatling/gatling/issues).

package/jest.config.js

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

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@gatling.io/grpc",
+  "version": "3.14.600",
+  "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/core": "3.14.600",
+    "@gatling.io/jvm-types": "3.14.600"
+  },
+  "devDependencies": {
+    "@types/jest": "30.0.0",
+    "jest": "30.1.3",
+    "prettier": "3.6.2",
+    "rimraf": "6.0.1",
+    "ts-jest": "29.4.1",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.2"
+  },
+  "scripts": {
+    "clean": "rimraf target",
+    "format": "prettier --write '**/*.ts'",
+    "format-check": "prettier --check '**/*.ts'",
+    "test": "jest",
+    "build": "tsc -p ."
+  }
+}

package/target/bidiStream.d.ts

@@ -0,0 +1,23 @@
+import { ActionBuilder, CheckBuilder, Duration, Session } from "@gatling.io/core";
+import { MessageResponseTimePolicy } from "./grpc";
+import { GrpcHeaders } from "./headers";
+import JvmDescriptorsDescriptor = com.google.protobuf.Descriptors$Descriptor;
+import JvmGrpcBidirectionalStreamingServiceBuilder = io.gatling.javaapi.grpc.GrpcBidirectionalStreamingServiceBuilder;
+export interface GrpcBidiStreamAwaitStreamEndActionBuilder extends ActionBuilder {
+}
+export interface GrpcBidirectionalStreamingServiceBuilder extends GrpcHeaders<GrpcBidirectionalStreamingServiceBuilder> {
+    check(...checks: CheckBuilder[]): GrpcBidirectionalStreamingServiceBuilder;
+    deadlineAfter(duration: Duration): GrpcBidirectionalStreamingServiceBuilder;
+    messageRequestName(messageRequestName: string): GrpcBidirectionalStreamingServiceBuilder;
+    messageRequestName(messageRequestName: (session: Session) => string): GrpcBidirectionalStreamingServiceBuilder;
+    messageResponseTimePolicy(messageResponseTimePolicy: MessageResponseTimePolicy): GrpcBidirectionalStreamingServiceBuilder;
+    streamName(streamName: string): GrpcBidirectionalStreamingServiceBuilder;
+    start(): ActionBuilder;
+    send(request: any): ActionBuilder;
+    send(request: (session: Session) => any): ActionBuilder;
+    halfClose(): ActionBuilder;
+    awaitStreamEnd(): GrpcBidiStreamAwaitStreamEndActionBuilder;
+    awaitStreamEnd(reconcile: (main: Session, forked: Session) => Session): GrpcBidiStreamAwaitStreamEndActionBuilder;
+    cancel(): ActionBuilder;
+}
+export declare const wrapGrpcBidirectionalStreamingServiceBuilder: (inputDescriptor: JvmDescriptorsDescriptor) => ((_underlying: JvmGrpcBidirectionalStreamingServiceBuilder<any, any>) => GrpcBidirectionalStreamingServiceBuilder);

package/target/bidiStream.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapGrpcBidirectionalStreamingServiceBuilder = void 0;
+const core_1 = require("@gatling.io/core");
+const dynamic_1 = require("./dynamic");
+const grpc_1 = require("./grpc");
+const headers_1 = require("./headers");
+const wrapGrpcBidiStreamAwaitStreamEndActionBuilder = (_underlying) => (0, core_1.wrapActionBuilder)(_underlying);
+const wrapGrpcBidirectionalStreamingServiceBuilder = (inputDescriptor) => (_underlying) => {
+    const toJvmDynamicMessage = (0, dynamic_1.wrapToJvmDynamicMessage)(inputDescriptor);
+    const wrap = (0, exports.wrapGrpcBidirectionalStreamingServiceBuilder)(inputDescriptor);
+    return {
+        ...(0, headers_1.wrapGrpcHeaders)(_underlying, wrap),
+        // Chainable methods / global stream configuration
+        // FIXME callCredentials
+        check: (...checks) => wrap(_underlying.check(checks.map((check) => check._underlying))),
+        deadlineAfter: (duration) => {
+            if ((0, core_1.isDuration)(duration)) {
+                return wrap(_underlying.deadlineAfter((0, core_1.toJvmDuration)(duration)));
+            }
+            throw Error(`deadlineAfter() called with invalid argument ${duration}`);
+        },
+        messageRequestName: (messageRequestName) => wrap(typeof messageRequestName === "function"
+            ? _underlying.messageRequestName((0, core_1.underlyingSessionTo)(messageRequestName))
+            : _underlying.messageRequestName(messageRequestName)),
+        messageResponseTimePolicy: (messageResponseTimePolicy) => wrap(_underlying.messageResponseTimePolicy((0, grpc_1.toJvmMessageResponseTimePolicy)(messageResponseTimePolicy))),
+        streamName: (streamName) => wrap(_underlying.streamName(streamName)),
+        // Terminal methods / specific actions
+        start: () => (0, core_1.wrapActionBuilder)(_underlying.start()),
+        send: (request) => {
+            return (0, core_1.wrapActionBuilder)(typeof request === "function"
+                ? _underlying.send((0, dynamic_1.underlyingSessionToJvmDynamicMessage)(request, toJvmDynamicMessage))
+                : _underlying.send(toJvmDynamicMessage(request)));
+        },
+        halfClose: () => (0, core_1.wrapActionBuilder)(_underlying.halfClose()),
+        awaitStreamEnd: (reconcile) => wrapGrpcBidiStreamAwaitStreamEndActionBuilder(typeof reconcile === "function"
+            ? _underlying.awaitStreamEnd((0, core_1.underlyingBiSessionTransform)(reconcile))
+            : _underlying.awaitStreamEnd()),
+        cancel: () => (0, core_1.wrapActionBuilder)(_underlying.cancel())
+    };
+};
+exports.wrapGrpcBidirectionalStreamingServiceBuilder = wrapGrpcBidirectionalStreamingServiceBuilder;

package/target/checks.d.ts

@@ -0,0 +1,9 @@
+import { CheckBuilderFind, CheckBuilderMultipleFind } from "@gatling.io/core";
+import { Status } from "./grpc";
+export declare const statusCode: () => CheckBuilderFind<Status.Code>;
+export declare const statusDescription: () => CheckBuilderFind<string>;
+export declare const asciiHeader: (key: string) => CheckBuilderMultipleFind<string>;
+export declare const binaryHeader: (key: string) => CheckBuilderMultipleFind<number[]>;
+export declare const asciiTrailer: (key: string) => CheckBuilderMultipleFind<string>;
+export declare const binaryTrailer: (key: string) => CheckBuilderMultipleFind<number[]>;
+export declare const response: (transform: (x: any) => any) => CheckBuilderFind<any>;

package/target/checks.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = exports.binaryTrailer = exports.asciiTrailer = exports.binaryHeader = exports.asciiHeader = exports.statusDescription = exports.statusCode = void 0;
+const core_1 = require("@gatling.io/core");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const dynamic_1 = require("./dynamic");
+const grpc_1 = require("./grpc");
+const statusCode = () => (0, core_1.wrapCheckBuilderFind)(grpc_1.GrpcDslAddons.statusCodeAsString());
+exports.statusCode = statusCode;
+const statusDescription = () => (0, core_1.wrapCheckBuilderFind)(jvm_types_1.GrpcDsl.statusDescription());
+exports.statusDescription = statusDescription;
+const asciiHeader = (key) => (0, core_1.wrapCheckBuilderMultipleFind)(jvm_types_1.GrpcDsl.asciiHeader(key));
+exports.asciiHeader = asciiHeader;
+// FIXME Uint8Array?
+const binaryHeader = (key) => (0, core_1.wrapCheckBuilderMultipleFind)(jvm_types_1.GrpcDsl.binaryHeader(key));
+exports.binaryHeader = binaryHeader;
+const asciiTrailer = (key) => (0, core_1.wrapCheckBuilderMultipleFind)(jvm_types_1.GrpcDsl.asciiTrailer(key));
+exports.asciiTrailer = asciiTrailer;
+const binaryTrailer = (key) => (0, core_1.wrapCheckBuilderMultipleFind)(jvm_types_1.GrpcDsl.binaryTrailer(key));
+exports.binaryTrailer = binaryTrailer;
+const response = (transform) => (0, core_1.wrapCheckBuilderFind)(jvm_types_1.GrpcDsl.response((0, dynamic_1.transformJvmDynamicMessage)(transform)));
+exports.response = response;

package/target/clientStream.d.ts

@@ -0,0 +1,23 @@
+import { ActionBuilder, CheckBuilder, Duration, Session } from "@gatling.io/core";
+import { GrpcHeaders } from "./headers";
+import { MessageResponseTimePolicy } from "./grpc";
+import JvmDescriptorsDescriptor = com.google.protobuf.Descriptors$Descriptor;
+import JvmGrpcClientStreamingServiceBuilder = io.gatling.javaapi.grpc.GrpcClientStreamingServiceBuilder;
+export interface GrpcClientStreamAwaitStreamEndActionBuilder extends ActionBuilder {
+}
+export interface GrpcClientStreamingServiceBuilder extends GrpcHeaders<GrpcClientStreamingServiceBuilder> {
+    check(...checks: CheckBuilder[]): GrpcClientStreamingServiceBuilder;
+    deadlineAfter(duration: Duration): GrpcClientStreamingServiceBuilder;
+    messageRequestName(messageRequestName: string): GrpcClientStreamingServiceBuilder;
+    messageRequestName(messageRequestName: (session: Session) => string): GrpcClientStreamingServiceBuilder;
+    messageResponseTimePolicy(messageResponseTimePolicy: MessageResponseTimePolicy): GrpcClientStreamingServiceBuilder;
+    streamName(streamName: string): GrpcClientStreamingServiceBuilder;
+    start(): ActionBuilder;
+    send(request: any): ActionBuilder;
+    send(request: (session: Session) => any): ActionBuilder;
+    halfClose(): ActionBuilder;
+    awaitStreamEnd(): GrpcClientStreamAwaitStreamEndActionBuilder;
+    awaitStreamEnd(reconcile: (main: Session, forked: Session) => Session): GrpcClientStreamAwaitStreamEndActionBuilder;
+    cancel(): ActionBuilder;
+}
+export declare const wrapGrpcClientStreamingServiceBuilder: (inputDescriptor: JvmDescriptorsDescriptor) => ((_underlying: JvmGrpcClientStreamingServiceBuilder<any, any>) => GrpcClientStreamingServiceBuilder);

package/target/clientStream.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapGrpcClientStreamingServiceBuilder = void 0;
+const core_1 = require("@gatling.io/core");
+const dynamic_1 = require("./dynamic");
+const headers_1 = require("./headers");
+const grpc_1 = require("./grpc");
+const wrapGrpcClientStreamAwaitStreamEndActionBuilder = (_underlying) => (0, core_1.wrapActionBuilder)(_underlying);
+const wrapGrpcClientStreamingServiceBuilder = (inputDescriptor) => (_underlying) => {
+    const toJvmDynamicMessage = (0, dynamic_1.wrapToJvmDynamicMessage)(inputDescriptor);
+    const wrap = (0, exports.wrapGrpcClientStreamingServiceBuilder)(inputDescriptor);
+    return {
+        ...(0, headers_1.wrapGrpcHeaders)(_underlying, wrap),
+        // Chainable methods / global stream configuration
+        // FIXME callCredentials
+        check: (...checks) => wrap(_underlying.check(checks.map((check) => check._underlying))),
+        deadlineAfter: (duration) => {
+            if ((0, core_1.isDuration)(duration)) {
+                return wrap(_underlying.deadlineAfter((0, core_1.toJvmDuration)(duration)));
+            }
+            throw Error(`deadlineAfter() called with invalid argument ${duration}`);
+        },
+        messageRequestName: (messageRequestName) => wrap(typeof messageRequestName === "function"
+            ? _underlying.messageRequestName((0, core_1.underlyingSessionTo)(messageRequestName))
+            : _underlying.messageRequestName(messageRequestName)),
+        messageResponseTimePolicy: (messageResponseTimePolicy) => wrap(_underlying.messageResponseTimePolicy((0, grpc_1.toJvmMessageResponseTimePolicy)(messageResponseTimePolicy))),
+        streamName: (streamName) => wrap(_underlying.streamName(streamName)),
+        // Terminal methods / specific actions
+        start: () => (0, core_1.wrapActionBuilder)(_underlying.start()),
+        send: (request) => {
+            return (0, core_1.wrapActionBuilder)(typeof request === "function"
+                ? _underlying.send((0, dynamic_1.underlyingSessionToJvmDynamicMessage)(request, toJvmDynamicMessage))
+                : _underlying.send(toJvmDynamicMessage(request)));
+        },
+        halfClose: () => (0, core_1.wrapActionBuilder)(_underlying.halfClose()),
+        awaitStreamEnd: (reconcile) => wrapGrpcClientStreamAwaitStreamEndActionBuilder(typeof reconcile === "function"
+            ? _underlying.awaitStreamEnd((0, core_1.underlyingBiSessionTransform)(reconcile))
+            : _underlying.awaitStreamEnd()),
+        cancel: () => (0, core_1.wrapActionBuilder)(_underlying.cancel())
+    };
+};
+exports.wrapGrpcClientStreamingServiceBuilder = wrapGrpcClientStreamingServiceBuilder;

package/target/dynamic.d.ts

@@ -0,0 +1,17 @@
+import { SessionTo } from "@gatling.io/core";
+import JvmDescriptorsDescriptor = com.google.protobuf.Descriptors$Descriptor;
+import JvmSession = io.gatling.javaapi.core.Session;
+export interface JvmGrpcMethodDescriptorWrapper {
+    inputDescriptor(): JvmDescriptorsDescriptor;
+    outputDescriptor(): JvmDescriptorsDescriptor;
+    descriptor(): any;
+}
+export interface JvmGrpcDynamicStatic {
+    convertFromMessage(message: any): Record<string, any>;
+    convertToMessage(input: Record<string, any>, descriptor: JvmDescriptorsDescriptor): any;
+    loadMethodDescriptor(pkg: string | null, service: string, method: string): JvmGrpcMethodDescriptorWrapper;
+}
+export declare const GrpcDynamic: JvmGrpcDynamicStatic;
+export declare const transformJvmDynamicMessage: (f: (x: any) => any) => ((dynamicMessage: any) => any);
+export declare const wrapToJvmDynamicMessage: (inputDescriptor: JvmDescriptorsDescriptor) => (request: Record<string, any>) => any;
+export declare const underlyingSessionToJvmDynamicMessage: (f: SessionTo<any>, toJvmDynamicMessage: (request: any) => any) => ((jvmSession: JvmSession) => any);

package/target/dynamic.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.underlyingSessionToJvmDynamicMessage = exports.wrapToJvmDynamicMessage = exports.transformJvmDynamicMessage = exports.GrpcDynamic = void 0;
+const core_1 = require("@gatling.io/core");
+exports.GrpcDynamic = Java.type("io.gatling.javaapi.grpc.GrpcDynamic");
+const transformJvmDynamicMessage = (f) => (dynamicMessage) => f(exports.GrpcDynamic.convertFromMessage(dynamicMessage));
+exports.transformJvmDynamicMessage = transformJvmDynamicMessage;
+const wrapToJvmDynamicMessage = (inputDescriptor) => (request) => exports.GrpcDynamic.convertToMessage(request, inputDescriptor);
+exports.wrapToJvmDynamicMessage = wrapToJvmDynamicMessage;
+const underlyingSessionToJvmDynamicMessage = (f, toJvmDynamicMessage) => (jvmSession) => toJvmDynamicMessage(f((0, core_1.wrapSession)(jvmSession)));
+exports.underlyingSessionToJvmDynamicMessage = underlyingSessionToJvmDynamicMessage;

package/target/grpc.d.ts

@@ -0,0 +1,151 @@
+import { SessionTo } from "@gatling.io/core";
+import JvmChannelCredentials = io.grpc.ChannelCredentials;
+import JvmCheckBuilderFind = io.gatling.javaapi.core.CheckBuilder$Find;
+import JvmGrpcDslMessageResponseTimePolicy = io.gatling.javaapi.grpc.GrpcDsl$MessageResponseTimePolicy;
+import JvmGrpcProtocolBuilder = io.gatling.javaapi.grpc.GrpcProtocolBuilder;
+import JvmSession = io.gatling.javaapi.core.Session;
+export interface GrpcDslAddonsStatic {
+    statusCodeAsString(): JvmCheckBuilderFind<Status.Code>;
+    channelCredentials(rootCerts?: string, certChain?: string, privateKey?: string): JvmChannelCredentials;
+    channelCredentialsEL(protocol: JvmGrpcProtocolBuilder, credentials: string): JvmGrpcProtocolBuilder;
+}
+export declare const GrpcDslAddons: GrpcDslAddonsStatic;
+export interface CallCredentials {
+}
+export interface ChannelCredentials {
+    rootCerts?: string;
+    certChain?: string;
+    privateKey?: string;
+}
+export declare const toJvmCredentials: (credentials: ChannelCredentials) => JvmChannelCredentials;
+export declare const underlyingSessionToCredentials: (f: SessionTo<ChannelCredentials>) => ((jvmSession: JvmSession) => JvmChannelCredentials);
+export type MessageResponseTimePolicy = "FROM_STREAM_START" | "FROM_LAST_MESSAGE_SENT" | "FROM_LAST_MESSAGE_RECEIVED";
+export declare const toJvmMessageResponseTimePolicy: (policy: MessageResponseTimePolicy) => JvmGrpcDslMessageResponseTimePolicy;
+export declare namespace Status {
+    type Code = 
+    /**
+     * The operation completed successfully.
+     */
+    "OK"
+    /**
+     * The operation was cancelled (typically by the caller).
+     */
+     | "CANCELLED"
+    /**
+     * Unknown error.  An example of where this error may be returned is
+     * if a Status value received from another address space belongs to
+     * an error-space that is not known in this address space.  Also
+     * errors raised by APIs that do not return enough error information
+     * may be converted to this error.
+     */
+     | "UNKNOWN"
+    /**
+     * Client specified an invalid argument.  Note that this differs
+     * from FAILED_PRECONDITION.  INVALID_ARGUMENT indicates arguments
+     * that are problematic regardless of the state of the system
+     * (e.g., a malformed file name).
+     */
+     | "INVALID_ARGUMENT"
+    /**
+     * Deadline expired before operation could complete.  For operations
+     * that change the state of the system, this error may be returned
+     * even if the operation has completed successfully.  For example, a
+     * successful response from a server could have been delayed long
+     * enough for the deadline to expire.
+     */
+     | "DEADLINE_EXCEEDED"
+    /**
+     * Some requested entity (e.g., file or directory) was not found.
+     */
+     | "NOT_FOUND"
+    /**
+     * Some entity that we attempted to create (e.g., file or directory) already exists.
+     */
+     | "ALREADY_EXISTS"
+    /**
+     * The caller does not have permission to execute the specified
+     * operation.  PERMISSION_DENIED must not be used for rejections
+     * caused by exhausting some resource (use RESOURCE_EXHAUSTED
+     * instead for those errors).  PERMISSION_DENIED must not be
+     * used if the caller cannot be identified (use UNAUTHENTICATED
+     * instead for those errors).
+     */
+     | "PERMISSION_DENIED"
+    /**
+     * Some resource has been exhausted, perhaps a per-user quota, or
+     * perhaps the entire file system is out of space.
+     */
+     | "RESOURCE_EXHAUSTED"
+    /**
+     * Operation was rejected because the system is not in a state
+     * required for the operation's execution.  For example, directory
+     * to be deleted may be non-empty, an rmdir operation is applied to
+     * a non-directory, etc.
+     *
+     * <p>A litmus test that may help a service implementor in deciding
+     * between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
+     * (a) Use UNAVAILABLE if the client can retry just the failing call.
+     * (b) Use ABORTED if the client should retry at a higher-level
+     * (e.g., restarting a read-modify-write sequence).
+     * (c) Use FAILED_PRECONDITION if the client should not retry until
+     * the system state has been explicitly fixed.  E.g., if an "rmdir"
+     * fails because the directory is non-empty, FAILED_PRECONDITION
+     * should be returned since the client should not retry unless
+     * they have first fixed up the directory by deleting files from it.
+     */
+     | "FAILED_PRECONDITION"
+    /**
+     * The operation was aborted, typically due to a concurrency issue
+     * like sequencer check failures, transaction aborts, etc.
+     *
+     * <p>See litmus test above for deciding between FAILED_PRECONDITION,
+     * ABORTED, and UNAVAILABLE.
+     */
+     | "ABORTED"
+    /**
+     * Operation was attempted past the valid range.  E.g., seeking or
+     * reading past end of file.
+     *
+     * <p>Unlike INVALID_ARGUMENT, this error indicates a problem that may
+     * be fixed if the system state changes. For example, a 32-bit file
+     * system will generate INVALID_ARGUMENT if asked to read at an
+     * offset that is not in the range [0,2^32-1], but it will generate
+     * OUT_OF_RANGE if asked to read from an offset past the current
+     * file size.
+     *
+     * <p>There is a fair bit of overlap between FAILED_PRECONDITION and OUT_OF_RANGE.
+     * We recommend using OUT_OF_RANGE (the more specific error) when it applies
+     * so that callers who are iterating through
+     * a space can easily look for an OUT_OF_RANGE error to detect when they are done.
+     */
+     | "OUT_OF_RANGE"
+    /**
+     * Operation is not implemented or not supported/enabled in this service.
+     */
+     | "UNIMPLEMENTED"
+    /**
+     * Internal errors.  Means some invariants expected by underlying
+     * system has been broken.  If you see one of these errors,
+     * something is very broken.
+     */
+     | "INTERNAL"
+    /**
+     * The service is currently unavailable.  This is a most likely a
+     * transient condition and may be corrected by retrying with
+     * a backoff. Note that it is not always safe to retry
+     * non-idempotent operations.
+     *
+     * <p>See litmus test above for deciding between FAILED_PRECONDITION,
+     * ABORTED, and UNAVAILABLE.
+     */
+     | "UNAVAILABLE"
+    /**
+     * Unrecoverable data loss or corruption.
+     */
+     | "DATA_LOSS"
+    /**
+     * The request does not have valid authentication credentials for the
+     * operation.
+     */
+     | "UNAUTHENTICATED";
+}

package/target/grpc.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJvmMessageResponseTimePolicy = exports.underlyingSessionToCredentials = exports.toJvmCredentials = exports.GrpcDslAddons = void 0;
+const core_1 = require("@gatling.io/core");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+exports.GrpcDslAddons = Java.type("io.gatling.javaapi.grpc.GrpcDslAddons");
+const toJvmCredentials = (credentials) => exports.GrpcDslAddons.channelCredentials(credentials.rootCerts, credentials.certChain, credentials.privateKey);
+exports.toJvmCredentials = toJvmCredentials;
+const underlyingSessionToCredentials = (f) => (jvmSession) => (0, exports.toJvmCredentials)(f((0, core_1.wrapSession)(jvmSession)));
+exports.underlyingSessionToCredentials = underlyingSessionToCredentials;
+const toJvmMessageResponseTimePolicy = (policy) => {
+    if (policy === "FROM_STREAM_START") {
+        return jvm_types_1.GrpcDsl$MessageResponseTimePolicy.FromStreamStart;
+    }
+    else if (policy === "FROM_LAST_MESSAGE_SENT") {
+        return jvm_types_1.GrpcDsl$MessageResponseTimePolicy.FromLastMessageSent;
+    }
+    else if (policy === "FROM_LAST_MESSAGE_RECEIVED") {
+        return jvm_types_1.GrpcDsl$MessageResponseTimePolicy.FromLastMessageReceived;
+    }
+    throw Error(`Unhandled message response time policy ${policy}`);
+};
+exports.toJvmMessageResponseTimePolicy = toJvmMessageResponseTimePolicy;

package/target/headers.d.ts

@@ -0,0 +1,19 @@
+import { Session } from "@gatling.io/core";
+import JvmGrpcHeaders = io.gatling.javaapi.grpc.GrpcHeaders;
+export declare namespace GrpcHeaders {
+    import JvmValue = io.gatling.javaapi.grpc.GrpcHeaders$Value;
+    interface Value<B, V> {
+        value(value: V): B;
+        value(value: (session: Session) => V): B;
+        valueEL(value: string): B;
+    }
+    const wrapAsciiValue: <B extends GrpcHeaders<B>, J>(_underlying: JvmValue<J, string>, wrap: (underlying: J) => B) => Value<B, string>;
+    const wrapBinaryValue: <B extends GrpcHeaders<B>, J>(_underlying: JvmValue<J, number[]>, wrap: (underlying: J) => B) => Value<B, number[]>;
+}
+export interface GrpcHeaders<B extends GrpcHeaders<B>> {
+    asciiHeader(key: string): GrpcHeaders.Value<B, string>;
+    asciiHeaders(map: Record<string, string>): B;
+    binaryHeader(key: string): GrpcHeaders.Value<B, number[]>;
+    binaryHeaders(map: Record<string, number[]>): B;
+}
+export declare const wrapGrpcHeaders: <B extends GrpcHeaders<B>, J>(_underlying: JvmGrpcHeaders<J, any>, wrap: (underlying: J) => B) => GrpcHeaders<B>;

package/target/headers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapGrpcHeaders = exports.GrpcHeaders = void 0;
+const core_1 = require("@gatling.io/core");
+var GrpcHeaders;
+(function (GrpcHeaders) {
+    GrpcHeaders.wrapAsciiValue = (_underlying, wrap) => ({
+        value: (value) => wrap((0, core_1.isSessionTo)(value) ? _underlying.value((0, core_1.underlyingSessionTo)(value)) : _underlying.value(value)),
+        valueEL: (value) => wrap(_underlying.valueEL(value))
+    });
+    GrpcHeaders.wrapBinaryValue = (_underlying, wrap) => ({
+        value: (value) => wrap((0, core_1.isSessionTo)(value)
+            ? _underlying.value((0, core_1.asByteArrayFunction)((0, core_1.underlyingSessionTo)(value)))
+            : _underlying.value((0, core_1.asByteArray)(value))),
+        valueEL: (value) => wrap(_underlying.valueEL(value))
+    });
+})(GrpcHeaders || (exports.GrpcHeaders = GrpcHeaders = {}));
+const wrapGrpcHeaders = (_underlying, wrap) => ({
+    asciiHeader: (key) => GrpcHeaders.wrapAsciiValue(_underlying.asciiHeader(key), wrap),
+    asciiHeaders: (map) => wrap(_underlying.asciiHeaders(map)),
+    binaryHeader: (key) => GrpcHeaders.wrapBinaryValue(_underlying.binaryHeader(key), wrap),
+    // FIXME Uint8Array?
+    binaryHeaders: (map) => wrap(_underlying.binaryHeaders((0, core_1.asByteArrayMap)(map)))
+});
+exports.wrapGrpcHeaders = wrapGrpcHeaders;

package/target/index.d.ts

@@ -0,0 +1,30 @@
+import { Expression, Session } from "@gatling.io/core";
+import { GrpcUnaryServiceBuilder } from "./unary";
+export * from "./bidiStream";
+export * from "./checks";
+export * from "./clientStream";
+export * from "./grpc";
+export * from "./protocol";
+export * from "./serverStream";
+export * from "./unary";
+import { GrpcBidirectionalStreamingServiceBuilder } from "./bidiStream";
+import { GrpcClientStreamingServiceBuilder } from "./clientStream";
+import { GrpcProtocolBuilder } from "./protocol";
+import { GrpcServerStreamingServiceBuilder } from "./serverStream";
+export declare namespace Grpc {
+    interface Apply {
+        (requestName: string): Grpc;
+        (requestName: (session: Session) => string): Grpc;
+    }
+    const apply: (requestName: Expression<string>) => Grpc;
+}
+export interface Grpc {
+    unary(fullMethodName: string): GrpcUnaryServiceBuilder;
+    serverStream(fullMethodName: string): GrpcServerStreamingServiceBuilder;
+    serverStream(fullMethodName: string, streamName: string): GrpcServerStreamingServiceBuilder;
+    clientStream(fullMethodName: string): GrpcClientStreamingServiceBuilder;
+    clientStream(fullMethodName: string, streamName: string): GrpcClientStreamingServiceBuilder;
+    bidiStream(fullMethodName: string): GrpcBidirectionalStreamingServiceBuilder;
+    bidiStream(fullMethodName: string, streamName: string): GrpcBidirectionalStreamingServiceBuilder;
+}
+export declare const grpc: Grpc.Apply & GrpcProtocolBuilder;

package/target/index.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpc = exports.Grpc = void 0;
+const core_1 = require("@gatling.io/core");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const unary_1 = require("./unary");
+__exportStar(require("./bidiStream"), exports);
+__exportStar(require("./checks"), exports);
+__exportStar(require("./clientStream"), exports);
+__exportStar(require("./grpc"), exports);
+__exportStar(require("./protocol"), exports);
+__exportStar(require("./serverStream"), exports);
+__exportStar(require("./unary"), exports);
+const bidiStream_1 = require("./bidiStream");
+const clientStream_1 = require("./clientStream");
+const dynamic_1 = require("./dynamic");
+const protocol_1 = require("./protocol");
+const serverStream_1 = require("./serverStream");
+var Grpc;
+(function (Grpc) {
+    Grpc.apply = (requestName) => {
+        // Handle overloading
+        const jvmGrpc = typeof requestName === "function"
+            ? jvm_types_1.GrpcDsl.grpc((0, core_1.underlyingSessionTo)(requestName))
+            : jvm_types_1.GrpcDsl.grpc(requestName);
+        return wrapGrpc(jvmGrpc);
+    };
+})(Grpc || (exports.Grpc = Grpc = {}));
+const methodDescriptorWrapper = (fullMethodName) => {
+    const split1 = fullMethodName.split("/");
+    if (split1.length !== 2) {
+        throw Error(`Invalid gRPC method name '${fullMethodName}': method name must use the format 'package.Service/Method', or 'Service/Method' if there is no package defined.`);
+    }
+    const [fullServiceName, methodName] = split1;
+    const split2 = fullServiceName.split(".");
+    const serviceName = split2.pop();
+    const packageName = split2.length > 0 ? split2.join(".") : null;
+    return dynamic_1.GrpcDynamic.loadMethodDescriptor(packageName, serviceName, methodName);
+};
+const wrapGrpc = (_underlying) => ({
+    unary: (fullMethodName) => {
+        const wrapper = methodDescriptorWrapper(fullMethodName);
+        return (0, unary_1.wrapGrpcUnaryServiceBuilder)(_underlying.unary(wrapper.descriptor()), wrapper.inputDescriptor());
+    },
+    serverStream: (fullMethodName, streamName) => {
+        const wrapper = methodDescriptorWrapper(fullMethodName);
+        const wrap = (0, serverStream_1.wrapGrpcServerStreamingServiceBuilder)(wrapper.inputDescriptor());
+        return wrap(typeof streamName === "undefined"
+            ? _underlying.serverStream(wrapper.descriptor())
+            : _underlying.serverStream(wrapper.descriptor(), streamName));
+    },
+    clientStream: (fullMethodName, streamName) => {
+        const wrapper = methodDescriptorWrapper(fullMethodName);
+        const wrap = (0, clientStream_1.wrapGrpcClientStreamingServiceBuilder)(wrapper.inputDescriptor());
+        return wrap(typeof streamName === "undefined"
+            ? _underlying.clientStream(wrapper.descriptor())
+            : _underlying.clientStream(wrapper.descriptor(), streamName));
+    },
+    bidiStream: (fullMethodName, streamName) => {
+        const wrapper = methodDescriptorWrapper(fullMethodName);
+        const wrap = (0, bidiStream_1.wrapGrpcBidirectionalStreamingServiceBuilder)(wrapper.inputDescriptor());
+        return wrap(typeof streamName === "undefined"
+            ? _underlying.bidiStream(wrapper.descriptor())
+            : _underlying.bidiStream(wrapper.descriptor(), streamName));
+    }
+});
+exports.grpc = Object.assign(Grpc.apply, protocol_1.grpcProtocolBuilder);

package/target/protocol.d.ts

@@ -0,0 +1,26 @@
+import { ProtocolBuilder, Session } from "@gatling.io/core";
+import { GrpcHeaders } from "./headers";
+import JvmGrpcProtocolBuilder = io.gatling.javaapi.grpc.GrpcProtocolBuilder;
+import { ChannelCredentials } from "./grpc";
+export interface GrpcProtocolBuilder extends GrpcHeaders<GrpcProtocolBuilder>, ProtocolBuilder {
+    channelCredentials(credentials: ChannelCredentials): GrpcProtocolBuilder;
+    channelCredentials(credentials: string): GrpcProtocolBuilder;
+    channelCredentials(credentials: (session: Session) => ChannelCredentials): GrpcProtocolBuilder;
+    forAddress(host: string, port: number): GrpcProtocolBuilder;
+    forTarget(target: string): GrpcProtocolBuilder;
+    overrideAuthority(authority: string): GrpcProtocolBuilder;
+    shareChannel(): GrpcProtocolBuilder;
+    shareSslContext(): GrpcProtocolBuilder;
+    useChannelPool(poolSize: number): GrpcProtocolBuilder;
+    usePlaintext(): GrpcProtocolBuilder;
+    useInsecureTrustManager(): GrpcProtocolBuilder;
+    useStandardTrustManager(): GrpcProtocolBuilder;
+    useCustomCertificateTrustManager(certificatePath: string): GrpcProtocolBuilder;
+    useCustomLoadBalancingPolicy(policy: string): GrpcProtocolBuilder;
+    useCustomLoadBalancingPolicy(policy: string, jsonPolicyConfig: string): GrpcProtocolBuilder;
+    usePickFirstLoadBalancingPolicy(): GrpcProtocolBuilder;
+    usePickRandomLoadBalancingPolicy(): GrpcProtocolBuilder;
+    useRoundRobinLoadBalancingPolicy(): GrpcProtocolBuilder;
+}
+export declare const wrapGrpcProtocolBuilder: (_underlying: JvmGrpcProtocolBuilder) => GrpcProtocolBuilder;
+export declare const grpcProtocolBuilder: GrpcProtocolBuilder;

package/target/protocol.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcProtocolBuilder = exports.wrapGrpcProtocolBuilder = void 0;
+const headers_1 = require("./headers");
+const grpc_1 = require("./grpc");
+const wrapGrpcProtocolBuilder = (_underlying) => ({
+    _underlying,
+    ...(0, headers_1.wrapGrpcHeaders)(_underlying, exports.wrapGrpcProtocolBuilder),
+    //public GrpcProtocolBuilder callCredentials(@NonNull Function<Session, CallCredentials> credentials) {
+    //public GrpcProtocolBuilder callCredentials(@NonNull String credentials) {
+    //public GrpcProtocolBuilder callCredentials(@NonNull CallCredentials credentials) {
+    channelCredentials: (credentials) => (0, exports.wrapGrpcProtocolBuilder)(typeof credentials === "string"
+        ? grpc_1.GrpcDslAddons.channelCredentialsEL(_underlying, credentials)
+        : typeof credentials === "function"
+            ? _underlying.channelCredentials((0, grpc_1.underlyingSessionToCredentials)(credentials))
+            : _underlying.channelCredentials((0, grpc_1.toJvmCredentials)(credentials))),
+    forAddress: (host, port) => (0, exports.wrapGrpcProtocolBuilder)(_underlying.forAddress(host, port)),
+    forTarget: (target) => (0, exports.wrapGrpcProtocolBuilder)(_underlying.forTarget(target)),
+    overrideAuthority: (authority) => (0, exports.wrapGrpcProtocolBuilder)(_underlying.overrideAuthority(authority)),
+    shareChannel: () => (0, exports.wrapGrpcProtocolBuilder)(_underlying.shareChannel()),
+    shareSslContext: () => (0, exports.wrapGrpcProtocolBuilder)(_underlying.shareSslContext()),
+    useChannelPool: (poolSize) => (0, exports.wrapGrpcProtocolBuilder)(_underlying.useChannelPool(poolSize)),
+    usePlaintext: () => (0, exports.wrapGrpcProtocolBuilder)(_underlying.usePlaintext()),
+    useInsecureTrustManager: () => (0, exports.wrapGrpcProtocolBuilder)(_underlying.useInsecureTrustManager()),
+    useStandardTrustManager: () => (0, exports.wrapGrpcProtocolBuilder)(_underlying.useStandardTrustManager()),
+    useCustomCertificateTrustManager: (certificatePath) => (0, exports.wrapGrpcProtocolBuilder)(_underlying.useCustomCertificateTrustManager(certificatePath)),
+    useCustomLoadBalancingPolicy: (policy, jsonPolicyConfig) => (0, exports.wrapGrpcProtocolBuilder)(typeof jsonPolicyConfig === "undefined"
+        ? _underlying.useCustomLoadBalancingPolicy(policy)
+        : _underlying.useCustomLoadBalancingPolicy(policy, jsonPolicyConfig)),
+    usePickFirstLoadBalancingPolicy: () => (0, exports.wrapGrpcProtocolBuilder)(_underlying.usePickFirstLoadBalancingPolicy()),
+    usePickRandomLoadBalancingPolicy: () => (0, exports.wrapGrpcProtocolBuilder)(_underlying.usePickRandomLoadBalancingPolicy()),
+    useRoundRobinLoadBalancingPolicy: () => (0, exports.wrapGrpcProtocolBuilder)(_underlying.useRoundRobinLoadBalancingPolicy())
+});
+exports.wrapGrpcProtocolBuilder = wrapGrpcProtocolBuilder;
+exports.grpcProtocolBuilder = (0, exports.wrapGrpcProtocolBuilder)(
+// GrpcDsl.grpc doesn't get properly generated by java2ts because of conflicts with methods of the same name
+Java.type("io.gatling.javaapi.grpc.GrpcDsl").grpc);

package/target/request.d.ts

@@ -0,0 +1 @@
+export {};

package/target/request.js

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

package/target/serverStream.d.ts

@@ -0,0 +1,23 @@
+import { ActionBuilder, CheckBuilder, Duration, Session } from "@gatling.io/core";
+import { GrpcHeaders } from "./headers";
+import { MessageResponseTimePolicy } from "./grpc";
+import JvmDescriptorsDescriptor = com.google.protobuf.Descriptors$Descriptor;
+import JvmGrpcServerStreamingServiceBuilder = io.gatling.javaapi.grpc.GrpcServerStreamingServiceBuilder;
+export interface GrpcServerStreamAwaitStreamEndActionBuilder extends ActionBuilder {
+}
+export interface GrpcServerStreamStreamSendActionBuilder extends ActionBuilder {
+}
+export interface GrpcServerStreamingServiceBuilder extends GrpcHeaders<GrpcServerStreamingServiceBuilder> {
+    check(...checks: CheckBuilder[]): GrpcServerStreamingServiceBuilder;
+    deadlineAfter(duration: Duration): GrpcServerStreamingServiceBuilder;
+    messageRequestName(messageRequestName: string): GrpcServerStreamingServiceBuilder;
+    messageRequestName(messageRequestName: (session: Session) => string): GrpcServerStreamingServiceBuilder;
+    messageResponseTimePolicy(messageResponseTimePolicy: MessageResponseTimePolicy): GrpcServerStreamingServiceBuilder;
+    streamName(streamName: string): GrpcServerStreamingServiceBuilder;
+    send(request: any): GrpcServerStreamStreamSendActionBuilder;
+    send(request: (session: Session) => any): GrpcServerStreamStreamSendActionBuilder;
+    awaitStreamEnd(): GrpcServerStreamAwaitStreamEndActionBuilder;
+    awaitStreamEnd(reconcile: (main: Session, forked: Session) => Session): GrpcServerStreamAwaitStreamEndActionBuilder;
+    cancel(): ActionBuilder;
+}
+export declare const wrapGrpcServerStreamingServiceBuilder: (inputDescriptor: JvmDescriptorsDescriptor) => ((_underlying: JvmGrpcServerStreamingServiceBuilder<any, any>) => GrpcServerStreamingServiceBuilder);

package/target/serverStream.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapGrpcServerStreamingServiceBuilder = void 0;
+const core_1 = require("@gatling.io/core");
+const dynamic_1 = require("./dynamic");
+const headers_1 = require("./headers");
+const grpc_1 = require("./grpc");
+const wrapGrpcServerStreamAwaitStreamEndActionBuilder = (_underlying) => (0, core_1.wrapActionBuilder)(_underlying);
+const wrapGrpcServerStreamStreamSendActionBuilder = (_underlying) => (0, core_1.wrapActionBuilder)(_underlying);
+const wrapGrpcServerStreamingServiceBuilder = (inputDescriptor) => (_underlying) => {
+    const toJvmDynamicMessage = (0, dynamic_1.wrapToJvmDynamicMessage)(inputDescriptor);
+    const wrap = (0, exports.wrapGrpcServerStreamingServiceBuilder)(inputDescriptor);
+    return {
+        ...(0, headers_1.wrapGrpcHeaders)(_underlying, wrap),
+        // Chainable methods / global stream configuration
+        // FIXME callCredentials
+        check: (...checks) => wrap(_underlying.check(checks.map((check) => check._underlying))),
+        deadlineAfter: (duration) => {
+            if ((0, core_1.isDuration)(duration)) {
+                return wrap(_underlying.deadlineAfter((0, core_1.toJvmDuration)(duration)));
+            }
+            throw Error(`deadlineAfter() called with invalid argument ${duration}`);
+        },
+        messageRequestName: (messageRequestName) => wrap(typeof messageRequestName === "function"
+            ? _underlying.messageRequestName((0, core_1.underlyingSessionTo)(messageRequestName))
+            : _underlying.messageRequestName(messageRequestName)),
+        messageResponseTimePolicy: (messageResponseTimePolicy) => wrap(_underlying.messageResponseTimePolicy((0, grpc_1.toJvmMessageResponseTimePolicy)(messageResponseTimePolicy))),
+        streamName: (streamName) => wrap(_underlying.streamName(streamName)),
+        // Terminal methods / specific actions
+        send: (request) => {
+            return wrapGrpcServerStreamStreamSendActionBuilder(typeof request === "function"
+                ? _underlying.send((0, dynamic_1.underlyingSessionToJvmDynamicMessage)(request, toJvmDynamicMessage))
+                : _underlying.send(toJvmDynamicMessage(request)));
+        },
+        awaitStreamEnd: (reconcile) => wrapGrpcServerStreamAwaitStreamEndActionBuilder(typeof reconcile === "function"
+            ? _underlying.awaitStreamEnd((0, core_1.underlyingBiSessionTransform)(reconcile))
+            : _underlying.awaitStreamEnd()),
+        cancel: () => (0, core_1.wrapActionBuilder)(_underlying.cancel())
+    };
+};
+exports.wrapGrpcServerStreamingServiceBuilder = wrapGrpcServerStreamingServiceBuilder;

package/target/unary.d.ts

@@ -0,0 +1,13 @@
+import { ActionBuilder, CheckBuilder, Duration, Session } from "@gatling.io/core";
+import { GrpcHeaders } from "./headers";
+import JvmDescriptorsDescriptor = com.google.protobuf.Descriptors$Descriptor;
+import JvmGrpcUnaryServiceBuilder = io.gatling.javaapi.grpc.GrpcUnaryServiceBuilder;
+export interface GrpcUnaryActionBuilder extends GrpcHeaders<GrpcUnaryActionBuilder>, ActionBuilder {
+    check(...checks: CheckBuilder[]): GrpcUnaryActionBuilder;
+    deadlineAfter(duration: Duration): GrpcUnaryActionBuilder;
+}
+export interface GrpcUnaryServiceBuilder {
+    send(request: any): GrpcUnaryActionBuilder;
+    send(request: (session: Session) => any): GrpcUnaryActionBuilder;
+}
+export declare const wrapGrpcUnaryServiceBuilder: (_underlying: JvmGrpcUnaryServiceBuilder<any, any>, inputDescriptor: JvmDescriptorsDescriptor) => GrpcUnaryServiceBuilder;

package/target/unary.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapGrpcUnaryServiceBuilder = void 0;
+const core_1 = require("@gatling.io/core");
+const dynamic_1 = require("./dynamic");
+const headers_1 = require("./headers");
+const wrapGrpcUnaryActionBuilder = (_underlying) => ({
+    _underlying,
+    ...(0, headers_1.wrapGrpcHeaders)(_underlying, wrapGrpcUnaryActionBuilder),
+    /*callCredentials: (credentials) =>
+      wrapGrpcUnaryActionBuilder(
+        typeof credentials === "string"
+          ? _underlying.callCredentials(credentials as string)
+          : typeof credentials === "function"
+            ? _underlying.callCredentials(underlyingSessionTo(credentials as any)) // FIXME ??
+            : _underlying.callCredentials(credentials as any)
+      ),*/
+    check: (...checks) => wrapGrpcUnaryActionBuilder(_underlying.check(checks.map((check) => check._underlying))),
+    deadlineAfter: (duration) => {
+        if ((0, core_1.isDuration)(duration)) {
+            return wrapGrpcUnaryActionBuilder(_underlying.deadlineAfter((0, core_1.toJvmDuration)(duration)));
+        }
+        throw Error(`deadlineAfter() called with invalid argument ${duration}`);
+    }
+});
+const wrapGrpcUnaryServiceBuilder = (_underlying, inputDescriptor) => {
+    const toJvmDynamicMessage = (0, dynamic_1.wrapToJvmDynamicMessage)(inputDescriptor);
+    return {
+        send: (request) => {
+            return wrapGrpcUnaryActionBuilder(typeof request === "function"
+                ? _underlying.send((0, dynamic_1.underlyingSessionToJvmDynamicMessage)(request, toJvmDynamicMessage))
+                : _underlying.send(toJvmDynamicMessage(request)));
+        }
+    };
+};
+exports.wrapGrpcUnaryServiceBuilder = wrapGrpcUnaryServiceBuilder;