@typia/interface 12.0.0-dev.20260309 → 12.0.0-dev.20260311

package/src/tags/JsonSchemaPlugin.ts

@@ -1,45 +1,45 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Injects custom properties into generated JSON Schema.
- *
- * `JsonSchemaPlugin<Schema>` is a type tag that merges custom properties into
- * the generated JSON Schema output. This enables vendor extensions (typically
- * prefixed with `x-`) and custom metadata that tools in your ecosystem may
- * require.
- *
- * This is metadata-only - it does not affect runtime validation. The properties
- * are simply merged into the schema for the annotated type.
- *
- * Common use cases:
- *
- * - OpenAPI vendor extensions (`x-*` properties)
- * - Custom UI hints for form generators
- * - Tool-specific metadata
- * - Integration with third-party schema consumers
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface FormField {
- *     // Add custom UI hints for form generation
- *     email: string &
- *       Format<"email"> &
- *       JsonSchemaPlugin<{
- *         "x-ui-widget": "email-input";
- *         "x-ui-placeholder": "Enter your email";
- *       }>;
- *     // Add custom sorting metadata
- *     priority: number &
- *       JsonSchemaPlugin<{
- *         "x-sort-order": "descending";
- *       }>;
- *   }
- *
- * @template Schema Object type containing the custom properties to merge
- */
-export type JsonSchemaPlugin<Schema extends object> = TagBase<{
-  target: "string" | "boolean" | "bigint" | "number" | "array" | "object";
-  kind: "jsonPlugin";
-  value: undefined;
-  schema: Schema;
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * Injects custom properties into generated JSON Schema.
+ *
+ * `JsonSchemaPlugin<Schema>` is a type tag that merges custom properties into
+ * the generated JSON Schema output. This enables vendor extensions (typically
+ * prefixed with `x-`) and custom metadata that tools in your ecosystem may
+ * require.
+ *
+ * This is metadata-only - it does not affect runtime validation. The properties
+ * are simply merged into the schema for the annotated type.
+ *
+ * Common use cases:
+ *
+ * - OpenAPI vendor extensions (`x-*` properties)
+ * - Custom UI hints for form generators
+ * - Tool-specific metadata
+ * - Integration with third-party schema consumers
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface FormField {
+ *     // Add custom UI hints for form generation
+ *     email: string &
+ *       Format<"email"> &
+ *       JsonSchemaPlugin<{
+ *         "x-ui-widget": "email-input";
+ *         "x-ui-placeholder": "Enter your email";
+ *       }>;
+ *     // Add custom sorting metadata
+ *     priority: number &
+ *       JsonSchemaPlugin<{
+ *         "x-sort-order": "descending";
+ *       }>;
+ *   }
+ *
+ * @template Schema Object type containing the custom properties to merge
+ */
+export type JsonSchemaPlugin<Schema extends object> = TagBase<{
+  target: "string" | "boolean" | "bigint" | "number" | "array" | "object";
+  kind: "jsonPlugin";
+  value: undefined;
+  schema: Schema;
+}>;

package/src/tags/MaxItems.ts

@@ -1,39 +1,39 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Array maximum items constraint.
- *
- * `MaxItems<N>` is a type tag that validates array values have at most the
- * specified number of elements. Apply it to array properties using TypeScript
- * intersection types.
- *
- * This constraint is commonly combined with {@link MinItems} to define a valid
- * size range. It can also be combined with {@link UniqueItems} to require unique
- * elements.
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It generates `maxItems` in JSON Schema output.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Upload {
- *     // Maximum 5 files per upload
- *     files: (File & MaxItems<5>)[];
- *   }
- *   interface Config {
- *     // Between 1-3 backup servers allowed
- *     backupServers: (Server & MinItems<1> & MaxItems<3>)[];
- *   }
- *
- * @template Value Maximum number of elements allowed
- */
-export type MaxItems<Value extends number> = TagBase<{
-  target: "array";
-  kind: "maxItems";
-  value: Value;
-  validate: `$input.length <= ${Value}`;
-  exclusive: true;
-  schema: {
-    maxItems: Value;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * Array maximum items constraint.
+ *
+ * `MaxItems<N>` is a type tag that validates array values have at most the
+ * specified number of elements. Apply it to array properties using TypeScript
+ * intersection types.
+ *
+ * This constraint is commonly combined with {@link MinItems} to define a valid
+ * size range. It can also be combined with {@link UniqueItems} to require unique
+ * elements.
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `maxItems` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Upload {
+ *     // Maximum 5 files per upload
+ *     files: (File & MaxItems<5>)[];
+ *   }
+ *   interface Config {
+ *     // Between 1-3 backup servers allowed
+ *     backupServers: (Server & MinItems<1> & MaxItems<3>)[];
+ *   }
+ *
+ * @template Value Maximum number of elements allowed
+ */
+export type MaxItems<Value extends number> = TagBase<{
+  target: "array";
+  kind: "maxItems";
+  value: Value;
+  validate: `$input.length <= ${Value}`;
+  exclusive: true;
+  schema: {
+    maxItems: Value;
+  };
+}>;

package/src/tags/MaxLength.ts

@@ -1,37 +1,37 @@
-import { TagBase } from "./TagBase";
-
-/**
- * String maximum length constraint.
- *
- * `MaxLength<N>` is a type tag that validates string values have at most the
- * specified number of characters. Apply it to `string` properties using
- * TypeScript intersection types.
- *
- * This constraint is commonly combined with {@link MinLength} to define a valid
- * length range. Multiple length constraints can be applied to the same property
- * (all must pass).
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It generates `maxLength` in JSON Schema output.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Article {
- *     // Title limited to 100 characters
- *     title: string & MaxLength<100>;
- *     // Description between 10-500 characters
- *     description: string & MinLength<10> & MaxLength<500>;
- *   }
- *
- * @template Value Maximum number of characters allowed
- */
-export type MaxLength<Value extends number> = TagBase<{
-  target: "string";
-  kind: "maxLength";
-  value: Value;
-  validate: `$input.length <= ${Value}`;
-  exclusive: true;
-  schema: {
-    maxLength: Value;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * String maximum length constraint.
+ *
+ * `MaxLength<N>` is a type tag that validates string values have at most the
+ * specified number of characters. Apply it to `string` properties using
+ * TypeScript intersection types.
+ *
+ * This constraint is commonly combined with {@link MinLength} to define a valid
+ * length range. Multiple length constraints can be applied to the same property
+ * (all must pass).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `maxLength` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Article {
+ *     // Title limited to 100 characters
+ *     title: string & MaxLength<100>;
+ *     // Description between 10-500 characters
+ *     description: string & MinLength<10> & MaxLength<500>;
+ *   }
+ *
+ * @template Value Maximum number of characters allowed
+ */
+export type MaxLength<Value extends number> = TagBase<{
+  target: "string";
+  kind: "maxLength";
+  value: Value;
+  validate: `$input.length <= ${Value}`;
+  exclusive: true;
+  schema: {
+    maxLength: Value;
+  };
+}>;

package/src/tags/Maximum.ts

@@ -1,44 +1,44 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Inclusive maximum value constraint (value <= max).
- *
- * `Maximum<N>` is a type tag that validates numeric values are less than or
- * equal to the specified bound. Apply it to `number` or `bigint` properties
- * using TypeScript intersection types.
- *
- * This constraint is **mutually exclusive** with {@link ExclusiveMaximum} - you
- * cannot use both on the same property. Use `Maximum` for inclusive bounds (<=)
- * and `ExclusiveMaximum` for exclusive bounds (<).
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It also generates `maximum` in JSON Schema output.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Rating {
- *     // Score from 0-100
- *     score: number & Minimum<0> & Maximum<100>;
- *     // Percentage cannot exceed 1.0
- *     ratio: number & Maximum<1.0>;
- *   }
- *
- * @template Value The maximum allowed value (inclusive)
- */
-export type Maximum<Value extends number | bigint> = TagBase<{
-  target: Value extends bigint ? "bigint" : "number";
-  kind: "maximum";
-  value: Value;
-  validate: `$input <= ${Cast<Value>}`;
-  exclusive: ["maximum", "exclusiveMaximum"];
-  schema: Value extends bigint
-    ? { maximum: Numeric<Value> }
-    : { maximum: Value };
-}>;
-
-type Cast<Value extends number | bigint> = Value extends number
-  ? Value
-  : `BigInt(${Value})`;
-type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
-  ? N
-  : never;
+import { TagBase } from "./TagBase";
+
+/**
+ * Inclusive maximum value constraint (value <= max).
+ *
+ * `Maximum<N>` is a type tag that validates numeric values are less than or
+ * equal to the specified bound. Apply it to `number` or `bigint` properties
+ * using TypeScript intersection types.
+ *
+ * This constraint is **mutually exclusive** with {@link ExclusiveMaximum} - you
+ * cannot use both on the same property. Use `Maximum` for inclusive bounds (<=)
+ * and `ExclusiveMaximum` for exclusive bounds (<).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It also generates `maximum` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Rating {
+ *     // Score from 0-100
+ *     score: number & Minimum<0> & Maximum<100>;
+ *     // Percentage cannot exceed 1.0
+ *     ratio: number & Maximum<1.0>;
+ *   }
+ *
+ * @template Value The maximum allowed value (inclusive)
+ */
+export type Maximum<Value extends number | bigint> = TagBase<{
+  target: Value extends bigint ? "bigint" : "number";
+  kind: "maximum";
+  value: Value;
+  validate: `$input <= ${Cast<Value>}`;
+  exclusive: ["maximum", "exclusiveMaximum"];
+  schema: Value extends bigint
+    ? { maximum: Numeric<Value> }
+    : { maximum: Value };
+}>;
+
+type Cast<Value extends number | bigint> = Value extends number
+  ? Value
+  : `BigInt(${Value})`;
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;

package/src/tags/MinItems.ts

@@ -1,39 +1,39 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Array minimum items constraint.
- *
- * `MinItems<N>` is a type tag that validates array values have at least the
- * specified number of elements. Apply it to array properties using TypeScript
- * intersection types.
- *
- * This constraint is commonly combined with {@link MaxItems} to define a valid
- * size range. It can also be combined with {@link UniqueItems} to require unique
- * elements.
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It generates `minItems` in JSON Schema output.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Order {
- *     // Must have at least 1 item
- *     items: (Product & MinItems<1>)[];
- *   }
- *   interface Team {
- *     // Team must have 2-10 members
- *     members: (User & MinItems<2> & MaxItems<10>)[];
- *   }
- *
- * @template Value Minimum number of elements required
- */
-export type MinItems<Value extends number> = TagBase<{
-  target: "array";
-  kind: "minItems";
-  value: Value;
-  validate: `${Value} <= $input.length`;
-  exclusive: true;
-  schema: {
-    minItems: Value;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * Array minimum items constraint.
+ *
+ * `MinItems<N>` is a type tag that validates array values have at least the
+ * specified number of elements. Apply it to array properties using TypeScript
+ * intersection types.
+ *
+ * This constraint is commonly combined with {@link MaxItems} to define a valid
+ * size range. It can also be combined with {@link UniqueItems} to require unique
+ * elements.
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `minItems` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Order {
+ *     // Must have at least 1 item
+ *     items: (Product & MinItems<1>)[];
+ *   }
+ *   interface Team {
+ *     // Team must have 2-10 members
+ *     members: (User & MinItems<2> & MaxItems<10>)[];
+ *   }
+ *
+ * @template Value Minimum number of elements required
+ */
+export type MinItems<Value extends number> = TagBase<{
+  target: "array";
+  kind: "minItems";
+  value: Value;
+  validate: `${Value} <= $input.length`;
+  exclusive: true;
+  schema: {
+    minItems: Value;
+  };
+}>;

package/src/tags/MinLength.ts

@@ -1,37 +1,37 @@
-import { TagBase } from "./TagBase";
-
-/**
- * String minimum length constraint.
- *
- * `MinLength<N>` is a type tag that validates string values have at least the
- * specified number of characters. Apply it to `string` properties using
- * TypeScript intersection types.
- *
- * This constraint is commonly combined with {@link MaxLength} to define a valid
- * length range. Multiple length constraints can be applied to the same property
- * (all must pass).
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It generates `minLength` in JSON Schema output.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface User {
- *     // Username must be at least 3 characters
- *     username: string & MinLength<3> & MaxLength<20>;
- *     // Password must be at least 8 characters
- *     password: string & MinLength<8>;
- *   }
- *
- * @template Value Minimum number of characters required
- */
-export type MinLength<Value extends number> = TagBase<{
-  target: "string";
-  kind: "minLength";
-  value: Value;
-  validate: `${Value} <= $input.length`;
-  exclusive: true;
-  schema: {
-    minLength: Value;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * String minimum length constraint.
+ *
+ * `MinLength<N>` is a type tag that validates string values have at least the
+ * specified number of characters. Apply it to `string` properties using
+ * TypeScript intersection types.
+ *
+ * This constraint is commonly combined with {@link MaxLength} to define a valid
+ * length range. Multiple length constraints can be applied to the same property
+ * (all must pass).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `minLength` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface User {
+ *     // Username must be at least 3 characters
+ *     username: string & MinLength<3> & MaxLength<20>;
+ *     // Password must be at least 8 characters
+ *     password: string & MinLength<8>;
+ *   }
+ *
+ * @template Value Minimum number of characters required
+ */
+export type MinLength<Value extends number> = TagBase<{
+  target: "string";
+  kind: "minLength";
+  value: Value;
+  validate: `${Value} <= $input.length`;
+  exclusive: true;
+  schema: {
+    minLength: Value;
+  };
+}>;

package/src/tags/Minimum.ts

@@ -1,44 +1,44 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Inclusive minimum value constraint (value >= min).
- *
- * `Minimum<N>` is a type tag that validates numeric values are greater than or
- * equal to the specified bound. Apply it to `number` or `bigint` properties
- * using TypeScript intersection types.
- *
- * This constraint is **mutually exclusive** with {@link ExclusiveMinimum} - you
- * cannot use both on the same property. Use `Minimum` for inclusive bounds (>=)
- * and `ExclusiveMinimum` for exclusive bounds (>).
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It also generates `minimum` in JSON Schema output.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Product {
- *     // Price must be 0 or greater
- *     price: number & Minimum<0>;
- *     // Quantity must be at least 1
- *     quantity: number & Minimum<1>;
- *   }
- *
- * @template Value The minimum allowed value (inclusive)
- */
-export type Minimum<Value extends number | bigint> = TagBase<{
-  target: Value extends bigint ? "bigint" : "number";
-  kind: "minimum";
-  value: Value;
-  validate: `${Cast<Value>} <= $input`;
-  exclusive: ["minimum", "exclusiveMinimum"];
-  schema: Value extends bigint
-    ? { minimum: Numeric<Value> }
-    : { minimum: Value };
-}>;
-
-type Cast<Value extends number | bigint> = Value extends number
-  ? Value
-  : `BigInt(${Value})`;
-type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
-  ? N
-  : never;
+import { TagBase } from "./TagBase";
+
+/**
+ * Inclusive minimum value constraint (value >= min).
+ *
+ * `Minimum<N>` is a type tag that validates numeric values are greater than or
+ * equal to the specified bound. Apply it to `number` or `bigint` properties
+ * using TypeScript intersection types.
+ *
+ * This constraint is **mutually exclusive** with {@link ExclusiveMinimum} - you
+ * cannot use both on the same property. Use `Minimum` for inclusive bounds (>=)
+ * and `ExclusiveMinimum` for exclusive bounds (>).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It also generates `minimum` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Product {
+ *     // Price must be 0 or greater
+ *     price: number & Minimum<0>;
+ *     // Quantity must be at least 1
+ *     quantity: number & Minimum<1>;
+ *   }
+ *
+ * @template Value The minimum allowed value (inclusive)
+ */
+export type Minimum<Value extends number | bigint> = TagBase<{
+  target: Value extends bigint ? "bigint" : "number";
+  kind: "minimum";
+  value: Value;
+  validate: `${Cast<Value>} <= $input`;
+  exclusive: ["minimum", "exclusiveMinimum"];
+  schema: Value extends bigint
+    ? { minimum: Numeric<Value> }
+    : { minimum: Value };
+}>;
+
+type Cast<Value extends number | bigint> = Value extends number
+  ? Value
+  : `BigInt(${Value})`;
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;