mavenagi 1.2.9 → 1.2.11

package/dist/core/schemas/builders/primitives/boolean.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare const boolean: () => Schema<boolean, boolean>;

package/dist/core/schemas/builders/primitives/number.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare const number: () => Schema<number, number>;

package/dist/core/schemas/builders/primitives/string.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare const string: () => Schema<string, string>;

package/dist/core/schemas/builders/primitives/unknown.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare const unknown: () => Schema<unknown, unknown>;

package/dist/core/schemas/builders/record/record.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "../../Schema";
-import { RecordSchema } from "./types";
+import { type Schema } from "../../Schema";
+import type { RecordSchema } from "./types";
 export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

package/dist/core/schemas/builders/record/record.js

@@ -6,7 +6,7 @@ const entries_1 = require("../../utils/entries");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 function record(keySchema, valueSchema) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -41,7 +41,7 @@ function record(keySchema, valueSchema) {
         },
         getType: () => Schema_1.SchemaType.RECORD,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
 }
 function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
@@ -63,7 +63,7 @@ function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transfo
         let key = stringKey;
         if (isKeyNumeric) {
             const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
-            if (!isNaN(numberKey)) {
+            if (!Number.isNaN(numberKey)) {
                 key = numberKey;
             }
         }

package/dist/core/schemas/builders/record/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema } from "../../Schema";
-import { SchemaUtils } from "../schema-utils";
+import type { BaseSchema } from "../../Schema";
+import type { SchemaUtils } from "../schema-utils/index";
 export type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
 export type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;

package/dist/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare class JsonError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/dist/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare class ParseError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
+import { type BaseSchema, type Schema, type SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
     nullable: () => Schema<Raw | null, Parsed | null>;
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;

package/dist/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -1,2 +1,2 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare function stringifyValidationError(error: ValidationError): string;

package/dist/core/schemas/builders/set/set.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function set<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Set<Parsed>>;

package/dist/core/schemas/builders/set/set.js

@@ -4,10 +4,10 @@ exports.set = set;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const list_1 = require("../list");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../list/index");
+const index_2 = require("../schema-utils/index");
 function set(schema) {
-    const listSchema = (0, list_1.list)(schema);
+    const listSchema = (0, index_1.list)(schema);
     const baseSchema = {
         parse: (raw, opts) => {
             const parsedList = listSchema.parse(raw, opts);
@@ -39,5 +39,5 @@ function set(schema) {
         },
         getType: () => Schema_1.SchemaType.SET,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_2.getSchemaUtils)(baseSchema));
 }

package/dist/core/schemas/builders/undiscriminated-union/types.d.ts

@@ -1,4 +1,4 @@
-import { inferParsed, inferRaw, Schema } from "../../Schema";
+import type { inferParsed, inferRaw, Schema } from "../../Schema";
 export type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
 export type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
 export type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "../../Schema";
-import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
+import { type Schema } from "../../Schema";
+import type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
 export declare function undiscriminatedUnion<Schemas extends [Schema<any, any>, ...Schema<any, any>[]]>(schemas: Schemas): Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.undiscriminatedUnion = undiscriminatedUnion;
 const Schema_1 = require("../../Schema");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const schema_utils_1 = require("../schema-utils");
+const index_1 = require("../schema-utils/index");
 function undiscriminatedUnion(schemas) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -14,7 +14,7 @@ function undiscriminatedUnion(schemas) {
         },
         getType: () => Schema_1.SchemaType.UNDISCRIMINATED_UNION,
     };
-    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
 }
 function validateAndTransformUndiscriminatedUnion(transform, schemas, opts) {
     const errors = [];

package/dist/core/schemas/builders/union/types.d.ts

@@ -1,5 +1,5 @@
-import { inferParsedObject, inferRawObject, ObjectSchema } from "../object";
-import { Discriminant } from "./discriminant";
+import type { inferParsedObject, inferRawObject, ObjectSchema } from "../object/index";
+import type { Discriminant } from "./discriminant";
 export type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
     [K in DiscriminantValues]: ObjectSchema<any, any>;
 };

package/dist/core/schemas/builders/union/union.d.ts

@@ -1,4 +1,4 @@
-import { ObjectLikeSchema } from "../object-like";
-import { Discriminant } from "./discriminant";
-import { inferParsedUnion, inferRawUnion, UnionSubtypes } from "./types";
+import { type ObjectLikeSchema } from "../object-like";
+import type { Discriminant } from "./discriminant";
+import type { inferParsedUnion, inferRawUnion, UnionSubtypes } from "./types";
 export declare function union<D extends string | Discriminant<any, any>, U extends UnionSubtypes<any>>(discriminant: D, union: U): ObjectLikeSchema<inferRawUnion<D, U>, inferParsedUnion<D, U>>;

package/dist/core/schemas/builders/union/union.js

@@ -17,15 +17,15 @@ const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageFo
 const isPlainObject_1 = require("../../utils/isPlainObject");
 const keys_1 = require("../../utils/keys");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
-const enum_1 = require("../enum");
+const index_1 = require("../enum/index");
 const object_like_1 = require("../object-like");
-const schema_utils_1 = require("../schema-utils");
+const index_2 = require("../schema-utils/index");
 function union(discriminant, union) {
     const rawDiscriminant = typeof discriminant === "string" ? discriminant : discriminant.rawDiscriminant;
     const parsedDiscriminant = typeof discriminant === "string"
         ? discriminant
         : discriminant.parsedDiscriminant;
-    const discriminantValueSchema = (0, enum_1.enum_)((0, keys_1.keys)(union));
+    const discriminantValueSchema = (0, index_1.enum_)((0, keys_1.keys)(union));
     const baseSchema = {
         parse: (raw, opts) => {
             return transformAndValidateUnion({
@@ -65,7 +65,7 @@ function union(discriminant, union) {
         },
         getType: () => Schema_1.SchemaType.UNION,
     };
-    return Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema));
+    return Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_2.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema));
 }
 function transformAndValidateUnion({ value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnrecognizedUnionMembers = false, transformAdditionalProperties, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {

package/dist/core/schemas/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./builders";
+export * from "./builders/index";
 export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";

package/dist/core/schemas/index.js

@@ -14,4 +14,4 @@ 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 });
-__exportStar(require("./builders"), exports);
+__exportStar(require("./builders/index"), exports);

package/dist/core/schemas/utils/createIdentitySchemaCreator.d.ts

@@ -1,2 +1,2 @@
-import { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
+import type { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
 export declare function createIdentitySchemaCreator<T>(schemaType: SchemaType, validate: (value: unknown, opts?: SchemaOptions) => MaybeValid<T>): () => Schema<T, T>;

package/dist/core/schemas/utils/createIdentitySchemaCreator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIdentitySchemaCreator = createIdentitySchemaCreator;
-const schema_utils_1 = require("../builders/schema-utils");
+const index_1 = require("../builders/schema-utils/index");
 const maybeSkipValidation_1 = require("./maybeSkipValidation");
 function createIdentitySchemaCreator(schemaType, validate) {
     return () => {
@@ -10,6 +10,6 @@ function createIdentitySchemaCreator(schemaType, validate) {
             json: validate,
             getType: () => schemaType,
         };
-        return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+        return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, index_1.getSchemaUtils)(baseSchema));
     };
 }

package/dist/core/schemas/utils/maybeSkipValidation.d.ts

@@ -1,2 +1,2 @@
-import { BaseSchema } from "../Schema";
+import type { BaseSchema } from "../Schema";
 export declare function maybeSkipValidation<S extends BaseSchema<Raw, Parsed>, Raw, Parsed>(schema: S): S;

package/dist/core/stream/Stream.d.ts

@@ -33,6 +33,7 @@ export declare class Stream<T> implements AsyncIterable<T> {
     private messageTerminator;
     private streamTerminator;
     private controller;
+    private decoder;
     constructor({ stream, parse, eventShape, signal }: Stream.Args & {
         parse: (val: unknown) => Promise<T>;
     });

package/dist/core/stream/Stream.js

@@ -47,6 +47,10 @@ class Stream {
             this.messageTerminator = eventShape.messageTerminator;
         }
         signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", () => this.controller.abort());
+        // Initialize shared TextDecoder
+        if (typeof TextDecoder !== "undefined") {
+            this.decoder = new TextDecoder("utf-8");
+        }
     }
     iterMessages() {
         return __asyncGenerator(this, arguments, function* iterMessages_1() {
@@ -63,7 +67,7 @@ class Stream {
                     buf += this.decodeChunk(chunk);
                     let terminatorIndex;
                     while ((terminatorIndex = buf.indexOf(this.messageTerminator)) >= 0) {
-                        let line = buf.slice(0, terminatorIndex + 1);
+                        let line = buf.slice(0, terminatorIndex);
                         buf = buf.slice(terminatorIndex + this.messageTerminator.length);
                         if (!line.trim()) {
                             continue;
@@ -116,10 +120,9 @@ class Stream {
     }
     decodeChunk(chunk) {
         let decoded = "";
-        // If TextDecoder is present, use it
-        if (typeof TextDecoder !== "undefined") {
-            const decoder = new TextDecoder("utf8");
-            decoded += decoder.decode(chunk);
+        // If TextDecoder is available, use the streaming decoder instance
+        if (this.decoder != null) {
+            decoded += this.decoder.decode(chunk, { stream: true });
         }
         // Buffer is present in Node.js environment
         else if (runtime_1.RUNTIME.type === "node" && typeof chunk !== "undefined") {

package/dist/core/url/encodePathParam.d.ts

@@ -0,0 +1 @@
+export declare function encodePathParam(param: unknown): string;

package/dist/core/url/encodePathParam.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePathParam = encodePathParam;
+function encodePathParam(param) {
+    if (param === null) {
+        return "null";
+    }
+    const typeofParam = typeof param;
+    switch (typeofParam) {
+        case "undefined":
+            return "undefined";
+        case "string":
+        case "number":
+        case "boolean":
+            break;
+        default:
+            param = String(param);
+            break;
+    }
+    return encodeURIComponent(param);
+}

package/dist/core/url/index.d.ts

@@ -1,2 +1,3 @@
+export { encodePathParam } from "./encodePathParam";
 export { join } from "./join";
 export { toQueryString } from "./qs";

package/dist/core/url/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toQueryString = exports.join = void 0;
+exports.toQueryString = exports.join = exports.encodePathParam = void 0;
+var encodePathParam_1 = require("./encodePathParam");
+Object.defineProperty(exports, "encodePathParam", { enumerable: true, get: function () { return encodePathParam_1.encodePathParam; } });
 var join_1 = require("./join");
 Object.defineProperty(exports, "join", { enumerable: true, get: function () { return join_1.join; } });
 var qs_1 = require("./qs");

package/dist/core/url/join.js

@@ -18,7 +18,7 @@ function join(base, ...segments) {
             return joinPath(base, ...segments);
         }
         const lastSegment = segments[segments.length - 1];
-        const shouldPreserveTrailingSlash = lastSegment && lastSegment.endsWith("/");
+        const shouldPreserveTrailingSlash = lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.endsWith("/");
         for (const segment of segments) {
             const cleanSegment = trimSlashes(segment);
             if (cleanSegment) {
@@ -38,7 +38,7 @@ function joinPath(base, ...segments) {
     }
     let result = base;
     const lastSegment = segments[segments.length - 1];
-    const shouldPreserveTrailingSlash = lastSegment && lastSegment.endsWith("/");
+    const shouldPreserveTrailingSlash = lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.endsWith("/");
     for (const segment of segments) {
         const cleanSegment = trimSlashes(segment);
         if (cleanSegment) {
@@ -54,7 +54,7 @@ function joinPathSegments(left, right) {
     if (left.endsWith("/")) {
         return left + right;
     }
-    return left + "/" + right;
+    return `${left}/${right}`;
 }
 function trimSlashes(str) {
     if (!str)

package/dist/core/websocket/events.d.ts

@@ -0,0 +1,36 @@
+export declare class Event {
+    target: any;
+    type: string;
+    constructor(type: string, target: any);
+}
+export declare class ErrorEvent extends Event {
+    message: string;
+    error: Error;
+    constructor(error: Error, target: any);
+}
+export declare class CloseEvent extends Event {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+    constructor(code: number | undefined, reason: string | undefined, target: any);
+}
+export interface WebSocketEventMap {
+    close: CloseEvent;
+    error: ErrorEvent;
+    message: MessageEvent;
+    open: Event;
+}
+export interface WebSocketEventListenerMap {
+    close: (event: CloseEvent) => void | {
+        handleEvent: (event: CloseEvent) => void;
+    };
+    error: (event: ErrorEvent) => void | {
+        handleEvent: (event: ErrorEvent) => void;
+    };
+    message: (event: MessageEvent) => void | {
+        handleEvent: (event: MessageEvent) => void;
+    };
+    open: (event: Event) => void | {
+        handleEvent: (event: Event) => void;
+    };
+}

package/dist/core/websocket/events.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloseEvent = exports.ErrorEvent = exports.Event = void 0;
+class Event {
+    constructor(type, target) {
+        this.target = target;
+        this.type = type;
+    }
+}
+exports.Event = Event;
+class ErrorEvent extends Event {
+    constructor(error, target) {
+        super("error", target);
+        this.message = error.message;
+        this.error = error;
+    }
+}
+exports.ErrorEvent = ErrorEvent;
+class CloseEvent extends Event {
+    constructor(code = 1000, reason = "", target) {
+        super("close", target);
+        this.wasClean = true;
+        this.code = code;
+        this.reason = reason;
+    }
+}
+exports.CloseEvent = CloseEvent;

package/dist/core/websocket/index.d.ts

@@ -0,0 +1 @@
+export * from "./ws";

package/dist/core/websocket/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./ws"), exports);

package/dist/core/websocket/ws.d.ts

@@ -0,0 +1,147 @@
+import * as Events from "./events";
+export type Event = Events.Event;
+export type ErrorEvent = Events.ErrorEvent;
+export type CloseEvent = Events.CloseEvent;
+export declare namespace ReconnectingWebSocket {
+    interface Args {
+        url: string;
+        protocols?: string | string[];
+        options?: ReconnectingWebSocket.Options;
+        headers?: Record<string, unknown>;
+        queryParameters?: Record<string, string | string[] | object | object[] | null | undefined>;
+    }
+    type Options = {
+        WebSocket?: any;
+        maxReconnectionDelay?: number;
+        minReconnectionDelay?: number;
+        reconnectionDelayGrowFactor?: number;
+        minUptime?: number;
+        connectionTimeout?: number;
+        maxRetries?: number;
+        maxEnqueuedMessages?: number;
+        startClosed?: boolean;
+        debug?: boolean;
+    };
+    type UrlProvider = string | (() => string) | (() => Promise<string>);
+    type Message = string | ArrayBuffer | Blob | ArrayBufferView;
+    type ListenersMap = {
+        error: Array<Events.WebSocketEventListenerMap["error"]>;
+        message: Array<Events.WebSocketEventListenerMap["message"]>;
+        open: Array<Events.WebSocketEventListenerMap["open"]>;
+        close: Array<Events.WebSocketEventListenerMap["close"]>;
+    };
+}
+export declare class ReconnectingWebSocket {
+    private _ws?;
+    private _listeners;
+    private _retryCount;
+    private _uptimeTimeout;
+    private _connectTimeout;
+    private _shouldReconnect;
+    private _connectLock;
+    private _binaryType;
+    private _closeCalled;
+    private _messageQueue;
+    private readonly _url;
+    private readonly _protocols?;
+    private readonly _options;
+    private readonly _headers?;
+    private readonly _queryParameters?;
+    constructor({ url, protocols, options, headers, queryParameters }: ReconnectingWebSocket.Args);
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    readonly CONNECTING: typeof ReconnectingWebSocket.CONNECTING;
+    readonly OPEN: typeof ReconnectingWebSocket.OPEN;
+    readonly CLOSING: typeof ReconnectingWebSocket.CLOSING;
+    readonly CLOSED: typeof ReconnectingWebSocket.CLOSED;
+    get binaryType(): BinaryType;
+    set binaryType(value: BinaryType);
+    /**
+     * Returns the number or connection retries
+     */
+    get retryCount(): number;
+    /**
+     * The number of bytes of data that have been queued using calls to send() but not yet
+     * transmitted to the network. This value resets to zero once all queued data has been sent.
+     * This value does not reset to zero when the connection is closed; if you keep calling send(),
+     * this will continue to climb. Read only
+     */
+    get bufferedAmount(): number;
+    /**
+     * The extensions selected by the server. This is currently only the empty string or a list of
+     * extensions as negotiated by the connection
+     */
+    get extensions(): string;
+    /**
+     * A string indicating the name of the sub-protocol the server selected;
+     * this will be one of the strings specified in the protocols parameter when creating the
+     * WebSocket object
+     */
+    get protocol(): string;
+    /**
+     * The current state of the connection; this is one of the Ready state constants
+     */
+    get readyState(): number;
+    /**
+     * The URL as resolved by the constructor
+     */
+    get url(): string;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+     */
+    onclose: ((event: Events.CloseEvent) => void) | null;
+    /**
+     * An event listener to be called when an error occurs
+     */
+    onerror: ((event: Events.ErrorEvent) => void) | null;
+    /**
+     * An event listener to be called when a message is received from the server
+     */
+    onmessage: ((event: MessageEvent) => void) | null;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+     * this indicates that the connection is ready to send and receive data
+     */
+    onopen: ((event: Event) => void) | null;
+    /**
+     * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+     * CLOSED, this method does nothing
+     */
+    close(code?: number, reason?: string): void;
+    /**
+     * Closes the WebSocket connection or connection attempt and connects again.
+     * Resets retry counter;
+     */
+    reconnect(code?: number, reason?: string): void;
+    /**
+     * Enqueue specified data to be transmitted to the server over the WebSocket connection
+     */
+    send(data: ReconnectingWebSocket.Message): void;
+    /**
+     * Register an event handler of a specific event type
+     */
+    addEventListener<T extends keyof Events.WebSocketEventListenerMap>(type: T, listener: Events.WebSocketEventListenerMap[T]): void;
+    dispatchEvent(event: Event): boolean;
+    /**
+     * Removes an event listener
+     */
+    removeEventListener<T extends keyof Events.WebSocketEventListenerMap>(type: T, listener: Events.WebSocketEventListenerMap[T]): void;
+    private _debug;
+    private _getNextDelay;
+    private _wait;
+    private _getNextUrl;
+    private _connect;
+    private _handleTimeout;
+    private _disconnect;
+    private _acceptOpen;
+    private _callEventListener;
+    private _handleOpen;
+    private _handleMessage;
+    private _handleError;
+    private _handleClose;
+    private _removeListeners;
+    private _addListeners;
+    private _clearTimeouts;
+}