typia 6.0.0-dev.20240122 → 6.0.0

package/src/protobuf.ts

@@ -1,5 +1,8 @@
+import * as Namespace from "./functional/Namespace";
+
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
+import { TypeGuardError } from "./TypeGuardError";
 
 /* ===========================================================
     PROTOCOL BUFFER
@@ -92,7 +95,7 @@ export function message(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function decode(input: Uint8Array): never;
+function decode(input: Uint8Array): never;
 
 /**
  * Protocol Buffer Decoder.
@@ -122,14 +125,19 @@ export function decode(input: Uint8Array): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function decode<T>(input: Uint8Array): Resolved<T>;
+function decode<T>(input: Uint8Array): Resolved<T>;
 
 /**
  * @internal
  */
-export function decode(): never {
+function decode(): never {
   halt("decode");
 }
+const decodePure = /** @__PURE__ */ Object.assign<typeof decode, {}>(
+  decode,
+  /** @__PURE__ */ Namespace.protobuf.decode("decode"),
+);
+export { decodePure as decode };
 
 /**
  * > You must configure the generic argument `T`.
@@ -156,11 +164,15 @@ export function decode(): never {
  *
  * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Decoded value
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertDecode(input: Uint8Array): never;
+function assertDecode(
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Protocol Buffer Decoder wity type assertion, but not safe.
@@ -185,19 +197,34 @@ export function assertDecode(input: Uint8Array): never;
  *
  * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Decoded value
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertDecode<T>(input: Uint8Array): Resolved<T>;
+function assertDecode<T>(
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Resolved<T>;
 
 /**
  * @internal
  */
-export function assertDecode(): never {
+function assertDecode(): never {
   halt("assertDecode");
 }
 
+const assertDecodePure = /** @__PURE__ */ Object.assign<
+  typeof assertDecode,
+  {},
+  {}
+>(
+  assertDecode,
+  /** @__PURE__ */ Namespace.assert("protobuf.assertDecode"),
+  /** @__PURE__ */ Namespace.protobuf.decode("assertDecode"),
+);
+export { assertDecodePure as assertDecode };
+
 /**
  * > You must configure the generic argument `T`.
  *
@@ -227,7 +254,7 @@ export function assertDecode(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isDecode(input: Uint8Array): never;
+function isDecode(input: Uint8Array): never;
 
 /**
  * Protocol Buffer Decoder wity type checking, but not safe.
@@ -256,14 +283,20 @@ export function isDecode(input: Uint8Array): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isDecode<T>(input: Uint8Array): Resolved<T> | null;
+function isDecode<T>(input: Uint8Array): Resolved<T> | null;
 
 /**
  * @internal
  */
-export function isDecode(): never {
+function isDecode(): never {
   halt("isDecode");
 }
+const isDecodePure = /** @__PURE__ */ Object.assign<typeof isDecode, {}, {}>(
+  isDecode,
+  /** @__PURE__ */ Namespace.is(),
+  /** @__PURE__ */ Namespace.protobuf.decode("isDecode"),
+);
+export { isDecodePure as isDecode };
 
 /**
  * > You must configure the generic argument `T`.
@@ -295,7 +328,7 @@ export function isDecode(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateDecode(input: Uint8Array): never;
+function validateDecode(input: Uint8Array): never;
 
 /**
  * Protocol Buffer Decoder wity type validation, but not safe.
@@ -325,14 +358,24 @@ export function validateDecode(input: Uint8Array): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;
+function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;
 
 /**
  * @internal
  */
-export function validateDecode(): never {
+function validateDecode(): never {
   halt("validateDecode");
 }
+const validateDecodePure = /** @__PURE__ */ Object.assign<
+  typeof validateDecode,
+  {},
+  {}
+>(
+  validateDecode,
+  /** @__PURE__ */ Namespace.validate(),
+  /** @__PURE__ */ Namespace.protobuf.decode("validateDecode"),
+);
+export { validateDecodePure as validateDecode };
 
 /* -----------------------------------------------------------
     ENCODE
@@ -364,14 +407,19 @@ export function validateDecode(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function encode<T>(input: T): Uint8Array;
+function encode<T>(input: T): Uint8Array;
 
 /**
  * @internal
  */
-export function encode(): never {
+function encode(): never {
   halt("encode");
 }
+const encodePure = /** @__PURE__ */ Object.assign<typeof encode, {}>(
+  encode,
+  /** @__PURE__ */ Namespace.protobuf.encode("encode"),
+);
+export { encodePure as encode };
 
 /**
  * Protocol Buffer Encoder with type assertion.
@@ -400,11 +448,15 @@ export function encode(): never {
  *
  * @template T Type of the value input
  * @param input A value to encode
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Encoded binary data
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertEncode<T>(input: T): Uint8Array;
+function assertEncode<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Uint8Array;
 
 /**
  * Protocol Buffer Encoder with type assertion.
@@ -433,18 +485,32 @@ export function assertEncode<T>(input: T): Uint8Array;
  *
  * @template T Type of the value input
  * @param input A value to encode
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Encoded binary data
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertEncode<T>(input: unknown): Uint8Array;
+function assertEncode<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Uint8Array;
 
 /**
  * @internal
  */
-export function assertEncode(): never {
+function assertEncode(): never {
   halt("assertEncode");
 }
+const assertEncodePure = /** @__PURE__ */ Object.assign<
+  typeof assertEncode,
+  {},
+  {}
+>(
+  assertEncode,
+  /** @__PURE__ */ Namespace.assert("protobuf.assertEncode"),
+  /** @__PURE__ */ Namespace.protobuf.encode("assertEncode"),
+);
+export { assertEncodePure as assertEncode };
 
 /**
  * Protocol Buffer Encoder with type checking.
@@ -477,7 +543,7 @@ export function assertEncode(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isEncode<T>(input: T): Uint8Array | null;
+function isEncode<T>(input: T): Uint8Array | null;
 
 /**
  * Protocol Buffer Encoder with type checking.
@@ -510,14 +576,20 @@ export function isEncode<T>(input: T): Uint8Array | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isEncode<T>(input: unknown): Uint8Array | null;
+function isEncode<T>(input: unknown): Uint8Array | null;
 
 /**
  * @internal
  */
-export function isEncode(): never {
+function isEncode(): never {
   halt("isEncode");
 }
+const isEncodePure = /** @__PURE__ */ Object.assign<typeof isEncode, {}, {}>(
+  isEncode,
+  /** @__PURE__ */ Namespace.is(),
+  /** @__PURE__ */ Namespace.protobuf.encode("isEncode"),
+);
+export { isEncodePure as isEncode };
 
 /**
  * Protocol Buffer Encoder with type validation.
@@ -551,7 +623,7 @@ export function isEncode(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateEncode<T>(input: T): IValidation<Uint8Array>;
+function validateEncode<T>(input: T): IValidation<Uint8Array>;
 
 /**
  * Protocol Buffer Encoder with type validation.
@@ -585,14 +657,24 @@ export function validateEncode<T>(input: T): IValidation<Uint8Array>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateEncode<T>(input: unknown): IValidation<Uint8Array>;
+function validateEncode<T>(input: unknown): IValidation<Uint8Array>;
 
 /**
  * @internal
  */
-export function validateEncode(): never {
+function validateEncode(): never {
   halt("validateEncode");
 }
+const validateEncodePure = /** @__PURE__ */ Object.assign<
+  typeof validateEncode,
+  {},
+  {}
+>(
+  validateEncode,
+  /** @__PURE__ */ Namespace.validate(),
+  /** @__PURE__ */ Namespace.protobuf.encode("validateEncode"),
+);
+export { validateEncodePure as validateEncode };
 
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
@@ -606,7 +688,7 @@ export function validateEncode(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createDecode(): never;
+function createDecode(): never;
 
 /**
  * Creates a reusable {@link decode} function.
@@ -616,14 +698,19 @@ export function createDecode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createDecode<T>(): (input: Uint8Array) => Resolved<T>;
+function createDecode<T>(): (input: Uint8Array) => Resolved<T>;
 
 /**
  * @internal
  */
-export function createDecode<T>(): (input: Uint8Array) => Resolved<T> {
+function createDecode<T>(): (input: Uint8Array) => Resolved<T> {
   halt("createDecode");
 }
+const createDecodePure = /** @__PURE__ */ Object.assign<
+  typeof createDecode,
+  {}
+>(createDecode, /** @__PURE__ */ Namespace.protobuf.decode("createDecode"));
+export { createDecodePure as createDecode };
 
 /**
  * Creates a reusable {@link isDecode} function.
@@ -634,7 +721,7 @@ export function createDecode<T>(): (input: Uint8Array) => Resolved<T> {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsDecode(): never;
+function createIsDecode(): never;
 
 /**
  * Creates a reusable {@link isDecode} function.
@@ -644,42 +731,68 @@ export function createIsDecode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;
+function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;
 
 /**
  * @internal
  */
-export function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null {
+function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null {
   halt("createIsDecode");
 }
+const createIsDecodePure = /** @__PURE__ */ Object.assign<
+  typeof createIsDecode,
+  {},
+  {}
+>(
+  createIsDecode,
+  /** @__PURE__ */ Namespace.is(),
+  /** @__PURE__ */ Namespace.protobuf.decode("createIsDecode"),
+);
+export { createIsDecodePure as createIsDecode };
 
 /**
  * Creates a reusable {@link assertDecode} function.
  *
  * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertDecode(): never;
+function createAssertDecode(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertDecode} function.
  *
  * @template T Target type
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assertDecode` function
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T>;
+function createAssertDecode<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: Uint8Array) => Resolved<T>;
 
 /**
  * @internal
  */
-export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
+function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
   halt("createAssertDecode");
 }
+const createAssertDecodePure = /** @__PURE__ */ Object.assign<
+  typeof createAssertDecode,
+  {},
+  {}
+>(
+  createAssertDecode,
+  /** @__PURE__ */ Namespace.assert("protobuf.createAssertDecode"),
+  /** @__PURE__ */ Namespace.protobuf.decode("createAssertDecode"),
+);
+export { createAssertDecodePure as createAssertDecode };
 
 /**
  * Creates a reusable {@link validateDecode} function.
@@ -690,7 +803,7 @@ export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateDecode(): never;
+function createValidateDecode(): never;
 
 /**
  * Creates a reusable {@link validateDecode} function.
@@ -700,18 +813,28 @@ export function createValidateDecode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateDecode<T>(): (
+function createValidateDecode<T>(): (
   input: Uint8Array,
 ) => IValidation<Resolved<T>>;
 
 /**
  * @internal
  */
-export function createValidateDecode<T>(): (
+function createValidateDecode<T>(): (
   input: Uint8Array,
 ) => IValidation<Resolved<T>> {
   halt("createValidateDecode");
 }
+const createValidateDecodePure = /** @__PURE__ */ Object.assign<
+  typeof createValidateDecode,
+  {},
+  {}
+>(
+  createValidateDecode,
+  /** @__PURE__ */ Namespace.validate(),
+  /** @__PURE__ */ Namespace.protobuf.decode("createValidateDecode"),
+);
+export { createValidateDecodePure as createValidateDecode };
 
 /**
  * Creates a reusable {@link encode} function.
@@ -722,7 +845,7 @@ export function createValidateDecode<T>(): (
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createEncode(): never;
+function createEncode(): never;
 
 /**
  * Creates a reusable {@link encode} function.
@@ -732,14 +855,19 @@ export function createEncode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createEncode<T>(): (input: T) => Uint8Array;
+function createEncode<T>(): (input: T) => Uint8Array;
 
 /**
  * @internal
  */
-export function createEncode<T>(): (input: T) => Uint8Array {
+function createEncode<T>(): (input: T) => Uint8Array {
   halt("createEncode");
 }
+const createEncodePure = /** @__PURE__ */ Object.assign<
+  typeof createEncode,
+  {}
+>(createEncode, /** @__PURE__ */ Namespace.protobuf.encode("createEncode"));
+export { createEncodePure as createEncode };
 
 /**
  * Creates a reusable {@link isEncode} function.
@@ -750,7 +878,7 @@ export function createEncode<T>(): (input: T) => Uint8Array {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsEncode(): never;
+function createIsEncode(): never;
 
 /**
  * Creates a reusable {@link isEncode} function.
@@ -760,42 +888,68 @@ export function createIsEncode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsEncode<T>(): (input: T) => Uint8Array | null;
+function createIsEncode<T>(): (input: T) => Uint8Array | null;
 
 /**
  * @internal
  */
-export function createIsEncode<T>(): (input: T) => Uint8Array | null {
+function createIsEncode<T>(): (input: T) => Uint8Array | null {
   halt("createIsEncode");
 }
+const createIsEncodePure = /** @__PURE__ */ Object.assign<
+  typeof createIsEncode,
+  {},
+  {}
+>(
+  createIsEncode,
+  /** @__PURE__ */ Namespace.is(),
+  /** @__PURE__ */ Namespace.protobuf.encode("createIsEncode"),
+);
+export { createIsEncodePure as createIsEncode };
 
 /**
  * Creates a reusable {@link assertEncode} function.
  *
  * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertEncode(): never;
+function createAssertEncode(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertEncode} function.
  *
  * @template T Target type
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assertEncode` function
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertEncode<T>(): (input: T) => Uint8Array;
+function createAssertEncode<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => Uint8Array;
 
 /**
  * @internal
  */
-export function createAssertEncode<T>(): (input: T) => Uint8Array {
+function createAssertEncode<T>(): (input: T) => Uint8Array {
   halt("createAssertEncode");
 }
+const createAssertEncodePure = /** @__PURE__ */ Object.assign<
+  typeof createAssertEncode,
+  {},
+  {}
+>(
+  createAssertEncode,
+  /** @__PURE__ */ Namespace.assert("protobuf.createAssertEncode"),
+  /** @__PURE__ */ Namespace.protobuf.encode("createAssertEncode"),
+);
+export { createAssertEncodePure as createAssertEncode };
 
 /**
  * Creates a reusable {@link validateEncode} function.
@@ -806,7 +960,7 @@ export function createAssertEncode<T>(): (input: T) => Uint8Array {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateEncode(): never;
+function createValidateEncode(): never;
 
 /**
  * Creates a reusable {@link validateEncode} function.
@@ -816,18 +970,24 @@ export function createValidateEncode(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateEncode<T>(): (
-  input: T,
-) => IValidation<Uint8Array>;
+function createValidateEncode<T>(): (input: T) => IValidation<Uint8Array>;
 
 /**
  * @internal
  */
-export function createValidateEncode<T>(): (
-  input: T,
-) => IValidation<Uint8Array> {
+function createValidateEncode<T>(): (input: T) => IValidation<Uint8Array> {
   halt("createValidateEncode");
 }
+const createValidateEncodePure = /** @__PURE__ */ Object.assign<
+  typeof createValidateEncode,
+  {},
+  {}
+>(
+  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
  */
-export function metadata(): never;
+function metadata(): never;
 
 /**
  * Metadata Application.
@@ -32,15 +32,21 @@ export function metadata(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function metadata<Types extends unknown[]>(): IMetadataApplication;
+function metadata<Types extends unknown[]>(): IMetadataApplication;
 
 /**
  * @internal
  */
-export function metadata(): never {
+function metadata(): never {
   halt("metadata");
 }
 
+const metadataPure = /** @__PURE__ */ Object.assign<typeof metadata, {}>(
+  metadata,
+  { from: (input: unknown) => input },
+);
+export { metadataPure as metadata };
+
 /**
  * @internal
  */

package/src/schemas/json/IJsonApplication.ts

@@ -1,9 +1,16 @@
-import { IJsonComponents } from "./IJsonComponents";
-import { IJsonSchema } from "./IJsonSchema";
+import type { OpenApi, OpenApiV3 } from "@samchon/openapi";
 
-export interface IJsonApplication {
-  schemas: IJsonSchema[];
-  components: IJsonComponents;
-  purpose: "swagger" | "ajv";
-  surplus: boolean;
+export type IJsonApplication<Version extends "3.0" | "3.1" = "3.1"> =
+  Version extends "3.0" ? IJsonApplication.IV3_0 : IJsonApplication.IV3_1;
+export namespace IJsonApplication {
+  export interface IV3_0 {
+    version: "3.0";
+    schemas: OpenApiV3.IJsonSchema[];
+    components: OpenApiV3.IComponents;
+  }
+  export interface IV3_1 {
+    version: "3.1";
+    components: OpenApi.IComponents;
+    schemas: OpenApi.IJsonSchema[];
+  }
 }

package/src/schemas/metadata/IMetadataConstant.ts

@@ -1,5 +1,7 @@
 import { Atomic } from "../../typings/Atomic";
 
+import { IMetadataConstantValue } from "./IMetadataConstantValue";
+
 export type IMetadataConstant =
   | IMetadataConstant.IBase<"boolean", boolean>
   | IMetadataConstant.IBase<"number", number>
@@ -11,6 +13,6 @@ export namespace IMetadataConstant {
     Value extends Atomic.Type,
   > {
     type: Type;
-    values: Value[];
+    values: IMetadataConstantValue<Value>[];
   }
 }

package/src/schemas/metadata/IMetadataConstantValue.ts

@@ -0,0 +1,8 @@
+import { Atomic } from "../../typings/Atomic";
+
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataConstantValue<T extends Atomic.Type> {
+  value: T;
+  tags: IMetadataTypeTag[][] | undefined;
+}

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -7,6 +7,7 @@ export interface IMetadataTypeTag {
   exclusive: boolean | string[];
   value?: any;
   validate?: string | undefined;
+  schema?: object | undefined;
 
   /**
    * @internal