typia 5.3.12-dev.20240118 → 6.0.0-dev.20240119

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -18,7 +18,7 @@ import { IProject } from "../../transformers/IProject";
 
 import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 
 export namespace ProtobufDecodeProgrammer {
@@ -44,9 +44,11 @@ export namespace ProtobufDecodeProgrammer {
         );
       const reader = StatementFactory.constant(
         "reader",
-        ts.factory.createNewExpression(importer.use("Reader"), undefined, [
-          ts.factory.createIdentifier("input"),
-        ]),
+        ts.factory.createNewExpression(
+          importer.use("ProtobufReader"),
+          undefined,
+          [ts.factory.createIdentifier("input")],
+        ),
       );
 
       return ts.factory.createArrowFunction(
@@ -66,7 +68,7 @@ export namespace ProtobufDecodeProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            ...importer.declare(modulo),
+            ...importer.declare(),
             ...functors,
             reader,
             ts.factory.createReturnStatement(

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -20,7 +20,7 @@ import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 import { ProtobufWire } from "../helpers/ProtobufWire";
 import { UnionPredicator } from "../helpers/UnionPredicator";
@@ -54,12 +54,18 @@ export namespace ProtobufEncodeProgrammer {
           write_encoder(project)(importer)(collection)(meta),
         ),
         callEncoder("sizer")(
-          ts.factory.createNewExpression(importer.use("Sizer"), undefined, []),
+          ts.factory.createNewExpression(
+            importer.use("ProtobufSizer"),
+            undefined,
+            [],
+          ),
         ),
         callEncoder("writer")(
-          ts.factory.createNewExpression(importer.use("Writer"), undefined, [
-            ts.factory.createIdentifier("sizer"),
-          ]),
+          ts.factory.createNewExpression(
+            importer.use("ProtobufWriter"),
+            undefined,
+            [ts.factory.createIdentifier("sizer")],
+          ),
         ),
         ts.factory.createReturnStatement(
           ts.factory.createCallExpression(
@@ -83,10 +89,7 @@ export namespace ProtobufEncodeProgrammer {
         ],
         ts.factory.createTypeReferenceNode("Uint8Array"),
         undefined,
-        ts.factory.createBlock(
-          [...importer.declare(modulo, false), ...block],
-          true,
-        ),
+        ts.factory.createBlock([...importer.declare(false), ...block], true),
       );
     };
 
@@ -792,7 +795,7 @@ export namespace ProtobufEncodeProgrammer {
     (value: ts.Expression) =>
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          importer.use("throws"),
+          importer.use("throws", true),
           [],
           [
             ts.factory.createObjectLiteralExpression(

package/src/protobuf.ts

@@ -1,5 +1,3 @@
-import * as Namespace from "./functional/Namespace";
-
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
 
@@ -94,7 +92,7 @@ export function message(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function decode(input: Uint8Array): never;
+export function decode(input: Uint8Array): never;
 
 /**
  * Protocol Buffer Decoder.
@@ -124,16 +122,14 @@ function decode(input: Uint8Array): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function decode<T>(input: Uint8Array): Resolved<T>;
+export function decode<T>(input: Uint8Array): Resolved<T>;
 
 /**
  * @internal
  */
-function decode(): never {
+export function decode(): never {
   halt("decode");
 }
-const decodePure = /** @__PURE__ */ Object.assign(decode, /** @__PURE__ */ Namespace.protobuf.decode("decode"));
-export { decodePure as decode };
 
 /**
  * > You must configure the generic argument `T`.
@@ -164,7 +160,7 @@ export { decodePure as decode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertDecode(input: Uint8Array): never;
+export function assertDecode(input: Uint8Array): never;
 
 /**
  * Protocol Buffer Decoder wity type assertion, but not safe.
@@ -193,22 +189,15 @@ function assertDecode(input: Uint8Array): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertDecode<T>(input: Uint8Array): Resolved<T>;
+export function assertDecode<T>(input: Uint8Array): Resolved<T>;
 
 /**
  * @internal
  */
-function assertDecode(): never {
+export function assertDecode(): never {
   halt("assertDecode");
 }
 
-const assertDecodePure = /** @__PURE__ */ Object.assign(
-  assertDecode,
-  /** @__PURE__ */ Namespace.assert("protobuf.assertDecode"),
-  /** @__PURE__ */ Namespace.protobuf.decode("assertDecode"),
-);
-export { assertDecodePure as assertDecode };
-
 /**
  * > You must configure the generic argument `T`.
  *
@@ -238,7 +227,7 @@ export { assertDecodePure as assertDecode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isDecode(input: Uint8Array): never;
+export function isDecode(input: Uint8Array): never;
 
 /**
  * Protocol Buffer Decoder wity type checking, but not safe.
@@ -267,20 +256,14 @@ function isDecode(input: Uint8Array): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isDecode<T>(input: Uint8Array): Resolved<T> | null;
+export function isDecode<T>(input: Uint8Array): Resolved<T> | null;
 
 /**
  * @internal
  */
-function isDecode(): never {
+export function isDecode(): never {
   halt("isDecode");
 }
-const isDecodePure = /** @__PURE__ */ Object.assign(
-  isDecode,
-  /** @__PURE__ */ Namespace.is(),
-  /** @__PURE__ */ Namespace.protobuf.decode("isDecode")
-);
-export { isDecodePure as isDecode };
 
 /**
  * > You must configure the generic argument `T`.
@@ -312,7 +295,7 @@ export { isDecodePure as isDecode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateDecode(input: Uint8Array): never;
+export function validateDecode(input: Uint8Array): never;
 
 /**
  * Protocol Buffer Decoder wity type validation, but not safe.
@@ -342,20 +325,14 @@ function validateDecode(input: Uint8Array): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;
+export function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;
 
 /**
  * @internal
  */
-function validateDecode(): never {
+export function validateDecode(): never {
   halt("validateDecode");
 }
-const validateDecodePure = /** @__PURE__ */ Object.assign(
-  validateDecode,
-  /** @__PURE__ */ Namespace.validate(),
-  /** @__PURE__ */ Namespace.protobuf.decode("validateDecode")
-);
-export { validateDecodePure as validateDecode };
 
 /* -----------------------------------------------------------
     ENCODE
@@ -387,16 +364,14 @@ export { validateDecodePure as validateDecode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function encode<T>(input: T): Uint8Array;
+export function encode<T>(input: T): Uint8Array;
 
 /**
  * @internal
  */
-function encode(): never {
+export function encode(): never {
   halt("encode");
 }
-const encodePure = /** @__PURE__ */ Object.assign(encode, /** @__PURE__ */ Namespace.protobuf.encode("encode"));
-export { encodePure as encode };
 
 /**
  * Protocol Buffer Encoder with type assertion.
@@ -429,7 +404,7 @@ export { encodePure as encode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertEncode<T>(input: T): Uint8Array;
+export function assertEncode<T>(input: T): Uint8Array;
 
 /**
  * Protocol Buffer Encoder with type assertion.
@@ -462,20 +437,14 @@ function assertEncode<T>(input: T): Uint8Array;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertEncode<T>(input: unknown): Uint8Array;
+export function assertEncode<T>(input: unknown): Uint8Array;
 
 /**
  * @internal
  */
-function assertEncode(): never {
+export function assertEncode(): never {
   halt("assertEncode");
 }
-const assertEncodePure = /** @__PURE__ */ Object.assign(
-  assertEncode,
-  /** @__PURE__ */ Namespace.assert("protobuf.assertEncode"),
-  /** @__PURE__ */ Namespace.protobuf.encode("assertEncode"),
-);
-export { assertEncodePure as assertEncode };
 
 /**
  * Protocol Buffer Encoder with type checking.
@@ -508,7 +477,7 @@ export { assertEncodePure as assertEncode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isEncode<T>(input: T): Uint8Array | null;
+export function isEncode<T>(input: T): Uint8Array | null;
 
 /**
  * Protocol Buffer Encoder with type checking.
@@ -541,20 +510,14 @@ function isEncode<T>(input: T): Uint8Array | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isEncode<T>(input: unknown): Uint8Array | null;
+export function isEncode<T>(input: unknown): Uint8Array | null;
 
 /**
  * @internal
  */
-function isEncode(): never {
+export function isEncode(): never {
   halt("isEncode");
 }
-const isEncodePure = /** @__PURE__ */ Object.assign(
-  isEncode,
-  /** @__PURE__ */ Namespace.is(),
-  /** @__PURE__ */ Namespace.protobuf.encode("isEncode")
-);
-export { isEncodePure as isEncode };
 
 /**
  * Protocol Buffer Encoder with type validation.
@@ -588,7 +551,7 @@ export { isEncodePure as isEncode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateEncode<T>(input: T): IValidation<Uint8Array>;
+export function validateEncode<T>(input: T): IValidation<Uint8Array>;
 
 /**
  * Protocol Buffer Encoder with type validation.
@@ -622,20 +585,14 @@ function validateEncode<T>(input: T): IValidation<Uint8Array>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateEncode<T>(input: unknown): IValidation<Uint8Array>;
+export function validateEncode<T>(input: unknown): IValidation<Uint8Array>;
 
 /**
  * @internal
  */
-function validateEncode(): never {
+export function validateEncode(): never {
   halt("validateEncode");
 }
-const validateEncodePure = /** @__PURE__ */ Object.assign(
-  validateEncode,
-  /** @__PURE__ */ Namespace.validate(),
-  /** @__PURE__ */ Namespace.protobuf.encode("validateEncode")
-);
-export { validateEncodePure as validateEncode };
 
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
@@ -649,7 +606,7 @@ export { validateEncodePure as validateEncode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createDecode(): never;
+export function createDecode(): never;
 
 /**
  * Creates a reusable {@link decode} function.
@@ -659,16 +616,14 @@ function createDecode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createDecode<T>(): (input: Uint8Array) => Resolved<T>;
+export function createDecode<T>(): (input: Uint8Array) => Resolved<T>;
 
 /**
  * @internal
  */
-function createDecode<T>(): (input: Uint8Array) => Resolved<T> {
+export function createDecode<T>(): (input: Uint8Array) => Resolved<T> {
   halt("createDecode");
 }
-const createDecodePure = /** @__PURE__ */ Object.assign(createDecode, /** @__PURE__ */ Namespace.protobuf.decode("createDecode"));
-export { createDecodePure as createDecode };
 
 /**
  * Creates a reusable {@link isDecode} function.
@@ -679,7 +634,7 @@ export { createDecodePure as createDecode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsDecode(): never;
+export function createIsDecode(): never;
 
 /**
  * Creates a reusable {@link isDecode} function.
@@ -689,20 +644,14 @@ function createIsDecode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;
+export function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;
 
 /**
  * @internal
  */
-function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null {
+export function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null {
   halt("createIsDecode");
 }
-const createIsDecodePure = /** @__PURE__ */ Object.assign(
-  createIsDecode,
-  /** @__PURE__ */ Namespace.is(),
-  /** @__PURE__ */ Namespace.protobuf.decode("createIsDecode"),
-);
-export { createIsDecodePure as createIsDecode };
 
 /**
  * Creates a reusable {@link assertDecode} function.
@@ -713,7 +662,7 @@ export { createIsDecodePure as createIsDecode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertDecode(): never;
+export function createAssertDecode(): never;
 
 /**
  * Creates a reusable {@link assertDecode} function.
@@ -723,20 +672,14 @@ function createAssertDecode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T>;
+export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T>;
 
 /**
  * @internal
  */
-function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
+export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
   halt("createAssertDecode");
 }
-const createAssertDecodePure = /** @__PURE__ */ Object.assign(
-  createAssertDecode,
-  /** @__PURE__ */ Namespace.assert("protobuf.createAssertDecode"),
-  /** @__PURE__ */ Namespace.protobuf.decode("createAssertDecode"),
-);
-export { createAssertDecodePure as createAssertDecode };
 
 /**
  * Creates a reusable {@link validateDecode} function.
@@ -747,7 +690,7 @@ export { createAssertDecodePure as createAssertDecode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateDecode(): never;
+export function createValidateDecode(): never;
 
 /**
  * Creates a reusable {@link validateDecode} function.
@@ -757,24 +700,18 @@ function createValidateDecode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateDecode<T>(): (
+export function createValidateDecode<T>(): (
   input: Uint8Array,
 ) => IValidation<Resolved<T>>;
 
 /**
  * @internal
  */
-function createValidateDecode<T>(): (
+export function createValidateDecode<T>(): (
   input: Uint8Array,
 ) => IValidation<Resolved<T>> {
   halt("createValidateDecode");
 }
-const createValidateDecodePure = /** @__PURE__ */ Object.assign(
-  createValidateDecode,
-  /** @__PURE__ */ Namespace.validate(),
-  /** @__PURE__ */ Namespace.protobuf.decode("createValidateDecode"),
-);
-export { createValidateDecodePure as createValidateDecode };
 
 /**
  * Creates a reusable {@link encode} function.
@@ -785,7 +722,7 @@ export { createValidateDecodePure as createValidateDecode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createEncode(): never;
+export function createEncode(): never;
 
 /**
  * Creates a reusable {@link encode} function.
@@ -795,16 +732,14 @@ function createEncode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createEncode<T>(): (input: T) => Uint8Array;
+export function createEncode<T>(): (input: T) => Uint8Array;
 
 /**
  * @internal
  */
-function createEncode<T>(): (input: T) => Uint8Array {
+export function createEncode<T>(): (input: T) => Uint8Array {
   halt("createEncode");
 }
-const createEncodePure = /** @__PURE__ */ Object.assign(createEncode, /** @__PURE__ */ Namespace.protobuf.encode("createEncode"));
-export { createEncodePure as createEncode };
 
 /**
  * Creates a reusable {@link isEncode} function.
@@ -815,7 +750,7 @@ export { createEncodePure as createEncode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsEncode(): never;
+export function createIsEncode(): never;
 
 /**
  * Creates a reusable {@link isEncode} function.
@@ -825,20 +760,14 @@ function createIsEncode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsEncode<T>(): (input: T) => Uint8Array | null;
+export function createIsEncode<T>(): (input: T) => Uint8Array | null;
 
 /**
  * @internal
  */
-function createIsEncode<T>(): (input: T) => Uint8Array | null {
+export function createIsEncode<T>(): (input: T) => Uint8Array | null {
   halt("createIsEncode");
 }
-const createIsEncodePure = /** @__PURE__ */ Object.assign(
-  createIsEncode,
-  /** @__PURE__ */ Namespace.is(),
-  /** @__PURE__ */ Namespace.protobuf.encode("createIsEncode")
-);
-export { createIsEncodePure as createIsEncode };
 
 /**
  * Creates a reusable {@link assertEncode} function.
@@ -849,7 +778,7 @@ export { createIsEncodePure as createIsEncode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertEncode(): never;
+export function createAssertEncode(): never;
 
 /**
  * Creates a reusable {@link assertEncode} function.
@@ -859,20 +788,14 @@ function createAssertEncode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertEncode<T>(): (input: T) => Uint8Array;
+export function createAssertEncode<T>(): (input: T) => Uint8Array;
 
 /**
  * @internal
  */
-function createAssertEncode<T>(): (input: T) => Uint8Array {
+export function createAssertEncode<T>(): (input: T) => Uint8Array {
   halt("createAssertEncode");
 }
-const createAssertEncodePure = /** @__PURE__ */ Object.assign(
-  createAssertEncode,
-  /** @__PURE__ */ Namespace.assert("protobuf.createAssertEncode"),
-  /** @__PURE__ */ Namespace.protobuf.encode("createAssertEncode"),
-);
-export { createAssertEncodePure as createAssertEncode };
 
 /**
  * Creates a reusable {@link validateEncode} function.
@@ -883,7 +806,7 @@ export { createAssertEncodePure as createAssertEncode };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateEncode(): never;
+export function createValidateEncode(): never;
 
 /**
  * Creates a reusable {@link validateEncode} function.
@@ -893,24 +816,18 @@ function createValidateEncode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateEncode<T>(): (
+export function createValidateEncode<T>(): (
   input: T,
 ) => IValidation<Uint8Array>;
 
 /**
  * @internal
  */
-function createValidateEncode<T>(): (
+export function createValidateEncode<T>(): (
   input: T,
 ) => IValidation<Uint8Array> {
   halt("createValidateEncode");
 }
-const createValidateEncodePure = /** @__PURE__ */ Object.assign(
-  createValidateEncode,
-  /** @__PURE__ */ Namespace.validate(),
-  /** @__PURE__ */ Namespace.protobuf.encode("createValidateEncode")
-);
-export { createValidateEncodePure as createValidateEncode };
 
 /**
  * @internal

package/src/reflect.ts

@@ -16,7 +16,7 @@ import { IMetadataApplication } from "./schemas/metadata/IMetadataApplication";
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function metadata(): never;
+export function metadata(): never;
 
 /**
  * Metadata Application.
@@ -32,18 +32,15 @@ function metadata(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function metadata<Types extends unknown[]>(): IMetadataApplication;
+export function metadata<Types extends unknown[]>(): IMetadataApplication;
 
 /**
  * @internal
  */
-function metadata(): never {
+export function metadata(): never {
   halt("metadata");
 }
 
-const metadataPure = /** @__PURE__ */ Object.assign(metadata, { from: (input: unknown) => input });
-export { metadataPure as metadata };
-
 /**
  * @internal
  */

package/src/schemas/metadata/IMetadataConstant.ts

@@ -1,7 +1,5 @@
 import { Atomic } from "../../typings/Atomic";
 
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
 export type IMetadataConstant =
   | IMetadataConstant.IBase<"boolean", boolean>
   | IMetadataConstant.IBase<"number", number>
@@ -14,10 +12,5 @@ export namespace IMetadataConstant {
   > {
     type: Type;
     values: Value[];
-
-    /**
-     * @internal
-     */
-    tags?: Type extends "boolean" ? IMetadataTypeTag[][] | undefined : never;
   }
 }

package/src/schemas/metadata/IMetadataObject.ts

@@ -10,9 +10,4 @@ export interface IMetadataObject {
   index: number;
   recursive: boolean;
   nullables: boolean[];
-
-  /**
-   * @internal
-   */
-  validated: boolean;
 }

package/src/schemas/metadata/MetadataObject.ts

@@ -65,7 +65,7 @@ export class MetadataObject {
       jsDocTags: obj.jsDocTags,
 
       index: obj.index,
-      validated: obj.validated,
+      validated: false,
       recursive: obj.recursive,
       nullables: obj.nullables.slice(),
     });
@@ -125,7 +125,6 @@ export class MetadataObject {
       jsDocTags: this.jsDocTags,
 
       index: this.index,
-      validated: this.validated,
       recursive: this.recursive,
       nullables: this.nullables.slice(),
     };