@gatling.io/http 0.1.0

package/target/request/index.js

@@ -0,0 +1,207 @@
+"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.wrapHttpRequestActionBuilder = void 0;
+const core_1 = require("@gatling.io/core");
+__exportStar(require("./body"), exports);
+__exportStar(require("./request"), exports);
+const requestWithParamsActionBuilderImpl = (jvmBuilder, wrap) => ({
+    queryParam: (name, value) => {
+        if (typeof name === "function") {
+            if (typeof value === "function") {
+                return wrap(jvmBuilder.queryParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(value))));
+            }
+            else if (typeof value === "string") {
+                // FIXME it shows the value:any overload?
+                return wrap(jvmBuilder.queryParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), value));
+            }
+            else {
+                // FIXME it shows the value:func overload?
+                return wrap(jvmBuilder.queryParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), value));
+            }
+        }
+        else {
+            if (typeof value === "function") {
+                // FIXME it shows the value:any overload?
+                return wrap(jvmBuilder.queryParam(name, (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(value))));
+            }
+            else if (typeof value === "string") {
+                // FIXME it shows the value:any overload?
+                return wrap(jvmBuilder.queryParam(name, value));
+            }
+            else {
+                return wrap(jvmBuilder.queryParam(name, value));
+            }
+        }
+    },
+    multivaluedQueryParam: (name, values) => {
+        if (typeof name === "function") {
+            if (typeof values === "function") {
+                return wrap(jvmBuilder.multivaluedQueryParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionToJava)(values))));
+            }
+            else if (typeof values === "string") {
+                return wrap(jvmBuilder.multivaluedQueryParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), values));
+            }
+            else {
+                return wrap(jvmBuilder.multivaluedQueryParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), values));
+            }
+        }
+        else {
+            if (typeof values === "function") {
+                return wrap(jvmBuilder.multivaluedQueryParam(name, (0, core_1.wrapCallback)((0, core_1.underlyingSessionToJava)(values))));
+            }
+            else if (typeof values === "string") {
+                return wrap(jvmBuilder.multivaluedQueryParam(name, values));
+            }
+            else {
+                return wrap(jvmBuilder.multivaluedQueryParam(name, values));
+            }
+        }
+    },
+    queryParamMap: (map) => {
+        if (typeof map === "function") {
+            return wrap(jvmBuilder.queryParamMap((0, core_1.wrapCallback)((0, core_1.underlyingSessionToJava)(map))));
+        }
+        else if (typeof map === "object") {
+            return wrap(jvmBuilder.queryParamMap(map));
+        }
+        else {
+            return wrap(jvmBuilder.queryParamMap(map));
+        }
+    },
+    header: (name, value) => wrap(typeof value === "function"
+        ? jvmBuilder.header(name, (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(value)))
+        : jvmBuilder.header(name, value)),
+    headers: (headers) => wrap(jvmBuilder.headers(headers)),
+    ignoreProtocolHeaders: () => wrap(jvmBuilder.ignoreProtocolHeaders()),
+    basicAuth: (username, password) => wrap(typeof username === "function"
+        ? typeof password === "function"
+            ? jvmBuilder.basicAuth((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(username)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(password)))
+            : jvmBuilder.basicAuth((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(username)), password)
+        : typeof password === "function"
+            ? jvmBuilder.basicAuth(username, (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(password)))
+            : jvmBuilder.basicAuth(username, password)),
+    digestAuth: (username, password) => wrap(typeof username === "function"
+        ? typeof password === "function"
+            ? jvmBuilder.digestAuth((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(username)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(password)))
+            : jvmBuilder.digestAuth((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(username)), password)
+        : typeof password === "function"
+            ? jvmBuilder.digestAuth(username, (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(password)))
+            : jvmBuilder.digestAuth(username, password)),
+    disableUrlEncoding: () => wrap(jvmBuilder.disableUrlEncoding()),
+    proxy: (proxy) => wrap(jvmBuilder.proxy(proxy._underlying)),
+    signWithOAuth1: (consumerKey, clientSharedSecret, token, tokenSecret) => wrap(typeof consumerKey === "function" &&
+        typeof clientSharedSecret === "function" &&
+        typeof token === "function" &&
+        typeof tokenSecret === "function"
+        ? jvmBuilder.signWithOAuth1((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(consumerKey)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(clientSharedSecret)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(token)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(tokenSecret)))
+        : jvmBuilder.signWithOAuth1(consumerKey, clientSharedSecret, token, tokenSecret))
+});
+const requestWithBodyActionBuilderImpl = (jvmBuilder, wrap) => ({
+    body: (body) => wrap(jvmBuilder.body(body._underlying)),
+    bodyPart: (part) => wrap(jvmBuilder.bodyPart(part._underlying)),
+    bodyParts: (...parts) => wrap(jvmBuilder.bodyParts(parts.map((part) => part._underlying))),
+    asMultipartForm: () => wrap(jvmBuilder.asMultipartForm()),
+    asFormUrlEncoded: () => wrap(jvmBuilder.asFormUrlEncoded()),
+    formParam: (key, value) => {
+        if (typeof key === "function") {
+            if (typeof value === "function") {
+                return wrap(jvmBuilder.formParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(key)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(value))));
+            }
+            else if (typeof value === "string") {
+                // FIXME it shows the value:any overload?
+                return wrap(jvmBuilder.formParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(key)), value));
+            }
+            else {
+                // FIXME it shows the value:func overload?
+                return wrap(jvmBuilder.formParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(key)), value));
+            }
+        }
+        else {
+            if (typeof value === "function") {
+                // FIXME it shows the value:any overload?
+                return wrap(jvmBuilder.formParam(key, (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(value))));
+            }
+            else if (typeof value === "string") {
+                // FIXME it shows the value:any overload?
+                return wrap(jvmBuilder.formParam(key, value));
+            }
+            else {
+                return wrap(jvmBuilder.formParam(key, value));
+            }
+        }
+    },
+    multivaluedFormParam: (key, values) => {
+        if (typeof key === "function") {
+            if (typeof values === "function") {
+                return wrap(jvmBuilder.multivaluedFormParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(key)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionToJava)(values))));
+            }
+            else if (typeof values === "string") {
+                throw Error(`multivaluedFormParam() called with invalid arguments ${key}, ${values}`);
+            }
+            else {
+                return wrap(jvmBuilder.multivaluedFormParam((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(key)), values));
+            }
+        }
+        else {
+            if (typeof values === "function") {
+                return wrap(jvmBuilder.multivaluedFormParam(key, (0, core_1.wrapCallback)((0, core_1.underlyingSessionToJava)(values))));
+            }
+            else if (typeof values === "string") {
+                return wrap(jvmBuilder.multivaluedFormParam(key, values));
+            }
+            else {
+                return wrap(jvmBuilder.multivaluedFormParam(key, values));
+            }
+        }
+    },
+    formParamMap: (map) => wrap(typeof map === "function"
+        ? jvmBuilder.formParamMap((0, core_1.wrapCallback)((0, core_1.underlyingSessionToJava)(map)))
+        : jvmBuilder.formParamMap(map)),
+    form: (form) => wrap(typeof form === "function"
+        ? jvmBuilder.form((0, core_1.wrapCallback)((0, core_1.underlyingSessionToJava)(form)))
+        : jvmBuilder.form(form)),
+    formUpload: (name, filePath) => wrap(typeof name === "function"
+        ? typeof filePath === "function"
+            ? jvmBuilder.formUpload((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(filePath)))
+            : jvmBuilder.formUpload((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(name)), filePath)
+        : typeof filePath === "function"
+            ? jvmBuilder.formUpload(name, (0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(filePath)))
+            : jvmBuilder.formUpload(name, filePath)),
+    asJson: () => wrap(jvmBuilder.asJson()),
+    asXml: () => wrap(jvmBuilder.asXml())
+});
+const requestActionBuilderImpl = (jvmBuilder, wrap) => ({
+    check: (...checks) => wrap(jvmBuilder.check(checks.map((c) => c._underlying))),
+    checkIf: (condition) => (0, core_1.wrapCondition)(typeof condition === "string"
+        ? jvmBuilder.checkIf(condition)
+        : jvmBuilder.checkIf((0, core_1.wrapCallback)((0, core_1.underlyingSessionTo)(condition))), wrap),
+    ignoreProtocolChecks: () => wrap(jvmBuilder.ignoreProtocolChecks()),
+    silent: () => wrap(jvmBuilder.silent()),
+    notSilent: () => wrap(jvmBuilder.notSilent()),
+    disableFollowRedirect: () => wrap(jvmBuilder.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)
+});
+exports.wrapHttpRequestActionBuilder = wrapHttpRequestActionBuilder;

package/target/request/request.d.ts

@@ -0,0 +1,9 @@
+import { Wrapper } from "@gatling.io/core";
+import { HttpHeaders } from "../headers";
+import { RequestBody } from "./body";
+import JvmRequest = io.gatling.http.client.Request;
+export interface Request extends Wrapper<JvmRequest> {
+    body(): RequestBody;
+    headers(): HttpHeaders;
+}
+export declare const wrapRequest: (_underlying: JvmRequest) => Request;

package/target/request/request.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapRequest = void 0;
+const headers_1 = require("../headers");
+const body_1 = require("./body");
+const wrapRequest = (_underlying) => ({
+    _underlying,
+    body: () => (0, body_1.wrapRequestBody)(_underlying.getBody()),
+    headers: () => (0, headers_1.wrapHttpHeaders)(_underlying.getHeaders())
+});
+exports.wrapRequest = wrapRequest;

package/target/response/body.d.ts

@@ -0,0 +1,9 @@
+import { Wrapper } from "@gatling.io/core";
+import JvmResponseBody = io.gatling.http.response.ResponseBody;
+export interface ResponseBody extends Wrapper<JvmResponseBody> {
+    bytes(): number[];
+    chars(): string[];
+    length(): number;
+    string(): string;
+}
+export declare const wrapResponseBody: (_underlying: JvmResponseBody) => ResponseBody;

package/target/response/body.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapResponseBody = void 0;
+const wrapResponseBody = (_underlying) => ({
+    _underlying,
+    bytes: () => _underlying.bytes(),
+    chars: () => _underlying.chars(),
+    length: () => _underlying.length(),
+    string: () => _underlying.string()
+});
+exports.wrapResponseBody = wrapResponseBody;

package/target/response/index.d.ts

@@ -0,0 +1,15 @@
+import { Wrapper } from "@gatling.io/core";
+import { HttpHeaders } from "../headers";
+import { ResponseBody } from "./body";
+import { HttpResponseStatus } from "./status";
+import JvmResponse = io.gatling.http.response.Response;
+export * from "./body";
+export * from "./status";
+export interface Response extends Wrapper<JvmResponse> {
+    body(): ResponseBody;
+    headers(): HttpHeaders;
+    isHttp2(): boolean;
+    isRedirect(): boolean;
+    status(): HttpResponseStatus;
+}
+export declare const wrapResponse: (_underlying: JvmResponse) => Response;

package/target/response/index.js

@@ -0,0 +1,46 @@
+"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.wrapResponse = void 0;
+const headers_1 = require("../headers");
+const body_1 = require("./body");
+const status_1 = require("./status");
+__exportStar(require("./body"), exports);
+__exportStar(require("./status"), exports);
+const wrapResponse = (_underlying) => ({
+    _underlying,
+    body: () => (0, body_1.wrapResponseBody)(_underlying.body()),
+    //copy: (
+    //  request: Request = wrapRequest(_underlying.request()),
+    //  startTimestamp: number = _underlying.startTimestamp(),
+    //  endTimestamp: number = _underlying.endTimestamp(),
+    //  //status: any /*io.netty.handler.codec.http.HttpResponseStatus*/,
+    //  //headers: HttpHeaders,
+    //  //body: any /*io.gatling.http.response.ResponseBody*/,
+    //  //checksums: any /*scala.collection.immutable.Map*/,
+    //  isHttp2: boolean = _underlying.isHttp2()
+    //): Response => wrapResponse(_underlying.copy(
+    //  request = request._underlying,
+    //  startTimestamp = startTimestamp,
+    //  endTimestamp = endTimestamp,
+    //  isHttp2
+    //)),
+    headers: () => (0, headers_1.wrapHttpHeaders)(_underlying.headers()),
+    isHttp2: () => _underlying.isHttp2(),
+    isRedirect: () => _underlying.isRedirect(),
+    status: () => (0, status_1.fromJvmHttpResponseStatus)(_underlying.status())
+});
+exports.wrapResponse = wrapResponse;

package/target/response/status.d.ts

@@ -0,0 +1,236 @@
+export declare class HttpResponseStatus {
+    readonly code: number;
+    readonly reasonPhrase: string;
+    /**
+     * 100 Continue
+     */
+    static readonly CONTINUE: HttpResponseStatus;
+    /**
+     * 101 Switching Protocols
+     */
+    static readonly SWITCHING_PROTOCOLS: HttpResponseStatus;
+    /**
+     * 102 Processing (WebDAV, RFC2518)
+     */
+    static readonly PROCESSING: HttpResponseStatus;
+    /**
+     * 103 Early Hints (RFC 8297)
+     */
+    static readonly EARLY_HINTS: HttpResponseStatus;
+    /**
+     * 200 OK
+     */
+    static readonly OK: HttpResponseStatus;
+    /**
+     * 201 Created
+     */
+    static readonly CREATED: HttpResponseStatus;
+    /**
+     * 202 Accepted
+     */
+    static readonly ACCEPTED: HttpResponseStatus;
+    /**
+     * 203 Non-Authoritative Information (since HTTP/1.1)
+     */
+    static readonly NON_AUTHORITATIVE_INFORMATION: HttpResponseStatus;
+    /**
+     * 204 No Content
+     */
+    static readonly NO_CONTENT: HttpResponseStatus;
+    /**
+     * 205 Reset Content
+     */
+    static readonly RESET_CONTENT: HttpResponseStatus;
+    /**
+     * 206 Partial Content
+     */
+    static readonly PARTIAL_CONTENT: HttpResponseStatus;
+    /**
+     * 207 Multi-Status (WebDAV, RFC2518)
+     */
+    static readonly MULTI_STATUS: HttpResponseStatus;
+    /**
+     * 300 Multiple Choices
+     */
+    static readonly MULTIPLE_CHOICES: HttpResponseStatus;
+    /**
+     * 301 Moved Permanently
+     */
+    static readonly MOVED_PERMANENTLY: HttpResponseStatus;
+    /**
+     * 302 Found
+     */
+    static readonly FOUND: HttpResponseStatus;
+    /**
+     * 303 See Other (since HTTP/1.1)
+     */
+    static readonly SEE_OTHER: HttpResponseStatus;
+    /**
+     * 304 Not Modified
+     */
+    static readonly NOT_MODIFIED: HttpResponseStatus;
+    /**
+     * 305 Use Proxy (since HTTP/1.1)
+     */
+    static readonly USE_PROXY: HttpResponseStatus;
+    /**
+     * 307 Temporary Redirect (since HTTP/1.1)
+     */
+    static readonly TEMPORARY_REDIRECT: HttpResponseStatus;
+    /**
+     * 308 Permanent Redirect (RFC7538)
+     */
+    static readonly PERMANENT_REDIRECT: HttpResponseStatus;
+    /**
+     * 400 Bad Request
+     */
+    static readonly BAD_REQUEST: HttpResponseStatus;
+    /**
+     * 401 Unauthorized
+     */
+    static readonly UNAUTHORIZED: HttpResponseStatus;
+    /**
+     * 402 Payment Required
+     */
+    static readonly PAYMENT_REQUIRED: HttpResponseStatus;
+    /**
+     * 403 Forbidden
+     */
+    static readonly FORBIDDEN: HttpResponseStatus;
+    /**
+     * 404 Not Found
+     */
+    static readonly NOT_FOUND: HttpResponseStatus;
+    /**
+     * 405 Method Not Allowed
+     */
+    static readonly METHOD_NOT_ALLOWED: HttpResponseStatus;
+    /**
+     * 406 Not Acceptable
+     */
+    static readonly NOT_ACCEPTABLE: HttpResponseStatus;
+    /**
+     * 407 Proxy Authentication Required
+     */
+    static readonly PROXY_AUTHENTICATION_REQUIRED: HttpResponseStatus;
+    /**
+     * 408 Request Timeout
+     */
+    static readonly REQUEST_TIMEOUT: HttpResponseStatus;
+    /**
+     * 409 Conflict
+     */
+    static readonly CONFLICT: HttpResponseStatus;
+    /**
+     * 410 Gone
+     */
+    static readonly GONE: HttpResponseStatus;
+    /**
+     * 411 Length Required
+     */
+    static readonly LENGTH_REQUIRED: HttpResponseStatus;
+    /**
+     * 412 Precondition Failed
+     */
+    static readonly PRECONDITION_FAILED: HttpResponseStatus;
+    /**
+     * 413 Request Entity Too Large
+     */
+    static readonly REQUEST_ENTITY_TOO_LARGE: HttpResponseStatus;
+    /**
+     * 414 Request-URI Too Long
+     */
+    static readonly REQUEST_URI_TOO_LONG: HttpResponseStatus;
+    /**
+     * 415 Unsupported Media Type
+     */
+    static readonly UNSUPPORTED_MEDIA_TYPE: HttpResponseStatus;
+    /**
+     * 416 Requested Range Not Satisfiable
+     */
+    static readonly REQUESTED_RANGE_NOT_SATISFIABLE: HttpResponseStatus;
+    /**
+     * 417 Expectation Failed
+     */
+    static readonly EXPECTATION_FAILED: HttpResponseStatus;
+    /**
+     * 421 Misdirected Request
+     *
+     * @see <a href="https://tools.ietf.org/html/rfc7540#section-9.1.2">421 (Misdirected Request) Status Code</a>
+     */
+    static readonly MISDIRECTED_REQUEST: HttpResponseStatus;
+    /**
+     * 422 Unprocessable Entity (WebDAV, RFC4918)
+     */
+    static readonly UNPROCESSABLE_ENTITY: HttpResponseStatus;
+    /**
+     * 423 Locked (WebDAV, RFC4918)
+     */
+    static readonly LOCKED: HttpResponseStatus;
+    /**
+     * 424 Failed Dependency (WebDAV, RFC4918)
+     */
+    static readonly FAILED_DEPENDENCY: HttpResponseStatus;
+    /**
+     * 425 Unordered Collection (WebDAV, RFC3648)
+     */
+    static readonly UNORDERED_COLLECTION: HttpResponseStatus;
+    /**
+     * 426 Upgrade Required (RFC2817)
+     */
+    static readonly UPGRADE_REQUIRED: HttpResponseStatus;
+    /**
+     * 428 Precondition Required (RFC6585)
+     */
+    static readonly PRECONDITION_REQUIRED: HttpResponseStatus;
+    /**
+     * 429 Too Many Requests (RFC6585)
+     */
+    static readonly TOO_MANY_REQUESTS: HttpResponseStatus;
+    /**
+     * 431 Request Header Fields Too Large (RFC6585)
+     */
+    static readonly REQUEST_HEADER_FIELDS_TOO_LARGE: HttpResponseStatus;
+    /**
+     * 500 Internal Server Error
+     */
+    static readonly INTERNAL_SERVER_ERROR: HttpResponseStatus;
+    /**
+     * 501 Not Implemented
+     */
+    static readonly NOT_IMPLEMENTED: HttpResponseStatus;
+    /**
+     * 502 Bad Gateway
+     */
+    static readonly BAD_GATEWAY: HttpResponseStatus;
+    /**
+     * 503 Service Unavailable
+     */
+    static readonly SERVICE_UNAVAILABLE: HttpResponseStatus;
+    /**
+     * 504 Gateway Timeout
+     */
+    static readonly GATEWAY_TIMEOUT: HttpResponseStatus;
+    /**
+     * 505 HTTP Version Not Supported
+     */
+    static readonly HTTP_VERSION_NOT_SUPPORTED: HttpResponseStatus;
+    /**
+     * 506 Variant Also Negotiates (RFC2295)
+     */
+    static readonly VARIANT_ALSO_NEGOTIATES: HttpResponseStatus;
+    /**
+     * 507 Insufficient Storage (WebDAV, RFC4918)
+     */
+    static readonly INSUFFICIENT_STORAGE: HttpResponseStatus;
+    /**
+     * 510 Not Extended (RFC2774)
+     */
+    static readonly NOT_EXTENDED: HttpResponseStatus;
+    /**
+     * 511 Network Authentication Required (RFC6585)
+     */
+    static readonly NETWORK_AUTHENTICATION_REQUIRED: HttpResponseStatus;
+    private constructor();
+}
+export declare const fromJvmHttpResponseStatus: (jvmStatus: io.netty.handler.codec.http.HttpResponseStatus) => HttpResponseStatus;