typia 7.0.0-dev.20241011-2 → 7.0.0-dev.20241012

package/src/factories/MetadataTypeTagSchemaFactory.ts

@@ -1,10 +1,10 @@
 import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
 
 export namespace MetadataTypeTagSchemaFactory {
   export const object = (props: {
     report: (msg: string) => false;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }): object | undefined => {
     if (props.object.recursive) {
       props.report(`${props.object.name} has recursive type`);
@@ -31,7 +31,7 @@ export namespace MetadataTypeTagSchemaFactory {
 
   const iterate = (props: {
     report: (message: string) => false;
-    object: MetadataObject;
+    object: MetadataObjectType;
     key: string;
     metadata: Metadata;
   }): any => {
@@ -75,7 +75,7 @@ export namespace MetadataTypeTagSchemaFactory {
     } else if (props.metadata.objects.length)
       return object({
         report: props.report,
-        object: props.metadata.objects[0]!,
+        object: props.metadata.objects[0]!.type,
       });
     else props.report(`${props.object.name}.${props.key} has non-literal type`);
   };

package/src/factories/ProtobufFactory.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
 
 import { ProtobufUtil } from "../programmers/helpers/ProtobufUtil";
 
@@ -53,7 +53,7 @@ export namespace ProtobufFactory {
       const onlyObject: boolean =
         meta.size() === 1 &&
         meta.objects.length === 1 &&
-        meta.objects[0]!.properties.every((p) => p.key.isSoleLiteral()) &&
+        meta.objects[0]!.type.properties.every((p) => p.key.isSoleLiteral()) &&
         meta.isRequired() === true &&
         meta.nullable === false;
       if (onlyObject === false)
@@ -133,7 +133,7 @@ export namespace ProtobufFactory {
           a.type.value.maps.length ||
           (a.type.value.objects.length &&
             a.type.value.objects.some(
-              (o) => ProtobufUtil.isStaticObject(o) === false,
+              (o) => ProtobufUtil.isStaticObject(o.type) === false,
             )),
       )
     )
@@ -147,7 +147,7 @@ export namespace ProtobufFactory {
     // EMPTY PROPERTY
     if (
       meta.objects.length &&
-      meta.objects.some((obj) => obj.properties.length === 0)
+      meta.objects.some((obj) => obj.type.properties.length === 0)
     )
       noSupport("empty object type");
     // MULTIPLE DYNAMIC KEY TYPED PROPERTIES
@@ -155,7 +155,7 @@ export namespace ProtobufFactory {
       meta.objects.length &&
       meta.objects.some(
         (obj) =>
-          obj.properties.filter((p) => !p.key.isSoleLiteral()).length > 1,
+          obj.type.properties.filter((p) => !p.key.isSoleLiteral()).length > 1,
       )
     )
       noSupport(
@@ -166,8 +166,8 @@ export namespace ProtobufFactory {
       meta.objects.length &&
       meta.objects.some(
         (obj) =>
-          obj.properties.some((p) => p.key.isSoleLiteral()) &&
-          obj.properties.some((p) => !p.key.isSoleLiteral()),
+          obj.type.properties.some((p) => p.key.isSoleLiteral()) &&
+          obj.type.properties.some((p) => !p.key.isSoleLiteral()),
       )
     )
       noSupport(
@@ -176,15 +176,15 @@ export namespace ProtobufFactory {
     // DYNAMIC OBJECT, BUT PROPERTY VALUE TYPE IS ARRAY
     if (
       meta.objects.length &&
-      isDynamicObject(meta.objects[0]!) &&
-      meta.objects[0]!.properties.some((p) => !!p.value.arrays.length)
+      isDynamicObject(meta.objects[0]!.type) &&
+      meta.objects[0]!.type.properties.some((p) => !!p.value.arrays.length)
     )
       noSupport("dynamic object with array value type");
-    // UNION WITH DYNAMIC OBJECT
+    // UNION WITH DYNAMIC OBJECTa
     if (
       meta.size() > 1 &&
       meta.objects.length &&
-      isDynamicObject(meta.objects[0]!)
+      isDynamicObject(meta.objects[0]!.type)
     )
       noSupport("union type with dynamic object type");
     // UNION IN DYNAMIC PROPERTY VALUE
@@ -192,8 +192,8 @@ export namespace ProtobufFactory {
       meta.objects.length &&
       meta.objects.some(
         (obj) =>
-          isDynamicObject(obj) &&
-          obj.properties.some((p) => ProtobufUtil.isUnion(p.value)),
+          isDynamicObject(obj.type) &&
+          obj.type.properties.some((p) => ProtobufUtil.isUnion(p.value)),
       )
     )
       noSupport("union type in dynamic property");
@@ -231,7 +231,7 @@ export namespace ProtobufFactory {
   };
 }
 
-const isDynamicObject = (obj: MetadataObject): boolean =>
+const isDynamicObject = (obj: MetadataObjectType): boolean =>
   obj.properties[0]!.key.isSoleLiteral() === false;
 
 const BANNED_NATIVE_TYPES: Map<string, string | null> = new Map([

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
 
 import { Writable } from "../../../typings/Writable";
@@ -16,7 +16,7 @@ import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
 
 export const emplace_metadata_object = (
   props: IMetadataIteratorProps,
-): MetadataObject => {
+): MetadataObjectType => {
   // EMPLACE OBJECT
   const [obj, newbie] = props.collection.emplace(props.checker, props.type);
   ArrayUtil.add(

package/src/factories/internal/metadata/iterate_metadata_collection.ts

@@ -1,6 +1,6 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
 import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -114,7 +114,7 @@ const isTupleRecursive = (props: {
 
 const isObjectRecursive = (props: {
   visited: Set<Metadata>;
-  object: MetadataObject;
+  object: MetadataObjectType;
   metadata: Metadata;
 }): boolean => {
   if (props.visited.has(props.metadata)) return false;
@@ -128,7 +128,8 @@ const isObjectRecursive = (props: {
   return (
     props.metadata.objects.some(
       (o) =>
-        props.object === o || o.properties.some((prop) => next(prop.value)),
+        props.object === o.type ||
+        o.type.properties.some((prop) => next(prop.value)),
     ) ||
     props.metadata.aliases.some((alias) => next(alias.value)) ||
     props.metadata.arrays.some(

package/src/factories/internal/metadata/iterate_metadata_comment_tags.ts

@@ -1,11 +1,11 @@
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
 
 import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
 import { MetadataFactory } from "../../MetadataFactory";
 
 export const iterate_metadata_comment_tags = (props: {
   errors: MetadataFactory.IError[];
-  object: MetadataObject;
+  object: MetadataObjectType;
 }) => {
   if (props.object.tagged_ === true) return;
   props.object.tagged_ = true;

package/src/factories/internal/metadata/iterate_metadata_intersection.ts

@@ -99,7 +99,7 @@ export const iterate_metadata_intersection = (
       c.isRequired() === true &&
       c.objects.length &&
       c.objects.length === c.size() &&
-      c.objects.every((o) => o.properties.every((p) => p.value.optional)),
+      c.objects.every((o) => o.type.properties.every((p) => p.value.optional)),
   );
   const arrays: Set<string> = new Set(
     individuals.map(([c]) => c.arrays.map((a) => a.type.name)).flat(),
@@ -188,7 +188,10 @@ export const iterate_metadata_intersection = (
     const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze({
       errors: props.errors,
       type: target,
-      objects: objects.map((om) => om.objects).flat(),
+      objects: objects
+        .map((om) => om.objects)
+        .flat()
+        .map((om) => om.type),
       explore: props.explore,
     });
     if (tags.length)

package/src/factories/internal/metadata/iterate_metadata_object.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -21,7 +22,14 @@ export const iterate_metadata_object = (
       return false;
   }
 
-  const obj: MetadataObject = emplace_metadata_object(props);
-  ArrayUtil.add(props.metadata.objects, obj, (elem) => elem.name === obj.name);
+  const obj: MetadataObjectType = emplace_metadata_object(props);
+  ArrayUtil.add(
+    props.metadata.objects,
+    MetadataObject.create({
+      type: obj,
+      tags: [],
+    }),
+    (elem) => elem.type.name === obj.name,
+  );
   return true;
 };

package/src/factories/internal/metadata/iterate_metadata_sort.ts

@@ -1,5 +1,5 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
 
 import { MetadataCollection } from "../../MetadataCollection";
 
@@ -45,7 +45,11 @@ const iterate = (props: {
   // SORT OBJECTS
   if (props.metadata.objects.length > 1) {
     props.metadata.objects.sort((x, y) =>
-      MetadataObject.covers(x, y) ? -1 : MetadataObject.covers(y, x) ? 1 : 0,
+      MetadataObjectType.covers(x.type, y.type)
+        ? -1
+        : MetadataObjectType.covers(y.type, x.type)
+          ? 1
+          : 0,
     );
     props.metadata.union_index = props.collection.getUnionIndex(props.metadata);
   }

package/src/programmers/CheckerProgrammer.ts

@@ -11,7 +11,7 @@ import { ValueFactory } from "../factories/ValueFactory";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
 import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
 import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 
@@ -810,13 +810,15 @@ export namespace CheckerProgrammer {
         head: ExpressionFactory.isObject({
           checkNull: true,
           checkArray: props.metadata.objects.some((obj) =>
-            obj.properties.every(
+            obj.type.properties.every(
               (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
             ),
           ),
           input: props.input,
         }),
-        expected: props.metadata.objects.map((obj) => obj.name).join(" | "),
+        expected: props.metadata.objects
+          .map((obj) => obj.type.name)
+          .join(" | "),
         body: explore_objects({
           config: props.config,
           functor: props.functor,
@@ -944,7 +946,7 @@ export namespace CheckerProgrammer {
   export const decode_object = (props: {
     config: IConfig;
     functor: FunctionProgrammer;
-    object: MetadataObject;
+    object: MetadataObjectType;
     input: ts.Expression;
     explore: IExplore;
   }) => {
@@ -1581,7 +1583,7 @@ export namespace CheckerProgrammer {
       ? decode_object({
           config: props.config,
           functor: props.functor,
-          object: props.metadata.objects[0]!,
+          object: props.metadata.objects[0]!.type,
           input: props.input,
           explore: props.explore,
         })

package/src/programmers/FeatureProgrammer.ts

@@ -8,7 +8,7 @@ import { ValueFactory } from "../factories/ValueFactory";
 
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
 
 import { ITypiaContext } from "../transformers/ITypiaContext";
 
@@ -94,7 +94,7 @@ export namespace FeatureProgrammer {
        */
       decoder: (props: {
         input: ts.Expression;
-        object: MetadataObject;
+        object: MetadataObjectType;
         explore: IExplore;
       }) => ts.Expression;
 
@@ -104,7 +104,7 @@ export namespace FeatureProgrammer {
       joiner(props: {
         entries: IExpressionEntry<Output>[];
         input?: ts.Expression;
-        object?: MetadataObject;
+        object?: MetadataObjectType;
       }): ts.ConciseBody;
 
       /**
@@ -114,7 +114,7 @@ export namespace FeatureProgrammer {
        * the `decoder` function of the specified object type.
        */
       unionizer: (props: {
-        objects: MetadataObject[];
+        objects: MetadataObjectType[];
         input: ts.Expression;
         explore: IExplore;
       }) => ts.Expression;
@@ -440,7 +440,10 @@ export namespace FeatureProgrammer {
       }),
     );
 
-  const write_union = (props: { config: IConfig; objects: MetadataObject[] }) =>
+  const write_union = (props: {
+    config: IConfig;
+    objects: MetadataObjectType[];
+  }) =>
     ts.factory.createArrowFunction(
       undefined,
       undefined,
@@ -521,7 +524,7 @@ export namespace FeatureProgrammer {
   export const decode_object = (props: {
     config: Pick<IConfig, "trace" | "path" | "prefix">;
     functor: FunctionProgrammer;
-    object: MetadataObject;
+    object: MetadataObjectType;
     input: ts.Expression;
     explore: IExplore;
   }) =>

package/src/programmers/IsProgrammer.ts

@@ -6,7 +6,7 @@ import { MetadataCollection } from "../factories/MetadataCollection";
 import { ValueFactory } from "../factories/ValueFactory";
 
 import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
 
 import { IProgrammerProps } from "../transformers/IProgrammerProps";
 import { ITypiaContext } from "../transformers/ITypiaContext";
@@ -237,7 +237,7 @@ export namespace IsProgrammer {
   export const decode_object = (props: {
     context: ITypiaContext;
     functor: FunctionProgrammer;
-    object: MetadataObject;
+    object: MetadataObjectType;
     input: ts.Expression;
     explore: FeatureProgrammer.IExplore;
   }) =>

package/src/programmers/RandomProgrammer.ts

@@ -15,7 +15,7 @@ import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
 import { MetadataAtomic } from "../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
 import { MetadataTemplate } from "../schemas/metadata/MetadataTemplate";
 import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
@@ -408,7 +408,7 @@ export namespace RandomProgrammer {
       expressions.push(
         decode_object({
           ...props,
-          object,
+          object: object.type,
         }),
       );
     for (const name of props.metadata.natives)
@@ -661,7 +661,7 @@ export namespace RandomProgrammer {
   const decode_object = (props: {
     functor: FunctionProgrammer;
     explore: IExplore;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }) =>
     ts.factory.createCallExpression(
       ts.factory.createIdentifier(

package/src/programmers/helpers/ProtobufUtil.ts

@@ -1,11 +1,11 @@
 import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
 export namespace ProtobufUtil {
-  export const isStaticObject = (obj: MetadataObject): boolean =>
+  export const isStaticObject = (obj: MetadataObjectType): boolean =>
     obj.properties.length >= 1 &&
     obj.properties.every((p) => p.key.isSoleLiteral());
 

package/src/programmers/helpers/PruneJoiner.ts

@@ -2,7 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { metadata_to_pattern } from "../internal/metadata_to_pattern";
 import { prune_object_properties } from "../internal/prune_object_properties";
@@ -12,7 +12,7 @@ export namespace PruneJoiner {
   export const object = (props: {
     input: ts.Expression;
     entries: IExpressionEntry[];
-    object: MetadataObject;
+    object: MetadataObjectType;
   }): ts.ConciseBody => {
     // PREPARE ASSETS
     const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());

package/src/programmers/helpers/RandomJoiner.ts

@@ -8,7 +8,7 @@ import { LiteralFactory } from "../../factories/LiteralFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
@@ -88,7 +88,7 @@ export namespace RandomJoiner {
 
   export const object = (props: {
     decode: Decoder;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }): ts.ConciseBody => {
     if (props.object.properties.length === 0) return LiteralFactory.write({});
 

package/src/programmers/helpers/UnionExplorer.ts

@@ -6,7 +6,7 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -22,7 +22,7 @@ export namespace UnionExplorer {
       explore: FeatureProgrammer.IExplore;
     }): ts.Expression;
   }
-  export type ObjectCombiner = Decoder<MetadataObject[]>;
+  export type ObjectCombiner = Decoder<MetadataObjectType[]>;
 
   /* -----------------------------------------------------------
         OBJECT
@@ -30,7 +30,7 @@ export namespace UnionExplorer {
   export const object = (props: {
     config: FeatureProgrammer.IConfig;
     level?: number;
-    objects: MetadataObject[];
+    objects: MetadataObjectType[];
     input: ts.Expression;
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression => {
@@ -64,7 +64,7 @@ export namespace UnionExplorer {
           })
         : condition;
     }
-    const remained: MetadataObject[] = props.objects.filter(
+    const remained: MetadataObjectType[] = props.objects.filter(
       (t) => specList.find((s) => s.object === t) === undefined,
     );
 

package/src/programmers/helpers/UnionPredicator.ts

@@ -1,5 +1,5 @@
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { ArrayUtil } from "../../utils/ArrayUtil";
@@ -8,12 +8,14 @@ import { MapUtil } from "../../utils/MapUtil";
 export namespace UnionPredicator {
   export interface ISpecialized {
     index: number;
-    object: MetadataObject;
+    object: MetadataObjectType;
     property: MetadataProperty;
     neighbour: boolean;
   }
 
-  export const object = (objects: MetadataObject[]): Array<ISpecialized> => {
+  export const object = (
+    objects: MetadataObjectType[],
+  ): Array<ISpecialized> => {
     // PROPERTY MATRIX
     const matrix: Map<string, Array<MetadataProperty | null>> = new Map();
     for (const obj of objects)

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -8,7 +8,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { IProgrammerProps } from "../../transformers/IProgrammerProps";
@@ -52,7 +52,7 @@ export namespace HttpFormDataProgrammer {
       });
 
     // DO TRANSFORM
-    const object: MetadataObject = result.data.objects[0]!;
+    const object: MetadataObjectType = result.data.objects[0]!.type;
     const statements: ts.Statement[] = decode_object({
       context: props.context,
       object,
@@ -160,7 +160,7 @@ export namespace HttpFormDataProgrammer {
 
   const decode_object = (props: {
     context: ITypiaContext;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }): ts.Statement[] => {
     // const input: ts.Identifier = ts.factory.createIdentifier("input");
     const output: ts.Identifier = ts.factory.createIdentifier("output");

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -9,7 +9,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { IProgrammerProps } from "../../transformers/IProgrammerProps";
@@ -56,7 +56,7 @@ export namespace HttpHeadersProgrammer {
       });
 
     // DO TRANSFORM
-    const object: MetadataObject = result.data.objects[0]!;
+    const object: MetadataObjectType = result.data.objects[0]!.type;
     const statements: ts.Statement[] = decode_object({
       context: props.context,
       object,
@@ -204,7 +204,7 @@ export namespace HttpHeadersProgrammer {
 
   const decode_object = (props: {
     context: ITypiaContext;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }): ts.Statement[] => {
     const output: ts.Identifier = ts.factory.createIdentifier("output");
     const optionals: string[] = [];

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -8,7 +8,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { IProgrammerProps } from "../../transformers/IProgrammerProps";
@@ -60,7 +60,7 @@ export namespace HttpQueryProgrammer {
       });
 
     // DO TRANSFORM
-    const object: MetadataObject = result.data.objects[0]!;
+    const object: MetadataObjectType = result.data.objects[0]!.type;
     const statements: ts.Statement[] = decode_object({
       context: props.context,
       object,
@@ -130,7 +130,7 @@ export namespace HttpQueryProgrammer {
           const everyPropertiesAreOptional: boolean =
             meta.size() === 1 &&
             meta.objects.length === 1 &&
-            meta.objects[0]!.properties.every(
+            meta.objects[0]!.type.properties.every(
               (p) => p.value.isRequired() === false,
             );
           if (everyPropertiesAreOptional === false)
@@ -179,7 +179,7 @@ export namespace HttpQueryProgrammer {
 
   const decode_object = (props: {
     context: ITypiaContext;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }): ts.Statement[] => {
     const input: ts.Identifier = ts.factory.createIdentifier("input");
     const output: ts.Identifier = ts.factory.createIdentifier("output");

package/src/programmers/internal/application_union_discriminator.ts

@@ -10,11 +10,11 @@ export const application_union_discriminator = (
   if (
     metadata.size() === 0 ||
     metadata.size() !== metadata.objects.length ||
-    metadata.objects.some((o) => o.isLiteral()) === true
+    metadata.objects.some((o) => o.type.isLiteral()) === true
   )
     return undefined;
   const specialized: UnionPredicator.ISpecialized[] = UnionPredicator.object(
-    metadata.objects,
+    metadata.objects.map((o) => o.type),
   );
   const meet: boolean =
     specialized.length === metadata.objects.length &&

package/src/programmers/internal/application_v30_alias.ts

@@ -20,7 +20,7 @@ export const application_v30_alias = <BlockNever extends boolean>(props: {
 }): OpenApiV3.IJsonSchema.IReference => {
   if (props.alias.value.size() === 1 && props.alias.value.objects.length === 1)
     return application_v30_object({
-      object: props.alias.value.objects[0]!,
+      object: props.alias.value.objects[0]!.type,
       components: props.components,
       nullable: props.nullable,
     }) as OpenApiV3.IJsonSchema.IReference;