Typia Guide Documents

`encode()` functions

export namespace protobuf {
  export function encode<T>(input: T): Uint8Array;
  export function isEncode<T>(input: T): Uint8Array | null;
  export function assertEncode<T>(input: T): Uint8Array;
  export function validateEncode<T>(input: T): IValidation<Uint8Array>;
}

export class TypeGuardError extends Error {
  public readonly method: string;
  public readonly path: string | undefined;
  public readonly expected: string;
  public readonly value: any;
}

export type IValidation<T> = IValidation.ISuccess<T> | IValidation.IFailure;
export namespace IValidation {
  export interface ISuccess<T> {
    success: true;
    data: T;
  }
  export interface IFailure {
    success: false;
    errors: IError[];
    data: unknown;
  }
  export interface IError {
    path: string;
    expected: string;
    value: any;
  }
}

typia/Resolved.ts

/**
 * Resolved type erased every methods.
 *
 * `Resolved` is a type of TMP (Type Meta Programming) type which converts
 * its argument as a resolved type that erased every method properties.
 *
 * If the target argument is a built-in class which returns its origin primitive type
 * through the `valueOf()` method like the `String` or `Number`, its return type would
 * be the `string` or `number`. Otherwise, the built-in class does not have the
 * `valueOf()` method, the return type would be same with the target argument.
 *
 * Otherwise, the target argument is a type of custom class, all of its custom methods
 * would be erased and its prototype would be changed to the primitive `object`.
 * Therefore, return type of the TMP type finally be the resolved object.
 *
 * Before                  | After
 * ------------------------|----------------------------------------
 * `Boolean`               | `boolean`
 * `Number`                | `number`
 * `BigInt`                | `bigint`
 * `String`                | `string`
 * `Class`                 | `interface`
 * Native Class or Others  | No change
 *
 * @template T Target argument type.
 * @author Jeongho Nam - https://github.com/samchon
 * @author Kyungsu Kang - https://github.com/kakasoo
 */
export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true
  ? T
  : ResolvedMain<T>;
 
type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
 
type ResolvedMain<T> = T extends [never]
  ? never // (special trick for jsonable | null) type
  : ValueOf<T> extends boolean | number | bigint | string
  ? ValueOf<T>
  : T extends Function
  ? never
  : T extends object
  ? ResolvedObject<T>
  : ValueOf<T>;
 
type ResolvedObject<T extends object> = T extends Array<infer U>
  ? IsTuple<T> extends true
    ? ResolvedTuple<T>
    : ResolvedMain<U>[]
  : T extends Set<infer U>
  ? Set<ResolvedMain<U>>
  : T extends Map<infer K, infer V>
  ? Map<ResolvedMain<K>, ResolvedMain<V>>
  : T extends WeakSet<any> | WeakMap<any, any>
  ? never
  : T extends
      | Date
      | Uint8Array
      | Uint8ClampedArray
      | Uint16Array
      | Uint32Array
      | BigUint64Array
      | Int8Array
      | Int16Array
      | Int32Array
      | BigInt64Array
      | Float32Array
      | Float64Array
      | ArrayBuffer
      | SharedArrayBuffer
      | DataView
      | Blob
      | File
  ? T
  : {
      [P in keyof T]: ResolvedMain<T[P]>;
    };
 
type ResolvedTuple<T extends readonly any[]> = T extends []
  ? []
  : T extends [infer F]
  ? [ResolvedMain<F>]
  : T extends [infer F, ...infer Rest extends readonly any[]]
  ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
  : T extends [(infer F)?]
  ? [ResolvedMain<F>?]
  : T extends [(infer F)?, ...infer Rest extends readonly any[]]
  ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
  : [];
 
type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
  never,
]
  ? false
  : T extends readonly any[]
  ? number extends T["length"]
    ? false
    : true
  : false;
 
type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
  ? boolean
  : IsValueOf<Instance, Number> extends true
  ? number
  : IsValueOf<Instance, String> extends true
  ? string
  : Instance;
 
type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
  ? Object extends IValueOf<infer Primitive>
    ? Instance extends Primitive
      ? false
      : true // not Primitive, but Object
    : false // cannot be
  : false;
 
interface IValueOf<T> {
  valueOf(): T;
}

Protocol Buffer Encoder.

You can easily convert a JavaScript object to a binary data of Protocol Buffer, without any extra Protocol Buffer Message Schema definition. typia.protobuf.encode<T>() function analyzes your type T, and generates a Protocol Buffer Message Schema internally. And then, it converts the input instance to the binary data of Protocol Buffer format.

By the way, typia.protobuf.encode<T>() function does not validate the input value. It just believes user and input value, and converts to the Protocol Buffer binary data directly without any validation. By the way, if the input value was not validate, the encoded binary data never can be decoded. So, if you can’t sure the input value type, you should use below functions instead.

typia.protobuf.isEncode<T>(): typia.is<T>() + typia.protobuf.encode<T>()
typia.protobuf.assertEncode<T>(): typia.assert<T>() + typia.protobuf.encode<T>()
typia.protobuf.validateEncode<T>(): typia.validate<T>() + typia.protobuf.encode<T>()

AOT compliation

typia.protobuf.encode<T>() and other similar functions are still much faster than any other competitive libraries, even though they include type checking process. This is the power of AOT compilation, writing optimal dedicated code by analyzing TypeScript type, in the compilation level.

protobuf.encode.ts

import typia, { tags } from "typia";
 
const member: IMember = typia.random<IMember>();
const byte: Uint8Array = typia.protobuf.encode<IMember>(member);
console.log(byte);
 
interface IMember {
  id:
    | (string & tags.Sequence<11>)
    | (number & tags.Type<"uint64"> & tags.Sequence<12>)
    | (Uint8Array & tags.Sequence<13>);
  name: (string & tags.Sequence<20>) | null;
  children: Array<IMember> & tags.Sequence<30>;
  keywords: Map<string, string> & tags.Sequence<40>;
  thumbnail:
    | (string & tags.Format<"uri"> & tags.ContentMediaType<"image/*">)
    | Uint8Array;
  email: string & tags.Format<"email">;
  hobbies: Array<IHobby>;
}
interface IHobby {
  id: string & tags.Format<"uuid">;
  name: string;
  valid: boolean;
}

protobuf.encode.js

import * as __typia_transform__randomString from "typia/lib/internal/_randomString.js";
import * as __typia_transform__randomInteger from "typia/lib/internal/_randomInteger.js";
import * as __typia_transform__randomArray from "typia/lib/internal/_randomArray.js";
import * as __typia_transform__randomPick from "typia/lib/internal/_randomPick.js";
import * as __typia_transform__randomFormatUri from "typia/lib/internal/_randomFormatUri.js";
import * as __typia_transform__randomFormatEmail from "typia/lib/internal/_randomFormatEmail.js";
import * as __typia_transform__randomFormatUuid from "typia/lib/internal/_randomFormatUuid.js";
import * as __typia_transform__randomBoolean from "typia/lib/internal/_randomBoolean.js";
import * as __typia_transform__throwTypeGuardError from "typia/lib/internal/_throwTypeGuardError.js";
import * as __typia_transform__isTypeUint64 from "typia/lib/internal/_isTypeUint64.js";
import * as __typia_transform__isFormatUri from "typia/lib/internal/_isFormatUri.js";
import * as __typia_transform__isFormatEmail from "typia/lib/internal/_isFormatEmail.js";
import * as __typia_transform__isFormatUuid from "typia/lib/internal/_isFormatUuid.js";
import * as __typia_transform__ProtobufSizer from "typia/lib/internal/_ProtobufSizer.js";
import * as __typia_transform__ProtobufWriter from "typia/lib/internal/_ProtobufWriter.js";
import typia from "typia";
const member = (() => {
  const _ro0 = (_recursive = true, _depth = 0) => ({
    id: __typia_transform__randomPick._randomPick([
      () =>
        (_generator?.string ?? __typia_transform__randomString._randomString)({
          type: "string",
          "x-protobuf-sequence": 11,
        }),
      () =>
        (
          _generator?.integer ?? __typia_transform__randomInteger._randomInteger
        )({
          type: "integer",
          "x-protobuf-sequence": 12,
        }),
      () =>
        new Uint8Array(
          5 >= _depth
            ? (
                _generator?.array ?? __typia_transform__randomArray._randomArray
              )({
                type: "array",
                element: () =>
                  (
                    _generator?.integer ??
                    __typia_transform__randomInteger._randomInteger
                  )({
                    type: "integer",
                    minimum: 0,
                    maximum: 255,
                  }),
              })
            : [],
        ),
    ])(),
    name: __typia_transform__randomPick._randomPick([
      () => null,
      () =>
        (_generator?.string ?? __typia_transform__randomString._randomString)({
          type: "string",
          "x-protobuf-sequence": 20,
        }),
    ])(),
    children:
      5 >= _depth
        ? (_generator?.array ?? __typia_transform__randomArray._randomArray)({
            type: "array",
            "x-protobuf-sequence": 30,
            element: () => _ro0(true, _recursive ? 1 + _depth : _depth),
          })
        : [],
    keywords: new Map(
      5 >= _depth
        ? (_generator?.array ?? __typia_transform__randomArray._randomArray)({
            type: "array",
            element: () => [
              (
                _generator?.string ??
                __typia_transform__randomString._randomString
              )({
                type: "string",
              }),
              (
                _generator?.string ??
                __typia_transform__randomString._randomString
              )({
                type: "string",
              }),
            ],
          })
        : [],
    ),
    thumbnail: __typia_transform__randomPick._randomPick([
      () =>
        (
          _generator?.uri ?? __typia_transform__randomFormatUri._randomFormatUri
        )(),
      () =>
        new Uint8Array(
          5 >= _depth
            ? (
                _generator?.array ?? __typia_transform__randomArray._randomArray
              )({
                type: "array",
                element: () =>
                  (
                    _generator?.integer ??
                    __typia_transform__randomInteger._randomInteger
                  )({
                    type: "integer",
                    minimum: 0,
                    maximum: 255,
                  }),
              })
            : [],
        ),
    ])(),
    email: (
      _generator?.email ??
      __typia_transform__randomFormatEmail._randomFormatEmail
    )(),
    hobbies:
      5 >= _depth
        ? (_generator?.array ?? __typia_transform__randomArray._randomArray)({
            type: "array",
            element: () => _ro1(true, _recursive ? 1 + _depth : _depth),
          })
        : [],
  });
  const _ro1 = (_recursive = false, _depth = 0) => ({
    id: (
      _generator?.uuid ?? __typia_transform__randomFormatUuid._randomFormatUuid
    )(),
    name: (_generator?.string ?? __typia_transform__randomString._randomString)(
      {
        type: "string",
      },
    ),
    valid: (
      _generator?.boolean ?? __typia_transform__randomBoolean._randomBoolean
    )({
      type: "boolean",
    }),
  });
  let _generator;
  return (generator) => {
    _generator = generator;
    return _ro0();
  };
})()();
const byte = (() => {
  const encoder = (writer, input) => {
    const _peo0 = (input) => {
      // property "id": ((Uint8Array & Sequence<13>) | (number & Type<"uint64"> & Sequence<12>) | (string & Sequence<11>));
      if (input.id instanceof Uint8Array) {
        writer.uint32(106);
        writer.bytes(input.id);
      } else if ("number" === typeof input.id) {
        writer.uint32(96);
        writer.uint64(input.id);
      } else if ("string" === typeof input.id) {
        writer.uint32(90);
        writer.string(input.id);
      } else
        __typia_transform__throwTypeGuardError._throwTypeGuardError({
          method: "typia.protobuf.encode",
          expected:
            '((Uint8Array & Sequence<13>) | (number & Type<"uint64"> & Sequence<12>) | (string & Sequence<11>))',
          value: input.id,
        });
      // property "name": ((string & Sequence<20>) | null);
      if (null !== input.name) {
        writer.uint32(162);
        writer.string(input.name);
      }
      // property "children": (Array<IMember> & Sequence<30>);
      if (0 !== input.children.length) {
        for (const elem of input.children) {
          writer.uint32(242);
          writer.fork();
          _peo0(elem);
          writer.ldelim();
        }
      }
      // property "keywords": (Map<string, string> & Sequence<40>);
      for (const [key, value] of input.keywords) {
        writer.uint32(322);
        writer.fork();
        writer.uint32(10);
        writer.string(key);
        writer.uint32(18);
        writer.string(value);
        writer.ldelim();
      }
      // property "thumbnail": ((string & Format<"uri"> & ContentMediaType<"image/*">) | Uint8Array);
      if (input.thumbnail instanceof Uint8Array) {
        writer.uint32(330);
        writer.bytes(input.thumbnail);
      } else if ("string" === typeof input.thumbnail) {
        writer.uint32(338);
        writer.string(input.thumbnail);
      } else
        __typia_transform__throwTypeGuardError._throwTypeGuardError({
          method: "typia.protobuf.encode",
          expected:
            '((string & Format<"uri"> & ContentMediaType<"image/*">) | Uint8Array)',
          value: input.thumbnail,
        });
      // property "email": (string & Format<"email">);
      writer.uint32(346);
      writer.string(input.email);
      // property "hobbies": Array<IHobby>;
      if (0 !== input.hobbies.length) {
        for (const elem of input.hobbies) {
          writer.uint32(354);
          writer.fork();
          _peo1(elem);
          writer.ldelim();
        }
      }
    };
    const _peo1 = (input) => {
      // property "id": (string & Format<"uuid">);
      writer.uint32(10);
      writer.string(input.id);
      // property "name": string;
      writer.uint32(18);
      writer.string(input.name);
      // property "valid": boolean;
      writer.uint32(24);
      writer.bool(input.valid);
    };
    const _io0 = (input) =>
      null !== input.id &&
      undefined !== input.id &&
      ("string" === typeof input.id ||
        ("number" === typeof input.id &&
          __typia_transform__isTypeUint64._isTypeUint64(input.id)) ||
        input.id instanceof Uint8Array) &&
      (null === input.name || "string" === typeof input.name) &&
      Array.isArray(input.children) &&
      input.children.every(
        (elem) => "object" === typeof elem && null !== elem && _io0(elem),
      ) &&
      input.keywords instanceof Map &&
      (() =>
        [...input.keywords].every(
          (elem) =>
            Array.isArray(elem) &&
            elem.length === 2 &&
            "string" === typeof elem[0] &&
            "string" === typeof elem[1],
        ))() &&
      null !== input.thumbnail &&
      undefined !== input.thumbnail &&
      (("string" === typeof input.thumbnail &&
        __typia_transform__isFormatUri._isFormatUri(input.thumbnail)) ||
        input.thumbnail instanceof Uint8Array) &&
      "string" === typeof input.email &&
      __typia_transform__isFormatEmail._isFormatEmail(input.email) &&
      Array.isArray(input.hobbies) &&
      input.hobbies.every(
        (elem) => "object" === typeof elem && null !== elem && _io1(elem),
      );
    const _io1 = (input) =>
      "string" === typeof input.id &&
      __typia_transform__isFormatUuid._isFormatUuid(input.id) &&
      "string" === typeof input.name &&
      "boolean" === typeof input.valid;
    _peo0(input);
    return writer;
  };
  return (input) => {
    const sizer = encoder(
      new __typia_transform__ProtobufSizer._ProtobufSizer(),
      input,
    );
    const writer = encoder(
      new __typia_transform__ProtobufWriter._ProtobufWriter(sizer),
      input,
    );
    return writer.buffer();
  };
})()(member);
console.log(byte);

Reusable Functions

export namespace protobuf {
  export function encode<T>(): (input: T) => Uint8Array;
  export function isEncode<T>(): (input: T) => Uint8Array | null;
  export function assertEncode<T>(): (input: T) => Uint8Array;
  export function validateEncode<T>(): (input: T) => IValidation<Uint8Array>;
}

export class TypeGuardError extends Error {
  public readonly method: string;
  public readonly path: string | undefined;
  public readonly expected: string;
  public readonly value: any;
}

export type IValidation<T> = IValidation.ISuccess<T> | IValidation.IFailure;
export namespace IValidation {
  export interface ISuccess<T> {
    success: true;
    data: T;
  }
  export interface IFailure {
    success: false;
    errors: IError[];
    data: unknown;
  }
  export interface IError {
    path: string;
    expected: string;
    value: any;
  }
}

/**
 * Resolved type erased every methods.
 *
 * `Resolved` is a type of TMP (Type Meta Programming) type which converts
 * its argument as a resolved type that erased every method properties.
 *
 * If the target argument is a built-in class which returns its origin primitive type
 * through the `valueOf()` method like the `String` or `Number`, its return type would
 * be the `string` or `number`. Otherwise, the built-in class does not have the
 * `valueOf()` method, the return type would be same with the target argument.
 *
 * Otherwise, the target argument is a type of custom class, all of its custom methods
 * would be erased and its prototype would be changed to the primitive `object`.
 * Therefore, return type of the TMP type finally be the resolved object.
 *
 * Before                  | After
 * ------------------------|----------------------------------------
 * `Boolean`               | `boolean`
 * `Number`                | `number`
 * `BigInt`                | `bigint`
 * `String`                | `string`
 * `Class`                 | `interface`
 * Native Class or Others  | No change
 *
 * @template T Target argument type.
 * @author Jeongho Nam - https://github.com/samchon
 * @author Kyungsu Kang - https://github.com/kakasoo
 */
export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true
  ? T
  : ResolvedMain<T>;
 
type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
 
type ResolvedMain<T> = T extends [never]
  ? never // (special trick for jsonable | null) type
  : ValueOf<T> extends boolean | number | bigint | string
  ? ValueOf<T>
  : T extends Function
  ? never
  : T extends object
  ? ResolvedObject<T>
  : ValueOf<T>;
 
type ResolvedObject<T extends object> = T extends Array<infer U>
  ? IsTuple<T> extends true
    ? ResolvedTuple<T>
    : ResolvedMain<U>[]
  : T extends Set<infer U>
  ? Set<ResolvedMain<U>>
  : T extends Map<infer K, infer V>
  ? Map<ResolvedMain<K>, ResolvedMain<V>>
  : T extends WeakSet<any> | WeakMap<any, any>
  ? never
  : T extends
      | Date
      | Uint8Array
      | Uint8ClampedArray
      | Uint16Array
      | Uint32Array
      | BigUint64Array
      | Int8Array
      | Int16Array
      | Int32Array
      | BigInt64Array
      | Float32Array
      | Float64Array
      | ArrayBuffer
      | SharedArrayBuffer
      | DataView
      | Blob
      | File
  ? T
  : {
      [P in keyof T]: ResolvedMain<T[P]>;
    };
 
type ResolvedTuple<T extends readonly any[]> = T extends []
  ? []
  : T extends [infer F]
  ? [ResolvedMain<F>]
  : T extends [infer F, ...infer Rest extends readonly any[]]
  ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
  : T extends [(infer F)?]
  ? [ResolvedMain<F>?]
  : T extends [(infer F)?, ...infer Rest extends readonly any[]]
  ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
  : [];
 
type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
  never,
]
  ? false
  : T extends readonly any[]
  ? number extends T["length"]
    ? false
    : true
  : false;
 
type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
  ? boolean
  : IsValueOf<Instance, Number> extends true
  ? number
  : IsValueOf<Instance, String> extends true
  ? string
  : Instance;
 
type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
  ? Object extends IValueOf<infer Primitive>
    ? Instance extends Primitive
      ? false
      : true // not Primitive, but Object
    : false // cannot be
  : false;
 
interface IValueOf<T> {
  valueOf(): T;
}

Reusable typia.protobuf.encode<T>() function generators.

If you repeat to call typia.protobuf.encode<T>() function on the same type, size of JavaScript files would be larger because of duplicated AOT compilation. To prevent it, you can generate reusable function through typia.protobuf.createEncode<T>() function.

Just look at the code below, then you may understand how to use it.

protobuf.createEncode.ts

import typia, { tags } from "typia";
 
export const encode = typia.protobuf.createEncode<IMember>();
 
interface IMember {
  id:
    | (string & tags.Sequence<11>)
    | (number & tags.Type<"uint64"> & tags.Sequence<12>)
    | (Uint8Array & tags.Sequence<13>);
  name: (string & tags.Sequence<20>) | null;
  children: Array<IMember> & tags.Sequence<30>;
  keywords: Map<string, string> & tags.Sequence<40>;
  thumbnail:
    | (string & tags.Format<"uri"> & tags.ContentMediaType<"image/*">)
    | Uint8Array;
  email: string & tags.Format<"email">;
  hobbies: Array<IHobby>;
}
interface IHobby {
  id: string & tags.Format<"uuid">;
  name: string;
  valid: boolean;
}

protobuf.createEncode.js

import * as __typia_transform__throwTypeGuardError from "typia/lib/internal/_throwTypeGuardError.js";
import * as __typia_transform__isTypeUint64 from "typia/lib/internal/_isTypeUint64.js";
import * as __typia_transform__isFormatUri from "typia/lib/internal/_isFormatUri.js";
import * as __typia_transform__isFormatEmail from "typia/lib/internal/_isFormatEmail.js";
import * as __typia_transform__isFormatUuid from "typia/lib/internal/_isFormatUuid.js";
import * as __typia_transform__ProtobufSizer from "typia/lib/internal/_ProtobufSizer.js";
import * as __typia_transform__ProtobufWriter from "typia/lib/internal/_ProtobufWriter.js";
import typia from "typia";
export const encode = (() => {
  const encoder = (writer, input) => {
    const _peo0 = (input) => {
      // property "id": ((Uint8Array & Sequence<13>) | (number & Type<"uint64"> & Sequence<12>) | (string & Sequence<11>));
      if (input.id instanceof Uint8Array) {
        writer.uint32(106);
        writer.bytes(input.id);
      } else if ("number" === typeof input.id) {
        writer.uint32(96);
        writer.uint64(input.id);
      } else if ("string" === typeof input.id) {
        writer.uint32(90);
        writer.string(input.id);
      } else
        __typia_transform__throwTypeGuardError._throwTypeGuardError({
          method: "typia.protobuf.createEncode",
          expected:
            '((Uint8Array & Sequence<13>) | (number & Type<"uint64"> & Sequence<12>) | (string & Sequence<11>))',
          value: input.id,
        });
      // property "name": ((string & Sequence<20>) | null);
      if (null !== input.name) {
        writer.uint32(162);
        writer.string(input.name);
      }
      // property "children": (Array<IMember> & Sequence<30>);
      if (0 !== input.children.length) {
        for (const elem of input.children) {
          writer.uint32(242);
          writer.fork();
          _peo0(elem);
          writer.ldelim();
        }
      }
      // property "keywords": (Map<string, string> & Sequence<40>);
      for (const [key, value] of input.keywords) {
        writer.uint32(322);
        writer.fork();
        writer.uint32(10);
        writer.string(key);
        writer.uint32(18);
        writer.string(value);
        writer.ldelim();
      }
      // property "thumbnail": ((string & Format<"uri"> & ContentMediaType<"image/*">) | Uint8Array);
      if (input.thumbnail instanceof Uint8Array) {
        writer.uint32(330);
        writer.bytes(input.thumbnail);
      } else if ("string" === typeof input.thumbnail) {
        writer.uint32(338);
        writer.string(input.thumbnail);
      } else
        __typia_transform__throwTypeGuardError._throwTypeGuardError({
          method: "typia.protobuf.createEncode",
          expected:
            '((string & Format<"uri"> & ContentMediaType<"image/*">) | Uint8Array)',
          value: input.thumbnail,
        });
      // property "email": (string & Format<"email">);
      writer.uint32(346);
      writer.string(input.email);
      // property "hobbies": Array<IHobby>;
      if (0 !== input.hobbies.length) {
        for (const elem of input.hobbies) {
          writer.uint32(354);
          writer.fork();
          _peo1(elem);
          writer.ldelim();
        }
      }
    };
    const _peo1 = (input) => {
      // property "id": (string & Format<"uuid">);
      writer.uint32(10);
      writer.string(input.id);
      // property "name": string;
      writer.uint32(18);
      writer.string(input.name);
      // property "valid": boolean;
      writer.uint32(24);
      writer.bool(input.valid);
    };
    const _io0 = (input) =>
      null !== input.id &&
      undefined !== input.id &&
      ("string" === typeof input.id ||
        ("number" === typeof input.id &&
          __typia_transform__isTypeUint64._isTypeUint64(input.id)) ||
        input.id instanceof Uint8Array) &&
      (null === input.name || "string" === typeof input.name) &&
      Array.isArray(input.children) &&
      input.children.every(
        (elem) => "object" === typeof elem && null !== elem && _io0(elem),
      ) &&
      input.keywords instanceof Map &&
      (() =>
        [...input.keywords].every(
          (elem) =>
            Array.isArray(elem) &&
            elem.length === 2 &&
            "string" === typeof elem[0] &&
            "string" === typeof elem[1],
        ))() &&
      null !== input.thumbnail &&
      undefined !== input.thumbnail &&
      (("string" === typeof input.thumbnail &&
        __typia_transform__isFormatUri._isFormatUri(input.thumbnail)) ||
        input.thumbnail instanceof Uint8Array) &&
      "string" === typeof input.email &&
      __typia_transform__isFormatEmail._isFormatEmail(input.email) &&
      Array.isArray(input.hobbies) &&
      input.hobbies.every(
        (elem) => "object" === typeof elem && null !== elem && _io1(elem),
      );
    const _io1 = (input) =>
      "string" === typeof input.id &&
      __typia_transform__isFormatUuid._isFormatUuid(input.id) &&
      "string" === typeof input.name &&
      "boolean" === typeof input.valid;
    _peo0(input);
    return writer;
  };
  return (input) => {
    const sizer = encoder(
      new __typia_transform__ProtobufSizer._ProtobufSizer(),
      input,
    );
    const writer = encoder(
      new __typia_transform__ProtobufWriter._ProtobufWriter(sizer),
      input,
    );
    return writer.buffer();
  };
})();

References

Protocol Buffer supports special numeric types like int32 or uint64 that are not supported in TypeScript. Also, types of Protocol Buffer cannot fully meet TypeScript type specs either, as expression power of TypeScript types are much stronger than Protocol Buffer.

To know how to define special numeric types like uint64, and to understand which TypeScript types are not supported in Protocol Buffer specs, it would better to read below documents. I recommend you to read them before using typia.protobuf.encode<T>() related functions.

Typia Guide Documents > Protocol Buffer > Message Schema

Message Schema decode() functions

encode() functions

Reusable Functions

References

`encode()` functions