gingersnap 0.22.0

package/networking/NetworkService.mjs

@@ -0,0 +1,373 @@
+import { __awaiter } from '../_virtual/_tslib.mjs';
+import { Model } from '../data/model/model.mjs';
+import * as R from 'ramda';
+import { CallExecutionError } from '../errors/CallExecutionError.mjs';
+import '../data/model/types.mjs';
+import { Credentials } from '../data/model/credentials.mjs';
+import { ResponseType, BodyType } from './types.mjs';
+import { Call } from '../stream/call.mjs';
+import { THROTTLE_DEFAULT_MS } from './decorators/options.mjs';
+import { CachingMethod } from './decorators/requests.mjs';
+import { HTTPStatus } from './http.mjs';
+import 'uuid';
+import { request } from './request.mjs';
+import { Future } from '../future/future.mjs';
+import { Stream } from '../stream.mjs';
+import hash from 'object-hash';
+import { CacheManager } from '../data/store/manager.mjs';
+import { Collectors } from '../stream/collector.mjs';
+
+/**
+ * A Snap Service for managing network requests
+ */
+class NetworkService {
+    constructor({ baseUrl, retryLimit, cacheManager } = {}) {
+        var _a, _b, _c;
+        this.retryLimit = retryLimit;
+        this.__internal__ = (_a = this.__internal__) !== null && _a !== void 0 ? _a : { classConfig: {}, methodConfig: {} };
+        this.baseUrl = (_c = (_b = this.__internal__.classConfig.baseUrl) !== null && _b !== void 0 ? _b : baseUrl) !== null && _c !== void 0 ? _c : "";
+        this.cacheManager = cacheManager !== null && cacheManager !== void 0 ? cacheManager : new CacheManager();
+    }
+    /**
+     * Converts the given value to a JSON object
+     * @param value Any data
+     * @private
+     */
+    convertToJSON(value) {
+        if (value instanceof Model) {
+            return value.json();
+        }
+        else if (value instanceof Array || Array.isArray(value)) {
+            return `[${value.map((v) => this.convertToJSON(v))}]`;
+        }
+        return typeof value === "string" ? value : JSON.stringify(value);
+    }
+    /**
+     * Internal method called to wrap all network request methods with actual networking functionalities
+     * @private
+     */
+    __setup__() {
+        const hostname = this.baseUrl;
+        const self = this;
+        R.forEach(([key, value]) => {
+            var _a, _b, _c, _d, _e, _f;
+            let headers = (_a = value.headers) !== null && _a !== void 0 ? _a : {};
+            const apiPath = (_b = value.apiPath) !== null && _b !== void 0 ? _b : "";
+            const oldMethod = self[key];
+            const auth = { global: (_f = (_d = (_c = value.authRefresher) === null || _c === void 0 ? void 0 : _c.global) !== null && _d !== void 0 ? _d : (_e = value.authenticator) === null || _e === void 0 ? void 0 : _e.global) !== null && _f !== void 0 ? _f : false };
+            if (value.requestType === undefined) {
+                this.__setup_authentication__(value, key, self[key], auth);
+                return;
+            }
+            const requestType = value.requestType;
+            const cacheInfo = value.cache;
+            let cache;
+            if (cacheInfo) {
+                cache = this.cacheManager.createCache(this.baseUrl, cacheInfo.persist, (resp) => __awaiter(this, void 0, void 0, function* () {
+                    return JSON.stringify({
+                        headers: Object.fromEntries(resp.headers),
+                        status: resp.status,
+                        statusText: resp.statusText,
+                        body: yield Stream.of(resp.body).collect(Collectors.asList()),
+                    });
+                }), (v) => {
+                    const { headers, status, statusText, body } = JSON.parse(v);
+                    return new Response(Stream.of(body).readableStream, { status, statusText, headers });
+                }, undefined, cacheInfo.duration);
+            }
+            self[key] = (...args) => {
+                var _a;
+                let url = new URL((hostname.endsWith("/") ? hostname.substring(0, hostname.length) : hostname) +
+                    (apiPath.startsWith("/") ? apiPath : "/" + apiPath));
+                return new Call((signal) => __awaiter(this, void 0, void 0, function* () {
+                    headers = Object.assign(Object.assign({}, headers), this.__get_auth_headers__(auth));
+                    const result = this.__constructor_call_args__(url, headers, value, args);
+                    headers = result.headers;
+                    url = result.url;
+                    const body = result.body;
+                    if (cache && cacheInfo.method === CachingMethod.HIT_FIRST) {
+                        let key = `${url.toString()}-${requestType.toString()}-${hash.sha1(headers)}`;
+                        if (body) {
+                            key += hash(body);
+                        }
+                        const result = yield cache.get(key).registerSignal(signal);
+                        if (result) {
+                            return result.clone();
+                        }
+                    }
+                    const lookup = (retries = 0) => request(url, { headers, method: requestType.toString(), body }).thenApply(({ value: resp }) => __awaiter(this, void 0, void 0, function* () {
+                        let credentials;
+                        if (resp.status === HTTPStatus.UNAUTHORIZED &&
+                            !value.noAuth &&
+                            self[key] !== auth.authenticator &&
+                            self[key] !== auth.authRefresher &&
+                            (credentials = yield this.__get_credentials__(auth))) {
+                            return request(url, {
+                                headers: Object.assign(Object.assign({}, headers), credentials.buildAuthHeaders()),
+                                method: requestType.toString(),
+                                body,
+                            });
+                        }
+                        else if ((resp.status === HTTPStatus.GATEWAY_TIMEOUT || resp.status === HTTPStatus.SERVICE_UNAVAILABLE) &&
+                            self.retryLimit &&
+                            retries < self.retryLimit) {
+                            return Future.sleep({ milliseconds: THROTTLE_DEFAULT_MS }).thenApply(() => lookup(retries + 1));
+                        }
+                        if (cache) {
+                            let key = `${url.toString()}-${requestType.toString()}-${hash.sha1(headers)}`;
+                            if (resp.ok) {
+                                if (body) {
+                                    key += hash(body);
+                                }
+                                cache.set(key, resp.clone());
+                            }
+                            else if (cache && !resp.ok && cacheInfo.method === CachingMethod.FALLBACK_ON_MISSING) {
+                                return cache.get(key);
+                            }
+                        }
+                        return resp;
+                    }));
+                    return lookup().registerSignal(signal);
+                }), oldMethod, value.responseClass, value.throttle, (_a = value.responseType) !== null && _a !== void 0 ? _a : ResponseType.NONE, value.responseArray);
+            };
+            this.__setup_authentication__(value, key, self[key], auth);
+        }, R.toPairs(this.__internal__.methodConfig));
+    }
+    __constructor_call_args__(url, headers, value, args) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        let body;
+        if (value.parameters) {
+            const paramHeaders = (_a = value.parameters.headers) !== null && _a !== void 0 ? _a : {};
+            const paramQueries = (_b = value.parameters.queries) !== null && _b !== void 0 ? _b : {};
+            const paramHeaderPairs = R.concat(R.toPairs(paramHeaders), R.map((k) => [k, paramHeaders[k]], Object.getOwnPropertySymbols(paramHeaders)));
+            const paramQueryPairs = R.concat(R.toPairs(paramQueries), R.map((k) => [k, paramQueries[k]], Object.getOwnPropertySymbols(paramQueries)));
+            R.forEach(([key, index]) => {
+                const arg = args[index];
+                if (arg === undefined) {
+                    throw new CallExecutionError(`header parameter is missing at index ${index}`);
+                }
+                if (typeof key === "symbol" && typeof arg === "object") {
+                    headers = Object.assign(Object.assign({}, headers), arg);
+                }
+                else {
+                    headers[key] = headers[key] ? `${R.prop(key, headers)};${String(args[index])}` : String(args[index]);
+                }
+            }, paramHeaderPairs);
+            R.forEach(([key, index]) => {
+                if (args[index] === undefined) {
+                    throw new CallExecutionError(`path parameter is missing at index ${index}`);
+                }
+                url.pathname = url.pathname.replace(encodeURI(`{${key}}`), encodeURI(args[index]));
+            }, R.toPairs((_c = value.parameters.pathVariables) !== null && _c !== void 0 ? _c : {}));
+            R.forEach(([key, index]) => {
+                const arg = args[index];
+                if (arg === undefined) {
+                    throw new CallExecutionError(`query parameter is missing at index ${index}`);
+                }
+                if (typeof key === "symbol" && typeof arg === "object") {
+                    R.forEach(([k, v]) => {
+                        url.searchParams.set(k, v);
+                    }, R.toPairs(arg));
+                }
+                else {
+                    url.searchParams.set(key, arg);
+                }
+            }, paramQueryPairs);
+            if ((_d = value.parameters.body) === null || _d === void 0 ? void 0 : _d.type) {
+                switch (value.parameters.body.type) {
+                    case BodyType.STRING: {
+                        const index = (_e = value.parameters.body.parameterIndex) !== null && _e !== void 0 ? _e : -1;
+                        if (args[index] === undefined) {
+                            throw new CallExecutionError(`body parameter is missing at index ${index}`);
+                        }
+                        body = this.convertToJSON(args[index]);
+                        break;
+                    }
+                    case BodyType.JSON: {
+                        headers["Content-Type"] = (_f = headers["Content-Type"]) !== null && _f !== void 0 ? _f : "application/json";
+                        const index = (_g = value.parameters.body.parameterIndex) !== null && _g !== void 0 ? _g : -1;
+                        let data = {};
+                        if (args[index] === undefined) {
+                            const fields = value.parameters.body.fields;
+                            if (!fields) {
+                                throw new CallExecutionError(`body parameter is missing at index ${index}`);
+                            }
+                            R.forEach(([key, index]) => {
+                                const arg = args[index];
+                                if (arg === undefined) {
+                                    throw new CallExecutionError(`form field is missing at index ${index}`);
+                                }
+                                data[key] = arg;
+                            }, R.toPairs((_h = value.parameters.body.fields) !== null && _h !== void 0 ? _h : {}));
+                            R.forEach(([key, index]) => {
+                                const arg = args[index];
+                                if (arg !== undefined && arg !== null) {
+                                    data[key] = arg;
+                                }
+                            }, R.toPairs((_j = value.parameters.body.optionalFields) !== null && _j !== void 0 ? _j : {}));
+                        }
+                        else {
+                            data = args[index];
+                        }
+                        body = this.convertToJSON(data);
+                        break;
+                    }
+                    case BodyType.XML: {
+                        const index = value.parameters.body.parameterIndex;
+                        const arg = args[index];
+                        if (arg === undefined) {
+                            throw new CallExecutionError(`body parameter is missing at index ${index}`);
+                        }
+                        body = arg instanceof Model ? arg.xml() : new XMLSerializer().serializeToString(arg);
+                        break;
+                    }
+                    case BodyType.FORMURLENCODED: {
+                        headers["Content-Type"] = (_k = headers["Content-Type"]) !== null && _k !== void 0 ? _k : "application/x-www-form-urlencoded";
+                        const formData = new URLSearchParams();
+                        R.forEach(([key, index]) => {
+                            const arg = args[index];
+                            if (arg === undefined) {
+                                throw new CallExecutionError(`form field is missing at index ${index}`);
+                            }
+                            formData.set(key, arg);
+                        }, R.toPairs((_l = value.parameters.body.fields) !== null && _l !== void 0 ? _l : {}));
+                        R.forEach(([key, index]) => {
+                            const arg = args[index];
+                            if (arg !== undefined && arg !== null) {
+                                formData.set(key, arg);
+                            }
+                        }, R.toPairs((_m = value.parameters.body.optionalFields) !== null && _m !== void 0 ? _m : {}));
+                        body = formData;
+                        break;
+                    }
+                    case BodyType.MULTIPART: {
+                        headers["Content-Type"] = (_o = headers["Content-Type"]) !== null && _o !== void 0 ? _o : "multipart/form-data";
+                        const formData = new FormData();
+                        R.forEach(([key, index]) => {
+                            const arg = args[index];
+                            if (arg === undefined) {
+                                throw new CallExecutionError(`form part is missing at index ${index}`);
+                            }
+                            formData.append(key, arg);
+                        }, R.toPairs((_p = value.parameters.body.parts) !== null && _p !== void 0 ? _p : {}));
+                        body = formData;
+                        break;
+                    }
+                    default:
+                        throw new CallExecutionError(`Unsupported body type: ${(_q = value.parameters.body) === null || _q === void 0 ? void 0 : _q.type}`);
+                }
+            }
+        }
+        return { body, headers, url };
+    }
+    /**
+     * Retrieves the authentication headers
+     * @param auth AuthInstance
+     * @private
+     */
+    __get_auth_headers__(auth) {
+        const classRef = this.constructor;
+        if (!auth.global && classRef.credentials)
+            return classRef.credentials.buildAuthHeaders();
+        else if (auth.global && NetworkService.credentials)
+            return NetworkService.credentials.buildAuthHeaders();
+        return {};
+    }
+    /**
+     * Retrieves the auth credentials, and if no valid on exists, attempt to fetch it via the authenticator/authRefresher
+     * @param auth AuthInstance
+     * @private
+     */
+    __get_credentials__(auth) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result;
+            let credentials;
+            const classRef = this.constructor;
+            if (auth.global && NetworkService.credentials && auth.authRefresher) {
+                result = auth.authRefresher(NetworkService.credentials);
+            }
+            else if (!auth.global && classRef.credentials && auth.authRefresher) {
+                result = auth.authRefresher(classRef.credentials);
+            }
+            else if (auth.authenticator) {
+                result = auth.authenticator();
+            }
+            else {
+                return;
+            }
+            if (result instanceof Call) {
+                credentials = yield result.execute();
+            }
+            else if (result instanceof Promise) {
+                credentials = yield result;
+            }
+            else {
+                credentials = result;
+            }
+            if (auth.global)
+                NetworkService.credentials = credentials;
+            else
+                classRef.credentials = credentials;
+            return credentials;
+        });
+    }
+    /**
+     * Configures authentication if none exist by assigning the authenticator to the correct scope
+     * (Global -> Service, Local -> this)
+     * @param config MethodConfiguration
+     * @param methodName name of the method that should hold the authenticator
+     * @param functor authenticator
+     * @param auth AuthInstance
+     * @private
+     */
+    __setup_authentication__(config, methodName, functor, auth) {
+        const classRef = this.constructor;
+        if (config.authenticator) {
+            if (config.authenticator.global && !NetworkService.authenticator) {
+                NetworkService.authenticator = functor;
+            }
+            else if (!config.authenticator.global && !classRef.authenticator) {
+                classRef.authenticator = functor;
+            }
+            const parentRef = config.authenticator.global ? NetworkService : classRef;
+            const oldMethod = this[methodName];
+            this[methodName] = (...args) => {
+                const result = oldMethod(...args);
+                if (result instanceof Promise) {
+                    return result.then((v) => {
+                        if (v instanceof Credentials) {
+                            parentRef.credentials = v;
+                        }
+                        return v;
+                    });
+                }
+                else if (result instanceof Credentials) {
+                    parentRef.credentials = result;
+                }
+                return result;
+            };
+        }
+        if (config.authRefresher) {
+            if (config.authRefresher.global && !NetworkService.authRefresher) {
+                NetworkService.authRefresher = functor;
+            }
+            else if (!config.authRefresher.global && !classRef.authRefresher) {
+                classRef.authRefresher = functor;
+            }
+        }
+        if (NetworkService.authenticator) {
+            auth.authenticator = NetworkService.authenticator;
+        }
+        else if (classRef.authenticator) {
+            auth.authenticator = classRef.authenticator;
+        }
+        if (NetworkService.authRefresher) {
+            auth.authRefresher = NetworkService.authRefresher;
+        }
+        else if (classRef.authRefresher) {
+            auth.authRefresher = classRef.authRefresher;
+        }
+    }
+}
+
+export { NetworkService };

package/networking/SocketService.cjs

@@ -0,0 +1,218 @@
+'use strict';
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var NetworkService = require('./NetworkService.cjs');
+var socket = require('../socket.cjs');
+var R = require('ramda');
+var CallExecutionError = require('../errors/CallExecutionError.cjs');
+var ParsingError = require('../errors/ParsingError.cjs');
+var stream = require('../stream.cjs');
+var future = require('../future/future.cjs');
+var result = require('../future/result.cjs');
+var json = require('../data/decoders/json.cjs');
+require('@msgpack/msgpack');
+var model = require('../data/model/model.cjs');
+require('../data/model/types.cjs');
+require('../data/model/credentials.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+class WebSocketService extends NetworkService.NetworkService {
+    constructor(_a = {}) {
+        var { decoder } = _a, other = _tslib.__rest(_a, ["decoder"]);
+        super(other !== null && other !== void 0 ? other : {});
+        const internals = this.__internal__;
+        this.socket = new socket.StreamableWebSocket(this.baseUrl, decoder !== null && decoder !== void 0 ? decoder : (internals.classConfig.Decoder ? new internals.classConfig.Decoder() : new json.JSONDecoder()));
+    }
+    get connected() {
+        return this.socket.opened;
+    }
+    /**
+     * Called when socket connection is closed
+     * @protected
+     */
+    onceConnectionClosed() { }
+    /**
+     * Shutdown the socket connection
+     */
+    shutdown() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this.socket.close();
+            this.onceConnectionClosed();
+            yield this.socket.closedFuture();
+        });
+    }
+    /**
+     * Awaits socket closed
+     */
+    closedFuture() {
+        return this.socket.closedFuture();
+    }
+    ready() {
+        return future.Future.shield(this.socket.open());
+    }
+    __setup__() {
+        const internals = this.__internal__;
+        if (this.socket.decoder.load) {
+            this.socket.decoder.load();
+        }
+        const socketMethods = R__namespace.filter(([_, v]) => { var _a, _b; return ((_b = (_a = v.socketReadStream) !== null && _a !== void 0 ? _a : v.socketWriteStream) !== null && _b !== void 0 ? _b : v.socketRequestReply) !== undefined; }, R__namespace.toPairs(internals.methodConfig));
+        R__namespace.forEach(([key, config]) => {
+            var _a;
+            const oldMethod = this[key];
+            const details = (_a = internals.methodConfig[key]) === null || _a === void 0 ? void 0 : _a.socketReadStream;
+            let dataComparator = (v) => false;
+            if (config.socketReadStream) {
+                if (!details)
+                    throw new ParsingError.ParsingError([], "ReadStreamDetailsMissing");
+                if (!config.responseClass)
+                    throw new ParsingError.ParsingError([], "ResponseTypeMissing");
+                let equalsChecker;
+                switch (typeof details.value) {
+                    case "boolean":
+                        equalsChecker = R__namespace.equals(Boolean(details.value));
+                        break;
+                    case "string":
+                        equalsChecker = R__namespace.equals(String(details.value));
+                        break;
+                    case "number":
+                        equalsChecker = R__namespace.equals(Number(details.value));
+                        break;
+                    default:
+                        if (details.value instanceof RegExp)
+                            equalsChecker = details.value.test;
+                        else
+                            equalsChecker = R__namespace.equals(details.value);
+                }
+                dataComparator = R__namespace.compose((v) => equalsChecker(v), R__namespace.view(typeof details.keyPath === "string" ? R__namespace.lensProp(details.keyPath) : R__namespace.lensPath(details.keyPath)));
+            }
+            // TODO add caching for websockets
+            // const cacheInfo = config.cache;
+            // let cache: Cache<string, ArrayBuffer> | undefined;
+            //
+            // if (cacheInfo) {
+            //   cache = this.cacheManager.createCache(
+            //     this.baseUrl,
+            //     cacheInfo.persist,
+            //     async (buffer) => JSON.stringify(new Uint8Array(buffer)),
+            //     (v) => Uint8Array.of(JSON.parse(v)).buffer,
+            //     undefined,
+            //     cacheInfo.duration
+            //   );
+            // }
+            this[key] = (body) => {
+                var _a, _b;
+                if (config.socketRequestReply) {
+                    const guid = config.socketRequestReply.guidGen();
+                    const lens = R__namespace.lensPath(config.socketRequestReply.guidPath);
+                    return stream.Stream.seed(() => future.Future.of(() => _tslib.__awaiter(this, void 0, void 0, function* () {
+                        if (!this.socket.opened) {
+                            yield this.socket.open();
+                        }
+                        let data = body;
+                        if (body instanceof model.Model) {
+                            data = body.object();
+                        }
+                        data = R__namespace.set(lens, guid, data);
+                        yield this.socket.send(JSON.stringify(data));
+                        return 1;
+                    })))
+                        .map(() => this.socket.streamView(R__namespace.compose(R__namespace.equals(guid), R__namespace.view(lens)), config.socketRequestReply.objectMaxSize, config.socketRequestReply.expiryPeriod))
+                        .map((data) => {
+                        if (config.responseClass.prototype instanceof model.Model) {
+                            const ModelClass = config.responseClass;
+                            return ModelClass.fromJSON(data);
+                        }
+                        return config.responseClass(data);
+                    })
+                        .flatten()
+                        .map((v) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                        let result$1 = oldMethod(v);
+                        if (result$1 === null || result$1 === undefined)
+                            return v;
+                        if (result$1 instanceof Promise)
+                            result$1 = yield result$1;
+                        if (result$1 instanceof result.FutureResult)
+                            result$1 = result$1.value;
+                        return result$1;
+                    }));
+                }
+                else if (config.socketWriteStream) {
+                    if (body === undefined || body === null)
+                        throw new CallExecutionError.CallExecutionError("Empty body detected for a write stream");
+                    return new stream.Stream((signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                        if (!this.socket.opened) {
+                            yield this.socket.open();
+                        }
+                        if (body instanceof model.Model) {
+                            yield this.socket.send(body.blob());
+                        }
+                        else if (body instanceof ArrayBuffer || body instanceof Blob) {
+                            yield this.socket.send(body);
+                        }
+                        else {
+                            yield this.socket.send(JSON.stringify(body));
+                        }
+                        const result = oldMethod();
+                        if (result instanceof Promise) {
+                            yield result;
+                        }
+                        return null;
+                    })).once();
+                }
+                else {
+                    let stream = this.socket.streamView(dataComparator);
+                    if (((_a = config.socketReadStream) === null || _a === void 0 ? void 0 : _a.skip) !== undefined)
+                        stream = stream.skip(config.socketReadStream.skip);
+                    if (((_b = config.socketReadStream) === null || _b === void 0 ? void 0 : _b.take) !== undefined)
+                        stream = stream.take(config.socketReadStream.take);
+                    return stream
+                        .map((data) => {
+                        if (config.responseClass.prototype instanceof model.Model) {
+                            const ModelClass = config.responseClass;
+                            return ModelClass.fromJSON(data);
+                        }
+                        return config.responseClass(data);
+                    })
+                        .flatten()
+                        .map((v) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                        let result$1 = oldMethod(v);
+                        if (result$1 === null || result$1 === undefined)
+                            return v;
+                        if (result$1 instanceof Promise)
+                            result$1 = yield result$1;
+                        if (result$1 instanceof result.FutureResult)
+                            result$1 = result$1.value;
+                        return result$1;
+                    }));
+                }
+            };
+        }, socketMethods);
+        if (!this.socket.opened) {
+            void this.socket.open();
+        }
+        const originalMethodConfig = internals.methodConfig;
+        internals.methodConfig = R__namespace.fromPairs(R__namespace.filter(([_, v]) => !(v.socketReadStream && v.socketWriteStream), R__namespace.toPairs(internals.methodConfig)));
+        super.__setup__();
+        internals.methodConfig = originalMethodConfig;
+    }
+}
+
+exports.WebSocketService = WebSocketService;

package/networking/SocketService.d.ts

@@ -0,0 +1,23 @@
+import { NetworkService } from "./NetworkService";
+import { Future } from "../future";
+import { GingerSnapProps } from "./index";
+export declare class WebSocketService extends NetworkService {
+    private readonly socket;
+    constructor({ decoder, ...other }?: GingerSnapProps);
+    get connected(): boolean;
+    /**
+     * Called when socket connection is closed
+     * @protected
+     */
+    protected onceConnectionClosed(): void;
+    /**
+     * Shutdown the socket connection
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Awaits socket closed
+     */
+    closedFuture(): Future<void>;
+    ready(): Future<void>;
+    protected __setup__(): void;
+}