typia 7.0.0-dev.20241011-2 → 7.0.0-dev.20241018

package/lib/factories/ProtobufFactory.js

@@ -53,13 +53,16 @@ var TransformerError_1 = require("../transformers/TransformerError");
 var MetadataFactory_1 = require("./MetadataFactory");
 var ProtobufFactory;
 (function (ProtobufFactory) {
+    /* -----------------------------------------------------------
+      METADATA COMPOSER
+    ----------------------------------------------------------- */
     ProtobufFactory.metadata = function (props) {
         // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
         var result = MetadataFactory_1.MetadataFactory.analyze(__assign(__assign({}, props), { transformer: props.transformer, options: {
                 escape: false,
                 constant: true,
                 absorb: true,
-                validate: validate,
+                validate: validate(),
             } }));
         if (result.success === false)
             throw TransformerError_1.TransformerError.from({
@@ -68,176 +71,837 @@ var ProtobufFactory;
             });
         return result.data;
     };
-    var validate = function (meta, explore) {
-        var e_1, _a, e_2, _b;
-        var errors = [];
-        var insert = function (msg) { return errors.push(msg); };
-        if (explore.top === true) {
-            var onlyObject = meta.size() === 1 &&
-                meta.objects.length === 1 &&
-                meta.objects[0].properties.every(function (p) { return p.key.isSoleLiteral(); }) &&
-                meta.isRequired() === true &&
-                meta.nullable === false;
-            if (onlyObject === false)
-                insert("target type must be a sole and static object type");
-        }
-        //----
-        // NOT SUPPORTED TYPES
-        //----
-        var noSupport = function (msg) { return insert("does not support ".concat(msg)); };
-        // PROHIBIT ANY TYPE
-        if (meta.any)
-            noSupport("any type");
-        // PROHIBIT FUNCTIONAL TYPE
-        if (meta.functions.length)
-            noSupport("functional type");
-        // PROHIBIT TUPLE TYPE
-        if (meta.tuples.length)
-            noSupport("tuple type");
-        // PROHIBIT SET TYPE
-        if (meta.sets.length)
-            noSupport("Set type");
-        // NATIVE TYPE, BUT NOT Uint8Array
-        if (meta.natives.length)
+    /* -----------------------------------------------------------
+      VALIDATORS
+    ----------------------------------------------------------- */
+    var validate = function () {
+        var visited = new WeakSet();
+        return function (meta, explore) {
+            var e_1, _a, e_2, _b, e_3, _c;
+            var errors = [];
+            var insert = function (msg) { return errors.push(msg); };
+            if (explore.top === true) {
+                var onlyObject = meta.size() === 1 &&
+                    meta.objects.length === 1 &&
+                    meta.objects[0].type.properties.every(function (p) {
+                        return p.key.isSoleLiteral();
+                    }) &&
+                    meta.isRequired() === true &&
+                    meta.nullable === false;
+                if (onlyObject === false)
+                    insert("target type must be a sole and static object type");
+            }
+            if (explore.object !== null && visited.has(explore.object) === false) {
+                visited.add(explore.object);
+                validateRegularObject({
+                    object: explore.object,
+                    errors: errors,
+                });
+                try {
+                    for (var _d = __values(explore.object.properties), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var p = _e.value;
+                        validateRegularProperty({
+                            value: p.value,
+                            errors: errors,
+                        });
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            //----
+            // NOT SUPPORTED TYPES
+            //----
+            var noSupport = function (msg) { return insert("does not support ".concat(msg)); };
+            // PROHIBIT ANY TYPE
+            if (meta.any)
+                noSupport("any type");
+            // PROHIBIT FUNCTIONAL TYPE
+            if (meta.functions.length)
+                noSupport("functional type");
+            // PROHIBIT TUPLE TYPE
+            if (meta.tuples.length)
+                noSupport("tuple type");
+            // PROHIBIT SET TYPE
+            if (meta.sets.length)
+                noSupport("Set type");
+            // NATIVE TYPE, BUT NOT Uint8Array
+            if (meta.natives.length)
+                try {
+                    for (var _f = __values(meta.natives), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var native = _g.value;
+                        if (native.name === "Uint8Array")
+                            continue;
+                        var instead = BANNED_NATIVE_TYPES.get(native.name);
+                        if (instead === undefined)
+                            noSupport("".concat(native.name, " type"));
+                        else
+                            noSupport("".concat(native.name, " type. Use ").concat(instead, " type instead."));
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            //----
+            // ATOMIC CASES
+            //----
+            if (meta.atomics.length) {
+                var numbers = ProtobufUtil_1.ProtobufUtil.getNumbers(meta);
+                var bigints = ProtobufUtil_1.ProtobufUtil.getBigints(meta);
+                try {
+                    for (var _h = __values(["int64", "uint64"]), _j = _h.next(); !_j.done; _j = _h.next()) {
+                        var type = _j.value;
+                        if (numbers.has(type) && bigints.has(type))
+                            insert("tags.Type<\"".concat(type, "\"> cannot be used in both number and bigint types. Recommend to remove from number type"));
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            //----
+            // ARRRAY CASES
+            //----
+            // DO NOT ALLOW MULTI-DIMENTIONAL ARRAY
+            if (meta.arrays.length &&
+                meta.arrays.some(function (array) { return !!array.type.value.arrays.length; }))
+                noSupport("over two dimenstional array type");
+            // CHILD OF ARRAY TYPE MUST BE REQUIRED
+            if (meta.arrays.length &&
+                meta.arrays.some(function (array) {
+                    return array.type.value.isRequired() === false ||
+                        array.type.value.nullable === true;
+                }))
+                noSupport("optional type in array");
+            // UNION IN ARRAY
+            if (meta.arrays.length &&
+                meta.arrays.some(function (a) {
+                    var _a;
+                    return a.type.value.size() > 1 &&
+                        a.type.value.constants.length !== 1 &&
+                        ((_a = a.type.value.constants[0]) === null || _a === void 0 ? void 0 : _a.values.length) !== a.type.value.size();
+                }))
+                noSupport("union type in array");
+            // DO DYNAMIC OBJECT IN ARRAY
+            if (meta.arrays.length &&
+                meta.arrays.some(function (a) {
+                    return a.type.value.maps.length ||
+                        (a.type.value.objects.length &&
+                            a.type.value.objects.some(function (o) { return ProtobufUtil_1.ProtobufUtil.isStaticObject(o.type) === false; }));
+                }))
+                noSupport("dynamic object in array");
+            // UNION WITH ARRAY
+            if (meta.size() > 1 && meta.arrays.length)
+                noSupport("union type with array type");
+            //----
+            // OBJECT CASES
+            //----
+            // EMPTY PROPERTY
+            if (meta.objects.length &&
+                meta.objects.some(function (obj) { return obj.type.properties.length === 0; }))
+                noSupport("empty object type");
+            // MULTIPLE DYNAMIC KEY TYPED PROPERTIES
+            if (meta.objects.length &&
+                meta.objects.some(function (obj) {
+                    return obj.type.properties.filter(function (p) { return !p.key.isSoleLiteral(); }).length >
+                        1;
+                }))
+                noSupport("object type with multiple dynamic key typed properties. Keep only one.");
+            // STATIC AND DYNAMIC PROPERTIES ARE COMPATIBLE
+            if (meta.objects.length &&
+                meta.objects.some(function (obj) {
+                    return obj.type.properties.some(function (p) { return p.key.isSoleLiteral(); }) &&
+                        obj.type.properties.some(function (p) { return !p.key.isSoleLiteral(); });
+                }))
+                noSupport("object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.");
+            // DYNAMIC OBJECT, BUT PROPERTY VALUE TYPE IS ARRAY
+            if (meta.objects.length &&
+                isDynamicObject(meta.objects[0].type) &&
+                meta.objects[0].type.properties.some(function (p) { return !!p.value.arrays.length; }))
+                noSupport("dynamic object with array value type");
+            // UNION WITH DYNAMIC OBJECTa
+            if (meta.size() > 1 &&
+                meta.objects.length &&
+                isDynamicObject(meta.objects[0].type))
+                noSupport("union type with dynamic object type");
+            // UNION IN DYNAMIC PROPERTY VALUE
+            if (meta.objects.length &&
+                meta.objects.some(function (obj) {
+                    return isDynamicObject(obj.type) &&
+                        obj.type.properties.some(function (p) { return ProtobufUtil_1.ProtobufUtil.isUnion(p.value); });
+                }))
+                noSupport("union type in dynamic property");
+            //----
+            // MAP CASES
+            //----
+            // KEY TYPE IS UNION
+            if (meta.maps.length &&
+                meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.isUnion(m.key); }))
+                noSupport("union key typed map");
+            // KEY TYPE IS NOT ATOMIC
+            if (meta.maps.length &&
+                meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.getAtomics(m.key).size !== 1; }))
+                noSupport("non-atomic key typed map");
+            // MAP TYPE, BUT PROPERTY KEY TYPE IS OPTIONAL
+            if (meta.maps.length &&
+                meta.maps.some(function (m) { return m.key.isRequired() === false || m.key.nullable; }))
+                noSupport("optional key typed map");
+            // MAP TYPE, BUT VALUE TYPE IS ARRAY
+            if (meta.maps.length && meta.maps.some(function (m) { return !!m.value.arrays.length; }))
+                noSupport("map type with array value type");
+            // UNION WITH MAP
+            if (meta.size() > 1 && meta.maps.length)
+                noSupport("union type with map type");
+            // UNION IN MAP
+            if (meta.maps.length &&
+                meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.isUnion(m.value); }))
+                noSupport("union type in map value type");
+            return errors;
+        };
+    };
+    /* -----------------------------------------------------------
+      SEQUENE VALIDATOR
+    ----------------------------------------------------------- */
+    var validateRegularObject = function (next) {
+        var e_4, _a;
+        var entire = new Map();
+        var visitProperty = function (p) {
+            var e_5, _a, e_6, _b, e_7, _c, e_8, _d, e_9, _e, e_10, _f, e_11, _g;
+            var local = new Set();
+            var tagger = function (matrix) {
+                matrix.forEach(function (tags) {
+                    var value = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
+                    if (value !== null)
+                        local.add(value);
+                });
+            };
+            try {
+                for (var _h = __values(p.value.constants), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var c = _j.value;
+                    try {
+                        for (var _k = (e_6 = void 0, __values(c.values)), _l = _k.next(); !_l.done; _l = _k.next()) {
+                            var v = _l.value;
+                            tagger(v.tags);
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
             try {
-                for (var _c = __values(meta.natives), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var native = _d.value;
-                    if (native === "Uint8Array")
-                        continue;
-                    var instead = BANNED_NATIVE_TYPES.get(native);
-                    if (instead === undefined)
-                        noSupport("".concat(native, " type"));
+                for (var _m = __values(p.value.atomics), _o = _m.next(); !_o.done; _o = _m.next()) {
+                    var a = _o.value;
+                    tagger(a.tags);
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_o && !_o.done && (_c = _m.return)) _c.call(_m);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            try {
+                for (var _p = __values(p.value.templates), _q = _p.next(); !_q.done; _q = _p.next()) {
+                    var t = _q.value;
+                    tagger(t.tags);
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            try {
+                for (var _r = __values(p.value.objects), _s = _r.next(); !_s.done; _s = _r.next()) {
+                    var o = _s.value;
+                    tagger(o.tags);
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_s && !_s.done && (_e = _r.return)) _e.call(_r);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            try {
+                for (var _t = __values(p.value.arrays), _u = _t.next(); !_u.done; _u = _t.next()) {
+                    var a = _u.value;
+                    tagger(a.tags);
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_u && !_u.done && (_f = _t.return)) _f.call(_t);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+            try {
+                for (var local_1 = __values(local), local_1_1 = local_1.next(); !local_1_1.done; local_1_1 = local_1.next()) {
+                    var s = local_1_1.value;
+                    if (entire.has(s))
+                        next.errors.push("The Sequence<".concat(s, "> tag is duplicated in two properties (").concat(JSON.stringify(entire.get(s)), " and ").concat(JSON.stringify(p.key.getSoleLiteral()), ")"));
                     else
-                        noSupport("".concat(native, " type. Use ").concat(instead, " type instead."));
+                        entire.set(s, p.key.getSoleLiteral());
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
             finally {
                 try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        //----
-        // ATOMIC CASES
-        //----
-        if (meta.atomics.length) {
-            var numbers = ProtobufUtil_1.ProtobufUtil.getNumbers(meta);
-            var bigints = ProtobufUtil_1.ProtobufUtil.getBigints(meta);
-            var _loop_1 = function (type) {
-                if (numbers.some(function (n) { return n === type; }) && bigints.some(function (b) { return b === type; }))
-                    insert("tags.Type<\"".concat(type, "\"> cannot be used in both number and bigint types. Recommend to remove from number type"));
-            };
+                    if (local_1_1 && !local_1_1.done && (_g = local_1.return)) _g.call(local_1);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+        };
+        try {
+            for (var _b = __values(next.object.properties), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var p = _c.value;
+                visitProperty(p);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    var validateRegularProperty = function (next) {
+        var e_12, _a, e_13, _b, e_14, _c, e_15, _d, e_16, _e;
+        var expected = 0;
+        var sequences = new Set();
+        var add = function (value) {
+            if (sequences.has(value))
+                return false;
+            sequences.add(value);
+            ++expected;
+            return true;
+        };
+        try {
+            for (var _f = __values([
+                validateBooleanSequence,
+                validateNumericSequences({
+                    type: "bigint",
+                    default: "int64",
+                    categories: BIGINT_TYPES,
+                }),
+                validateNumericSequences({
+                    type: "number",
+                    default: "double",
+                    categories: NUMBER_TYPES,
+                }),
+                validateStringSequence,
+            ]), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var validator = _g.value;
+                validator({ metadata: next.value, errors: next.errors, add: add });
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        try {
+            for (var _h = __values(next.value.arrays), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var array = _j.value;
+                validateInstanceSequence({
+                    type: "array",
+                    tags: array.tags,
+                    errors: next.errors,
+                    add: add,
+                });
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+        try {
+            for (var _k = __values(next.value.objects), _l = _k.next(); !_l.done; _l = _k.next()) {
+                var object = _l.value;
+                validateInstanceSequence({
+                    type: "object",
+                    tags: object.tags,
+                    errors: next.errors,
+                    add: add,
+                });
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        try {
+            for (var _m = __values(next.value.maps), _o = _m.next(); !_o.done; _o = _m.next()) {
+                var map = _o.value;
+                validateInstanceSequence({
+                    type: "map",
+                    tags: map.tags,
+                    errors: next.errors,
+                    add: add,
+                });
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        try {
+            for (var _p = __values(next.value.natives), _q = _p.next(); !_q.done; _q = _p.next()) {
+                var native = _q.value;
+                if (native.name === "Uint8Array")
+                    validateInstanceSequence({
+                        type: "Uint8Array",
+                        tags: native.tags,
+                        errors: next.errors,
+                        add: add,
+                    });
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
             try {
-                for (var _e = __values(["int64", "uint64"]), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var type = _f.value;
-                    _loop_1(type);
+                if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+    };
+    var validateBooleanSequence = function (next) {
+        var e_17, _a, e_18, _b, e_19, _c;
+        // PREPARE EMPLACER
+        var unique = new Set();
+        var expected = 0;
+        var actual = 0;
+        var emplace = function (matrix) {
+            var e_20, _a, e_21, _b;
+            try {
+                for (var matrix_1 = __values(matrix), matrix_1_1 = matrix_1.next(); !matrix_1_1.done; matrix_1_1 = matrix_1.next()) {
+                    var tags = matrix_1_1.value;
+                    try {
+                        for (var tags_1 = (e_21 = void 0, __values(tags)), tags_1_1 = tags_1.next(); !tags_1_1.done; tags_1_1 = tags_1.next()) {
+                            var tag = tags_1_1.value;
+                            var sequence = ProtobufUtil_1.ProtobufUtil.getSequence([tag]);
+                            if (sequence !== null) {
+                                unique.add(sequence);
+                                ++actual;
+                            }
+                            ++expected;
+                        }
+                    }
+                    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+                    finally {
+                        try {
+                            if (tags_1_1 && !tags_1_1.done && (_b = tags_1.return)) _b.call(tags_1);
+                        }
+                        finally { if (e_21) throw e_21.error; }
+                    }
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_20_1) { e_20 = { error: e_20_1 }; }
             finally {
                 try {
-                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    if (matrix_1_1 && !matrix_1_1.done && (_a = matrix_1.return)) _a.call(matrix_1);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_20) throw e_20.error; }
+            }
+        };
+        try {
+            // GATHER SEQUENCE TAGS
+            for (var _d = __values(next.metadata.atomics), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var atomic = _e.value;
+                if (atomic.type === "boolean")
+                    emplace(atomic.tags);
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+        try {
+            for (var _f = __values(next.metadata.constants), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var constant = _g.value;
+                if (constant.type === "boolean")
+                    try {
+                        for (var _h = (e_19 = void 0, __values(constant.values)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                            var value = _j.value;
+                            emplace(value.tags);
+                        }
+                    }
+                    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+                    finally {
+                        try {
+                            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                        }
+                        finally { if (e_19) throw e_19.error; }
+                    }
+            }
+        }
+        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
             }
+            finally { if (e_18) throw e_18.error; }
+        }
+        // PREDICATE
+        if (unique.size && actual !== expected)
+            next.errors.push("The sequence tag must be declared in every union type members");
+        else if (unique.size > 1)
+            next.errors.push("The sequence tag value must be the same in boolean type (including literal types)");
+        else if (unique.size === 1) {
+            var value = unique.values().next().value;
+            if (next.add(value) === false)
+                next.errors.push("The sequence tag value ".concat(value, " in boolean type is duplicated with other types"));
         }
-        //----
-        // ARRRAY CASES
-        //----
-        // DO NOT ALLOW MULTI-DIMENTIONAL ARRAY
-        if (meta.arrays.length &&
-            meta.arrays.some(function (array) { return !!array.type.value.arrays.length; }))
-            noSupport("over two dimenstional array type");
-        // CHILD OF ARRAY TYPE MUST BE REQUIRED
-        if (meta.arrays.length &&
-            meta.arrays.some(function (array) {
-                return array.type.value.isRequired() === false ||
-                    array.type.value.nullable === true;
-            }))
-            noSupport("optional type in array");
-        // UNION IN ARRAY
-        if (meta.arrays.length &&
-            meta.arrays.some(function (a) {
+    };
+    var validateNumericSequences = function (config) {
+        return function (next) {
+            var e_22, _a, e_23, _b, e_24, _c, e_25, _d;
+            // FIND TYPE CATEGORIES
+            var categories = new Set();
+            var getType = function (tags) {
                 var _a;
-                return a.type.value.size() > 1 &&
-                    a.type.value.constants.length !== 1 &&
-                    ((_a = a.type.value.constants[0]) === null || _a === void 0 ? void 0 : _a.values.length) !== a.type.value.size();
-            }))
-            noSupport("union type in array");
-        // DO DYNAMIC OBJECT IN ARRAY
-        if (meta.arrays.length &&
-            meta.arrays.some(function (a) {
-                return a.type.value.maps.length ||
-                    (a.type.value.objects.length &&
-                        a.type.value.objects.some(function (o) { return ProtobufUtil_1.ProtobufUtil.isStaticObject(o) === false; }));
-            }))
-            noSupport("dynamic object in array");
-        // UNION WITH ARRAY
-        if (meta.size() > 1 && meta.arrays.length)
-            noSupport("union type with array type");
-        //----
-        // OBJECT CASES
-        //----
-        // EMPTY PROPERTY
-        if (meta.objects.length &&
-            meta.objects.some(function (obj) { return obj.properties.length === 0; }))
-            noSupport("empty object type");
-        // MULTIPLE DYNAMIC KEY TYPED PROPERTIES
-        if (meta.objects.length &&
-            meta.objects.some(function (obj) {
-                return obj.properties.filter(function (p) { return !p.key.isSoleLiteral(); }).length > 1;
-            }))
-            noSupport("object type with multiple dynamic key typed properties. Keep only one.");
-        // STATIC AND DYNAMIC PROPERTIES ARE COMPATIBLE
-        if (meta.objects.length &&
-            meta.objects.some(function (obj) {
-                return obj.properties.some(function (p) { return p.key.isSoleLiteral(); }) &&
-                    obj.properties.some(function (p) { return !p.key.isSoleLiteral(); });
-            }))
-            noSupport("object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.");
-        // DYNAMIC OBJECT, BUT PROPERTY VALUE TYPE IS ARRAY
-        if (meta.objects.length &&
-            isDynamicObject(meta.objects[0]) &&
-            meta.objects[0].properties.some(function (p) { return !!p.value.arrays.length; }))
-            noSupport("dynamic object with array value type");
-        // UNION WITH DYNAMIC OBJECT
-        if (meta.size() > 1 &&
-            meta.objects.length &&
-            isDynamicObject(meta.objects[0]))
-            noSupport("union type with dynamic object type");
-        // UNION IN DYNAMIC PROPERTY VALUE
-        if (meta.objects.length &&
-            meta.objects.some(function (obj) {
-                return isDynamicObject(obj) &&
-                    obj.properties.some(function (p) { return ProtobufUtil_1.ProtobufUtil.isUnion(p.value); });
-            }))
-            noSupport("union type in dynamic property");
-        //----
-        // MAP CASES
-        //----
-        // KEY TYPE IS UNION
-        if (meta.maps.length && meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.isUnion(m.key); }))
-            noSupport("union key typed map");
-        // KEY TYPE IS NOT ATOMIC
-        if (meta.maps.length &&
-            meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.getAtomics(m.key).length !== 1; }))
-            noSupport("non-atomic key typed map");
-        // MAP TYPE, BUT PROPERTY KEY TYPE IS OPTIONAL
-        if (meta.maps.length &&
-            meta.maps.some(function (m) { return m.key.isRequired() === false || m.key.nullable; }))
-            noSupport("optional key typed map");
-        // MAP TYPE, BUT VALUE TYPE IS ARRAY
-        if (meta.maps.length && meta.maps.some(function (m) { return !!m.value.arrays.length; }))
-            noSupport("map type with array value type");
-        // UNION WITH MAP
-        if (meta.size() > 1 && meta.maps.length)
-            noSupport("union type with map type");
-        // UNION IN MAP
-        if (meta.maps.length &&
-            meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.isUnion(m.value); }))
-            noSupport("union type in map value type");
-        return errors;
+                var found = tags.find(function (t) { return t.kind === "type" && config.categories.has(t.value); });
+                return (_a = found === null || found === void 0 ? void 0 : found.value) !== null && _a !== void 0 ? _a : config.default;
+            };
+            var exploreCategory = function (matrix) {
+                var e_26, _a;
+                try {
+                    for (var matrix_2 = __values(matrix), matrix_2_1 = matrix_2.next(); !matrix_2_1.done; matrix_2_1 = matrix_2.next()) {
+                        var tags = matrix_2_1.value;
+                        categories.add(getType(tags));
+                    }
+                }
+                catch (e_26_1) { e_26 = { error: e_26_1 }; }
+                finally {
+                    try {
+                        if (matrix_2_1 && !matrix_2_1.done && (_a = matrix_2.return)) _a.call(matrix_2);
+                    }
+                    finally { if (e_26) throw e_26.error; }
+                }
+            };
+            try {
+                for (var _e = __values(next.metadata.atomics), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var atomic = _f.value;
+                    if (atomic.type === config.type)
+                        exploreCategory(atomic.tags);
+                }
+            }
+            catch (e_22_1) { e_22 = { error: e_22_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                }
+                finally { if (e_22) throw e_22.error; }
+            }
+            try {
+                for (var _g = __values(next.metadata.constants), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var constant = _h.value;
+                    if (constant.type === config.type)
+                        try {
+                            for (var _j = (e_24 = void 0, __values(constant.values)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                var value = _k.value;
+                                exploreCategory(value.tags);
+                            }
+                        }
+                        catch (e_24_1) { e_24 = { error: e_24_1 }; }
+                        finally {
+                            try {
+                                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                            }
+                            finally { if (e_24) throw e_24.error; }
+                        }
+                }
+            }
+            catch (e_23_1) { e_23 = { error: e_23_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                }
+                finally { if (e_23) throw e_23.error; }
+            }
+            var _loop_1 = function (category) {
+                var e_27, _l, e_28, _m, e_29, _o, e_30, _p, e_31, _q;
+                var unique = new Set();
+                var expected = 0;
+                var actual = 0;
+                var emplace = function (tags) {
+                    var sequence = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
+                    if (sequence !== null) {
+                        unique.add(sequence);
+                        ++actual;
+                    }
+                    ++expected;
+                };
+                try {
+                    for (var _r = (e_27 = void 0, __values(next.metadata.atomics)), _s = _r.next(); !_s.done; _s = _r.next()) {
+                        var atomic = _s.value;
+                        if (atomic.type === config.type)
+                            try {
+                                for (var _t = (e_28 = void 0, __values(atomic.tags)), _u = _t.next(); !_u.done; _u = _t.next()) {
+                                    var tags = _u.value;
+                                    if (getType(tags) === category)
+                                        emplace(tags);
+                                }
+                            }
+                            catch (e_28_1) { e_28 = { error: e_28_1 }; }
+                            finally {
+                                try {
+                                    if (_u && !_u.done && (_m = _t.return)) _m.call(_t);
+                                }
+                                finally { if (e_28) throw e_28.error; }
+                            }
+                    }
+                }
+                catch (e_27_1) { e_27 = { error: e_27_1 }; }
+                finally {
+                    try {
+                        if (_s && !_s.done && (_l = _r.return)) _l.call(_r);
+                    }
+                    finally { if (e_27) throw e_27.error; }
+                }
+                try {
+                    for (var _v = (e_29 = void 0, __values(next.metadata.constants)), _w = _v.next(); !_w.done; _w = _v.next()) {
+                        var constant = _w.value;
+                        if (constant.type === config.type)
+                            try {
+                                for (var _x = (e_30 = void 0, __values(constant.values)), _y = _x.next(); !_y.done; _y = _x.next()) {
+                                    var value = _y.value;
+                                    try {
+                                        for (var _z = (e_31 = void 0, __values(value.tags)), _0 = _z.next(); !_0.done; _0 = _z.next()) {
+                                            var tags = _0.value;
+                                            if (getType(tags) === category)
+                                                emplace(tags);
+                                        }
+                                    }
+                                    catch (e_31_1) { e_31 = { error: e_31_1 }; }
+                                    finally {
+                                        try {
+                                            if (_0 && !_0.done && (_q = _z.return)) _q.call(_z);
+                                        }
+                                        finally { if (e_31) throw e_31.error; }
+                                    }
+                                }
+                            }
+                            catch (e_30_1) { e_30 = { error: e_30_1 }; }
+                            finally {
+                                try {
+                                    if (_y && !_y.done && (_p = _x.return)) _p.call(_x);
+                                }
+                                finally { if (e_30) throw e_30.error; }
+                            }
+                    }
+                }
+                catch (e_29_1) { e_29 = { error: e_29_1 }; }
+                finally {
+                    try {
+                        if (_w && !_w.done && (_o = _v.return)) _o.call(_v);
+                    }
+                    finally { if (e_29) throw e_29.error; }
+                }
+                if (unique.size && actual !== expected) {
+                    console.log(category, actual, expected, unique);
+                    next.errors.push("The sequence tag must be declared in every union type members");
+                }
+                else if (unique.size > 1)
+                    next.errors.push("The sequence tag value must be the same in ".concat(config.type, " type (including literal types)"));
+                else if (unique.size === 1) {
+                    var value = unique.values().next().value;
+                    if (next.add(value) === false)
+                        next.errors.push("The sequence tag value ".concat(value, " in ").concat(config.type, " type is duplicated with other types"));
+                }
+            };
+            try {
+                // ITERATE TYPE CATEGORIES
+                for (var categories_1 = __values(categories), categories_1_1 = categories_1.next(); !categories_1_1.done; categories_1_1 = categories_1.next()) {
+                    var category = categories_1_1.value;
+                    _loop_1(category);
+                }
+            }
+            catch (e_25_1) { e_25 = { error: e_25_1 }; }
+            finally {
+                try {
+                    if (categories_1_1 && !categories_1_1.done && (_d = categories_1.return)) _d.call(categories_1);
+                }
+                finally { if (e_25) throw e_25.error; }
+            }
+        };
+    };
+    var validateStringSequence = function (next) {
+        var e_32, _a, e_33, _b, e_34, _c, e_35, _d;
+        var unique = new Set();
+        var expected = 0;
+        var actual = 0;
+        var emplace = function (matrix) {
+            var e_36, _a, e_37, _b;
+            try {
+                for (var matrix_3 = __values(matrix), matrix_3_1 = matrix_3.next(); !matrix_3_1.done; matrix_3_1 = matrix_3.next()) {
+                    var tags = matrix_3_1.value;
+                    try {
+                        for (var tags_2 = (e_37 = void 0, __values(tags)), tags_2_1 = tags_2.next(); !tags_2_1.done; tags_2_1 = tags_2.next()) {
+                            var tag = tags_2_1.value;
+                            var sequence = ProtobufUtil_1.ProtobufUtil.getSequence([tag]);
+                            if (sequence !== null) {
+                                unique.add(sequence);
+                                ++actual;
+                            }
+                            ++expected;
+                        }
+                    }
+                    catch (e_37_1) { e_37 = { error: e_37_1 }; }
+                    finally {
+                        try {
+                            if (tags_2_1 && !tags_2_1.done && (_b = tags_2.return)) _b.call(tags_2);
+                        }
+                        finally { if (e_37) throw e_37.error; }
+                    }
+                }
+            }
+            catch (e_36_1) { e_36 = { error: e_36_1 }; }
+            finally {
+                try {
+                    if (matrix_3_1 && !matrix_3_1.done && (_a = matrix_3.return)) _a.call(matrix_3);
+                }
+                finally { if (e_36) throw e_36.error; }
+            }
+        };
+        try {
+            for (var _e = __values(next.metadata.atomics), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var atomic = _f.value;
+                if (atomic.type === "string")
+                    emplace(atomic.tags);
+            }
+        }
+        catch (e_32_1) { e_32 = { error: e_32_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_32) throw e_32.error; }
+        }
+        try {
+            for (var _g = __values(next.metadata.constants), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var constant = _h.value;
+                if (constant.type === "string")
+                    try {
+                        for (var _j = (e_34 = void 0, __values(constant.values)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                            var value = _k.value;
+                            emplace(value.tags);
+                        }
+                    }
+                    catch (e_34_1) { e_34 = { error: e_34_1 }; }
+                    finally {
+                        try {
+                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                        }
+                        finally { if (e_34) throw e_34.error; }
+                    }
+            }
+        }
+        catch (e_33_1) { e_33 = { error: e_33_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_33) throw e_33.error; }
+        }
+        try {
+            for (var _l = __values(next.metadata.templates), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var template = _m.value;
+                emplace(template.tags);
+            }
+        }
+        catch (e_35_1) { e_35 = { error: e_35_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+            }
+            finally { if (e_35) throw e_35.error; }
+        }
+        if (unique.size && actual !== expected)
+            next.errors.push("The sequence tag must be declared in every union type members");
+        else if (unique.size > 1)
+            next.errors.push("The sequence tag value must be the same in string types including literal and template types");
+        else if (unique.size === 1) {
+            var value = unique.values().next().value;
+            if (next.add(value) === false)
+                next.errors.push("The sequence tag value ".concat(value, " in string type is duplicated with other types"));
+        }
+    };
+    var validateInstanceSequence = function (next) {
+        var e_38, _a;
+        var unique = new Set();
+        var count = 0;
+        try {
+            for (var _b = __values(next.tags), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tags = _c.value;
+                var value = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
+                if (value === null)
+                    continue;
+                unique.add(value);
+                ++count;
+            }
+        }
+        catch (e_38_1) { e_38 = { error: e_38_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_38) throw e_38.error; }
+        }
+        if (unique.size && count !== next.tags.length)
+            next.errors.push("The sequence tag must be declared in every union type members");
+        else if (unique.size > 1)
+            next.errors.push("The sequence tag value must be the same in ".concat(next.type === "array" ? "an array" : "object", " type."));
+        else if (unique.size === 1) {
+            var value = unique.values().next().value;
+            if (next.add(value) === false)
+                next.errors.push("The sequence tag value ".concat(value, " in ").concat(next.type, " type is duplicated with other types"));
+        }
     };
 })(ProtobufFactory || (exports.ProtobufFactory = ProtobufFactory = {}));
 var isDynamicObject = function (obj) {
@@ -268,4 +932,13 @@ var BANNED_NATIVE_TYPES = new Map(__spreadArray(__spreadArray([
     ["WeakSet", "Array"],
     ["WeakMap", "Map"],
 ], false));
+var NUMBER_TYPES = new Set([
+    "int32",
+    "uint32",
+    "int64",
+    "uint64",
+    "float",
+    "double",
+]);
+var BIGINT_TYPES = new Set(["int64", "uint64"]);
 //# sourceMappingURL=ProtobufFactory.js.map