typia 7.0.0-dev.20241012 → 7.0.0-dev.20241019

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,1270 @@ 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].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");
-        }
-        //----
-        // 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 _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"));
+    /**
+     * @internal
+     */
+    ProtobufFactory.emplaceObject = function (object) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(object.properties), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var p = _c.value;
+                emplaceProperty(p);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var properties = object.properties
+            .map(function (p) { return p.of_protobuf_; })
+            .filter(function (p) { return p !== undefined; });
+        var unique = new Set(properties
+            .filter(function (p) { return p !== undefined; })
+            .filter(function (p) { return p.fixed === true; })
+            .map(function (p) { return p.union.map(function (u) { return u.index; }); })
+            .flat());
+        var index = 1;
+        properties.forEach(function (schema) {
+            var e_2, _a;
+            if (schema.fixed === true)
+                index = Math.max(index, Math.max.apply(Math, __spreadArray([], __read(schema.union.map(function (u) { return u.index; })), false)) + 1);
+            else {
+                try {
+                    for (var _b = __values(schema.union), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var u = _c.value;
+                        while (unique.has(index) === true)
+                            ++index;
+                        u.index = index;
+                        unique.add(index);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                ++index;
+            }
+        });
+    };
+    var emplaceProperty = function (prop) {
+        var e_3, _a, e_4, _b, e_5, _c, e_6, _d;
+        var _e, _f, _g, _h, _j;
+        var union = [];
+        try {
+            for (var _k = __values(prop.value.natives), _l = _k.next(); !_l.done; _l = _k.next()) {
+                var native = _l.value;
+                if (native.name === "Uint8Array")
+                    union.push({
+                        type: "bytes",
+                        index: ProtobufUtil_1.ProtobufUtil.getSequence((_e = native.tags[0]) !== null && _e !== void 0 ? _e : []),
+                    });
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_l && !_l.done && (_a = _k.return)) _a.call(_k);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        union.push.apply(union, __spreadArray([], __read(emplaceAtomic(prop.value).values()), false));
+        try {
+            for (var _m = __values(prop.value.arrays), _o = _m.next(); !_o.done; _o = _m.next()) {
+                var array = _o.value;
+                union.push({
+                    type: "array",
+                    array: array.type,
+                    value: emplaceSchema(array.type.value),
+                    index: ProtobufUtil_1.ProtobufUtil.getSequence((_f = array.tags[0]) !== null && _f !== void 0 ? _f : []),
+                });
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_o && !_o.done && (_b = _m.return)) _b.call(_m);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        try {
+            for (var _p = __values(prop.value.objects), _q = _p.next(); !_q.done; _q = _p.next()) {
+                var obj = _q.value;
+                if (isDynamicObject(obj.type))
+                    union.push({
+                        type: "map",
+                        map: obj.type,
+                        key: emplaceSchema(obj.type.properties[0].key),
+                        value: emplaceSchema(obj.type.properties[0].value),
+                        index: ProtobufUtil_1.ProtobufUtil.getSequence((_g = obj.tags[0]) !== null && _g !== void 0 ? _g : []),
+                    });
+                else
+                    union.push({
+                        type: "object",
+                        object: obj.type,
+                        index: ProtobufUtil_1.ProtobufUtil.getSequence((_h = obj.tags[0]) !== null && _h !== void 0 ? _h : []),
+                    });
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_q && !_q.done && (_c = _p.return)) _c.call(_p);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        try {
+            for (var _r = __values(prop.value.maps), _s = _r.next(); !_s.done; _s = _r.next()) {
+                var map = _s.value;
+                union.push({
+                    type: "map",
+                    map: map,
+                    key: emplaceSchema(map.key),
+                    value: emplaceSchema(map.value),
+                    index: ProtobufUtil_1.ProtobufUtil.getSequence((_j = map.tags[0]) !== null && _j !== void 0 ? _j : []),
+                });
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_s && !_s.done && (_d = _r.return)) _d.call(_r);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        prop.of_protobuf_ = {
+            union: union,
+            fixed: union.every(function (p) { return p.index !== null; }),
+        };
+    };
+    var emplaceSchema = function (metadata) {
+        var e_7, _a, e_8, _b, e_9, _c, e_10, _d;
+        try {
+            for (var _e = __values(metadata.natives), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var native = _f.value;
+                if (native.name === "Uint8Array")
+                    return {
+                        type: "bytes",
+                    };
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        var atomic = emplaceAtomic(metadata);
+        if (atomic.size)
+            return atomic.values().next().value;
+        try {
+            for (var _g = __values(metadata.arrays), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var array = _h.value;
+                return {
+                    type: "array",
+                    array: array.type,
+                    value: emplaceSchema(array.type.value),
+                };
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        try {
+            for (var _j = __values(metadata.objects), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var obj = _k.value;
+                if (isDynamicObject(obj.type))
+                    return {
+                        type: "map",
+                        map: obj.type,
+                        key: emplaceSchema(obj.type.properties[0].key),
+                        value: emplaceSchema(obj.type.properties[0].value),
+                    };
+                else
+                    return {
+                        type: "object",
+                        object: obj.type,
+                    };
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        try {
+            for (var _l = __values(metadata.maps), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var map = _m.value;
+                return {
+                    type: "map",
+                    map: map,
+                    key: emplaceSchema(map.key),
+                    value: emplaceSchema(map.value),
+                };
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        throw new Error("Error on ProtobufFactory.emplaceSchema(): any type detected.");
+    };
+    var emplaceAtomic = function (meta) {
+        var e_11, _a, e_12, _b, e_13, _c, e_14, _d;
+        var _e, _f, _g, _h, _j, _k, _l, _m;
+        var map = new Map();
+        try {
+            // CONSTANTS
+            for (var _o = __values(meta.constants), _p = _o.next(); !_p.done; _p = _o.next()) {
+                var c = _p.value;
+                if (c.type === "boolean")
+                    map.set("bool", {
+                        type: "bool",
+                        index: getSequence((_f = (_e = c.values[0]) === null || _e === void 0 ? void 0 : _e.tags[0]) !== null && _f !== void 0 ? _f : []),
+                    });
+                else if (c.type === "bigint") {
+                    var init = getBigintType(c.values.map(function (v) { return BigInt(v.value); }));
+                    try {
+                        for (var _q = (e_12 = void 0, __values(c.values)), _r = _q.next(); !_r.done; _r = _q.next()) {
+                            var value = _r.value;
+                            emplaceBigint({
+                                map: map,
+                                tags: value.tags,
+                                init: init,
+                            });
+                        }
+                    }
+                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                    finally {
+                        try {
+                            if (_r && !_r.done && (_b = _q.return)) _b.call(_q);
+                        }
+                        finally { if (e_12) throw e_12.error; }
+                    }
+                }
+                else if (c.type === "number") {
+                    var init = getNumberType(c.values.map(function (v) { return v.value; }));
+                    try {
+                        for (var _s = (e_13 = void 0, __values(c.values)), _t = _s.next(); !_t.done; _t = _s.next()) {
+                            var value = _t.value;
+                            emplaceNumber({
+                                map: map,
+                                tags: value.tags,
+                                init: init,
+                            });
+                        }
+                    }
+                    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                    finally {
+                        try {
+                            if (_t && !_t.done && (_c = _s.return)) _c.call(_s);
+                        }
+                        finally { if (e_13) throw e_13.error; }
+                    }
+                }
+                else if (c.type === "string")
+                    map.set("string", {
+                        type: "string",
+                        index: getSequence((_h = (_g = c.values[0]) === null || _g === void 0 ? void 0 : _g.tags[0]) !== null && _h !== void 0 ? _h : []),
+                    });
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_p && !_p.done && (_a = _o.return)) _a.call(_o);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        // TEMPLATE
+        if (meta.templates.length)
+            map.set("string", {
+                type: "string",
+                index: getSequence((_k = (_j = meta.templates[0]) === null || _j === void 0 ? void 0 : _j.tags[0]) !== null && _k !== void 0 ? _k : []),
+            });
+        try {
+            // ATOMICS
+            for (var _u = __values(meta.atomics), _v = _u.next(); !_v.done; _v = _u.next()) {
+                var atomic = _v.value;
+                if (atomic.type === "boolean")
+                    map.set("bool", {
+                        type: "bool",
+                        index: getSequence((_l = atomic.tags[0]) !== null && _l !== void 0 ? _l : []),
+                    });
+                else if (atomic.type === "bigint")
+                    emplaceBigint({
+                        map: map,
+                        tags: atomic.tags,
+                        init: "int64",
+                    });
+                else if (atomic.type === "number")
+                    emplaceNumber({
+                        map: map,
+                        tags: atomic.tags,
+                        init: "double",
+                    });
+                else if (atomic.type === "string")
+                    map.set("string", {
+                        type: "string",
+                        index: getSequence((_m = atomic.tags[0]) !== null && _m !== void 0 ? _m : []),
+                    });
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_v && !_v.done && (_d = _u.return)) _d.call(_u);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        // SORTING IF REQUIRED
+        if (map.size && map.values().next().value.index === null)
+            return new Map(Array.from(map).sort(function (x, y) { return ProtobufUtil_1.ProtobufUtil.compare(x[0], y[0]); }));
+        return map;
+    };
+    var emplaceBigint = function (next) {
+        var e_15, _a;
+        var _b, _c;
+        if (next.tags.length === 0) {
+            next.map.set(next.init, {
+                type: "bigint",
+                name: next.init,
+                index: null,
+            });
+            return;
+        }
+        try {
+            for (var _d = __values(next.tags), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var row = _e.value;
+                var value = (_c = (_b = row.find(function (tag) {
+                    return tag.kind === "type" &&
+                        (tag.value === "int64" || tag.value === "uint64");
+                })) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : next.init;
+                next.map.set(next.init, {
+                    type: "bigint",
+                    name: value,
+                    index: ProtobufUtil_1.ProtobufUtil.getSequence(row),
+                });
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+    };
+    var emplaceNumber = function (next) {
+        var e_16, _a;
+        var _b, _c;
+        if (next.tags.length === 0) {
+            next.map.set(next.init, {
+                type: "number",
+                name: next.init,
+                index: null,
+            });
+            return;
+        }
+        try {
+            for (var _d = __values(next.tags), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var row = _e.value;
+                var value = (_c = (_b = row.find(function (tag) {
+                    return tag.kind === "type" &&
+                        (tag.value === "int32" ||
+                            tag.value === "uint32" ||
+                            tag.value === "int64" ||
+                            tag.value === "uint64" ||
+                            tag.value === "float" ||
+                            tag.value === "double");
+                })) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : next.init;
+                next.map.set(value, {
+                    type: "number",
+                    name: value,
+                    index: ProtobufUtil_1.ProtobufUtil.getSequence(row),
+                });
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+    };
+    var getBigintType = function (values) {
+        return values.some(function (v) { return v < 0; }) ? "int64" : "uint64";
+    };
+    var getNumberType = function (values) {
+        return values.every(function (v) { return Math.floor(v) === v; })
+            ? values.every(function (v) { return -2147483648 <= v && v <= 2147483647; })
+                ? "int32"
+                : "int64"
+            : "double";
+    };
+    var getSequence = function (tags) {
+        var sequence = tags.find(function (t) {
+            var _a;
+            return t.kind === "sequence" &&
+                typeof ((_a = t.schema) === null || _a === void 0 ? void 0 : _a["x-protobuf-sequence"]) === "number";
+        });
+        if (sequence === undefined)
+            return null;
+        var value = Number(sequence.schema["x-protobuf-sequence"]);
+        return Number.isNaN(value) ? null : value;
+    };
+    /* -----------------------------------------------------------
+      VALIDATORS
+    ----------------------------------------------------------- */
+    var validate = function () {
+        var visited = new WeakSet();
+        return function (meta, explore) {
+            var e_17, _a, e_18, _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].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);
+                validateObject({
+                    object: explore.object,
+                    errors: errors,
+                });
+                try {
+                    ProtobufFactory.emplaceObject(explore.object);
+                }
+                catch (_c) { }
+            }
+            //----
+            // 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 _d = __values(meta.natives), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var native = _e.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_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; }
+                }
+            //----
+            // ATOMIC CASES
+            //----
+            if (meta.atomics.length) {
+                var numbers = ProtobufUtil_1.ProtobufUtil.getNumbers(meta);
+                var bigints = ProtobufUtil_1.ProtobufUtil.getBigints(meta);
+                try {
+                    for (var _f = __values(["int64", "uint64"]), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var type = _g.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_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; }
+                }
+            }
+            //----
+            // 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 validateObject = function (next) {
+        var e_19, _a, e_20, _b;
+        try {
+            for (var _c = __values(next.object.properties), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var property = _d.value;
+                validateProperty({
+                    metadata: property.value,
+                    errors: next.errors,
+                });
+            }
+        }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
+        var entire = new Map();
+        var visitProperty = function (p) {
+            var e_21, _a, e_22, _b, e_23, _c, e_24, _d, e_25, _e, e_26, _f, e_27, _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_22 = void 0, __values(c.values)), _l = _k.next(); !_l.done; _l = _k.next()) {
+                            var v = _l.value;
+                            tagger(v.tags);
+                        }
+                    }
+                    catch (e_22_1) { e_22 = { error: e_22_1 }; }
+                    finally {
+                        try {
+                            if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
+                        }
+                        finally { if (e_22) throw e_22.error; }
+                    }
+                }
+            }
+            catch (e_21_1) { e_21 = { error: e_21_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
+                }
+                finally { if (e_21) throw e_21.error; }
+            }
+            try {
+                for (var _m = __values(p.value.atomics), _o = _m.next(); !_o.done; _o = _m.next()) {
+                    var a = _o.value;
+                    tagger(a.tags);
+                }
+            }
+            catch (e_23_1) { e_23 = { error: e_23_1 }; }
+            finally {
+                try {
+                    if (_o && !_o.done && (_c = _m.return)) _c.call(_m);
+                }
+                finally { if (e_23) throw e_23.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_24_1) { e_24 = { error: e_24_1 }; }
+            finally {
+                try {
+                    if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
+                }
+                finally { if (e_24) throw e_24.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_25_1) { e_25 = { error: e_25_1 }; }
+            finally {
+                try {
+                    if (_s && !_s.done && (_e = _r.return)) _e.call(_r);
+                }
+                finally { if (e_25) throw e_25.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_26_1) { e_26 = { error: e_26_1 }; }
+            finally {
+                try {
+                    if (_u && !_u.done && (_f = _t.return)) _f.call(_t);
+                }
+                finally { if (e_26) throw e_26.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_27_1) { e_27 = { error: e_27_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_27) throw e_27.error; }
+            }
+        };
+        try {
+            for (var _e = __values(next.object.properties), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var p = _f.value;
+                visitProperty(p);
+            }
+        }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_20) throw e_20.error; }
+        }
+    };
+    var validateProperty = function (next) {
+        var e_28, _a, e_29, _b, e_30, _c, e_31, _d, e_32, _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.metadata, errors: next.errors, add: add });
+            }
+        }
+        catch (e_28_1) { e_28 = { error: e_28_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+            }
+            finally { if (e_28) throw e_28.error; }
+        }
+        try {
+            for (var _h = __values(next.metadata.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_29_1) { e_29 = { error: e_29_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+            }
+            finally { if (e_29) throw e_29.error; }
+        }
+        try {
+            for (var _k = __values(next.metadata.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_30_1) { e_30 = { error: e_30_1 }; }
+        finally {
+            try {
+                if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
+            }
+            finally { if (e_30) throw e_30.error; }
+        }
+        try {
+            for (var _m = __values(next.metadata.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_31_1) { e_31 = { error: e_31_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 (_o && !_o.done && (_d = _m.return)) _d.call(_m);
+            }
+            finally { if (e_31) throw e_31.error; }
+        }
+        try {
+            for (var _p = __values(next.metadata.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_32_1) { e_32 = { error: e_32_1 }; }
+        finally {
+            try {
+                if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
+            }
+            finally { if (e_32) throw e_32.error; }
+        }
+    };
+    var validateBooleanSequence = function (next) {
+        var e_33, _a, e_34, _b, e_35, _c;
+        // PREPARE EMPLACER
+        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_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_37 = 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_37_1) { e_37 = { error: e_37_1 }; }
+                    finally {
+                        try {
+                            if (tags_1_1 && !tags_1_1.done && (_b = tags_1.return)) _b.call(tags_1);
+                        }
+                        finally { if (e_37) throw e_37.error; }
+                    }
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_36_1) { e_36 = { error: e_36_1 }; }
             finally {
                 try {
-                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-                }
-                finally { if (e_2) throw e_2.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) {
+                    if (matrix_1_1 && !matrix_1_1.done && (_a = matrix_1.return)) _a.call(matrix_1);
+                }
+                finally { if (e_36) throw e_36.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_33_1) { e_33 = { error: e_33_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_33) throw e_33.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_35 = void 0, __values(constant.values)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                            var value = _j.value;
+                            emplace(value.tags);
+                        }
+                    }
+                    catch (e_35_1) { e_35 = { error: e_35_1 }; }
+                    finally {
+                        try {
+                            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                        }
+                        finally { if (e_35) throw e_35.error; }
+                    }
+            }
+        }
+        catch (e_34_1) { e_34 = { error: e_34_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_34) throw e_34.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"));
+        }
+    };
+    var validateNumericSequences = function (config) {
+        return function (next) {
+            var e_38, _a, e_39, _b, e_40, _c, e_41, _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.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).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_42, _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_42_1) { e_42 = { error: e_42_1 }; }
+                finally {
+                    try {
+                        if (matrix_2_1 && !matrix_2_1.done && (_a = matrix_2.return)) _a.call(matrix_2);
+                    }
+                    finally { if (e_42) throw e_42.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_38_1) { e_38 = { error: e_38_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                }
+                finally { if (e_38) throw e_38.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_40 = void 0, __values(constant.values)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                var value = _k.value;
+                                exploreCategory(value.tags);
+                            }
+                        }
+                        catch (e_40_1) { e_40 = { error: e_40_1 }; }
+                        finally {
+                            try {
+                                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                            }
+                            finally { if (e_40) throw e_40.error; }
+                        }
+                }
+            }
+            catch (e_39_1) { e_39 = { error: e_39_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                }
+                finally { if (e_39) throw e_39.error; }
+            }
+            var _loop_1 = function (category) {
+                var e_43, _l, e_44, _m, e_45, _o, e_46, _p, e_47, _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_43 = 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_44 = 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_44_1) { e_44 = { error: e_44_1 }; }
+                            finally {
+                                try {
+                                    if (_u && !_u.done && (_m = _t.return)) _m.call(_t);
+                                }
+                                finally { if (e_44) throw e_44.error; }
+                            }
+                    }
+                }
+                catch (e_43_1) { e_43 = { error: e_43_1 }; }
+                finally {
+                    try {
+                        if (_s && !_s.done && (_l = _r.return)) _l.call(_r);
+                    }
+                    finally { if (e_43) throw e_43.error; }
+                }
+                try {
+                    for (var _v = (e_45 = 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_46 = void 0, __values(constant.values)), _y = _x.next(); !_y.done; _y = _x.next()) {
+                                    var value = _y.value;
+                                    try {
+                                        for (var _z = (e_47 = 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_47_1) { e_47 = { error: e_47_1 }; }
+                                    finally {
+                                        try {
+                                            if (_0 && !_0.done && (_q = _z.return)) _q.call(_z);
+                                        }
+                                        finally { if (e_47) throw e_47.error; }
+                                    }
+                                }
+                            }
+                            catch (e_46_1) { e_46 = { error: e_46_1 }; }
+                            finally {
+                                try {
+                                    if (_y && !_y.done && (_p = _x.return)) _p.call(_x);
+                                }
+                                finally { if (e_46) throw e_46.error; }
+                            }
+                    }
+                }
+                catch (e_45_1) { e_45 = { error: e_45_1 }; }
+                finally {
+                    try {
+                        if (_w && !_w.done && (_o = _v.return)) _o.call(_v);
+                    }
+                    finally { if (e_45) throw e_45.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_41_1) { e_41 = { error: e_41_1 }; }
+            finally {
+                try {
+                    if (categories_1_1 && !categories_1_1.done && (_d = categories_1.return)) _d.call(categories_1);
+                }
+                finally { if (e_41) throw e_41.error; }
+            }
+        };
+    };
+    var validateStringSequence = function (next) {
+        var e_48, _a, e_49, _b, e_50, _c, e_51, _d;
+        var unique = new Set();
+        var expected = 0;
+        var actual = 0;
+        var emplace = function (matrix) {
+            var e_52, _a, e_53, _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_53 = 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_53_1) { e_53 = { error: e_53_1 }; }
+                    finally {
+                        try {
+                            if (tags_2_1 && !tags_2_1.done && (_b = tags_2.return)) _b.call(tags_2);
+                        }
+                        finally { if (e_53) throw e_53.error; }
+                    }
+                }
+            }
+            catch (e_52_1) { e_52 = { error: e_52_1 }; }
+            finally {
+                try {
+                    if (matrix_3_1 && !matrix_3_1.done && (_a = matrix_3.return)) _a.call(matrix_3);
+                }
+                finally { if (e_52) throw e_52.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_48_1) { e_48 = { error: e_48_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_48) throw e_48.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_50 = void 0, __values(constant.values)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                            var value = _k.value;
+                            emplace(value.tags);
+                        }
+                    }
+                    catch (e_50_1) { e_50 = { error: e_50_1 }; }
+                    finally {
+                        try {
+                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                        }
+                        finally { if (e_50) throw e_50.error; }
+                    }
+            }
+        }
+        catch (e_49_1) { e_49 = { error: e_49_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_49) throw e_49.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_51_1) { e_51 = { error: e_51_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+            }
+            finally { if (e_51) throw e_51.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_54, _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_54_1) { e_54 = { error: e_54_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_54) throw e_54.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 +1365,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