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

package/src/programmers/internal/application_v30_object.ts

@@ -4,7 +4,7 @@ import { CommentFactory } from "../../factories/CommentFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { PatternUtil } from "../../utils/PatternUtil";
 
@@ -17,7 +17,7 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  */
 export const application_v30_object = (props: {
   components: OpenApiV3.IComponents;
-  object: MetadataObject;
+  object: MetadataObjectType;
   nullable: boolean;
 }): OpenApiV3.IJsonSchema.IReference | OpenApiV3.IJsonSchema.IObject => {
   if (props.object.isLiteral() === true) return create_object_schema(props);
@@ -38,7 +38,7 @@ export const application_v30_object = (props: {
  */
 const create_object_schema = (props: {
   components: OpenApiV3.IComponents;
-  object: MetadataObject;
+  object: MetadataObjectType;
   nullable: boolean;
 }): OpenApiV3.IJsonSchema.IObject => {
   // ITERATE PROPERTIES

package/src/programmers/internal/application_v30_schema.ts

@@ -180,7 +180,7 @@ export const application_v30_schema = <BlockNever extends boolean>(props: {
   for (const object of props.metadata.objects)
     insert(
       application_v30_object({
-        object,
+        object: object.type,
         components: props.components,
         nullable: props.metadata.nullable,
       }),

package/src/programmers/internal/application_v31_alias.ts

@@ -18,7 +18,7 @@ export const application_v31_alias = <BlockNever extends boolean>(props: {
   if (props.alias.value.size() === 1 && props.alias.value.objects.length === 1)
     return application_v31_object({
       components: props.components,
-      object: props.alias.value.objects[0]!,
+      object: props.alias.value.objects[0]!.type,
     }) as OpenApi.IJsonSchema.IReference;
 
   const $ref: string = `#/components/schemas/${props.alias.name}`;

package/src/programmers/internal/application_v31_object.ts

@@ -4,7 +4,7 @@ import { CommentFactory } from "../../factories/CommentFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { PatternUtil } from "../../utils/PatternUtil";
 
@@ -18,7 +18,7 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  */
 export const application_v31_object = (props: {
   components: OpenApi.IComponents;
-  object: MetadataObject;
+  object: MetadataObjectType;
 }): OpenApi.IJsonSchema.IReference | OpenApi.IJsonSchema.IObject => {
   if (props.object.isLiteral() === true) return create_object_schema(props);
 
@@ -38,7 +38,7 @@ export const application_v31_object = (props: {
  */
 const create_object_schema = (props: {
   components: OpenApi.IComponents;
-  object: MetadataObject;
+  object: MetadataObjectType;
 }): OpenApi.IJsonSchema.IObject => {
   // ITERATE PROPERTIES
   const properties: Record<string, any> = {};

package/src/programmers/internal/application_v31_schema.ts

@@ -178,7 +178,7 @@ export const application_v31_schema = <BlockNever extends boolean>(props: {
     insert(
       application_v31_object({
         components: props.components,
-        object,
+        object: object.type,
       }),
     );
 

package/src/programmers/internal/decode_union_object.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 
@@ -10,17 +10,17 @@ import { FeatureProgrammer } from "../FeatureProgrammer";
 export const decode_union_object = (props: {
   checker: (next: {
     input: ts.Expression;
-    object: MetadataObject;
+    object: MetadataObjectType;
     explore: FeatureProgrammer.IExplore;
   }) => ts.Expression;
   decoder: (next: {
     input: ts.Expression;
-    object: MetadataObject;
+    object: MetadataObjectType;
     explore: FeatureProgrammer.IExplore;
   }) => ts.Expression;
   success: (exp: ts.Expression) => ts.Expression;
   escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
-  objects: MetadataObject[];
+  objects: MetadataObjectType[];
   input: ts.Expression;
   explore: FeatureProgrammer.IExplore;
 }): ts.CallExpression =>

package/src/programmers/internal/feature_object_entries.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 { ITypiaContext } from "../../transformers/ITypiaContext";
 
@@ -16,7 +16,7 @@ import { FeatureProgrammer } from "../FeatureProgrammer";
 export const feature_object_entries = <Output extends ts.ConciseBody>(props: {
   config: Pick<FeatureProgrammer.IConfig<Output>, "decoder" | "path" | "trace">;
   context: ITypiaContext;
-  object: MetadataObject;
+  object: MetadataObjectType;
   input: ts.Expression;
   from?: "object" | "top" | "array";
 }) =>

package/src/programmers/internal/llm_schema_object.ts

@@ -4,7 +4,7 @@ import { CommentFactory } from "../../factories/CommentFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { PatternUtil } from "../../utils/PatternUtil";
 
@@ -16,7 +16,7 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  * @internal
  */
 export const llm_schema_object = (props: {
-  object: MetadataObject;
+  object: MetadataObjectType;
   nullable: boolean;
 }): ILlmSchema.IObject => {
   // ITERATE PROPERTIES

package/src/programmers/internal/llm_schema_station.ts

@@ -144,14 +144,14 @@ export const llm_schema_station = (props: {
 
   // OBJECT
   for (const object of props.metadata.objects)
-    if (object.recursive)
+    if (object.type.recursive)
       throw new Error(
         "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive object type.",
       );
     else
       insert(
         llm_schema_object({
-          object,
+          object: object.type,
           nullable: props.metadata.nullable,
         }),
       );

package/src/programmers/internal/prune_object_properties.ts

@@ -1,13 +1,13 @@
 import ts from "typescript";
 
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { metadata_to_pattern } from "./metadata_to_pattern";
 
 /**
  * @internal
  */
-export const prune_object_properties = (object: MetadataObject) => {
+export const prune_object_properties = (object: MetadataObjectType) => {
   const input: ts.Expression = ts.factory.createIdentifier("input");
   const key: ts.Expression = ts.factory.createIdentifier("key");
 

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -3,7 +3,7 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { IJsonApplication } from "../../schemas/json/IJsonApplication";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataFunction } from "../../schemas/metadata/MetadataFunction";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { IJsDocTagInfo } from "../../module";
 import { JsonSchemasProgrammer } from "./JsonSchemasProgrammer";
@@ -26,7 +26,7 @@ export namespace JsonApplicationProgrammer {
         "JSON application's generic arugment must be a class/interface type.",
       );
 
-    const object: MetadataObject | undefined = metadata.objects[0];
+    const object: MetadataObjectType | undefined = metadata.objects[0]?.type;
     if (object !== undefined) {
       if (object.properties.some((p) => p.key.isSoleLiteral() === false))
         output.push("JSON application does not allow dynamic keys.");
@@ -74,7 +74,7 @@ export namespace JsonApplicationProgrammer {
     if (errors.length)
       throw new Error("Failed to write LLM application: " + errors.join("\n"));
 
-    const object: MetadataObject = props.metadata.objects[0]!;
+    const object: MetadataObjectType = props.metadata.objects[0]!.type;
     const definitions: Metadata[] = [];
     const setters: Array<(schema: IJsonApplication.Schema<Version>) => void> =
       [];

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -11,7 +11,7 @@ import { ValueFactory } from "../../factories/ValueFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -462,8 +462,8 @@ export namespace JsonStringifyProgrammer {
         is: () =>
           ExpressionFactory.isObject({
             checkNull: true,
-            checkArray: props.metadata.objects.some((objects) =>
-              objects.properties.every(
+            checkArray: props.metadata.objects.some((object) =>
+              object.type.properties.every(
                 (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
               ),
             ),
@@ -530,7 +530,7 @@ export namespace JsonStringifyProgrammer {
   const decode_object = (props: {
     functor: FunctionProgrammer;
     input: ts.Expression;
-    object: MetadataObject;
+    object: MetadataObjectType;
     explore: FeatureProgrammer.IExplore;
   }): ts.CallExpression =>
     FeatureProgrammer.decode_object({
@@ -762,7 +762,7 @@ export namespace JsonStringifyProgrammer {
       ? decode_object({
           functor: props.functor,
           input: props.input,
-          object: props.metadata.objects[0]!,
+          object: props.metadata.objects[0]!.type,
           explore: props.explore,
         })
       : ts.factory.createCallExpression(

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -5,7 +5,7 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataFunction } from "../../schemas/metadata/MetadataFunction";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { IJsDocTagInfo } from "../../module";
 import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
@@ -20,7 +20,7 @@ export namespace LlmApplicationProgrammer {
       top ??= metadata;
       if (explore.top === false)
         if (
-          explore.object === top?.objects[0] &&
+          explore.object === top?.objects[0]?.type &&
           typeof explore.property === "string" &&
           metadata.size() === 1 &&
           metadata.nullable === false &&
@@ -41,7 +41,7 @@ export namespace LlmApplicationProgrammer {
           "LLM application's generic arugment must be a class/interface type.",
         );
 
-      const object: MetadataObject | undefined = metadata.objects[0];
+      const object: MetadataObjectType | undefined = metadata.objects[0]?.type;
       if (object !== undefined) {
         if (object.properties.some((p) => p.key.isSoleLiteral() === false))
           output.push("LLM application does not allow dynamic keys.");
@@ -98,7 +98,7 @@ export namespace LlmApplicationProgrammer {
     if (errors.length)
       throw new Error("Failed to write LLM application: " + errors.join("\n"));
 
-    const object: MetadataObject = metadata.objects[0]!;
+    const object: MetadataObjectType = metadata.objects[0]!.type;
     return {
       functions: object.properties
         .filter(

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -35,7 +35,7 @@ export namespace LlmSchemaProgrammer {
     if (
       metadata.aliases.some((a) => a.recursive) ||
       metadata.arrays.some((a) => a.type.recursive) ||
-      metadata.objects.some((o) => o.recursive) ||
+      metadata.objects.some((o) => o.type.recursive) ||
       metadata.tuples.some((t) => t.type.recursive)
     )
       output.push("LLM schema does not support recursive type.");

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -9,7 +9,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 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 { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -336,7 +336,7 @@ export namespace MiscCloneProgrammer {
   const decode_object = (props: {
     functor: FunctionProgrammer;
     input: ts.Expression;
-    object: MetadataObject;
+    object: MetadataObjectType;
     explore: FeatureProgrammer.IExplore;
   }) =>
     FeatureProgrammer.decode_object({
@@ -711,7 +711,7 @@ export namespace MiscCloneProgrammer {
     props.metadata.objects.length === 1
       ? decode_object({
           ...props,
-          object: props.metadata.objects[0]!,
+          object: props.metadata.objects[0]!.type,
         })
       : ts.factory.createCallExpression(
           ts.factory.createIdentifier(

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -9,7 +9,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 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 { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -274,7 +274,7 @@ export namespace MiscPruneProgrammer {
   const decode_object = (props: {
     functor: FunctionProgrammer;
     input: ts.Expression;
-    object: MetadataObject;
+    object: MetadataObjectType;
     explore: FeatureProgrammer.IExplore;
   }) =>
     FeatureProgrammer.decode_object({
@@ -431,7 +431,7 @@ export namespace MiscPruneProgrammer {
     if (props.metadata.objects.length === 1)
       return decode_object({
         ...props,
-        object: props.metadata.objects[0]!,
+        object: props.metadata.objects[0]!.type,
       });
 
     return ts.factory.createCallExpression(

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -9,7 +9,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 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 { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -367,7 +367,7 @@ export namespace NotationGeneralProgrammer {
 
   const decode_object = (props: {
     functor: FunctionProgrammer;
-    object: MetadataObject;
+    object: MetadataObjectType;
     input: ts.Expression;
     explore: FeatureProgrammer.IExplore;
   }) =>
@@ -661,7 +661,7 @@ export namespace NotationGeneralProgrammer {
     if (props.metadata.objects.length === 1)
       return decode_object({
         functor: props.functor,
-        object: props.metadata.objects[0]!,
+        object: props.metadata.objects[0]!.type,
         input: props.input,
         explore: props.explore,
       });

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -11,7 +11,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { IProgrammerProps } from "../../transformers/IProgrammerProps";
@@ -93,7 +93,7 @@ export namespace ProtobufDecodeProgrammer {
             ts.factory.createReturnStatement(
               decode_regular_object({
                 top: true,
-                object: meta.objects[0]!,
+                object: meta.objects[0]!.type,
               }),
             ),
           ],
@@ -121,7 +121,7 @@ export namespace ProtobufDecodeProgrammer {
   const write_object_function = (props: {
     context: ITypiaContext;
     functor: FunctionProgrammer;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }): ts.ArrowFunction =>
     ts.factory.createArrowFunction(
       undefined,
@@ -311,7 +311,7 @@ export namespace ProtobufDecodeProgrammer {
                   ? ts.factory.createStringLiteral("")
                   : value.objects.length &&
                       value.objects.some(
-                        (obj) => !ProtobufUtil.isStaticObject(obj),
+                        (obj) => !ProtobufUtil.isStaticObject(obj.type),
                       )
                     ? ts.factory.createObjectLiteralExpression()
                     : ts.factory.createIdentifier("undefined"),
@@ -390,17 +390,17 @@ export namespace ProtobufDecodeProgrammer {
       );
     for (const object of props.metadata.objects)
       emplace(
-        object.name,
-        ProtobufUtil.isStaticObject(object)
+        object.type.name,
+        ProtobufUtil.isStaticObject(object.type)
           ? decode_regular_object({
               top: false,
-              object,
+              object: object.type,
             })
           : decode_dynamic_object({
               context: props.context,
               functor: props.functor,
               accessor: props.accessor,
-              object,
+              object: object.type,
               required,
             }),
       );
@@ -469,7 +469,7 @@ export namespace ProtobufDecodeProgrammer {
           ? () =>
               decode_regular_object({
                 top: false,
-                object: props.array.type.value.objects[0]!,
+                object: props.array.type.value.objects[0]!.type,
               })
           : null;
     if (decoder === null) throw new Error("Never reach here.");
@@ -544,7 +544,7 @@ export namespace ProtobufDecodeProgrammer {
 
   const decode_regular_object = (props: {
     top: boolean;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }): ts.Expression =>
     ts.factory.createCallExpression(
       ts.factory.createIdentifier(`${PREFIX}o${props.object.index}`),
@@ -567,7 +567,7 @@ export namespace ProtobufDecodeProgrammer {
     context: ITypiaContext;
     functor: FunctionProgrammer;
     accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression;
-    object: MetadataObject;
+    object: MetadataObjectType;
     required: boolean;
   }): ts.Statement[] => {
     const top: MetadataProperty = props.object.properties[0]!;

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -11,7 +11,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { IProgrammerProps } from "../../transformers/IProgrammerProps";
@@ -209,7 +209,7 @@ export namespace ProtobufEncodeProgrammer {
     context: ITypiaContext;
     functor: FunctionProgrammer;
     input: ts.Expression;
-    object: MetadataObject;
+    object: MetadataObjectType;
     explore: FeatureProgrammer.IExplore;
   }): ts.ArrowFunction => {
     let index: number = 1;
@@ -433,7 +433,7 @@ export namespace ProtobufEncodeProgrammer {
             ...props,
             level: 0,
             index,
-            objects: props.metadata.objects,
+            objects: props.metadata.objects.map((o) => o.type),
             explore: {
               ...props.explore,
               from: "object",
@@ -547,7 +547,7 @@ export namespace ProtobufEncodeProgrammer {
     functor: FunctionProgrammer;
     index: number | null;
     input: ts.Expression;
-    object: MetadataObject;
+    object: MetadataObjectType;
     explore: FeatureProgrammer.IExplore;
   }): ts.Block => {
     const top: MetadataProperty = props.object.properties[0]!;
@@ -852,9 +852,9 @@ export namespace ProtobufEncodeProgrammer {
     level: number;
     index: number | null;
     input: ts.Expression;
-    objects: MetadataObject[];
+    objects: MetadataObjectType[];
     explore: FeatureProgrammer.IExplore;
-    indexes?: Map<MetadataObject, number>;
+    indexes?: Map<MetadataObjectType, number>;
   }): ts.Block => {
     if (props.objects.length === 1)
       return decode_object({
@@ -874,7 +874,7 @@ export namespace ProtobufEncodeProgrammer {
     const specList: UnionPredicator.ISpecialized[] = UnionPredicator.object(
       props.objects,
     );
-    const indexes: Map<MetadataObject, number> =
+    const indexes: Map<MetadataObjectType, number> =
       props.indexes ??
       new Map(props.objects.map((t, i) => [t, props.index! + i]));
 
@@ -913,7 +913,7 @@ export namespace ProtobufEncodeProgrammer {
       });
       return StatementFactory.block(condition);
     }
-    const remained: MetadataObject[] = props.objects.filter(
+    const remained: MetadataObjectType[] = props.objects.filter(
       (t) => specList.find((s) => s.object === t) === undefined,
     );
 

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -5,7 +5,7 @@ import { ProtobufFactory } from "../../factories/ProtobufFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { ITypiaContext } from "../../transformers/ITypiaContext";
@@ -52,7 +52,7 @@ export namespace ProtobufMessageProgrammer {
 
   const emplace = (props: {
     hierarchies: Map<string, Hierarchy>;
-    object: MetadataObject;
+    object: MetadataObjectType;
   }) => {
     let hierarchies: Map<string, Hierarchy> = props.hierarchies;
     const accessors: string[] = props.object.name.split(".");
@@ -67,7 +67,7 @@ export namespace ProtobufMessageProgrammer {
     });
   };
 
-  const is_dynamic_object = (object: MetadataObject): boolean =>
+  const is_dynamic_object = (object: MetadataObjectType): boolean =>
     object.properties.length === 1 &&
     object.properties[0]!.key.isSoleLiteral() === false;
 
@@ -95,7 +95,7 @@ export namespace ProtobufMessageProgrammer {
     return elements.join("\n");
   };
 
-  const write_object = (object: MetadataObject): string => {
+  const write_object = (object: MetadataObjectType): string => {
     const sequence: IPointer<number> = { value: 0 };
     return object.properties
       .map((p) => {
@@ -137,11 +137,11 @@ export namespace ProtobufMessageProgrammer {
       );
     for (const obj of props.metadata.objects)
       elements.add(
-        is_dynamic_object(obj)
+        is_dynamic_object(obj.type)
           ? decode_map({
               sequence: props.sequence,
               entry: MetadataProperty.create({
-                ...obj.properties[0]!,
+                ...obj.type.properties[0]!,
                 key: (() => {
                   const key: Metadata = Metadata.initialize();
                   key.atomics.push(
@@ -154,7 +154,7 @@ export namespace ProtobufMessageProgrammer {
                 })(),
               }),
             })
-          : NameEncoder.encode(obj.name),
+          : NameEncoder.encode(obj.type.name),
       );
     for (const entry of props.metadata.maps)
       elements.add(
@@ -190,7 +190,7 @@ export namespace ProtobufMessageProgrammer {
 
 interface Hierarchy {
   key: string;
-  object: MetadataObject | null;
+  object: MetadataObjectType | null;
   children: Map<string, Hierarchy>;
 }
 

package/src/schemas/metadata/IMetadata.ts

@@ -27,7 +27,10 @@ export interface IMetadata {
     name: string;
     tags: IMetadataTypeTag[][];
   }[];
-  objects: string[];
+  objects: {
+    name: string;
+    tags: IMetadataTypeTag[][];
+  }[];
   aliases: string[];
 
   natives: string[];

package/src/schemas/metadata/IMetadataArray.ts

@@ -1,7 +1,6 @@
-import { IMetadataArrayType } from "./IMetadataArrayType";
 import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataArray {
-  type: IMetadataArrayType;
+  name: string;
   tags: IMetadataTypeTag[][];
 }

package/src/schemas/metadata/IMetadataComponents.ts

@@ -1,10 +1,10 @@
 import { IMetadataAlias } from "./IMetadataAlias";
 import { IMetadataArrayType } from "./IMetadataArrayType";
-import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataObjectType } from "./IMetadataObjectType";
 import { IMetadataTupleType } from "./IMetadataTupleType";
 
 export interface IMetadataComponents {
-  objects: IMetadataObject[];
+  objects: IMetadataObjectType[];
   aliases: IMetadataAlias[];
   arrays: IMetadataArrayType[];
   tuples: IMetadataTupleType[];

package/src/schemas/metadata/IMetadataDictionary.ts

@@ -1,10 +1,10 @@
 import { MetadataAlias } from "./MetadataAlias";
 import { MetadataArrayType } from "./MetadataArrayType";
-import { MetadataObject } from "./MetadataObject";
+import { MetadataObjectType } from "./MetadataObjectType";
 import { MetadataTupleType } from "./MetadataTupleType";
 
 export interface IMetadataDictionary {
-  objects: Map<string, MetadataObject>;
+  objects: Map<string, MetadataObjectType>;
   aliases: Map<string, MetadataAlias>;
   arrays: Map<string, MetadataArrayType>;
   tuples: Map<string, MetadataTupleType>;