gingersnap 0.22.0

package/networking/SocketService.mjs

@@ -0,0 +1,197 @@
+import { __rest, __awaiter } from '../_virtual/_tslib.mjs';
+import { NetworkService } from './NetworkService.mjs';
+import { StreamableWebSocket } from '../socket.mjs';
+import * as R from 'ramda';
+import { CallExecutionError } from '../errors/CallExecutionError.mjs';
+import { ParsingError } from '../errors/ParsingError.mjs';
+import { Stream } from '../stream.mjs';
+import { Future } from '../future/future.mjs';
+import { FutureResult } from '../future/result.mjs';
+import { JSONDecoder } from '../data/decoders/json.mjs';
+import '@msgpack/msgpack';
+import { Model } from '../data/model/model.mjs';
+import '../data/model/types.mjs';
+import '../data/model/credentials.mjs';
+
+class WebSocketService extends NetworkService {
+    constructor(_a = {}) {
+        var { decoder } = _a, other = __rest(_a, ["decoder"]);
+        super(other !== null && other !== void 0 ? other : {});
+        const internals = this.__internal__;
+        this.socket = new StreamableWebSocket(this.baseUrl, decoder !== null && decoder !== void 0 ? decoder : (internals.classConfig.Decoder ? new internals.classConfig.Decoder() : new JSONDecoder()));
+    }
+    get connected() {
+        return this.socket.opened;
+    }
+    /**
+     * Called when socket connection is closed
+     * @protected
+     */
+    onceConnectionClosed() { }
+    /**
+     * Shutdown the socket connection
+     */
+    shutdown() {
+        return __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.shield(this.socket.open());
+    }
+    __setup__() {
+        const internals = this.__internal__;
+        if (this.socket.decoder.load) {
+            this.socket.decoder.load();
+        }
+        const socketMethods = R.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.toPairs(internals.methodConfig));
+        R.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([], "ReadStreamDetailsMissing");
+                if (!config.responseClass)
+                    throw new ParsingError([], "ResponseTypeMissing");
+                let equalsChecker;
+                switch (typeof details.value) {
+                    case "boolean":
+                        equalsChecker = R.equals(Boolean(details.value));
+                        break;
+                    case "string":
+                        equalsChecker = R.equals(String(details.value));
+                        break;
+                    case "number":
+                        equalsChecker = R.equals(Number(details.value));
+                        break;
+                    default:
+                        if (details.value instanceof RegExp)
+                            equalsChecker = details.value.test;
+                        else
+                            equalsChecker = R.equals(details.value);
+                }
+                dataComparator = R.compose((v) => equalsChecker(v), R.view(typeof details.keyPath === "string" ? R.lensProp(details.keyPath) : R.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.lensPath(config.socketRequestReply.guidPath);
+                    return Stream.seed(() => Future.of(() => __awaiter(this, void 0, void 0, function* () {
+                        if (!this.socket.opened) {
+                            yield this.socket.open();
+                        }
+                        let data = body;
+                        if (body instanceof Model) {
+                            data = body.object();
+                        }
+                        data = R.set(lens, guid, data);
+                        yield this.socket.send(JSON.stringify(data));
+                        return 1;
+                    })))
+                        .map(() => this.socket.streamView(R.compose(R.equals(guid), R.view(lens)), config.socketRequestReply.objectMaxSize, config.socketRequestReply.expiryPeriod))
+                        .map((data) => {
+                        if (config.responseClass.prototype instanceof Model) {
+                            const ModelClass = config.responseClass;
+                            return ModelClass.fromJSON(data);
+                        }
+                        return config.responseClass(data);
+                    })
+                        .flatten()
+                        .map((v) => __awaiter(this, void 0, void 0, function* () {
+                        let result = oldMethod(v);
+                        if (result === null || result === undefined)
+                            return v;
+                        if (result instanceof Promise)
+                            result = yield result;
+                        if (result instanceof FutureResult)
+                            result = result.value;
+                        return result;
+                    }));
+                }
+                else if (config.socketWriteStream) {
+                    if (body === undefined || body === null)
+                        throw new CallExecutionError("Empty body detected for a write stream");
+                    return new Stream((signal) => __awaiter(this, void 0, void 0, function* () {
+                        if (!this.socket.opened) {
+                            yield this.socket.open();
+                        }
+                        if (body instanceof 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) {
+                            const ModelClass = config.responseClass;
+                            return ModelClass.fromJSON(data);
+                        }
+                        return config.responseClass(data);
+                    })
+                        .flatten()
+                        .map((v) => __awaiter(this, void 0, void 0, function* () {
+                        let result = oldMethod(v);
+                        if (result === null || result === undefined)
+                            return v;
+                        if (result instanceof Promise)
+                            result = yield result;
+                        if (result instanceof FutureResult)
+                            result = result.value;
+                        return result;
+                    }));
+                }
+            };
+        }, socketMethods);
+        if (!this.socket.opened) {
+            void this.socket.open();
+        }
+        const originalMethodConfig = internals.methodConfig;
+        internals.methodConfig = R.fromPairs(R.filter(([_, v]) => !(v.socketReadStream && v.socketWriteStream), R.toPairs(internals.methodConfig)));
+        super.__setup__();
+        internals.methodConfig = originalMethodConfig;
+    }
+}
+
+export { WebSocketService };

package/networking/decorators/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./options";
+export * from "./requests";
+export * from "../http";
+export * from "./socket";

package/networking/decorators/options.cjs

@@ -0,0 +1,289 @@
+'use strict';
+
+var types = require('../types.cjs');
+var R = require('ramda');
+require('reflect-metadata');
+
+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);
+
+/// //// Constants ///////
+const THROTTLE_DEFAULT_MS = 3000;
+const SUPPORTED_HEADER_VALUES = ["String", "Number", "Boolean"];
+/// // // Helpers ///////
+const createProps = (constructor) => {
+    const proto = constructor.prototype;
+    if (proto.__internal__ === undefined) {
+        proto.__internal__ = { classConfig: {}, methodConfig: {} };
+    }
+    return proto;
+};
+const createResponseDecorator = (type) => ({ modelType, format, isArray, modelTypeMapping, modelTypeKeyPath } = {
+    modelType: String,
+    isArray: false,
+}) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "responseType"]);
+    const formatLens = R__namespace.lensPath(["methodConfig", propertyKey, "dataFormat"]);
+    const typeLens = R__namespace.lensPath(["methodConfig", propertyKey, "responseClass"]);
+    const isArrayLens = R__namespace.lensPath(["methodConfig", propertyKey, "responseArray"]);
+    proto.__internal__ = R__namespace.set(lens, type, proto.__internal__);
+    proto.__internal__ = R__namespace.set(typeLens, modelType, proto.__internal__);
+    proto.__internal__ = R__namespace.set(isArrayLens, isArray, proto.__internal__);
+    proto.__internal__ = R__namespace.set(formatLens, format, proto.__internal__);
+};
+const createRequestBodyDecorator = (type) => (target, propertyKey, parameterIndex) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "parameters", "body"]);
+    proto.__internal__ = R__namespace.set(lens, { type, parameterIndex }, proto.__internal__);
+};
+const createRequestMultiBodyDecorator = (type) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "parameters", "body"]);
+    const changer = R__namespace.compose(R__namespace.mergeDeepLeft({ type }), R__namespace.or(R__namespace.__, {}));
+    proto.__internal__ = R__namespace.over(lens, changer, proto.__internal__);
+};
+const createRequestMultiBodyParameterDecorator = (key) => (value) => (target, propertyKey, parameterIndex) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "parameters", "body", key]);
+    const changer = R__namespace.compose(R__namespace.mergeDeepLeft({ [value]: parameterIndex }), R__namespace.or(R__namespace.__, {}));
+    proto.__internal__ = R__namespace.over(lens, changer, proto.__internal__);
+};
+/**
+ * Sets the host for the Snap Service
+ * @param value host
+ * @constructor
+ */
+const BaseUrl = (value) => (constructor) => {
+    const proto = createProps(constructor);
+    proto.__internal__.classConfig.baseUrl = value;
+};
+/**
+ * Marks the SnapService method as on that returns a JSON Response of a specific Model type
+ */
+const JSONResponse = createResponseDecorator(types.ResponseType.JSON);
+/**
+ * Marks the SnapService method as on that returns a XML Response of a specific Model type
+ */
+const XMLResponse = createResponseDecorator(types.ResponseType.XML);
+/**
+ * Marks the SnapService method as on that returns a String Response
+ */
+const StringResponse = createResponseDecorator(types.ResponseType.STRING)({ modelType: String });
+/**
+ * Marks the SnapService method as on that returns a Blob
+ */
+const BinaryResponse = createResponseDecorator(types.ResponseType.BINARY)({ modelType: Blob });
+/**
+ * Marks the SnapService method as on that has no return value
+ */
+const NoResponse = createResponseDecorator(types.ResponseType.NONE)();
+/**
+ * Marks the SnapService method that it should use multipart/form-data when submitting the request
+ */
+const Multipart = createRequestMultiBodyDecorator(types.BodyType.MULTIPART);
+/**
+ * Marks the SnapService method that it should use application/x-www-form-urlencoded when submitting the request
+ */
+const FormUrlEncoded = createRequestMultiBodyDecorator(types.BodyType.FORMURLENCODED);
+/**
+ * Sets the headers for the request
+ * @param value MapOfHeaders
+ * @constructor
+ */
+const Headers = (value) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "headers"]);
+    const changer = R__namespace.compose(R__namespace.mergeDeepLeft(value), R__namespace.or(R__namespace.__, {}));
+    proto.__internal__ = R__namespace.over(lens, changer, proto.__internal__);
+};
+/**
+ * Throttles the request by 3 seconds
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+const Throttle = (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "throttle"]);
+    proto.__internal__ = R__namespace.set(lens, { waitPeriodInMs: THROTTLE_DEFAULT_MS }, proto.__internal__);
+};
+/**
+ * Throttles the request by the value provided
+ * @param value ThrottleByProps - An object that contains the waitPeriodInMs
+ * @constructor
+ */
+const ThrottleBy = (value) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "throttle"]);
+    proto.__internal__ = R__namespace.set(lens, value, proto.__internal__);
+};
+/**
+ * Marks this method as an authenticator. When requests receive 401 status code, this method will be called to retrieve
+ * the credentials
+ * @param type Credentials - Type of credentials that this authenticator should return
+ * (BasicCredentials | BearerCredentials | APIKeyCredentials | define one of your own by subclassing Credentials)
+ * @param global Whether this authenticator should be used across all services
+ * @param socketField
+ * @constructor
+ */
+const Authenticator = (type, global = false, socketField = "accessToken") => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "authenticator"]);
+    proto.__internal__ = R__namespace.over(lens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { type, global })), proto.__internal__);
+};
+/**
+ * Marks this method as an auth refresher. Whenever a request receives a 401 status code for invalid credentials, this
+ * method will be called with the old Credentials, and should produce new credentials
+ * @param type Credentials - Type of credentials that this authenticator should return
+ * (BasicCredentials | BearerCredentials | APIKeyCredentials | define one of your own by subclassing Credentials)
+ * @param global Whether this auth refresher should be used across all services
+ * @constructor
+ */
+const AuthRefresher = (type, global = false) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "authRefresher"]);
+    proto.__internal__ = R__namespace.over(lens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { type, global })), proto.__internal__);
+};
+/**
+ * Marks argument as a property in the MultiPart form
+ */
+const Part = createRequestMultiBodyParameterDecorator("parts");
+/**
+ * Marks argument as a property in the FormUrlEncoded  form or a JSON payload
+ */
+const Field = createRequestMultiBodyParameterDecorator("fields");
+/**
+ * Marks argument as a property in the FormUrlEncoded  form or JSON payload, but it can be missing
+ */
+const OptionalField = createRequestMultiBodyParameterDecorator("OptionalFields");
+/**
+ * Marks argument that should be deserialized to a JSON string and attached as the body of the request
+ */
+const JSONBody = createRequestBodyDecorator(types.BodyType.JSON);
+/**
+ * Marks argument that should be deserialized to XML string and attached as the body of the request
+ */
+const XMLBody = createRequestBodyDecorator(types.BodyType.XML);
+/**
+ * Marks argument that should be the body of the request, and is a string
+ */
+const StringBody = createRequestBodyDecorator(types.BodyType.STRING);
+/**
+ * Marks argument that should contain a Map of the queries used in the request. Argument should be an object with each
+ * key value pair being the query name and value
+ * @constructor
+ */
+const QueryMap = (target, propertyKey, parameterIndex) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "parameters", "queries"]);
+    proto.__internal__ = R__namespace.over(lens, R__namespace.compose(R__namespace.mergeLeft({ [Symbol(propertyKey)]: parameterIndex }, R__namespace.__), R__namespace.or(R__namespace.__, {})), proto.__internal__);
+};
+/**
+ * Marks argument as a path variable in the request url
+ * @param value Name of the path variable
+ * @constructor
+ */
+const Path = (value) => {
+    return (target, propertyKey, parameterIndex) => {
+        const type = R__namespace.path([parameterIndex, "name"], Reflect.getMetadata("design:paramtypes", target, propertyKey));
+        if (!["String", "Number"].includes(type)) {
+            throw Error("Invalid type given for @Query. Should be of type string or number");
+        }
+        const proto = createProps(target.constructor);
+        const lens = R__namespace.lensPath(["methodConfig", propertyKey, "parameters", "pathVariables"]);
+        proto.__internal__ = R__namespace.over(lens, R__namespace.compose(R__namespace.mergeDeepWith(R__namespace.concat, { [value]: parameterIndex }), R__namespace.or(R__namespace.__, {})), proto.__internal__);
+    };
+};
+/**
+ * Marks argument as a query to be attached to the request url
+ * @param value Name of the query
+ * @constructor
+ */
+const Query = (value) => {
+    return (target, propertyKey, parameterIndex) => {
+        const proto = createProps(target.constructor);
+        const lens = R__namespace.lensPath(["methodConfig", propertyKey, "parameters", "queries"]);
+        proto.__internal__ = R__namespace.over(lens, R__namespace.compose(R__namespace.mergeDeepWith(R__namespace.concat, { [value]: parameterIndex }), R__namespace.or(R__namespace.__, {})), proto.__internal__);
+    };
+};
+/**
+ * Marks argument as a header to be attached to the request
+ * @param value Name of the header
+ * @constructor
+ */
+const Header = (value) => {
+    return (target, propertyKey, parameterIndex) => {
+        const type = R__namespace.path([parameterIndex, "name"], Reflect.getMetadata("design:paramtypes", target, propertyKey));
+        if (!SUPPORTED_HEADER_VALUES.includes(type)) {
+            throw Error("Invalid type given for @HeaderMap. Should be of type string, number or boolean");
+        }
+        const proto = createProps(target.constructor);
+        const lens = R__namespace.lensPath(["methodConfig", propertyKey, "parameters", "headers"]);
+        proto.__internal__ = R__namespace.over(lens, R__namespace.compose(R__namespace.mergeDeepWith(R__namespace.concat, { [value]: parameterIndex }), R__namespace.or(R__namespace.__, {})), proto.__internal__);
+    };
+};
+/**
+ * Marks argument that should contain a Map of the headers used in the request. Argument should be an object with each
+ * key value pair being the header name and value
+ * @constructor
+ */
+const HeaderMap = (target, propertyKey, parameterIndex) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey, "parameters", "headers"]);
+    const key = Symbol(propertyKey);
+    proto.__internal__ = R__namespace.over(lens, R__namespace.compose(R__namespace.mergeLeft({ [key]: parameterIndex }, R__namespace.__), R__namespace.or(R__namespace.__, {})), proto.__internal__);
+};
+/**
+ * Disables any authenticator that should be applied to this method
+ * @constructor
+ */
+const NoAuth = (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R__namespace.lensPath(["methodConfig", propertyKey]);
+    proto.__internal__ = R__namespace.set(lens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { noAuth: true })), proto.__internal__);
+};
+
+exports.AuthRefresher = AuthRefresher;
+exports.Authenticator = Authenticator;
+exports.BaseUrl = BaseUrl;
+exports.BinaryResponse = BinaryResponse;
+exports.Field = Field;
+exports.FormUrlEncoded = FormUrlEncoded;
+exports.Header = Header;
+exports.HeaderMap = HeaderMap;
+exports.Headers = Headers;
+exports.JSONBody = JSONBody;
+exports.JSONResponse = JSONResponse;
+exports.Multipart = Multipart;
+exports.NoAuth = NoAuth;
+exports.NoResponse = NoResponse;
+exports.OptionalField = OptionalField;
+exports.Part = Part;
+exports.Path = Path;
+exports.Query = Query;
+exports.QueryMap = QueryMap;
+exports.StringBody = StringBody;
+exports.StringResponse = StringResponse;
+exports.THROTTLE_DEFAULT_MS = THROTTLE_DEFAULT_MS;
+exports.Throttle = Throttle;
+exports.ThrottleBy = ThrottleBy;
+exports.XMLBody = XMLBody;
+exports.XMLResponse = XMLResponse;
+exports.createProps = createProps;

package/networking/decorators/options.d.ts

@@ -0,0 +1,148 @@
+import { MapOfHeaders, ServiceInternalProps, ThrottleByProps } from "../types";
+import "reflect-metadata";
+import { DataFormat } from "../../data/model";
+interface ResponseDetails {
+    modelType?: any;
+    modelTypeMapping?: {
+        [string: string]: any;
+    };
+    modelTypeKeyPath?: string | Array<string | number>;
+    isArray?: boolean;
+    format?: DataFormat;
+}
+export declare const THROTTLE_DEFAULT_MS = 3000;
+export declare const createProps: (constructor: any) => {
+    __internal__: ServiceInternalProps;
+};
+/**
+ * Sets the host for the Snap Service
+ * @param value host
+ * @constructor
+ */
+export declare const BaseUrl: (value: string) => (constructor: any) => void;
+/**
+ * Marks the SnapService method as on that returns a JSON Response of a specific Model type
+ */
+export declare const JSONResponse: ({ modelType, format, isArray, modelTypeMapping, modelTypeKeyPath }?: ResponseDetails) => (target: any, propertyKey: string) => void;
+/**
+ * Marks the SnapService method as on that returns a XML Response of a specific Model type
+ */
+export declare const XMLResponse: ({ modelType, format, isArray, modelTypeMapping, modelTypeKeyPath }?: ResponseDetails) => (target: any, propertyKey: string) => void;
+/**
+ * Marks the SnapService method as on that returns a String Response
+ */
+export declare const StringResponse: (target: any, propertyKey: string) => void;
+/**
+ * Marks the SnapService method as on that returns a Blob
+ */
+export declare const BinaryResponse: (target: any, propertyKey: string) => void;
+/**
+ * Marks the SnapService method as on that has no return value
+ */
+export declare const NoResponse: (target: any, propertyKey: string) => void;
+/**
+ * Marks the SnapService method that it should use multipart/form-data when submitting the request
+ */
+export declare const Multipart: (target: any, propertyKey: string) => void;
+/**
+ * Marks the SnapService method that it should use application/x-www-form-urlencoded when submitting the request
+ */
+export declare const FormUrlEncoded: (target: any, propertyKey: string) => void;
+/**
+ * Sets the headers for the request
+ * @param value MapOfHeaders
+ * @constructor
+ */
+export declare const Headers: (value: MapOfHeaders) => (target: any, propertyKey: string) => void;
+/**
+ * Throttles the request by 3 seconds
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+export declare const Throttle: (target: any, propertyKey: string) => void;
+/**
+ * Throttles the request by the value provided
+ * @param value ThrottleByProps - An object that contains the waitPeriodInMs
+ * @constructor
+ */
+export declare const ThrottleBy: (value: ThrottleByProps) => (target: any, propertyKey: string) => void;
+/**
+ * Marks this method as an authenticator. When requests receive 401 status code, this method will be called to retrieve
+ * the credentials
+ * @param type Credentials - Type of credentials that this authenticator should return
+ * (BasicCredentials | BearerCredentials | APIKeyCredentials | define one of your own by subclassing Credentials)
+ * @param global Whether this authenticator should be used across all services
+ * @param socketField
+ * @constructor
+ */
+export declare const Authenticator: <T>(type: T, global?: boolean, socketField?: string) => (target: any, propertyKey: string) => void;
+/**
+ * Marks this method as an auth refresher. Whenever a request receives a 401 status code for invalid credentials, this
+ * method will be called with the old Credentials, and should produce new credentials
+ * @param type Credentials - Type of credentials that this authenticator should return
+ * (BasicCredentials | BearerCredentials | APIKeyCredentials | define one of your own by subclassing Credentials)
+ * @param global Whether this auth refresher should be used across all services
+ * @constructor
+ */
+export declare const AuthRefresher: <T>(type: T, global?: boolean) => (target: any, propertyKey: string) => void;
+/**
+ * Marks argument as a property in the MultiPart form
+ */
+export declare const Part: (value: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument as a property in the FormUrlEncoded  form or a JSON payload
+ */
+export declare const Field: (value: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument as a property in the FormUrlEncoded  form or JSON payload, but it can be missing
+ */
+export declare const OptionalField: (value: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument that should be deserialized to a JSON string and attached as the body of the request
+ */
+export declare const JSONBody: (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument that should be deserialized to XML string and attached as the body of the request
+ */
+export declare const XMLBody: (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument that should be the body of the request, and is a string
+ */
+export declare const StringBody: (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument that should contain a Map of the queries used in the request. Argument should be an object with each
+ * key value pair being the query name and value
+ * @constructor
+ */
+export declare const QueryMap: (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument as a path variable in the request url
+ * @param value Name of the path variable
+ * @constructor
+ */
+export declare const Path: (value: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument as a query to be attached to the request url
+ * @param value Name of the query
+ * @constructor
+ */
+export declare const Query: (value: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument as a header to be attached to the request
+ * @param value Name of the header
+ * @constructor
+ */
+export declare const Header: (value: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Marks argument that should contain a Map of the headers used in the request. Argument should be an object with each
+ * key value pair being the header name and value
+ * @constructor
+ */
+export declare const HeaderMap: (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Disables any authenticator that should be applied to this method
+ * @constructor
+ */
+export declare const NoAuth: (target: any, propertyKey: string) => void;
+export {};