gingersnap 0.22.0

package/data/model/model.mjs

@@ -0,0 +1,518 @@
+import { __awaiter } from '../../_virtual/_tslib.mjs';
+import * as R from 'ramda';
+import { ParsingError } from '../../errors/ParsingError.mjs';
+import { NetworkError } from '../../errors/NetworkError.mjs';
+import { NoSuchElement } from '../../errors/NoSuchElement.mjs';
+import X2JS from 'x2js';
+import 'reflect-metadata';
+import { DataFormat } from './types.mjs';
+import Papa from 'papaparse';
+import { encode, decode } from '@msgpack/msgpack';
+import { parse } from '../../utils/parser.mjs';
+
+/** @ignore */
+const namespacedModelInternalProps = new Map();
+/**
+ * A container object which may or may not contain a non-null/non-undefined value
+ */
+class Optional {
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Returns an Optional with the specified present non-null value.
+     * @param value
+     */
+    static of(value) {
+        return new Optional(value);
+    }
+    /**
+     * Returns an empty Optional instance.
+     */
+    static empty() {
+        return new Optional(undefined);
+    }
+    /**
+     * Return true if there is a value present, otherwise false.
+     */
+    isPresent() {
+        return this.value !== undefined && this.value !== null;
+    }
+    /**
+     * If a value is present in this Optional, returns the value, otherwise throws NoSuchElement.
+     */
+    get() {
+        if (this.isPresent()) {
+            return this.value;
+        }
+        throw new NoSuchElement();
+    }
+}
+/**
+ * A Data de/serializer class that manages and validates data as JavaScript Objects
+ */
+class Model {
+    /**
+     * Converts arraybuffer to a model
+     * @param data arraybuffer
+     * @param format data format
+     * @param options configurations for deserializing the data
+     * @returns new model or an array of models
+     */
+    static fromBuffer(data, format = DataFormat.JSON, options) {
+        switch (format) {
+            case DataFormat.MESSAGE_PACK: {
+                const decoder = decode;
+                const result = decoder(data);
+                if ((options === null || options === void 0 ? void 0 : options.array) && !(result instanceof Array || Array.isArray(result)))
+                    throw new ParsingError([], "expected an array of models");
+                if ((!(options === null || options === void 0 ? void 0 : options.array) && result instanceof Array) || Array.isArray(result))
+                    throw new ParsingError([], "expected only one model");
+                if (result instanceof Array || Array.isArray(result))
+                    return result.map((v) => this.fromJSON(v));
+                return this.fromJSON(result);
+            }
+            case DataFormat.CSV: {
+                const text = data instanceof Uint8Array ? new TextDecoder().decode(data.buffer) : data.toString();
+                return this.fromString(text, format, options);
+            }
+            case DataFormat.XML:
+            case DataFormat.JSON:
+                return this.fromString(data instanceof Uint8Array ? new TextDecoder().decode(data) : data.toString(), format, options);
+        }
+    }
+    /**
+     * Downloads data from the given source and deserializes the data to one or more models
+     * @param source URL source to fetch the data
+     * @param format data format
+     * @param options configurations for deserializing and/or retrieving the data
+     * @returns one or more models
+     */
+    static fromURL(source, format = DataFormat.JSON, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fetcher = fetch;
+            const resp = yield fetcher(source, {
+                method: "GET",
+                headers: options === null || options === void 0 ? void 0 : options.requestHeaders,
+                mode: options === null || options === void 0 ? void 0 : options.mode,
+            });
+            if (!resp.ok)
+                throw new NetworkError(resp.status);
+            return yield this.fromBlob(yield resp.blob(), format, options);
+        });
+    }
+    /**
+     * Deserializes one or more models from a Blob
+     * @param data blob data
+     * @param format data format
+     * @param options configurations for deserializing the data
+     * @returns one or more models
+     */
+    static fromBlob(data, format = DataFormat.JSON, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fromBuffer(new Uint8Array(yield data.arrayBuffer()), format);
+        });
+    }
+    /**
+     * Deserializes one or more models from given string
+     *
+     * @remarks
+     * If the data format is a binary one, the provided string should be a hexadecimal string.
+     * @param data string data source
+     * @param format data format
+     * @param options
+     */
+    static fromString(data, format = DataFormat.JSON, options) {
+        var _a, _b, _c, _d, _e, _f;
+        switch (format) {
+            case DataFormat.JSON:
+                try {
+                    data = JSON.parse(data);
+                }
+                catch (e) {
+                    throw new ParsingError((_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e));
+                }
+                return this.fromJSON(data);
+            case DataFormat.XML:
+                return this.fromObject(this.__xmlParser__.xml2js(data), format);
+            case DataFormat.CSV: {
+                let result;
+                let text = data;
+                if (options === null || options === void 0 ? void 0 : options.headers)
+                    text = options.headers.join((_b = options === null || options === void 0 ? void 0 : options.delimiter) !== null && _b !== void 0 ? _b : ",") + ((_c = options.newline) !== null && _c !== void 0 ? _c : "\n") + text;
+                try {
+                    result = Papa.parse(text, {
+                        header: true,
+                        skipEmptyLines: true,
+                    });
+                }
+                catch (e) {
+                    throw new ParsingError([], (_d = e === null || e === void 0 ? void 0 : e.message) !== null && _d !== void 0 ? _d : String(e));
+                }
+                if (!(options === null || options === void 0 ? void 0 : options.ignoreErrors) && result.errors.length > 0)
+                    throw new ParsingError(result.errors);
+                if (!(options === null || options === void 0 ? void 0 : options.array) && result.data.length > 0)
+                    throw new ParsingError([], "Too many records found");
+                if (options === null || options === void 0 ? void 0 : options.array)
+                    return result.data.map((v) => this.fromObject(v));
+                return this.fromObject(result.data[0]);
+            }
+            default:
+                return this.fromBuffer(new Uint8Array((_f = (_e = data.match(/../g)) === null || _e === void 0 ? void 0 : _e.map((h) => parseInt(h, 16))) !== null && _f !== void 0 ? _f : []), format, options);
+        }
+    }
+    /**
+     * Converts a JSON object to a model
+     * @param data JSON Object
+     * @returns new model
+     */
+    static fromJSON(data) {
+        return this.fromObject(data, DataFormat.JSON);
+    }
+    /**
+     * Converts the current model to a JSON object
+     */
+    object(removeMissingFields = false) {
+        var _a, _b;
+        const serialize = (value) => {
+            if (value instanceof Model) {
+                return value.object(removeMissingFields);
+            }
+            else if (value instanceof Array || Array.isArray(value)) {
+                return value.map((v) => serialize(v));
+            }
+            else if (value instanceof Set) {
+                return Array.from(value);
+            }
+            else if (value instanceof Map) {
+                try {
+                    return Object.fromEntries(value.entries());
+                }
+                catch (e) {
+                    // failed to serialize map to object, which means it contains keys that are not serializable to object
+                    return value;
+                }
+            }
+            else if (value instanceof Function) {
+                return null;
+            }
+            return value;
+        };
+        return R.reduce((acc, [key, fieldProps]) => {
+            var _a;
+            if ((_a = fieldProps.ignore) === null || _a === void 0 ? void 0 : _a.serialize)
+                return acc;
+            const value = R.prop(key, this);
+            const serializedValue = serialize(value);
+            if (!removeMissingFields || (serializedValue !== null && serializedValue !== undefined)) {
+                acc[fieldProps.name] = serializedValue;
+            }
+            return acc;
+        }, {}, Array.from(((_b = (_a = Model.buildPropTree(Object.getPrototypeOf(this))) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : new Map()).entries()));
+    }
+    /**
+     * Converts the current model to a JSON string
+     */
+    json(removeMissingFields = false) {
+        return JSON.stringify(this.object(removeMissingFields));
+    }
+    /**
+     * Converts the current model to an arraybuffer
+     */
+    buffer(removeMissingFields = false) {
+        return new TextEncoder().encode(this.json(removeMissingFields));
+    }
+    /**
+     * Converts the current model to a blob
+     */
+    blob(removeMissingFields = false) {
+        return new Blob([this.buffer(removeMissingFields)]);
+    }
+    /**
+     * Converts the current model to an XML string
+     */
+    xml(removeMissingFields = false) {
+        return Model.__xmlParser__.js2xml(this.object(removeMissingFields));
+    }
+    /**
+     * Converts the current model to message pack binary format
+     * @returns message pack binary
+     */
+    messagePack(removeMissingFields = false) {
+        return encode(this.object(removeMissingFields)).buffer;
+    }
+    /**
+     * Converts the current model to csv format
+     * @param removeMissingFields
+     * @param config CSV unparsing configuration
+     * @returns csv string
+     */
+    csv(removeMissingFields = false, config) {
+        return Papa.unparse([this.object(removeMissingFields)], config);
+    }
+    clone() {
+        const newModel = new (Object.getPrototypeOf(this))();
+        for (const [key, value] of Object.entries(this)) {
+            newModel[key] = !R.isNil(value) ? R.clone(value) : value;
+        }
+        return newModel;
+    }
+    /**
+     * Retrieves the schema of the current model based on the selected format
+     * @param format data format
+     * @returns the schema for the current model
+     */
+    schema(format = DataFormat.JSON) {
+        return Object.getPrototypeOf(this).schema(format);
+    }
+    toString() {
+        return this.json(true);
+    }
+    /**
+     * Constructs the model properties by traversing the inheritance tree of the current Model being instantiated
+     * @param modelPrototype prototype of the model
+     * @ignore
+     */
+    static buildPropTree(modelPrototype) {
+        var _a;
+        let value;
+        let proto = !modelPrototype.name ? modelPrototype.constructor : modelPrototype;
+        const tree = { fields: new Map() };
+        while (proto && (proto === null || proto === void 0 ? void 0 : proto.name) !== "Function") {
+            let space = proto.name;
+            tree.fields.clear();
+            while (space && (value = namespacedModelInternalProps.get(space))) {
+                value.fields.forEach((value, key) => tree.fields.set(key, value));
+                space = (_a = value.parent) !== null && _a !== void 0 ? _a : "";
+            }
+            // could be that subclass didn't use any annotators. check parent
+            if (tree.fields.size === 0) {
+                proto = Object.getPrototypeOf(proto);
+            }
+            else {
+                break;
+            }
+        }
+        return tree;
+    }
+    /**
+     * Constructs a model from a JSON object
+     * @param data JSON object
+     * @param format
+     * @private
+     */
+    static fromObject(data, format = DataFormat.JSON) {
+        if (data instanceof Array || Array.isArray(data) || typeof data !== "object") {
+            throw new ParsingError([], "Invalid data provided. Must be an object");
+        }
+        const processValue = (fieldProps, value) => {
+            var _a, _b;
+            if ((_b = (_a = fieldProps.schema) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.useOptionalObj) {
+                return Optional.of(value);
+            }
+            return value;
+        };
+        const model = new this();
+        const props = this.buildPropTree(Object.getPrototypeOf(model));
+        R.forEach(([key, fieldProps]) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+            let value = data[key];
+            if (value === undefined || value === null) {
+                for (const alias of (_a = fieldProps.aliases) !== null && _a !== void 0 ? _a : []) {
+                    value = data[alias];
+                    if (value !== undefined)
+                        break;
+                }
+            }
+            if ((value === undefined || value === null) && ((_b = fieldProps.ignore) === null || _b === void 0 ? void 0 : _b.deserialize)) {
+                if ((_d = (_c = fieldProps.schema) === null || _c === void 0 ? void 0 : _c.options) === null || _d === void 0 ? void 0 : _d.useOptionalObj) {
+                    model[key] = Optional.empty();
+                }
+                return;
+            }
+            else if ((value === undefined || value === null) && (model[key] === undefined || model[key] === null)) {
+                throw new ParsingError([], `Property "${key}" is missing from the data provided. ${JSON.stringify(data)}`);
+            }
+            else if ((value === undefined || value === null) && !(model[key] === undefined || model[key] === null)) {
+                return;
+            }
+            if ((_e = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(model), key)) === null || _e === void 0 ? void 0 : _e.set) {
+                model[key] = processValue(fieldProps, value);
+            }
+            else if ((_f = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(model), key)) === null || _f === void 0 ? void 0 : _f.get) {
+                return;
+            }
+            else if (model[key] instanceof fieldProps.Type &&
+                typeof model[key] === "function" &&
+                fieldProps.Type instanceof Function) {
+                model[key](value);
+            }
+            else if (fieldProps.isArray && fieldProps.Type.prototype instanceof Model) {
+                const parser = parse({
+                    string: (v) => fieldProps.Type.fromString(v, format),
+                    object: (v) => fieldProps.Type.fromObject(v, format),
+                    default: () => {
+                        throw new ParsingError([], `value for ${key} is expected to be an Array, instead received ${typeof value}`);
+                    },
+                    supportArray: true,
+                });
+                model[key] = processValue(fieldProps, parser(value));
+            }
+            else if (fieldProps.Type.prototype instanceof Model) {
+                const parser = parse({
+                    string: (v) => fieldProps.Type.fromString(v, format),
+                    object: (v) => fieldProps.Type.fromObject(v, format),
+                    default: () => {
+                        throw new ParsingError([], `value for ${key} expected to be serializable object`);
+                    },
+                });
+                const result = parser(value);
+                if (result instanceof Array || Array.isArray(result)) {
+                    throw new ParsingError([], `value for ${key} expected to be serializable object, not an array`);
+                }
+                model[key] = processValue(fieldProps, result);
+            }
+            else if (fieldProps.isMap && fieldProps.ValueType.prototype instanceof Model) {
+                const parser = parse({
+                    string: (v) => fieldProps.ValueType.fromString(v, format),
+                    object: (v) => fieldProps.ValueType.fromObject(v, format),
+                    default: () => {
+                        throw new ParsingError([], `value for ${key} expected to be serializable object`);
+                    },
+                });
+                try {
+                    const data = new Map((!(value instanceof Array || Array.isArray(value)) && typeof value === "object"
+                        ? Object.entries(value)
+                        : value).map(([k, v]) => [fieldProps.KeyType(k), v]));
+                    data.forEach((value, key) => {
+                        data.set(key, parser(value));
+                    });
+                    model[key] = processValue(fieldProps, data);
+                }
+                catch (e) {
+                    if (e instanceof ParsingError)
+                        throw e;
+                    throw new ParsingError([], (_g = e === null || e === void 0 ? void 0 : e.message) !== null && _g !== void 0 ? _g : String(e));
+                }
+            }
+            else if (fieldProps.isMap) {
+                try {
+                    const data = new Map((!(value instanceof Array || Array.isArray(value)) && typeof value === "object"
+                        ? Object.entries(value)
+                        : value).map(([k, v]) => [fieldProps.KeyType(k), v]));
+                    model[key] = processValue(fieldProps, data);
+                    data.forEach((value, key) => {
+                        data.set(key, parse({ default: (v) => new fieldProps.Type(v) }, value));
+                    });
+                }
+                catch (e) {
+                    if (e instanceof ParsingError)
+                        throw e;
+                    throw new ParsingError([], (_h = e === null || e === void 0 ? void 0 : e.message) !== null && _h !== void 0 ? _h : String(e));
+                }
+            }
+            else if (fieldProps.isArray) {
+                if (typeof value === "string") {
+                    try {
+                        value = JSON.parse(value);
+                    }
+                    catch (e) {
+                        throw new ParsingError([], (_j = e === null || e === void 0 ? void 0 : e.message) !== null && _j !== void 0 ? _j : String(e));
+                    }
+                }
+                if (!(value instanceof Array || Array.isArray(value))) {
+                    throw new ParsingError([], `value for ${key} is expected to be an Array, instead received ${typeof value}`);
+                }
+                model[key] = processValue(fieldProps, value.map((v) => {
+                    var _a;
+                    switch (typeof v) {
+                        case "boolean":
+                        case "number":
+                        case "bigint":
+                        case "undefined":
+                        case "string":
+                            return v;
+                        default: {
+                            let val;
+                            try {
+                                val = new fieldProps.Type(v);
+                            }
+                            catch (e) {
+                                if (e instanceof ParsingError) {
+                                    throw e;
+                                }
+                                throw new ParsingError([], (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e));
+                            }
+                            if (isNaN(val.getTime())) {
+                                throw new ParsingError([], "Failed to convert to annotated  date type");
+                            }
+                            return val;
+                        }
+                    }
+                }));
+            }
+            else if (((_k = fieldProps.Type) === null || _k === void 0 ? void 0 : _k.name) === "String") {
+                model[key] = processValue(fieldProps, String(value));
+            }
+            else if (((_l = fieldProps.Type) === null || _l === void 0 ? void 0 : _l.name) === "Boolean") {
+                model[key] = processValue(fieldProps, Boolean(value));
+            }
+            else if (((_m = fieldProps.Type) === null || _m === void 0 ? void 0 : _m.name) === "Number") {
+                model[key] = processValue(fieldProps, Number(value));
+            }
+            else if (((_o = fieldProps.Type) === null || _o === void 0 ? void 0 : _o.name) === "Map") {
+                const valueType = typeof value;
+                switch (valueType) {
+                    case "object": {
+                        try {
+                            model[key] = processValue(fieldProps, value instanceof Array || Array.isArray(value) ? new Map(value) : new Map(Object.entries(value)));
+                        }
+                        catch (e) {
+                            throw new ParsingError([], (_p = e === null || e === void 0 ? void 0 : e.message) !== null && _p !== void 0 ? _p : String(e));
+                        }
+                        break;
+                    }
+                    case "string":
+                        try {
+                            value = JSON.parse(value);
+                            model[key] = processValue(fieldProps, value instanceof Array || Array.isArray(value) ? new Map(value) : new Map(Object.entries(value)));
+                        }
+                        catch (e) {
+                            throw new ParsingError([], (_q = e === null || e === void 0 ? void 0 : e.message) !== null && _q !== void 0 ? _q : String(e));
+                        }
+                        break;
+                    default:
+                        throw new ParsingError([value], `value for ${key} cannot be converted to a Map`);
+                }
+            }
+            else if (((_r = fieldProps.Type) === null || _r === void 0 ? void 0 : _r.name) === "Set") {
+                if (value instanceof Array || Array.isArray(value)) {
+                    model[key] = processValue(fieldProps, new Set(value));
+                }
+                else if (typeof value === "string") {
+                    model[key] = processValue(fieldProps, new Set(JSON.parse(value)));
+                }
+                throw new ParsingError([value], `value for ${key} cannot be converted to a Set`);
+            }
+            else {
+                model[key] = processValue(fieldProps, new fieldProps.Type(value));
+            }
+            if (fieldProps.readonly) {
+                Object.defineProperty(model, key, {
+                    value: model[key],
+                    writable: false,
+                    enumerable: true,
+                });
+            }
+            R.forEach(([k, v]) => {
+                if (v.__callback__)
+                    v.__callback__(k, v.properties, model, key);
+            }, R.toPairs((_s = fieldProps.customTags) !== null && _s !== void 0 ? _s : {}));
+        }, Array.from(props.fields.entries()));
+        return Object.seal(model);
+    }
+}
+/** @ignore */
+Model.__xmlParser__ = new X2JS();
+
+export { Model, Optional, namespacedModelInternalProps };

package/data/model/plugin.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+var R = require('ramda');
+var model = require('./model.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);
+
+const modelClassTags = {};
+/**
+ * Creates a custom class tag
+ * @param name Name of the tag
+ * @param properties any properties that should be saved
+ */
+const createModelClassAnnotationTag = (name, properties = {}) => (constructor) => {
+    modelClassTags[name] = {
+        properties,
+        modelClass: constructor.prototype,
+        modelClassName: constructor.name,
+    };
+};
+/**
+ * Retrieves a list of properties set by one or more custom class tags
+ * @param tagNames Array<string>
+ * @param ModelClass Class<Model>
+ */
+const getModelClassAnnotationTagProperties = (tagNames, ModelClass) => {
+    return R__namespace.map((tag) => modelClassTags[tag], tagNames).filter((v) => v);
+};
+/**
+ * Creates a custom field tag
+ * @param name Name of the tag
+ * @param properties any properties that should be saved
+ * @param onFieldCreated callback executed once property exist on a model (Optional)
+ */
+const createModelFieldAnnotationTag = (name, properties = {}, onFieldCreated) => (target, key) => {
+    var _a, _b;
+    const props = (_a = model.namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const result = R__namespace.find(([k, v]) => v.name === key, Array.from(props.fields.entries()));
+    if (!result) {
+        throw new Error(`Cannot create annotation tag of type ${name}, field does not exist as yet`);
+    }
+    props.fields.get(result[0]).customTags = (_b = props.fields.get(result[0]).customTags) !== null && _b !== void 0 ? _b : {};
+    props.fields.get(result[0]).customTags[name] = {
+        __callback__: onFieldCreated,
+        properties,
+    };
+    props.parent = Object.getPrototypeOf(target).constructor.name;
+    model.namespacedModelInternalProps.set(target.constructor.name, props);
+};
+/**
+ *  Retrieves a list of properties set by one or more custom field tags
+ * @param tagNames Array<String>
+ * @param ModelClass Class<Model>
+ */
+const getModelFieldAnnotationTagProperties = (tagNames, ModelClass) => {
+    const props = model.Model.buildPropTree(ModelClass);
+    return R__namespace.map(([k, v]) => {
+        if (v.customTags) {
+            const tagName = tagNames.find((t) => t in v.customTags);
+            return tagName
+                ? {
+                    tagName,
+                    fieldName: v.name,
+                    Type: v.Type,
+                    isArray: v.isArray,
+                    tagProperties: v.customTags[tagName].properties,
+                }
+                : null;
+        }
+        return null;
+    }, Array.from(props.fields.entries())).filter((v) => v);
+};
+
+exports.createModelClassAnnotationTag = createModelClassAnnotationTag;
+exports.createModelFieldAnnotationTag = createModelFieldAnnotationTag;
+exports.getModelClassAnnotationTagProperties = getModelClassAnnotationTagProperties;
+exports.getModelFieldAnnotationTagProperties = getModelFieldAnnotationTagProperties;

package/data/model/plugin.d.ts

@@ -0,0 +1,38 @@
+import { Model } from "./model";
+export interface FieldTagPropertyDescription {
+    Type: any;
+    fieldName: string;
+    isArray: boolean;
+    tagName: string;
+    tagProperties: Object;
+}
+export interface ModelTagPropertyDescription {
+    properties: Object;
+    modelClassName: string;
+    modelClass: any;
+}
+/**
+ * Creates a custom class tag
+ * @param name Name of the tag
+ * @param properties any properties that should be saved
+ */
+export declare const createModelClassAnnotationTag: (name: string, properties?: Object) => (constructor: any) => void;
+/**
+ * Retrieves a list of properties set by one or more custom class tags
+ * @param tagNames Array<string>
+ * @param ModelClass Class<Model>
+ */
+export declare const getModelClassAnnotationTagProperties: (tagNames: string[], ModelClass: any) => ModelTagPropertyDescription[];
+/**
+ * Creates a custom field tag
+ * @param name Name of the tag
+ * @param properties any properties that should be saved
+ * @param onFieldCreated callback executed once property exist on a model (Optional)
+ */
+export declare const createModelFieldAnnotationTag: (name: string, properties?: Object, onFieldCreated?: (tagName: string, properties: Object, target: Model, fieldName: string) => void) => (target: any, key: string) => void;
+/**
+ *  Retrieves a list of properties set by one or more custom field tags
+ * @param tagNames Array<String>
+ * @param ModelClass Class<Model>
+ */
+export declare const getModelFieldAnnotationTagProperties: (tagNames: string[], ModelClass: any) => FieldTagPropertyDescription[];