typia 7.0.0-dev.20241012 → 7.0.0-dev.20241018

package/src/programmers/internal/llm_schema_object.ts

@@ -4,11 +4,12 @@ import { CommentFactory } from "../../factories/CommentFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 
 import { PatternUtil } from "../../utils/PatternUtil";
 
 import { application_description } from "./application_description";
+import { application_plugin } from "./application_plugin";
 import { llm_schema_station } from "./llm_schema_station";
 import { metadata_to_pattern } from "./metadata_to_pattern";
 
@@ -16,9 +17,9 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  * @internal
  */
 export const llm_schema_object = (props: {
-  object: MetadataObjectType;
+  object: MetadataObject;
   nullable: boolean;
-}): ILlmSchema.IObject => {
+}): ILlmSchema.IObject[] => {
   // ITERATE PROPERTIES
   const properties: Record<string, any> = {};
   const extraMeta: ISuperfluous = {
@@ -27,7 +28,7 @@ export const llm_schema_object = (props: {
   };
   const required: string[] = [];
 
-  for (const property of props.object.properties) {
+  for (const property of props.object.type.properties) {
     if (
       // FUNCTIONAL TYPE
       property.value.functions.length &&
@@ -82,20 +83,22 @@ export const llm_schema_object = (props: {
     }
   }
 
-  return {
-    type: "object",
-    properties,
-    nullable: props.nullable,
-    required: required.length ? required : undefined,
-    title: (() => {
-      const info: IJsDocTagInfo | undefined = props.object.jsDocTags.find(
-        (tag) => tag.name === "title",
-      );
-      return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
-    })(),
-    description: application_description(props.object),
-    additionalProperties: join(extraMeta),
-  };
+  return application_plugin({
+    schema: {
+      type: "object",
+      properties,
+      nullable: props.nullable,
+      required: required.length ? required : undefined,
+      title: (() => {
+        const info: IJsDocTagInfo | undefined =
+          props.object.type.jsDocTags.find((tag) => tag.name === "title");
+        return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
+      })(),
+      description: application_description(props.object.type),
+      additionalProperties: join(extraMeta),
+    },
+    tags: props.object.tags,
+  });
 };
 
 /**

package/src/programmers/internal/llm_schema_station.ts

@@ -99,8 +99,8 @@ export const llm_schema_station = (props: {
 
   // NATIVES
   for (const native of props.metadata.natives)
-    if (AtomicPredicator.native(native)) {
-      const type: string = native.toLowerCase();
+    if (AtomicPredicator.native(native.name)) {
+      const type: string = native.name.toLowerCase();
       if (props.metadata.atomics.some((a) => a.type === type)) continue;
       else if (type === "boolean")
         insert(
@@ -138,7 +138,7 @@ export const llm_schema_station = (props: {
             }),
           )[0]!,
         );
-    } else insert(llm_schema_native(native));
+    } else insert(llm_schema_native(native.name));
   if (props.metadata.sets.length) insert(llm_schema_native("Set"));
   if (props.metadata.maps.length) insert(llm_schema_native("Map"));
 
@@ -149,16 +149,14 @@ export const llm_schema_station = (props: {
         "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive object type.",
       );
     else
-      insert(
-        llm_schema_object({
-          object: object.type,
-          nullable: props.metadata.nullable,
-        }),
-      );
+      llm_schema_object({
+        object,
+        nullable: props.metadata.nullable,
+      }).forEach(insert);
 
   // ALIASES
   for (const alias of props.metadata.aliases)
-    if (alias.recursive)
+    if (alias.type.recursive)
       throw new Error(
         "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive alias type.",
       );
@@ -166,7 +164,7 @@ export const llm_schema_station = (props: {
       insert(
         llm_schema_station({
           ...props,
-          metadata: alias.value,
+          metadata: alias.type.value,
         }),
       );
 

package/src/programmers/json/JsonSchemasProgrammer.ts

@@ -30,12 +30,12 @@ export namespace JsonSchemasProgrammer {
       output.push("JSON schema does not support Set type.");
     for (const native of metadata.natives)
       if (
-        AtomicPredicator.native(native) === false &&
-        native !== "Date" &&
-        native !== "Blob" &&
-        native !== "File"
+        AtomicPredicator.native(native.name) === false &&
+        native.name !== "Date" &&
+        native.name !== "Blob" &&
+        native.name !== "File"
       )
-        output.push(`JSON schema does not support ${native} type.`);
+        output.push(`JSON schema does not support ${native.name} type.`);
     return output;
   };
 

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -235,10 +235,10 @@ export namespace JsonStringifyProgrammer {
         type: "resolved",
         is:
           props.metadata.escaped.original.size() === 1 &&
-          props.metadata.escaped.original.natives[0] === "Date"
+          props.metadata.escaped.original.natives[0]?.name === "Date"
             ? () =>
                 check_native({
-                  type: "Date",
+                  name: "Date",
                   input: props.input,
                 })
             : () =>
@@ -427,14 +427,14 @@ export namespace JsonStringifyProgrammer {
           type: "object",
           is: () =>
             check_native({
-              type: native,
+              name: native.name,
               input: props.input,
             }),
           value: () =>
-            AtomicPredicator.native(native)
+            AtomicPredicator.native(native.name)
               ? decode_atomic({
                   ...props,
-                  type: native.toLowerCase() as Atomic.Literal,
+                  type: native.name.toLowerCase() as Atomic.Literal,
                 })
               : ts.factory.createStringLiteral("{}"),
         });

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -26,14 +26,14 @@ export namespace LlmSchemaProgrammer {
       output.push("LLM schema does not support Set type.");
     for (const native of metadata.natives)
       if (
-        AtomicPredicator.native(native) === false &&
-        native !== "Date" &&
-        native !== "Blob" &&
-        native !== "File"
+        AtomicPredicator.native(native.name) === false &&
+        native.name !== "Date" &&
+        native.name !== "Blob" &&
+        native.name !== "File"
       )
-        output.push(`LLM schema does not support ${native} type.`);
+        output.push(`LLM schema does not support ${native.name} type.`);
     if (
-      metadata.aliases.some((a) => a.recursive) ||
+      metadata.aliases.some((a) => a.type.recursive) ||
       metadata.arrays.some((a) => a.type.recursive) ||
       metadata.objects.some((o) => o.type.recursive) ||
       metadata.tuples.some((t) => t.type.recursive)

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -9,7 +9,9 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataSet } from "../../schemas/metadata/MetadataSet";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -270,16 +272,18 @@ export namespace MiscCloneProgrammer {
     for (const native of props.metadata.natives)
       unions.push({
         type: "native",
-        is: () => ExpressionFactory.isInstanceOf(native, props.input),
+        is: () => ExpressionFactory.isInstanceOf(native.name, props.input),
         value: () =>
-          native === "Boolean" || native === "Number" || native === "String"
+          native.name === "Boolean" ||
+          native.name === "Number" ||
+          native.name === "String"
             ? ts.factory.createCallExpression(
                 IdentifierFactory.access(props.input, "valueOf"),
                 undefined,
                 undefined,
               )
             : decode_native({
-                type: native,
+                type: native.name,
                 input: props.input,
               }),
       });
@@ -578,7 +582,7 @@ export namespace MiscCloneProgrammer {
     config: FeatureProgrammer.IConfig;
     functor: FunctionProgrammer;
     input: ts.Expression;
-    sets: Metadata[];
+    sets: MetadataSet[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
     ts.factory.createCallExpression(
@@ -634,7 +638,7 @@ export namespace MiscCloneProgrammer {
     config: FeatureProgrammer.IConfig;
     functor: FunctionProgrammer;
     input: ts.Expression;
-    maps: Metadata.Entry[];
+    maps: MetadataMap[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
     ts.factory.createCallExpression(
@@ -967,9 +971,9 @@ export namespace MiscCloneProgrammer {
         absorb: true,
         validate: (metadata) => {
           const output: string[] = [];
-          if (metadata.natives.some((n) => n === "WeakSet"))
+          if (metadata.natives.some((native) => native.name === "WeakSet"))
             output.push("unable to clone WeakSet");
-          else if (metadata.natives.some((n) => n === "WeakMap"))
+          else if (metadata.natives.some((native) => native.name === "WeakMap"))
             output.push("unable to clone WeakMap");
           return output;
         },

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -221,7 +221,7 @@ export namespace MiscPruneProgrammer {
       for (const native of props.metadata.natives)
         unions.push({
           type: "native",
-          is: () => ExpressionFactory.isInstanceOf(native, props.input),
+          is: () => ExpressionFactory.isInstanceOf(native.name, props.input),
           value: () => ts.factory.createReturnStatement(),
         });
     if (props.metadata.sets.length)

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -9,7 +9,9 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataSet } from "../../schemas/metadata/MetadataSet";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -298,19 +300,21 @@ export namespace NotationGeneralProgrammer {
           }),
       });
     for (const native of props.metadata.natives) {
-      if (native === "WeakSet" || native === "WeakMap") continue;
+      if (native.name === "WeakSet" || native.name === "WeakMap") continue;
       unions.push({
         type: "native",
-        is: () => ExpressionFactory.isInstanceOf(native, props.input),
+        is: () => ExpressionFactory.isInstanceOf(native.name, props.input),
         value: () =>
-          native === "Boolean" || native === "Number" || native === "String"
+          native.name === "Boolean" ||
+          native.name === "Number" ||
+          native.name === "String"
             ? ts.factory.createCallExpression(
                 IdentifierFactory.access(props.input, "valueOf"),
                 undefined,
                 undefined,
               )
             : decode_native({
-                name: native,
+                name: native.name,
                 input: props.input,
               }),
       });
@@ -530,7 +534,7 @@ export namespace NotationGeneralProgrammer {
     functor: FunctionProgrammer;
     input: ts.Expression;
     explore: FeatureProgrammer.IExplore;
-    sets: Metadata[];
+    sets: Array<MetadataSet>;
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.set({
@@ -585,7 +589,7 @@ export namespace NotationGeneralProgrammer {
     config: FeatureProgrammer.IConfig;
     functor: FunctionProgrammer;
     input: ts.Expression;
-    maps: Metadata.Entry[];
+    maps: Array<MetadataMap>;
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
     ts.factory.createCallExpression(

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -11,6 +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 { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
@@ -359,12 +360,13 @@ export namespace ProtobufDecodeProgrammer {
 
     const required: boolean =
       props.metadata.isRequired() && !props.metadata.nullable;
-    for (const atomic of ProtobufUtil.getAtomics(props.metadata))
+    // @todo
+    for (const [atomic] of ProtobufUtil.getAtomics(props.metadata))
       emplace(
         atomic,
         decode_atomic({
           metadata: props.metadata,
-          type: atomic,
+          type: atomic as ProtobufAtomic,
         }),
       );
     if (props.metadata.natives.length) emplace("bytes", decode_bytes("bytes"));
@@ -420,8 +422,9 @@ export namespace ProtobufDecodeProgrammer {
     );
     if (props.type !== "int64" && props.type !== "uint64") return call;
 
-    const isNumber: boolean = ProtobufUtil.getNumbers(props.metadata).some(
-      (n) => n === props.type,
+    // @todo
+    const isNumber: boolean = ProtobufUtil.getNumbers(props.metadata).has(
+      props.type,
     );
     return isNumber
       ? ts.factory.createCallExpression(
@@ -456,7 +459,11 @@ export namespace ProtobufDecodeProgrammer {
           ),
         ),
       );
-    const atomics = ProtobufUtil.getAtomics(props.array.type.value);
+
+    // @todo
+    const atomics = Array.from(
+      ProtobufUtil.getAtomics(props.array.type.value).keys(),
+    ) as ProtobufAtomic[];
     const decoder = atomics.length
       ? () =>
           decode_atomic({
@@ -610,7 +617,7 @@ export namespace ProtobufDecodeProgrammer {
     context: ITypiaContext;
     functor: FunctionProgrammer;
     accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression;
-    entry: Metadata.Entry;
+    entry: MetadataMap | MetadataProperty;
     required: boolean;
   }): ts.Statement[] =>
     decode_entry({
@@ -644,7 +651,7 @@ export namespace ProtobufDecodeProgrammer {
     functor: FunctionProgrammer;
     initializer: () => ts.Expression;
     setter: () => ts.Expression;
-    entry: Metadata.Entry;
+    entry: MetadataMap | MetadataProperty;
     required: boolean;
   }): ts.Statement[] => {
     const statements: ts.Statement[] = [

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -11,6 +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 { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
@@ -306,11 +307,12 @@ export namespace ProtobufEncodeProgrammer {
                 );
 
     // STARTS FROM ATOMIC TYPES
+    // @todo
     const unions: IUnion[] = [];
-    const numbers = ProtobufUtil.getNumbers(props.metadata);
-    const bigints = ProtobufUtil.getBigints(props.metadata);
+    const numbers = Array.from(ProtobufUtil.getNumbers(props.metadata).keys());
+    const bigints = Array.from(ProtobufUtil.getBigints(props.metadata).keys());
 
-    for (const atom of ProtobufUtil.getAtomics(props.metadata))
+    for (const [atom] of ProtobufUtil.getAtomics(props.metadata))
       if (atom === "bool")
         unions.push({
           type: "bool",
@@ -333,7 +335,7 @@ export namespace ProtobufEncodeProgrammer {
       )
         unions.push(
           decode_number({
-            candidates: numbers,
+            candidates: numbers as ProtobufAtomic.Numeric[],
             type: atom,
             input: props.input,
           }),
@@ -342,7 +344,7 @@ export namespace ProtobufEncodeProgrammer {
         if (numbers.some((n) => n === atom))
           unions.push(
             decode_number({
-              candidates: numbers,
+              candidates: numbers as ProtobufAtomic.Numeric[],
               type: atom,
               input: props.input,
             }),
@@ -350,7 +352,7 @@ export namespace ProtobufEncodeProgrammer {
         else
           unions.push(
             decode_bigint({
-              candidates: bigints,
+              candidates: bigints as ProtobufAtomic.BigNumeric[],
               type: atom,
               input: props.input,
             }),
@@ -489,7 +491,7 @@ export namespace ProtobufEncodeProgrammer {
     functor: FunctionProgrammer;
     index: number;
     input: ts.Expression;
-    entry: Metadata.Entry;
+    entry: MetadataMap | MetadataProperty;
     explore: FeatureProgrammer.IExplore;
   }): ts.Block => {
     const each: ts.Statement[] = [
@@ -822,7 +824,8 @@ export namespace ProtobufEncodeProgrammer {
     )
       return ProtobufWire.LEN;
 
-    const v = ProtobufUtil.getAtomics(metadata)[0]!;
+    // @todo
+    const v = ProtobufUtil.getAtomics(metadata).keys().next().value!;
     if (v === "string") return ProtobufWire.LEN;
     else if (
       v === "bool" ||

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -5,6 +5,7 @@ import { ProtobufFactory } from "../../factories/ProtobufFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
@@ -118,25 +119,27 @@ export namespace ProtobufMessageProgrammer {
   };
 
   /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
+    DECODERS
+  ----------------------------------------------------------- */
   const decode = (props: {
     sequence: IPointer<number>;
     metadata: Metadata;
   }): string => {
-    const elements: Set<string> = new Set();
-    if (props.metadata.natives.length) elements.add("bytes");
-    for (const atomic of ProtobufUtil.getAtomics(props.metadata))
-      elements.add(atomic);
+    const union: Map<string, number | null> = new Map();
+    for (const native of props.metadata.natives)
+      if (native.name === "Uint8Array")
+        union.set("bytes", ProtobufUtil.getSequence(native.tags[0] ?? []));
+    ProtobufUtil.getAtomics(props.metadata, union);
     for (const array of props.metadata.arrays)
-      elements.add(
+      union.set(
         `repeated ${decode({
           sequence: props.sequence,
           metadata: array.type.value,
         })}`,
+        ProtobufUtil.getSequence(array.tags[0] ?? []),
       );
     for (const obj of props.metadata.objects)
-      elements.add(
+      union.set(
         is_dynamic_object(obj.type)
           ? decode_map({
               sequence: props.sequence,
@@ -155,29 +158,51 @@ export namespace ProtobufMessageProgrammer {
               }),
             })
           : NameEncoder.encode(obj.type.name),
+        ProtobufUtil.getSequence(obj.tags[0] ?? []),
       );
     for (const entry of props.metadata.maps)
-      elements.add(
+      union.set(
         decode_map({
           sequence: props.sequence,
           entry,
         }),
+        ProtobufUtil.getSequence(entry.tags[0] ?? []),
       );
-    return elements.size === 1
-      ? [...elements][0]!
-      : [
-          "oneof ${name} {",
-          ...[...elements].map((str) => {
-            const index: number = ++props.sequence.value;
-            return `${TAB}${str} v${index} = ${index};`;
-          }),
-          "}",
-        ].join("\n");
+
+    const sequenced: boolean = Array.from(union.values()).every(
+      (x) => x !== null,
+    );
+    if (sequenced === false)
+      return union.size === 1
+        ? union.keys().next().value!
+        : [
+            "oneof ${name} {",
+            ...Array.from(union.keys()).map((str) => {
+              const index: number = ++props.sequence.value;
+              return `${TAB}${str} v${index} = ${index};`;
+            }),
+            "}",
+          ].join("\n");
+    else if (union.size === 1) {
+      const [key, value] = union.entries().next().value!;
+      props.sequence.value = value!;
+      return `${key} $\{name} = ${value}`;
+    }
+    props.sequence.value = Math.max(
+      ...Array.from(union.values()).filter((v) => v !== null),
+    );
+    return [
+      "oneof ${name} {",
+      ...Array.from(union.entries()).map(
+        ([key, value]) => `${TAB}${key} v${value} = ${value};`,
+      ),
+      "}",
+    ].join("\n");
   };
 
   const decode_map = (props: {
     sequence: IPointer<number>;
-    entry: Metadata.Entry;
+    entry: MetadataMap | MetadataProperty;
   }): string =>
     `map<${decode({
       sequence: props.sequence,

package/src/schemas/metadata/IMetadata.ts

@@ -1,39 +1,35 @@
-import { IMetadataAtomic } from "./IMetadataAtomic";
-import { IMetadataConstant } from "./IMetadataConstant";
-import { IMetadataEntry } from "./IMetadataEntry";
-import { IMetadataEscaped } from "./IMetadataEscaped";
-import { IMetadataFunction } from "./IMetadataFunction";
-import { IMetadataTemplate } from "./IMetadataTemplate";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadata {
-  any: boolean;
-  required: boolean;
-  optional: boolean;
-  nullable: boolean;
-  functions: IMetadataFunction[];
-
-  atomics: IMetadataAtomic[];
-  constants: IMetadataConstant[];
-  templates: IMetadataTemplate[];
-  escaped: IMetadataEscaped | null;
-
-  rest: IMetadata | null;
-  arrays: {
-    name: string;
-    tags: IMetadataTypeTag[][];
-  }[];
-  tuples: {
-    name: string;
-    tags: IMetadataTypeTag[][];
-  }[];
-  objects: {
-    name: string;
-    tags: IMetadataTypeTag[][];
-  }[];
-  aliases: string[];
-
-  natives: string[];
-  sets: IMetadata[];
-  maps: IMetadataEntry[];
-}
+import { IMetadataAlias } from "./IMetadataAlias";
+import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataAtomic } from "./IMetadataAtomic";
+import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataEscaped } from "./IMetadataEscaped";
+import { IMetadataFunction } from "./IMetadataFunction";
+import { IMetadataMap } from "./IMetadataMap";
+import { IMetadataNative } from "./IMetadataNative";
+import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataSet } from "./IMetadataSet";
+import { IMetadataTemplate } from "./IMetadataTemplate";
+import { IMetadataTuple } from "./IMetadataTuple";
+
+export interface IMetadata {
+  any: boolean;
+  required: boolean;
+  optional: boolean;
+  nullable: boolean;
+  functions: IMetadataFunction[];
+
+  atomics: IMetadataAtomic[];
+  constants: IMetadataConstant[];
+  templates: IMetadataTemplate[];
+  escaped: IMetadataEscaped | null;
+
+  rest: IMetadata | null;
+  arrays: IMetadataArray[];
+  tuples: IMetadataTuple[];
+  objects: IMetadataObject[];
+  aliases: IMetadataAlias[];
+
+  natives: IMetadataNative[];
+  sets: IMetadataSet[];
+  maps: IMetadataMap[];
+}

package/src/schemas/metadata/IMetadataAlias.ts

@@ -1,12 +1,6 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataAlias {
-  name: string;
-  value: IMetadata;
-  nullables: boolean[];
-
-  description: string | null;
-  jsDocTags: IJsDocTagInfo[];
-  recursive: boolean;
-}
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataAlias {
+  name: string;
+  tags: IMetadataTypeTag[][];
+}