typia 5.0.0-dev.2023084 → 5.0.0

package/src/schemas/json/IJsonSchema.ts

@@ -1,8 +1,9 @@
 import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../metadata/IMetadataTag";
 
 import { Atomic } from "../../typings/Atomic";
 
+import { Type } from "../../tags/Type";
+
 export type IJsonSchema = IJsonSchema.Known | IJsonSchema.IUnknown;
 export namespace IJsonSchema {
     export type Known =
@@ -36,14 +37,8 @@ export namespace IJsonSchema {
         default?: Atomic.Mapper[Literal];
     }
     export interface IString extends IAtomic<"string"> {
-        /**
-         * @type uint
-         */
-        minLength?: number;
-        /**
-         * @type uint
-         */
-        maxLength?: number;
+        minLength?: number & Type<"uint32">;
+        maxLength?: number & Type<"uint32">;
         pattern?: string;
         format?: string;
     }
@@ -55,20 +50,11 @@ export namespace IJsonSchema {
         multipleOf?: number;
     }
     export interface IInteger extends IAtomic<"integer"> {
-        /**
-         * @type int
-         */
-        minimum?: number;
-        /**
-         * @type int
-         */
-        maximum?: number;
+        minimum?: number & Type<"int32">;
+        maximum?: number & Type<"int32">;
         exclusiveMinimum?: boolean;
         exclusiveMaximum?: boolean;
-        /**
-         * @type int
-         */
-        multipleOf?: number;
+        multipleOf?: number & Type<"int32">;
     }
     export interface IBoolean extends IAtomic<"boolean"> {}
 
@@ -77,26 +63,14 @@ export namespace IJsonSchema {
     ----------------------------------------------------------- */
     export interface IArray extends ISignificant<"array"> {
         items: IJsonSchema;
-        /**
-         * @type uint
-         */
-        minItems?: number;
-        /**
-         * @type uint
-         */
-        maxItems?: number;
+        minItems?: number & Type<"uint32">;
+        maxItems?: number & Type<"uint32">;
         "x-typia-tuple"?: ITuple;
     }
     export interface ITuple extends ISignificant<"array"> {
         items: IJsonSchema[];
-        /**
-         * @type uint
-         */
-        minItems: number;
-        /**
-         * @type uint
-         */
-        maxItems?: number;
+        minItems: number & Type<"uint32">;
+        maxItems?: number & Type<"uint32">;
     }
     export interface IReference extends IAttribute {
         $ref: string;
@@ -124,7 +98,6 @@ export namespace IJsonSchema {
         deprecated?: boolean;
         title?: string;
         description?: string;
-        "x-typia-metaTags"?: IMetadataTag[];
         "x-typia-jsDocTags"?: IJsDocTagInfo[];
         "x-typia-required"?: boolean;
         "x-typia-optional"?: boolean;

package/src/schemas/metadata/IMetadata.ts

@@ -1,27 +1,34 @@
-import { IMetadataAtomic } from "./IMetadataAtomic";
-import { IMetadataConstant } from "./IMetadataConstant";
-import { IMetadataEntry } from "./IMetadataEntry";
-import { IMetadataEscaped } from "./IMetadataEscaped";
-
-export interface IMetadata {
-    any: boolean;
-    required: boolean;
-    optional: boolean;
-    nullable: boolean;
-    functional: boolean;
-
-    atomics: IMetadataAtomic[];
-    constants: IMetadataConstant[];
-    templates: IMetadata[][];
-    escaped: IMetadataEscaped | null;
-
-    rest: IMetadata | null;
-    arrays: string[];
-    tuples: string[];
-    objects: string[];
-    aliases: string[];
-
-    natives: string[];
-    sets: IMetadata[];
-    maps: IMetadataEntry[];
-}
+import { IMetadataAtomic } from "./IMetadataAtomic";
+import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataEntry } from "./IMetadataEntry";
+import { IMetadataEscaped } from "./IMetadataEscaped";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadata {
+    any: boolean;
+    required: boolean;
+    optional: boolean;
+    nullable: boolean;
+    functional: boolean;
+
+    atomics: IMetadataAtomic[];
+    constants: IMetadataConstant[];
+    templates: IMetadata[][];
+    escaped: IMetadataEscaped | null;
+
+    rest: IMetadata | null;
+    arrays: {
+        name: string;
+        tags: IMetadataTypeTag[][];
+    }[];
+    tuples: {
+        name: string;
+        tags: IMetadataTypeTag[][];
+    }[];
+    objects: string[];
+    aliases: string[];
+
+    natives: string[];
+    sets: IMetadata[];
+    maps: IMetadataEntry[];
+}

package/src/schemas/metadata/IMetadataAlias.ts

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

package/src/schemas/metadata/IMetadataArray.ts

@@ -1,10 +1,7 @@
-import { IMetadata } from "./IMetadata";
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataArray {
-    name: string;
-    value: IMetadata;
-
-    nullables: boolean[];
-    recursive: boolean;
-    index: number | null;
+    type: IMetadataArrayType;
+    tags: IMetadataTypeTag[][];
 }

package/src/schemas/metadata/IMetadataArrayType.ts

@@ -0,0 +1,10 @@
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataArrayType {
+    name: string;
+    value: IMetadata;
+
+    nullables: boolean[];
+    recursive: boolean;
+    index: number | null;
+}

package/src/schemas/metadata/IMetadataAtomic.ts

@@ -1,13 +1,6 @@
-import { Atomic } from "../../typings/Atomic";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataAtomic {
-    type: Atomic.Literal;
-    tags: IMetadataAtomic.Tag[][];
-}
-export namespace IMetadataAtomic {
-    export interface Tag {
-        kind: string;
-        value: any;
-        validate: string;
-    }
+    type: "boolean" | "bigint" | "number" | "string";
+    tags: IMetadataTypeTag[][];
 }

package/src/schemas/metadata/IMetadataCollection.ts

@@ -1,11 +1,11 @@
 import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataArrayType } from "./IMetadataArrayType";
 import { IMetadataObject } from "./IMetadataObject";
-import { IMetadataTuple } from "./IMetadataTuple";
+import { IMetadataTupleType } from "./IMetadataTupleType";
 
 export interface IMetadataCollection {
     objects: IMetadataObject[];
     aliases: IMetadataAlias[];
-    arrays: IMetadataArray[];
-    tuples: IMetadataTuple[];
+    arrays: IMetadataArrayType[];
+    tuples: IMetadataTupleType[];
 }

package/src/schemas/metadata/IMetadataDictionary.ts

@@ -1,7 +1,7 @@
 import { MetadataAlias } from "./MetadataAlias";
-import { MetadataArray } from "./MetadataArray";
+import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataObject } from "./MetadataObject";
-import { MetadataTuple } from "./MetadataTuple";
+import { MetadataTupleType } from "./MetadataTupleType";
 
 /**
  * @internal
@@ -9,6 +9,6 @@ import { MetadataTuple } from "./MetadataTuple";
 export interface IMetadataDictionary {
     objects: Map<string, MetadataObject>;
     aliases: Map<string, MetadataAlias>;
-    arrays: Map<string, MetadataArray>;
-    tuples: Map<string, MetadataTuple>;
+    arrays: Map<string, MetadataArrayType>;
+    tuples: Map<string, MetadataTupleType>;
 }

package/src/schemas/metadata/IMetadataEscaped.ts

@@ -1,6 +1,6 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataEscaped {
-    original: IMetadata;
-    returns: IMetadata;
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataEscaped {
+    original: IMetadata;
+    returns: IMetadata;
+}

package/src/schemas/metadata/IMetadataProperty.ts

@@ -1,11 +1,9 @@
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
 
 export interface IMetadataProperty {
     key: IMetadata;
     value: IMetadata;
     description: string | null;
-    tags: IMetadataTag[];
     jsDocTags: IJsDocTagInfo[];
 }

package/src/schemas/metadata/IMetadataTuple.ts

@@ -1,10 +1,7 @@
-import { IMetadata } from "./IMetadata";
+import { IMetadataTupleType } from "./IMetadataTupleType";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataTuple {
-    name: string;
-    elements: IMetadata[];
-
-    index: number | null;
-    recursive: boolean;
-    nullables: boolean[];
+    type: IMetadataTupleType;
+    tags: IMetadataTypeTag[][];
 }

package/src/schemas/metadata/IMetadataTupleType.ts

@@ -0,0 +1,10 @@
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataTupleType {
+    name: string;
+    elements: IMetadata[];
+
+    index: number | null;
+    recursive: boolean;
+    nullables: boolean[];
+}

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -0,0 +1,8 @@
+export interface IMetadataTypeTag {
+    target: "bigint" | "number" | "string" | "array";
+    name: string;
+    kind: string;
+    value: any;
+    validate: string;
+    exclusive: boolean | string[];
+}