typia 3.4.10 → 3.5.0-dev.20221219

package/src/factories/internal/{iterate_metadata_coalesce.ts → metadata/iterate_metadata_coalesce.ts}

@@ -1,10 +1,10 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { TypeFactory } from "../TypeFactory";
+import { TypeFactory } from "../../TypeFactory";
 
 export const iterate_metadata_coalesce = (
     meta: Metadata,

package/src/factories/internal/{iterate_metadata_constant.ts → metadata/iterate_metadata_constant.ts}

@@ -1,11 +1,11 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataConstant } from "../../metadata/MetadataConstant";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataConstant } from "../../../metadata/MetadataConstant";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataFactory } from "../../MetadataFactory";
 
 export const iterate_metadata_constant =
     (checker: ts.TypeChecker) =>

package/src/factories/internal/{iterate_metadata_map.ts → metadata/iterate_metadata_map.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { TypeFactory } from "../TypeFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_map =

package/src/factories/internal/{iterate_metadata_native.ts → metadata/iterate_metadata_native.ts}

@@ -1,10 +1,10 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { TypeFactory } from "../TypeFactory";
+import { TypeFactory } from "../../TypeFactory";
 
 export const iterate_metadata_native =
     (checker: ts.TypeChecker) =>

package/src/factories/internal/{iterate_metadata_object.ts → metadata/iterate_metadata_object.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataObject } from "../../metadata/MetadataObject";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { emplace_metadata_object } from "./emplace_metadata_object";
 import { iterate_metadata } from "./iterate_metadata";
 

package/src/factories/internal/{iterate_metadata_resolve.ts → metadata/iterate_metadata_resolve.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { TypeFactory } from "../TypeFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_resolve =

package/src/factories/internal/{iterate_metadata_set.ts → metadata/iterate_metadata_set.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { TypeFactory } from "../TypeFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_set =

package/src/factories/internal/{iterate_metadata_template.ts → metadata/iterate_metadata_template.ts}

@@ -1,9 +1,9 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { MetadataHelper } from "./MetadataHelper";
 import { explore_metadata } from "./explore_metadata";
 

package/src/factories/internal/{iterate_metadata_tuple.ts → metadata/iterate_metadata_tuple.ts}

@@ -1,13 +1,13 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_tuple =

package/src/factories/internal/{iterate_metadata_union.ts → metadata/iterate_metadata_union.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { TypeFactory } from "../TypeFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
 export const iterate_metadata_union =

package/src/factories/internal/protocols/ProtocolMetadataUtil.ts

@@ -0,0 +1,81 @@
+import { IMetadataTag } from "../../../metadata/IMetadataTag";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+export namespace ProtocolMetadataUtil {
+    export function size(meta: Metadata): number {
+        return (
+            meta.atomics.length +
+            meta.constants.filter(
+                (c) =>
+                    meta.atomics.find((type) => c.type === type) === undefined,
+            ).length +
+            (meta.templates.length !== 0 &&
+            meta.atomics.find((type) => type === "string") === undefined &&
+            meta.constants.find((c) => c.type === "string") === undefined
+                ? 1
+                : 0) +
+            meta.tuples.length +
+            meta.arrays.length +
+            meta.sets.length +
+            meta.maps.length +
+            meta.objects.length +
+            meta.natives.filter((n) => n === "Date").length +
+            (meta.natives.filter((n) => n !== "Date").length ? 1 : 0)
+        );
+    }
+
+    export function standalone(meta: Metadata): boolean {
+        return (
+            size(meta) === 1 &&
+            meta.required === true &&
+            meta.nullable === false &&
+            meta.tuples.length === 0 &&
+            meta.arrays.length === 0 &&
+            meta.sets.length === 0 &&
+            meta.maps.length === 0 &&
+            meta.objects.every((obj) =>
+                obj.properties.every((p) => p.key.isSoleLiteral()),
+            )
+        );
+    }
+
+    export function regular(obj: MetadataObject): boolean {
+        return obj.properties.every((p) => p.key.isSoleLiteral());
+    }
+
+    export function object(name: string, index: number): MetadataObject {
+        return MetadataObject.create({
+            name,
+            index,
+            properties: [],
+            description: undefined,
+            jsDocTags: [],
+            validated: false,
+            recursive: false,
+            nullables: [false],
+        });
+    }
+
+    export function property(
+        key: string,
+        value: Metadata,
+        tags: IMetadataTag[],
+    ): MetadataProperty {
+        return MetadataProperty.create({
+            key: (() => {
+                const meta: Metadata = Metadata.initialize();
+                meta.constants.push({
+                    type: "string",
+                    values: [key],
+                });
+                return meta;
+            })(),
+            value: value,
+            description: undefined,
+            tags,
+            jsDocTags: [],
+        });
+    }
+}

package/src/factories/internal/protocols/emplace_protocol_object.ts

@@ -0,0 +1,25 @@
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { emplace_protocol_property } from "./emplace_protocol_property";
+
+export const emplace_protocol_object =
+    (dict: Map<string, IProtocolMessage>) => (object: MetadataObject) => {
+        if (dict.has(object.name)) return;
+
+        const regular = object.properties.filter((p) => p.key.isSoleLiteral());
+        const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
+
+        if (!regular.length || dynamic.length) return;
+
+        const output: IProtocolMessage = {
+            name: object.name,
+            properties: [],
+        };
+        dict.set(object.name, output);
+
+        output.properties.push(
+            ...regular.map((prop) => emplace_protocol_property(dict)(prop)),
+        );
+        return output;
+    };

package/src/factories/internal/protocols/emplace_protocol_property.ts

@@ -0,0 +1,12 @@
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { IProtocolProperty } from "../../../messages/IProtocolProperty";
+import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
+
+export const emplace_protocol_property =
+    (dict: Map<string, IProtocolMessage>) =>
+    (property: MetadataProperty): IProtocolProperty => ({
+        key: property.key.getSoleLiteral()!,
+        ...iterate_protocol_metadata(dict)(property.value)(property.tags),
+    });

package/src/factories/internal/protocols/iterate_protocol_atomic.ts

@@ -0,0 +1,34 @@
+import { IMetadataTag } from "../../../metadata/IMetadataTag";
+
+import { Atomic } from "../../../typings/Atomic";
+
+export const iterate_protocol_atomic =
+    (tags: IMetadataTag[]) => (type: Atomic.Literal) => {
+        if (type === "boolean") return "bool";
+        else if (type === "number") return number(tags);
+        else if (type === "bigint") return bigint(tags);
+        else return "string";
+    };
+
+const number = (tagList: IMetadataTag[]) => {
+    const filtered: IMetadataTag.INumberType[] = tagList.filter(
+        (tag) => tag.kind === "type",
+    ) as IMetadataTag.INumberType[];
+
+    for (const { value } of filtered)
+        if (value === "int") return "int32";
+        else if (value === "uint") return "uint32";
+    return "double";
+};
+
+const bigint = (tagList: IMetadataTag[]) => {
+    const filtered: IMetadataTag.IBigintType[] = tagList.filter(
+        (tag) =>
+            tag.kind === "type" &&
+            (tag.value === "int64" || tag.value === "uint64"),
+    ) as IMetadataTag.IBigintType[];
+
+    for (const { value } of filtered)
+        if (value === "int64" || value === "uint64") return value;
+    return "int64";
+};

package/src/factories/internal/protocols/iterate_protocol_constant.ts

@@ -0,0 +1,27 @@
+import { MetadataConstant } from "../../../metadata/MetadataConstant";
+
+export const iterate_protocol_constant = ({
+    type,
+    values,
+}: MetadataConstant) => {
+    if (type === "boolean") return "bool";
+    else if (type === "number") return number(values);
+    else if (type === "bigint") return bigint(values);
+    else return "string";
+};
+
+const bigint = (values: bigint[]): string => {
+    return values.every((v) => v >= BigInt(0)) ? "uint64" : "int64";
+};
+
+const number = (values: number[]): string => {
+    return values.some((v) => Math.floor(v) !== v)
+        ? "double"
+        : values.every((v) => v >= 0)
+        ? values.every((v) => v <= 2 ** 64 - 1)
+            ? "uint32"
+            : "uint64"
+        : values.every((v) => -(2 ** 31) <= v && v <= 2 ** 31 - 1)
+        ? "int32"
+        : "int64";
+};

package/src/factories/internal/protocols/iterate_protocol_main.ts

@@ -0,0 +1,20 @@
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { MetadataCollection } from "../../MetadataCollection";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+
+export const iterate_protocol_main =
+    (dict: Map<string, IProtocolMessage>) =>
+    (meta: Metadata): string => {
+        // ONLY ONE OBJECT TYPE
+        if (ProtocolMetadataUtil.standalone(meta) && meta.objects.length === 1)
+            return MetadataCollection.escape(meta.getName());
+
+        const obj = ProtocolMetadataUtil.object("__Main", dict.size);
+        obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));
+        emplace_protocol_object(dict)(obj);
+
+        return MetadataCollection.escape(obj.name);
+    };

package/src/factories/internal/protocols/iterate_protocol_map.ts

@@ -0,0 +1,40 @@
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { MetadataCollection } from "../../MetadataCollection";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
+import { iterate_protocol_constant } from "./iterate_protocol_constant";
+
+export const iterate_protocol_map =
+    (container: "Object" | "Map") =>
+    (dict: Map<string, IProtocolMessage>) =>
+    (key: Metadata) =>
+    (value: Metadata) =>
+        `map<${getKeyName(key)}, ${getValueName(container)(dict)(value)}>`;
+
+const getKeyName = (meta: Metadata) => {
+    for (const atomic of meta.atomics)
+        return iterate_protocol_atomic([])(atomic);
+    for (const constant of meta.constants)
+        return iterate_protocol_constant(constant);
+    return "string";
+};
+
+const getValueName =
+    (container: "Object" | "Map") =>
+    (dict: Map<string, IProtocolMessage>) =>
+    (meta: Metadata) => {
+        if (ProtocolMetadataUtil.standalone(meta))
+            return MetadataCollection.escape(meta.getName());
+
+        const obj: MetadataObject = ProtocolMetadataUtil.object(
+            MetadataCollection.replace(`${container}.Value<${meta.getName()}>`),
+            dict.size,
+        );
+        obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));
+        emplace_protocol_object(dict)(obj);
+        return MetadataCollection.replace(obj.name);
+    };

package/src/factories/internal/protocols/iterate_protocol_metadata.ts

@@ -0,0 +1,75 @@
+import { IMetadataTag } from "../../../metadata/IMetadataTag";
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { IProtocolProperty } from "../../../messages/IProtocolProperty";
+import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
+import { iterate_protocol_constant } from "./iterate_protocol_constant";
+import { iterate_protocol_map } from "./iterate_protocol_map";
+import { iterate_protocol_native } from "./iterate_protocol_native";
+import { iterate_protocol_repeated } from "./iterate_protocol_repeated";
+import { iterate_protocol_tuple } from "./iterate_protocol_tuple";
+
+export const iterate_protocol_metadata =
+    (dict: Map<string, IProtocolMessage>) =>
+    (meta: Metadata) =>
+    (tags: IMetadataTag[]): Omit<IProtocolProperty, "key"> => {
+        // PREPARE ASSETS
+        const required: boolean = meta.required && !meta.nullable;
+        const oneOf: IProtocolProperty.IOneOf[] = [];
+
+        const add = (type: string) => {
+            if (oneOf.some((one) => one.type === type)) return;
+            oneOf.push({
+                type,
+            });
+        };
+
+        // WHEN SINGULAR ARRAY TYPE
+        if (meta.size() === 1 && meta.arrays.length + meta.sets.length === 1) {
+            const [container, child] =
+                meta.arrays.length === 1
+                    ? (["Array", meta.arrays[0]!] as const)
+                    : (["Set", meta.sets[0]!] as const);
+            add(iterate_protocol_repeated(container)(true)(dict)(child)(tags));
+            return {
+                required,
+                oneOf,
+                repeated: true,
+            };
+        }
+
+        // ATOMIC TYPES
+        for (const type of meta.atomics)
+            add(iterate_protocol_atomic(tags)(type));
+        for (const constant of meta.constants)
+            add(iterate_protocol_constant(constant));
+
+        // INSTANCE TYPES
+        for (const obj of meta.objects)
+            if (obj.properties.some((p) => !p.key.isSoleLiteral())) {
+                for (const prop of obj.properties)
+                    add(
+                        iterate_protocol_map("Object")(dict)(prop.key)(
+                            prop.value,
+                        ),
+                    );
+            } else add(obj.name);
+        for (const native of meta.natives)
+            add(iterate_protocol_native(dict)(native));
+        for (const tuple of meta.tuples)
+            add(iterate_protocol_tuple(dict)(tuple));
+        for (const array of meta.arrays)
+            add(iterate_protocol_repeated("Array")(false)(dict)(array)(tags));
+        for (const set of meta.sets)
+            add(iterate_protocol_repeated("Set")(false)(dict)(set)(tags));
+        for (const map of meta.maps)
+            add(iterate_protocol_map("Map")(dict)(map.key)(map.value));
+
+        // RETURNS
+        return {
+            required,
+            oneOf,
+            repeated: false,
+        };
+    };

package/src/factories/internal/protocols/iterate_protocol_native.ts

@@ -0,0 +1,34 @@
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+
+export const iterate_protocol_native =
+    (dict: Map<string, IProtocolMessage>) => (native: string) => {
+        if (native === "Date") {
+            const obj = ProtocolMetadataUtil.object("__Timestamp", dict.size);
+            obj.properties.push(
+                ProtocolMetadataUtil.property("seconds", integer("bigint"), [
+                    {
+                        kind: "type",
+                        value: "int64",
+                    },
+                ]),
+                ProtocolMetadataUtil.property("nanos", integer("number"), [
+                    {
+                        kind: "type",
+                        value: "int",
+                    },
+                ]),
+            );
+            emplace_protocol_object(dict)(obj);
+            return "__Timestamp";
+        } else return "bytes";
+    };
+
+const integer = (type: "number" | "bigint") => {
+    const meta = Metadata.initialize();
+    meta.atomics.push(type);
+    return meta;
+};

package/src/factories/internal/protocols/iterate_protocol_repeated.ts

@@ -0,0 +1,28 @@
+import { IMetadataTag } from "../../../metadata/IMetadataTag";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { MetadataCollection } from "../../MetadataCollection";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+
+export const iterate_protocol_repeated =
+    (container: "Array" | "Set") =>
+    (sole: boolean) =>
+    (dict: Map<string, IProtocolMessage>) =>
+    (meta: Metadata) =>
+    (tags: IMetadataTag[]): string => {
+        sole &&= ProtocolMetadataUtil.standalone(meta);
+        if (sole === true) return MetadataCollection.replace(meta.getName());
+
+        const obj: MetadataObject = ProtocolMetadataUtil.object(
+            MetadataCollection.replace(
+                `${container}.Element<${meta.getName()}>`,
+            ),
+            dict.size,
+        );
+        obj.properties.push(ProtocolMetadataUtil.property("value", meta, tags));
+        emplace_protocol_object(dict)(obj);
+        return MetadataCollection.replace(obj.name);
+    };

package/src/factories/internal/protocols/iterate_protocol_tuple.ts

@@ -0,0 +1,28 @@
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { MetadataCollection } from "../../MetadataCollection";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+
+export const iterate_protocol_tuple =
+    (dict: Map<string, IProtocolMessage>) =>
+    (tuple: Metadata[]): string => {
+        const name: string = MetadataCollection.replace(
+            `[${tuple.map((m) => m.getName()).join(", ")}]`,
+        );
+        if (dict.has(name)) return MetadataCollection.escape(name);
+
+        const obj: MetadataObject = ProtocolMetadataUtil.object(
+            name,
+            dict.size,
+        );
+        obj.properties.push(
+            ...tuple.map((value, i) =>
+                ProtocolMetadataUtil.property(`v${i}`, value, []),
+            ),
+        );
+        emplace_protocol_object(dict)(obj);
+        return MetadataCollection.escape(obj.name);
+    };

package/src/functional/$proto_bytes.ts

@@ -0,0 +1,25 @@
+import { $varint_decode_i32, $varint_encode } from "./$varint";
+
+export function $proto_bytes_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: Uint8Array,
+): number {
+    offset = $varint_encode(dst, offset, value.length);
+    dst.set(value, offset);
+    offset += value.length;
+    return offset;
+}
+
+export function $proto_bytes_decode(
+    src: Uint8Array,
+    offset: number,
+): [value: Uint8Array, offset: number] {
+    let length = 0;
+
+    [length, offset] = $varint_decode_i32(src, offset); // Max Length: ~2GB
+    const value = src.subarray(offset, offset + length);
+    offset += length;
+
+    return [value, offset];
+}

package/src/functional/$proto_field.ts

@@ -0,0 +1,30 @@
+import { $varint_decode_i32, $varint_encode } from "./$varint";
+
+export enum $proto_field_wiretype {
+    VARINT = 0,
+    I64 = 1,
+    LEN = 2,
+    SGROUP = 3, // deprecated
+    EGROUP = 4, // deprecated
+    I32 = 5,
+}
+
+export function $proto_field_encode(
+    dst: Uint8Array,
+    offset: number,
+    fieldNumber: number,
+    wireType: $proto_field_wiretype,
+): number {
+    const tag = (fieldNumber << 3) | Number(wireType);
+    return $varint_encode(dst, offset, tag);
+}
+
+export function $proto_field_decode(
+    buf: Uint8Array,
+    offset: number,
+): [fieldNumber: number, wireType: $proto_field_wiretype, offset: number] {
+    const [tag, o] = $varint_decode_i32(buf, offset);
+    const fieldNumber = tag >>> 3;
+    const wireType = tag & 0b111;
+    return [fieldNumber, wireType, o];
+}