@typia/interface 12.0.0-dev.20260307-2 → 12.0.0-dev.20260310

package/src/tags/Default.ts

@@ -1,50 +1,50 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Default value metadata for JSON Schema generation.
- *
- * `Default<Value>` is a type tag that specifies a default value for a property
- * in the generated JSON Schema. This is metadata-only - typia does not
- * automatically apply default values at runtime.
- *
- * The default value appears in the `default` field of the JSON Schema output,
- * which API documentation tools and code generators can use to show default
- * values or generate code that applies them.
- *
- * Only primitive literal types are supported: `boolean`, `bigint`, `number`,
- * and `string`. For complex defaults, consider using optional properties with
- * runtime default assignment.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Config {
- *     // Default to 10 items per page
- *     pageSize: (number & Default<10>) | undefined;
- *     // Default to enabled
- *     enabled: (boolean & Default<true>) | undefined;
- *     // Default sort order
- *     sortOrder: (string & Default<"asc">) | undefined;
- *   }
- *
- * @template Value The default value literal (must be a primitive)
- */
-export type Default<Value extends boolean | bigint | number | string> =
-  TagBase<{
-    target: Value extends boolean
-      ? "boolean"
-      : Value extends bigint
-        ? "bigint"
-        : Value extends number
-          ? "number"
-          : "string";
-    kind: "default";
-    value: Value;
-    exclusive: true;
-    schema: Value extends bigint
-      ? { default: Numeric<Value> }
-      : { default: Value };
-  }>;
-
-type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
-  ? N
-  : never;
+import { TagBase } from "./TagBase";
+
+/**
+ * Default value metadata for JSON Schema generation.
+ *
+ * `Default<Value>` is a type tag that specifies a default value for a property
+ * in the generated JSON Schema. This is metadata-only - typia does not
+ * automatically apply default values at runtime.
+ *
+ * The default value appears in the `default` field of the JSON Schema output,
+ * which API documentation tools and code generators can use to show default
+ * values or generate code that applies them.
+ *
+ * Only primitive literal types are supported: `boolean`, `bigint`, `number`,
+ * and `string`. For complex defaults, consider using optional properties with
+ * runtime default assignment.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Config {
+ *     // Default to 10 items per page
+ *     pageSize: (number & Default<10>) | undefined;
+ *     // Default to enabled
+ *     enabled: (boolean & Default<true>) | undefined;
+ *     // Default sort order
+ *     sortOrder: (string & Default<"asc">) | undefined;
+ *   }
+ *
+ * @template Value The default value literal (must be a primitive)
+ */
+export type Default<Value extends boolean | bigint | number | string> =
+  TagBase<{
+    target: Value extends boolean
+      ? "boolean"
+      : Value extends bigint
+        ? "bigint"
+        : Value extends number
+          ? "number"
+          : "string";
+    kind: "default";
+    value: Value;
+    exclusive: true;
+    schema: Value extends bigint
+      ? { default: Numeric<Value> }
+      : { default: Value };
+  }>;
+
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;

package/src/tags/Example.ts

@@ -1,48 +1,48 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Single example value for JSON Schema documentation.
- *
- * `Example<Value>` is a type tag that adds a representative example value to
- * the generated JSON Schema. This is metadata-only - it appears in the
- * `example` field of the schema and helps API consumers understand expected
- * values.
- *
- * Examples are displayed in API documentation tools like Swagger UI and can be
- * used by code generators to produce more helpful client code.
- *
- * Supports all JSON-compatible types: primitives, objects, arrays, and null.
- * For multiple named examples, use {@link Examples} instead.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface User {
- *     email: string & Format<"email"> & Example<"user@example.com">;
- *     age: number & Minimum<0> & Example<25>;
- *     tags: string[] & Example<["admin", "active"]>;
- *   }
- *
- * @template Value The example value (any JSON-compatible type)
- */
-export type Example<
-  Value extends
-    | boolean
-    | bigint
-    | number
-    | string
-    | object
-    | Array<unknown>
-    | null,
-> = TagBase<{
-  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
-  kind: "example";
-  value: Value;
-  exclusive: true;
-  schema: Value extends bigint
-    ? { example: Numeric<Value> }
-    : { example: Value };
-}>;
-
-type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
-  ? N
-  : never;
+import { TagBase } from "./TagBase";
+
+/**
+ * Single example value for JSON Schema documentation.
+ *
+ * `Example<Value>` is a type tag that adds a representative example value to
+ * the generated JSON Schema. This is metadata-only - it appears in the
+ * `example` field of the schema and helps API consumers understand expected
+ * values.
+ *
+ * Examples are displayed in API documentation tools like Swagger UI and can be
+ * used by code generators to produce more helpful client code.
+ *
+ * Supports all JSON-compatible types: primitives, objects, arrays, and null.
+ * For multiple named examples, use {@link Examples} instead.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface User {
+ *     email: string & Format<"email"> & Example<"user@example.com">;
+ *     age: number & Minimum<0> & Example<25>;
+ *     tags: string[] & Example<["admin", "active"]>;
+ *   }
+ *
+ * @template Value The example value (any JSON-compatible type)
+ */
+export type Example<
+  Value extends
+    | boolean
+    | bigint
+    | number
+    | string
+    | object
+    | Array<unknown>
+    | null,
+> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  kind: "example";
+  value: Value;
+  exclusive: true;
+  schema: Value extends bigint
+    ? { example: Numeric<Value> }
+    : { example: Value };
+}>;
+
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;

package/src/tags/Examples.ts

@@ -1,50 +1,50 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Multiple named examples for JSON Schema documentation.
- *
- * `Examples<Record>` is a type tag that adds multiple labeled example values to
- * the generated JSON Schema. Each example has a name and a value, providing
- * rich documentation for different use cases or scenarios.
- *
- * This is useful when a property can have various valid values and you want to
- * illustrate multiple possibilities, such as different user types, edge cases,
- * or common configurations.
- *
- * The examples appear in the `examples` field of the JSON Schema and are
- * displayed by API documentation tools. For a single unnamed example, use
- * {@link Example} instead.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Product {
- *     price: number &
- *       Examples<{
- *         budget: 9.99;
- *         premium: 99.99;
- *         enterprise: 999.99;
- *       }>;
- *     status: string &
- *       Examples<{
- *         active: "active";
- *         discontinued: "discontinued";
- *         preorder: "preorder";
- *       }>;
- *   }
- *
- * @template Value Record mapping example names to their values
- */
-export type Examples<
-  Value extends Record<
-    string,
-    boolean | bigint | number | string | object | Array<unknown> | null
-  >,
-> = TagBase<{
-  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
-  kind: "examples";
-  value: Value;
-  exclusive: true;
-  schema: {
-    examples: Value;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * Multiple named examples for JSON Schema documentation.
+ *
+ * `Examples<Record>` is a type tag that adds multiple labeled example values to
+ * the generated JSON Schema. Each example has a name and a value, providing
+ * rich documentation for different use cases or scenarios.
+ *
+ * This is useful when a property can have various valid values and you want to
+ * illustrate multiple possibilities, such as different user types, edge cases,
+ * or common configurations.
+ *
+ * The examples appear in the `examples` field of the JSON Schema and are
+ * displayed by API documentation tools. For a single unnamed example, use
+ * {@link Example} instead.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Product {
+ *     price: number &
+ *       Examples<{
+ *         budget: 9.99;
+ *         premium: 99.99;
+ *         enterprise: 999.99;
+ *       }>;
+ *     status: string &
+ *       Examples<{
+ *         active: "active";
+ *         discontinued: "discontinued";
+ *         preorder: "preorder";
+ *       }>;
+ *   }
+ *
+ * @template Value Record mapping example names to their values
+ */
+export type Examples<
+  Value extends Record<
+    string,
+    boolean | bigint | number | string | object | Array<unknown> | null
+  >,
+> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  kind: "examples";
+  value: Value;
+  exclusive: true;
+  schema: {
+    examples: Value;
+  };
+}>;

package/src/tags/ExclusiveMaximum.ts

@@ -1,46 +1,46 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Exclusive maximum value constraint (value < max).
- *
- * `ExclusiveMaximum<N>` is a type tag that validates numeric values are
- * strictly less than the specified bound (not equal). Apply it to `number` or
- * `bigint` properties using TypeScript intersection types.
- *
- * This constraint is **mutually exclusive** with {@link Maximum} - you cannot
- * use both on the same property. Use `ExclusiveMaximum` for exclusive bounds
- * (<) and `Maximum` for inclusive bounds (<=).
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It also generates `exclusiveMaximum` in JSON Schema.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Temperature {
- *     // Must be less than 100 (boiling point), not equal
- *     celsius: number & ExclusiveMaximum<100>;
- *   }
- *
- * @template Value The maximum bound (exclusive - value must be less)
- */
-export type ExclusiveMaximum<Value extends number | bigint> = TagBase<{
-  target: Value extends bigint ? "bigint" : "number";
-  kind: "exclusiveMaximum";
-  value: Value;
-  validate: `$input < ${Cast<Value>}`;
-  exclusive: ["exclusiveMaximum", "maximum"];
-  schema: Value extends bigint
-    ? {
-        exclusiveMaximum: Numeric<Value>;
-      }
-    : {
-        exclusiveMaximum: 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";
+
+/**
+ * Exclusive maximum value constraint (value < max).
+ *
+ * `ExclusiveMaximum<N>` is a type tag that validates numeric values are
+ * strictly less than the specified bound (not equal). Apply it to `number` or
+ * `bigint` properties using TypeScript intersection types.
+ *
+ * This constraint is **mutually exclusive** with {@link Maximum} - you cannot
+ * use both on the same property. Use `ExclusiveMaximum` for exclusive bounds
+ * (<) and `Maximum` for inclusive bounds (<=).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It also generates `exclusiveMaximum` in JSON Schema.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Temperature {
+ *     // Must be less than 100 (boiling point), not equal
+ *     celsius: number & ExclusiveMaximum<100>;
+ *   }
+ *
+ * @template Value The maximum bound (exclusive - value must be less)
+ */
+export type ExclusiveMaximum<Value extends number | bigint> = TagBase<{
+  target: Value extends bigint ? "bigint" : "number";
+  kind: "exclusiveMaximum";
+  value: Value;
+  validate: `$input < ${Cast<Value>}`;
+  exclusive: ["exclusiveMaximum", "maximum"];
+  schema: Value extends bigint
+    ? {
+        exclusiveMaximum: Numeric<Value>;
+      }
+    : {
+        exclusiveMaximum: 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/ExclusiveMinimum.ts

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

@@ -1,76 +1,76 @@
-import type { TagBase } from "./TagBase";
-
-/**
- * String format validation constraint.
- *
- * `Format<Value>` validates strings against predefined formats (email, uuid,
- * url, date-time, etc.). Mutually exclusive with {@link Pattern}.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template Value Format identifier (see {@link Format.Value} for options)
- */
-export type Format<Value extends Format.Value> = TagBase<{
-  target: "string";
-  kind: "format";
-  value: Value;
-  validate: `$importInternal("isFormat${PascalizeString<Value>}")($input)`;
-  exclusive: ["format", "pattern"];
-  schema: {
-    format: Value;
-  };
-}>;
-export namespace Format {
-  /**
-   * Supported format identifiers.
-   *
-   * Standard JSON Schema formats:
-   *
-   * - `email`, `idn-email`: Email addresses
-   * - `hostname`, `idn-hostname`: Hostnames
-   * - `uri`, `uri-reference`, `uri-template`, `url`: URLs
-   * - `iri`, `iri-reference`: Internationalized URLs
-   * - `uuid`: UUID strings
-   * - `ipv4`, `ipv6`: IP addresses
-   * - `date-time`, `date`, `time`, `duration`: Date/time formats
-   * - `json-pointer`, `relative-json-pointer`: JSON pointers
-   * - `regex`: Regular expression patterns
-   * - `byte`: Base64-encoded data
-   * - `password`: Password fields (for documentation only)
-   */
-  export type Value =
-    | "byte"
-    | "password"
-    | "regex"
-    | "uuid"
-    | "email"
-    | "hostname"
-    | "idn-email"
-    | "idn-hostname"
-    | "iri"
-    | "iri-reference"
-    | "ipv4"
-    | "ipv6"
-    | "uri"
-    | "uri-reference"
-    | "uri-template"
-    | "url"
-    | "date-time"
-    | "date"
-    | "time"
-    | "duration"
-    | "json-pointer"
-    | "relative-json-pointer";
-}
-
-type PascalizeString<Key extends string> = Key extends `-${infer R}`
-  ? `${PascalizeString<R>}`
-  : Key extends `${infer _F}-${infer _R}`
-    ? PascalizeSnakeString<Key>
-    : Capitalize<Key>;
-type PascalizeSnakeString<Key extends string> = Key extends `-${infer R}`
-  ? PascalizeSnakeString<R>
-  : Key extends `${infer F}${infer M}-${infer R}`
-    ? `${Uppercase<F>}${Lowercase<M>}${PascalizeSnakeString<R>}`
-    : Key extends `${infer F}${infer R}`
-      ? `${Uppercase<F>}${Lowercase<R>}`
-      : Key;
+import type { TagBase } from "./TagBase";
+
+/**
+ * String format validation constraint.
+ *
+ * `Format<Value>` validates strings against predefined formats (email, uuid,
+ * url, date-time, etc.). Mutually exclusive with {@link Pattern}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template Value Format identifier (see {@link Format.Value} for options)
+ */
+export type Format<Value extends Format.Value> = TagBase<{
+  target: "string";
+  kind: "format";
+  value: Value;
+  validate: `$importInternal("isFormat${PascalizeString<Value>}")($input)`;
+  exclusive: ["format", "pattern"];
+  schema: {
+    format: Value;
+  };
+}>;
+export namespace Format {
+  /**
+   * Supported format identifiers.
+   *
+   * Standard JSON Schema formats:
+   *
+   * - `email`, `idn-email`: Email addresses
+   * - `hostname`, `idn-hostname`: Hostnames
+   * - `uri`, `uri-reference`, `uri-template`, `url`: URLs
+   * - `iri`, `iri-reference`: Internationalized URLs
+   * - `uuid`: UUID strings
+   * - `ipv4`, `ipv6`: IP addresses
+   * - `date-time`, `date`, `time`, `duration`: Date/time formats
+   * - `json-pointer`, `relative-json-pointer`: JSON pointers
+   * - `regex`: Regular expression patterns
+   * - `byte`: Base64-encoded data
+   * - `password`: Password fields (for documentation only)
+   */
+  export type Value =
+    | "byte"
+    | "password"
+    | "regex"
+    | "uuid"
+    | "email"
+    | "hostname"
+    | "idn-email"
+    | "idn-hostname"
+    | "iri"
+    | "iri-reference"
+    | "ipv4"
+    | "ipv6"
+    | "uri"
+    | "uri-reference"
+    | "uri-template"
+    | "url"
+    | "date-time"
+    | "date"
+    | "time"
+    | "duration"
+    | "json-pointer"
+    | "relative-json-pointer";
+}
+
+type PascalizeString<Key extends string> = Key extends `-${infer R}`
+  ? `${PascalizeString<R>}`
+  : Key extends `${infer _F}-${infer _R}`
+    ? PascalizeSnakeString<Key>
+    : Capitalize<Key>;
+type PascalizeSnakeString<Key extends string> = Key extends `-${infer R}`
+  ? PascalizeSnakeString<R>
+  : Key extends `${infer F}${infer M}-${infer R}`
+    ? `${Uppercase<F>}${Lowercase<M>}${PascalizeSnakeString<R>}`
+    : Key extends `${infer F}${infer R}`
+      ? `${Uppercase<F>}${Lowercase<R>}`
+      : Key;