@gatling.io/http 0.1.0

package/target/checks.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = exports.headerRegex = exports.header = exports.currentLocationRegex = exports.currentLocation = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const core_1 = require("@gatling.io/core");
+/**
+ * Bootstrap a check that capture the response location, eg the landing url in a chain of
+ * redirects
+ *
+ * @returns the next step in the check DSL
+ */
+const currentLocation = () => (0, core_1.wrapCheckBuilderFind)(jvm_types_1.HttpDsl.currentLocation());
+exports.currentLocation = currentLocation;
+const currentLocationRegex = (pattern) => (0, core_1.wrapCheckBuilderCaptureGroup)(typeof pattern === "function"
+    ? jvm_types_1.HttpDsl.currentLocationRegex((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(pattern)))
+    : jvm_types_1.HttpDsl.currentLocationRegex(pattern));
+exports.currentLocationRegex = currentLocationRegex;
+const header = (name) => (0, core_1.wrapCheckBuilderMultipleFind)(typeof name === "function" ? jvm_types_1.HttpDsl.header((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name))) : jvm_types_1.HttpDsl.header(name));
+exports.header = header;
+const headerRegex = (name, pattern) => (0, core_1.wrapCheckBuilderCaptureGroup)(typeof name === "function"
+    ? typeof pattern === "function"
+        ? jvm_types_1.HttpDsl.headerRegex((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(pattern)))
+        : jvm_types_1.HttpDsl.headerRegex((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), pattern)
+    : typeof pattern === "function"
+        ? jvm_types_1.HttpDsl.headerRegex(name, (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(pattern)))
+        : // FIXME forced to use the charsequence version
+            jvm_types_1.HttpDsl.headerRegex(name, pattern));
+exports.headerRegex = headerRegex;
+/**
+ * Bootstrap a check that capture the response HTTP status code
+ *
+ * @returns the next step in the check DSL
+ */
+const status = () => (0, core_1.wrapCheckBuilderFind)(jvm_types_1.HttpDsl.status());
+exports.status = status;

package/target/cookies.d.ts

@@ -0,0 +1,100 @@
+import { ActionBuilder, Session, Wrapper } from "@gatling.io/core";
+import JvmAddCookie = io.gatling.javaapi.http.AddCookie;
+import JvmGetCookie = io.gatling.javaapi.http.GetCookie;
+export interface AddCookie extends Wrapper<JvmAddCookie> {
+    withDomain(domain: string): AddCookie;
+    withPath(path: string): AddCookie;
+    withMaxAge(maxAge: number): AddCookie;
+    withSecure(secure: boolean): AddCookie;
+}
+export interface GetCookie extends Wrapper<JvmGetCookie> {
+    withDomain(domain: string): GetCookie;
+    withDomain(domain: (session: Session) => string): GetCookie;
+    withPath(path: string): GetCookie;
+    withSecure(secure: boolean): GetCookie;
+    saveAs(saveAs: string): GetCookie;
+}
+/**
+ * Create an action to add a Cookie
+ *
+ * @param cookie - the DSL for adding a cookie
+ * @returns an ActionBuilder
+ */
+export declare const addCookie: (cookie: AddCookie) => ActionBuilder;
+/**
+ * Create an action to get a Cookie value into the Session
+ *
+ * @param cookie - the DSL for getting a cookie
+ * @returns an ActionBuilder
+ */
+export declare const getCookieValue: (cookie: GetCookie) => ActionBuilder;
+/**
+ * Create an action to flush the Session (non-persistent) Cookies of the user
+ *
+ * @returns an ActionBuilder
+ */
+export declare const flushSessionCookies: () => ActionBuilder;
+/**
+ * Create an action to flush all the Cookies of the user
+ *
+ * @returns an ActionBuilder
+ */
+export declare const flushCookieJar: () => ActionBuilder;
+/**
+ * Create an action to flush the HTTP cache of the user
+ *
+ * @returns an ActionBuilder
+ */
+export declare const flushHttpCache: () => ActionBuilder;
+export interface CookieApply {
+    /**
+     * Bootstrap the DSL for defining a Cookie to add
+     *
+     * @param name - the name of the cookie, expressed as a Gatling Expression Language String
+     * @param value - the value of the cookie, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    (name: string, value: string): AddCookie;
+    /**
+     * Bootstrap the DSL for defining a Cookie to add
+     *
+     * @param name - the name of the cookie, expressed as a function
+     * @param value - the value of the cookie, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    (name: string, value: (session: Session) => string): AddCookie;
+    /**
+     * Bootstrap the DSL for defining a Cookie to add
+     *
+     * @param name - the name of the cookie, expressed as a Gatling Expression Language String
+     * @param value - the value of the cookie, expressed as a function
+     * @returns the next DSL step
+     */
+    (name: (session: Session) => string, value: string): AddCookie;
+    /**
+     * Bootstrap the DSL for defining a Cookie to add
+     *
+     * @param name - the name of the cookie, expressed as a function
+     * @param value - the value of the cookie, expressed as a function
+     * @returns the next DSL step
+     */
+    (name: (session: Session) => string, value: (session: Session) => string): AddCookie;
+}
+export declare const Cookie: CookieApply;
+export interface CookieKeyApply {
+    /**
+     * Bootstrap the DSL for defining a Cookie to get
+     *
+     * @param name - the name of the cookie, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    (name: string): GetCookie;
+    /**
+     * Bootstrap the DSL for defining a Cookie to get
+     *
+     * @param name - the name of the cookie, expressed as a function
+     * @returns the next DSL step
+     */
+    (name: (session: Session) => string): GetCookie;
+}
+export declare const CookieKey: CookieKeyApply;

package/target/cookies.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieKey = exports.Cookie = exports.flushHttpCache = exports.flushCookieJar = exports.flushSessionCookies = exports.getCookieValue = exports.addCookie = void 0;
+const core_1 = require("@gatling.io/core");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const wrapAddCookie = (_underlying) => ({
+    _underlying,
+    withDomain: (domain) => wrapAddCookie(_underlying.withDomain(domain)),
+    withPath: (path) => wrapAddCookie(_underlying.withPath(path)),
+    withMaxAge: (maxAge) => wrapAddCookie(_underlying.withMaxAge(maxAge)),
+    withSecure: (secure) => wrapAddCookie(_underlying.withSecure(secure))
+});
+const wrapGetCookie = (_underlying) => ({
+    _underlying,
+    withDomain: (domain) => wrapGetCookie(typeof domain === "function"
+        ? _underlying.withDomain((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(domain)))
+        : _underlying.withPath(domain)),
+    withPath: (path) => wrapGetCookie(_underlying.withPath(path)),
+    withSecure: (secure) => wrapGetCookie(_underlying.withSecure(secure)),
+    saveAs: (saveAs) => wrapGetCookie(_underlying.saveAs(saveAs))
+});
+/**
+ * Create an action to add a Cookie
+ *
+ * @param cookie - the DSL for adding a cookie
+ * @returns an ActionBuilder
+ */
+const addCookie = (cookie) => (0, core_1.wrapActionBuilder)(jvm_types_1.HttpDsl.addCookie(cookie._underlying));
+exports.addCookie = addCookie;
+/**
+ * Create an action to get a Cookie value into the Session
+ *
+ * @param cookie - the DSL for getting a cookie
+ * @returns an ActionBuilder
+ */
+const getCookieValue = (cookie) => (0, core_1.wrapActionBuilder)(jvm_types_1.HttpDsl.getCookieValue(cookie._underlying));
+exports.getCookieValue = getCookieValue;
+/**
+ * Create an action to flush the Session (non-persistent) Cookies of the user
+ *
+ * @returns an ActionBuilder
+ */
+const flushSessionCookies = () => (0, core_1.wrapActionBuilder)(jvm_types_1.HttpDsl.flushSessionCookies());
+exports.flushSessionCookies = flushSessionCookies;
+/**
+ * Create an action to flush all the Cookies of the user
+ *
+ * @returns an ActionBuilder
+ */
+const flushCookieJar = () => (0, core_1.wrapActionBuilder)(jvm_types_1.HttpDsl.flushCookieJar());
+exports.flushCookieJar = flushCookieJar;
+/**
+ * Create an action to flush the HTTP cache of the user
+ *
+ * @returns an ActionBuilder
+ */
+const flushHttpCache = () => (0, core_1.wrapActionBuilder)(jvm_types_1.HttpDsl.flushHttpCache());
+exports.flushHttpCache = flushHttpCache;
+const Cookie = (name, value) => wrapAddCookie(typeof name === "function"
+    ? typeof value === "function"
+        ? jvm_types_1.HttpDsl.Cookie((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(value)))
+        : jvm_types_1.HttpDsl.Cookie((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), value)
+    : typeof value === "function"
+        ? jvm_types_1.HttpDsl.Cookie(name, (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(value)))
+        : jvm_types_1.HttpDsl.Cookie(name, value));
+exports.Cookie = Cookie;
+const CookieKey = (name) => wrapGetCookie(typeof name === "function"
+    ? jvm_types_1.HttpDsl.CookieKey((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)))
+    : jvm_types_1.HttpDsl.CookieKey(name));
+exports.CookieKey = CookieKey;

package/target/feeders.d.ts

@@ -0,0 +1,9 @@
+import { FileBasedFeederBuilder } from "@gatling.io/core";
+/**
+ * Bootstrap a feeder that reads from a sitemap XML file
+ *
+ * @param filePath - the path of the file, either relative to the root of the classpath, or absolute, expressed as a
+ * Gatling Expression Language String
+ * @returns the next DSL step
+ */
+export declare const sitemap: (filePath: string) => FileBasedFeederBuilder<string>;

package/target/feeders.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sitemap = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const core_1 = require("@gatling.io/core");
+/**
+ * Bootstrap a feeder that reads from a sitemap XML file
+ *
+ * @param filePath - the path of the file, either relative to the root of the classpath, or absolute, expressed as a
+ * Gatling Expression Language String
+ * @returns the next DSL step
+ */
+const sitemap = (filePath) => (0, core_1.wrapFileBasedFeederBuilder)(jvm_types_1.HttpDsl.sitemap(filePath));
+exports.sitemap = sitemap;

package/target/headers.d.ts

@@ -0,0 +1,26 @@
+import { Wrapper } from "@gatling.io/core";
+import JvmHttpHeaders = io.netty.handler.codec.http.HttpHeaders;
+/**
+ * Provides the constants for the standard HTTP header names and values and
+ * commonly used utility methods that accesses an {@link HttpMessage}.
+ * <p>
+ * Concrete instances of this class are most easily obtained from its default factory:
+ * {@link DefaultHttpHeadersFactory#headersFactory()}.
+ */
+export interface HttpHeaders extends Wrapper<JvmHttpHeaders> {
+    /**
+     * Adds a new header with the specified name and value.
+     *
+     * If the specified value is not a {@link String}, it is converted
+     * into a {@link String} by {@link Object#toString()}, except in the cases
+     * of {@link Date} and {@link Calendar}, which are formatted to the date
+     * format defined in <a href="https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1">RFC2616</a>.
+     *
+     * @param name - The name of the header being added
+     * @param value - The value of the header being added
+     *
+     * @returns {@code this}
+     */
+    add(name: string, value: any): HttpHeaders;
+}
+export declare const wrapHttpHeaders: (_underlying: JvmHttpHeaders) => HttpHeaders;

package/target/headers.js

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

package/target/index.d.ts

@@ -0,0 +1,163 @@
+import { Session } from "@gatling.io/core";
+import { HttpProtocolBuilder } from "./protocol";
+import { HttpRequestActionBuilder, Request } from "./request";
+import { Response } from "./response";
+export * from "./bodyPart";
+export * from "./checks";
+export * from "./cookies";
+export * from "./feeders";
+export * from "./headers";
+export * from "./method";
+export * from "./polling";
+export * from "./protocol";
+export * from "./proxy";
+export * from "./request";
+export * from "./response";
+import JvmRequest = io.gatling.http.client.Request;
+import JvmResponse = io.gatling.http.response.Response;
+import JvmSession = io.gatling.javaapi.core.Session;
+export type RequestTransform = (request: Request, session: Session) => Request;
+export declare const underlyingRequestTransform: (f: RequestTransform) => ((jvmRequest: JvmRequest, jvmSession: JvmSession) => JvmRequest);
+export type ResponseTransform = (response: Response, session: Session) => Response;
+export declare const underlyingResponseTransform: (f: ResponseTransform) => ((jvmResponse: JvmResponse, jvmSession: JvmSession) => JvmResponse);
+/**
+ * DSL for bootstrapping HTTP requests.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface Http {
+    /**
+     * Define a GET request
+     *
+     * @param url - the url, expressed as a Gatling Expression Language String
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    get(url: string): HttpRequestActionBuilder;
+    /**
+     * Define a GET request
+     *
+     * @param url - the url, expressed as a function
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    get(url: (session: Session) => string): HttpRequestActionBuilder;
+    /**
+     * Define a PUT request
+     *
+     * @param url - the url, expressed as a Gatling Expression Language String
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    put(url: string): HttpRequestActionBuilder;
+    /**
+     * Define a PUT request
+     *
+     * @param url - the url, expressed as a function
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    put(url: (session: Session) => string): HttpRequestActionBuilder;
+    /**
+     * Define a POST request
+     *
+     * @param url - the url, expressed as a Gatling Expression Language String
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    post(url: string): HttpRequestActionBuilder;
+    /**
+     * Define a POST request
+     *
+     * @param url - the url, expressed as a function
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    post(url: (session: Session) => string): HttpRequestActionBuilder;
+    /**
+     * Define a PATCH request
+     *
+     * @param url - the url, expressed as a Gatling Expression Language String
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    patch(url: string): HttpRequestActionBuilder;
+    /**
+     * Define a PATCH request
+     *
+     * @param url - the url, expressed as a function
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    patch(url: (session: Session) => string): HttpRequestActionBuilder;
+    /**
+     * Define a HEAD request
+     *
+     * @param url - the url, expressed as a Gatling Expression Language String
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    head(url: string): HttpRequestActionBuilder;
+    /**
+     * Define a HEAD request
+     *
+     * @param url - the url, expressed as a function
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    head(url: (session: Session) => string): HttpRequestActionBuilder;
+    /**
+     * Define a DELETE request
+     *
+     * @param url - the url, expressed as a Gatling Expression Language String
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    delete(url: string): HttpRequestActionBuilder;
+    /**
+     * Define a DELETE request
+     *
+     * @param url - the url, expressed as a function
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    delete(url: (session: Session) => string): HttpRequestActionBuilder;
+    /**
+     * Define a OPTIONS request
+     *
+     * @param url - the url, expressed as a Gatling Expression Language String
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    options(url: string): HttpRequestActionBuilder;
+    /**
+     * Define a OPTIONS request
+     *
+     * @param url - the url, expressed as a function
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    options(url: (session: Session) => string): HttpRequestActionBuilder;
+    /**
+     * Define a HTTP request
+     *
+     * @param method - the HTTP method
+     * @param url - the url, expressed as a Gatling Expression Language String
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    httpRequest(method: string, url: string): HttpRequestActionBuilder;
+    /**
+     * Define a HTTP request
+     *
+     * @param method - the HTTP method
+     * @param url - the url, expressed as a function
+     * @returns a new instance of HttpRequestActionBuilder
+     */
+    httpRequest(method: string, url: (session: Session) => string): HttpRequestActionBuilder;
+}
+/**
+ * The entrypoint of the Gatling HTTP DSL
+ */
+export interface HttpApply {
+    /**
+     * Bootstrap a HTTP request configuration
+     *
+     * @param name - the HTTP request name, expressed as a Gatling Expression Language String
+     * @returns the next DSL step
+     */
+    (name: string): Http;
+    /**
+     * Bootstrap a HTTP request configuration
+     *
+     * @param name - the HTTP request name, expressed as a function
+     * @returns the next DSL step
+     */
+    (name: (session: Session) => string): Http;
+}
+export declare const http: HttpApply & HttpProtocolBuilder;

package/target/index.js

@@ -0,0 +1,59 @@
+"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.http = exports.underlyingResponseTransform = exports.underlyingRequestTransform = void 0;
+const core_1 = require("@gatling.io/core");
+const core_2 = require("@gatling.io/core");
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const protocol_1 = require("./protocol");
+const request_1 = require("./request");
+const response_1 = require("./response");
+__exportStar(require("./bodyPart"), exports);
+__exportStar(require("./checks"), exports);
+__exportStar(require("./cookies"), exports);
+__exportStar(require("./feeders"), exports);
+__exportStar(require("./headers"), exports);
+__exportStar(require("./method"), exports);
+__exportStar(require("./polling"), exports);
+__exportStar(require("./protocol"), exports);
+__exportStar(require("./proxy"), exports);
+__exportStar(require("./request"), exports);
+__exportStar(require("./response"), 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;
+exports.underlyingResponseTransform = underlyingResponseTransform;
+const httpProtocolBuilder = (0, protocol_1.wrapHttpProtocolBuilder)(
+// HttpDsl.http doesn't get properly generated by java2ts because of conflicts with methods of the same name
+Java.type("io.gatling.javaapi.http.HttpDsl").http);
+const wrapHttp = (jvmHttp) => ({
+    get: (url) => (0, request_1.wrapHttpRequestActionBuilder)(typeof url === "function" ? jvmHttp.get((0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(url))) : jvmHttp.get(url)),
+    put: (url) => (0, request_1.wrapHttpRequestActionBuilder)(typeof url === "function" ? jvmHttp.put((0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(url))) : jvmHttp.put(url)),
+    post: (url) => (0, request_1.wrapHttpRequestActionBuilder)(typeof url === "function" ? jvmHttp.post((0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(url))) : jvmHttp.post(url)),
+    patch: (url) => (0, request_1.wrapHttpRequestActionBuilder)(typeof url === "function" ? jvmHttp.patch((0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(url))) : jvmHttp.patch(url)),
+    head: (url) => (0, request_1.wrapHttpRequestActionBuilder)(typeof url === "function" ? jvmHttp.head((0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(url))) : jvmHttp.head(url)),
+    delete: (url) => (0, request_1.wrapHttpRequestActionBuilder)(typeof url === "function" ? jvmHttp.delete((0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(url))) : jvmHttp.delete(url)),
+    options: (url) => (0, request_1.wrapHttpRequestActionBuilder)(typeof url === "function" ? jvmHttp.options((0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(url))) : jvmHttp.options(url)),
+    httpRequest: (method, url) => (0, request_1.wrapHttpRequestActionBuilder)(typeof url === "function"
+        ? jvmHttp.httpRequest(method, (0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(url)))
+        : jvmHttp.httpRequest(method, url))
+});
+const httpApply = (name) => {
+    // Handle overloading
+    const jvmHttp = typeof name === "string" ? jvm_types_1.HttpDsl.http(name) : jvm_types_1.HttpDsl.http((0, core_1.wrapCallback)((0, core_2.underlyingSessionTo)(name)));
+    return wrapHttp(jvmHttp);
+};
+exports.http = Object.assign(httpApply, httpProtocolBuilder);

package/target/method.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The OPTIONS method represents a request for information about the communication options
+ * available on the request/response chain identified by the Request-URI. This method allows
+ * the client to determine the options and/or requirements associated with a resource, or the
+ * capabilities of a server, without implying a resource action or initiating a resource
+ * retrieval.
+ */
+export type OPTIONS = "OPTIONS";
+/**
+ * The GET method means retrieve whatever information (in the form of an entity) is identified
+ * by the Request-URI.  If the Request-URI refers to a data-producing process, it is the
+ * produced data which shall be returned as the entity in the response and not the source text
+ * of the process, unless that text happens to be the output of the process.
+ */
+export type GET = "GET";
+/**
+ * The HEAD method is identical to GET except that the server MUST NOT return a message-body
+ * in the response.
+ */
+export type HEAD = "HEAD";
+/**
+ * The POST method is used to request that the origin server accept the entity enclosed in the
+ * request as a new subordinate of the resource identified by the Request-URI in the
+ * Request-Line.
+ */
+export type POST = "POST";
+/**
+ * The PUT method requests that the enclosed entity be stored under the supplied Request-URI.
+ */
+export type PUT = "PUT";
+/**
+ * The PATCH method requests that a set of changes described in the
+ * request entity be applied to the resource identified by the Request-URI.
+ */
+export type PATCH = "PATCH";
+/**
+ * The DELETE method requests that the origin server delete the resource identified by the
+ * Request-URI.
+ */
+export type DELETE = "DELETE";
+/**
+ * The TRACE method is used to invoke a remote, application-layer loop-back of the request
+ * message.
+ */
+export type TRACE = "TRACE";
+/**
+ * This specification reserves the method name CONNECT for use with a proxy that can dynamically
+ * switch to being a tunnel
+ */
+export type CONNECT = "CONNECT";
+/**
+ * The request method of HTTP or its derived protocols, such as
+ * <a href="https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol">RTSP</a> and
+ * <a href="https://en.wikipedia.org/wiki/Internet_Content_Adaptation_Protocol">ICAP</a>.
+ */
+export type HttpMethod = OPTIONS | GET | HEAD | POST | PUT | PATCH | DELETE | TRACE | CONNECT;

package/target/method.js

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

package/target/polling.d.ts

@@ -0,0 +1,39 @@
+import { ActionBuilder, Duration } from "@gatling.io/core";
+import { HttpRequestActionBuilder } from "./request";
+/** The prefix to bootstrap polling specific DSL */
+export declare const poll: () => Polling;
+/**
+ * DSL for building HTTP polling configurations
+ *
+ * Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface Polling {
+    /**
+     * Define a custom poller name so multiple pollers for the same virtual users don't conflict
+     *
+     * @param pollerName - the name
+     * @returns the next DSL step
+     */
+    pollerName(pollerName: string): Polling;
+    /**
+     * Define the polling period
+     *
+     * @param period - the period
+     * @returns the next DSL step
+     */
+    every(period: Duration): PollingEvery;
+    /**
+     * Stop polling
+     *
+     * @returns an ActionBuilder
+     */
+    stop(): ActionBuilder;
+}
+export interface PollingEvery {
+    /**
+     * Define the polling request
+     *
+     * @returns an ActionBuilder
+     */
+    exec(requestBuilder: HttpRequestActionBuilder): ActionBuilder;
+}

package/target/polling.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poll = void 0;
+const jvm_types_1 = require("@gatling.io/jvm-types");
+const core_1 = require("@gatling.io/core");
+/** The prefix to bootstrap polling specific DSL */
+const poll = () => wrapPolling(jvm_types_1.HttpDsl.poll());
+exports.poll = poll;
+const wrapPolling = (_underlying) => ({
+    pollerName: (pollerName) => wrapPolling(_underlying.pollerName(pollerName)),
+    every: (period) => wrapPollingEvery(_underlying.every((0, core_1.toJvmDuration)(period))),
+    stop: () => (0, core_1.wrapActionBuilder)(_underlying.stop())
+});
+const wrapPollingEvery = (_underlying) => ({
+    exec: (requestBuilder) => (0, core_1.wrapActionBuilder)(_underlying.exec(requestBuilder._underlying))
+});