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

package/src/tags/MultipleOf.ts

@@ -1,54 +1,54 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Divisibility constraint (value % divisor === 0).
- *
- * `MultipleOf<N>` is a type tag that validates numeric values are exactly
- * divisible by the specified divisor with no remainder. Apply it to `number` or
- * `bigint` properties using TypeScript intersection types.
- *
- * Common use cases:
- *
- * - `MultipleOf<2>` for even numbers
- * - `MultipleOf<0.01>` for currency with 2 decimal places
- * - `MultipleOf<100>` for values in hundreds
- *
- * This constraint can be combined with other numeric constraints like
- * {@link Minimum} and {@link Maximum}. Multiple `MultipleOf` constraints on the
- * same property are allowed (all must pass).
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It generates `multipleOf` in JSON Schema output.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Currency {
- *     // Must be exact cents (0.01, 0.02, ..., 1.00, 1.01, ...)
- *     amount: number & MultipleOf<0.01>;
- *   }
- *   interface Pagination {
- *     // Page size must be multiple of 10
- *     pageSize: number & MultipleOf<10>;
- *   }
- *
- * @template Value The divisor (value must be evenly divisible by this)
- */
-export type MultipleOf<Value extends number | bigint> = TagBase<{
-  target: Value extends bigint ? "bigint" : "number";
-  kind: "multipleOf";
-  value: Value;
-  validate: `$input % ${Cast<Value>} === ${Value extends bigint
-    ? Cast<0n>
-    : 0}`;
-  exclusive: true;
-  schema: Value extends bigint
-    ? { multipleOf: Numeric<Value> }
-    : { multipleOf: 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";
+
+/**
+ * Divisibility constraint (value % divisor === 0).
+ *
+ * `MultipleOf<N>` is a type tag that validates numeric values are exactly
+ * divisible by the specified divisor with no remainder. Apply it to `number` or
+ * `bigint` properties using TypeScript intersection types.
+ *
+ * Common use cases:
+ *
+ * - `MultipleOf<2>` for even numbers
+ * - `MultipleOf<0.01>` for currency with 2 decimal places
+ * - `MultipleOf<100>` for values in hundreds
+ *
+ * This constraint can be combined with other numeric constraints like
+ * {@link Minimum} and {@link Maximum}. Multiple `MultipleOf` constraints on the
+ * same property are allowed (all must pass).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `multipleOf` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Currency {
+ *     // Must be exact cents (0.01, 0.02, ..., 1.00, 1.01, ...)
+ *     amount: number & MultipleOf<0.01>;
+ *   }
+ *   interface Pagination {
+ *     // Page size must be multiple of 10
+ *     pageSize: number & MultipleOf<10>;
+ *   }
+ *
+ * @template Value The divisor (value must be evenly divisible by this)
+ */
+export type MultipleOf<Value extends number | bigint> = TagBase<{
+  target: Value extends bigint ? "bigint" : "number";
+  kind: "multipleOf";
+  value: Value;
+  validate: `$input % ${Cast<Value>} === ${Value extends bigint
+    ? Cast<0n>
+    : 0}`;
+  exclusive: true;
+  schema: Value extends bigint
+    ? { multipleOf: Numeric<Value> }
+    : { multipleOf: 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/Pattern.ts

@@ -1,59 +1,59 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Regular expression pattern constraint for strings.
- *
- * `Pattern<Regex>` is a type tag that validates string values match the
- * specified regular expression pattern. Apply it to `string` properties using
- * TypeScript intersection types.
- *
- * This constraint is **mutually exclusive** with {@link Format} - you cannot use
- * both on the same property. Use `Pattern` for custom regex validation, or
- * `Format` for standard formats (email, uuid, etc.).
- *
- * The pattern should be a valid JavaScript regular expression string without
- * the surrounding slashes. The entire string must match (implicit `^` and `$`
- * anchors).
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It generates `pattern` in JSON Schema output.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Product {
- *     // SKU format: 3 letters, dash, 4 digits
- *     sku: string & Pattern<"^[A-Z]{3}-[0-9]{4}$">;
- *     // Phone number: digits and optional dashes
- *     phone: string & Pattern<"^[0-9-]+$">;
- *   }
- *
- * @template Value Regular expression pattern as a string literal
- */
-export type Pattern<Value extends string> = TagBase<{
-  target: "string";
-  kind: "pattern";
-  value: Value;
-  validate: `RegExp("${Serialize<Value>}").test($input)`;
-  exclusive: ["format", "pattern"];
-  schema: {
-    pattern: Value;
-  };
-}>;
-
-type Serialize<T extends string, Output extends string = ""> = string extends T
-  ? never
-  : T extends ""
-    ? Output
-    : T extends `${infer P}${infer R}`
-      ? Serialize<R, `${Output}${P extends keyof Escaper ? Escaper[P] : P}`>
-      : never;
-
-type Escaper = {
-  '"': '\\"';
-  "\\": "\\\\";
-  "\b": "\\b";
-  "\f": "\\f";
-  "\n": "\\n";
-  "\r": "\\r";
-  "\t": "\\t";
-};
+import { TagBase } from "./TagBase";
+
+/**
+ * Regular expression pattern constraint for strings.
+ *
+ * `Pattern<Regex>` is a type tag that validates string values match the
+ * specified regular expression pattern. Apply it to `string` properties using
+ * TypeScript intersection types.
+ *
+ * This constraint is **mutually exclusive** with {@link Format} - you cannot use
+ * both on the same property. Use `Pattern` for custom regex validation, or
+ * `Format` for standard formats (email, uuid, etc.).
+ *
+ * The pattern should be a valid JavaScript regular expression string without
+ * the surrounding slashes. The entire string must match (implicit `^` and `$`
+ * anchors).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `pattern` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Product {
+ *     // SKU format: 3 letters, dash, 4 digits
+ *     sku: string & Pattern<"^[A-Z]{3}-[0-9]{4}$">;
+ *     // Phone number: digits and optional dashes
+ *     phone: string & Pattern<"^[0-9-]+$">;
+ *   }
+ *
+ * @template Value Regular expression pattern as a string literal
+ */
+export type Pattern<Value extends string> = TagBase<{
+  target: "string";
+  kind: "pattern";
+  value: Value;
+  validate: `RegExp("${Serialize<Value>}").test($input)`;
+  exclusive: ["format", "pattern"];
+  schema: {
+    pattern: Value;
+  };
+}>;
+
+type Serialize<T extends string, Output extends string = ""> = string extends T
+  ? never
+  : T extends ""
+    ? Output
+    : T extends `${infer P}${infer R}`
+      ? Serialize<R, `${Output}${P extends keyof Escaper ? Escaper[P] : P}`>
+      : never;
+
+type Escaper = {
+  '"': '\\"';
+  "\\": "\\\\";
+  "\b": "\\b";
+  "\f": "\\f";
+  "\n": "\\n";
+  "\r": "\\r";
+  "\t": "\\t";
+};

package/src/tags/Sequence.ts

@@ -1,43 +1,43 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Protocol Buffer field number assignment.
- *
- * `Sequence<N>` is a type tag that assigns a unique field number for Protocol
- * Buffer serialization. In protobuf, each field in a message must have a unique
- * numeric identifier that's used in the binary encoding.
- *
- * Field number guidelines:
- *
- * - **1-15**: Use one byte in encoding (ideal for frequently-used fields)
- * - **16-2047**: Use two bytes
- * - **2048-536,870,911**: Use more bytes (avoid for efficiency)
- * - **19000-19999**: Reserved by Protocol Buffers (cannot use)
- *
- * If not specified, typia auto-assigns field numbers. Use `Sequence` when you
- * need stable field numbers for backward compatibility or when integrating with
- * existing protobuf schemas.
- *
- * This tag is used by `typia.protobuf.encode()` and `typia.protobuf.decode()`.
- * The field number also appears in JSON Schema as `x-protobuf-sequence`.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Message {
- *     // Frequently accessed fields use low numbers
- *     id: (number & Sequence<1>) & Type<"uint32">;
- *     name: string & Sequence<2>;
- *     // Less common fields use higher numbers
- *     metadata: (Record<string, string> & Sequence<100>) | undefined;
- *   }
- *
- * @template N Field number (1 to 536,870,911, excluding 19000-19999)
- */
-export type Sequence<N extends number> = TagBase<{
-  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
-  kind: "sequence";
-  value: N;
-  schema: {
-    "x-protobuf-sequence": N;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * Protocol Buffer field number assignment.
+ *
+ * `Sequence<N>` is a type tag that assigns a unique field number for Protocol
+ * Buffer serialization. In protobuf, each field in a message must have a unique
+ * numeric identifier that's used in the binary encoding.
+ *
+ * Field number guidelines:
+ *
+ * - **1-15**: Use one byte in encoding (ideal for frequently-used fields)
+ * - **16-2047**: Use two bytes
+ * - **2048-536,870,911**: Use more bytes (avoid for efficiency)
+ * - **19000-19999**: Reserved by Protocol Buffers (cannot use)
+ *
+ * If not specified, typia auto-assigns field numbers. Use `Sequence` when you
+ * need stable field numbers for backward compatibility or when integrating with
+ * existing protobuf schemas.
+ *
+ * This tag is used by `typia.protobuf.encode()` and `typia.protobuf.decode()`.
+ * The field number also appears in JSON Schema as `x-protobuf-sequence`.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Message {
+ *     // Frequently accessed fields use low numbers
+ *     id: (number & Sequence<1>) & Type<"uint32">;
+ *     name: string & Sequence<2>;
+ *     // Less common fields use higher numbers
+ *     metadata: (Record<string, string> & Sequence<100>) | undefined;
+ *   }
+ *
+ * @template N Field number (1 to 536,870,911, excluding 19000-19999)
+ */
+export type Sequence<N extends number> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  kind: "sequence";
+  value: N;
+  schema: {
+    "x-protobuf-sequence": N;
+  };
+}>;

package/src/tags/TagBase.ts

@@ -1,131 +1,131 @@
-/**
- * Base type for all typia validation tags.
- *
- * `TagBase` is the foundation for all typia type tags (constraints like
- * `Minimum`, `MaxLength`, `Format`, etc.). It attaches compile-time metadata to
- * TypeScript types using a phantom property pattern.
- *
- * The typia transformer reads these tags at compile time and generates
- * appropriate runtime validation code. The tags themselves have no runtime
- * presence - they exist only in the type system.
- *
- * This is an internal implementation detail. Use the specific tag types (e.g.,
- * {@link Minimum}, {@link Format}, {@link Pattern}) rather than `TagBase`
- * directly.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template Props Tag properties defining validation behavior and schema output
- */
-export type TagBase<
-  Props extends TagBase.IProps<any, any, any, any, any, any>,
-> = {
-  /**
-   * Compile-time marker property for typia transformer.
-   *
-   * This phantom property carries tag metadata in the type system. It is never
-   * assigned at runtime - it exists only for the transformer to read during
-   * compilation.
-   */
-  "typia.tag"?: Props;
-};
-export namespace TagBase {
-  /**
-   * Configuration interface for validation tag properties.
-   *
-   * Defines all the metadata a validation tag can specify, including what types
-   * it applies to, how to validate values, and what to output in JSON Schema.
-   *
-   * @template Target Which primitive type(s) this tag can be applied to
-   * @template Kind Unique identifier for this tag type
-   * @template Value The constraint value specified by the user
-   * @template Validate The validation expression to generate
-   * @template Exclusive Whether this tag conflicts with others
-   * @template Schema Additional JSON Schema properties to output
-   */
-  export interface IProps<
-    Target extends
-      | "boolean"
-      | "bigint"
-      | "number"
-      | "string"
-      | "array"
-      | "object",
-    Kind extends string,
-    Value extends boolean | bigint | number | string | undefined,
-    Validate extends
-      | string
-      | {
-          [key in Target]?: string;
-        },
-    Exclusive extends boolean | string[],
-    Schema extends object | undefined,
-  > {
-    /**
-     * Target primitive type(s) this tag applies to.
-     *
-     * The transformer will error if the tag is applied to a property of a
-     * different type. For example, `MinLength` targets `"string"` and cannot be
-     * applied to numbers.
-     */
-    target: Target;
-
-    /**
-     * Unique identifier for this tag type.
-     *
-     * Used internally to identify the constraint kind. Examples: `"minimum"`,
-     * `"maxLength"`, `"format"`, `"pattern"`.
-     */
-    kind: Kind;
-
-    /**
-     * User-configured constraint value.
-     *
-     * The value provided by the user when applying the tag. For `Minimum<5>`,
-     * this would be `5`. For `Format<"email">`, this would be `"email"`.
-     */
-    value: Value;
-
-    /**
-     * Validation expression template.
-     *
-     * JavaScript expression string that validates the input value. Use `$input`
-     * as a placeholder for the actual value. The expression is inserted into
-     * the generated validation function.
-     *
-     * Can be a single string or an object mapping target types to different
-     * expressions (for tags supporting multiple types).
-     *
-     * @example
-     *   `"5 <= $input"`; // For Minimum<5>
-     *
-     * @example
-     *   `"$input.length <= 10"`; // For MaxLength<10>
-     */
-    validate?: Validate;
-
-    /**
-     * Tag exclusivity configuration.
-     *
-     * Controls which other tags cannot be combined with this one:
-     *
-     * - `true`: No duplicate tags of the same kind allowed
-     * - `string[]`: List of incompatible tag kinds
-     * - `false` (default): No exclusivity restrictions
-     *
-     * For example, `Minimum` and `ExclusiveMinimum` are mutually exclusive -
-     * only one can be applied to a property.
-     *
-     * @default false
-     */
-    exclusive?: Exclusive | string[];
-
-    /**
-     * Additional JSON Schema properties to output.
-     *
-     * Object containing schema properties to merge into the generated JSON
-     * Schema for the annotated type. For `Minimum<5>`, this would be `{
-     * minimum: 5 }`.
-     */
-    schema?: Schema;
-  }
-}
+/**
+ * Base type for all typia validation tags.
+ *
+ * `TagBase` is the foundation for all typia type tags (constraints like
+ * `Minimum`, `MaxLength`, `Format`, etc.). It attaches compile-time metadata to
+ * TypeScript types using a phantom property pattern.
+ *
+ * The typia transformer reads these tags at compile time and generates
+ * appropriate runtime validation code. The tags themselves have no runtime
+ * presence - they exist only in the type system.
+ *
+ * This is an internal implementation detail. Use the specific tag types (e.g.,
+ * {@link Minimum}, {@link Format}, {@link Pattern}) rather than `TagBase`
+ * directly.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template Props Tag properties defining validation behavior and schema output
+ */
+export type TagBase<
+  Props extends TagBase.IProps<any, any, any, any, any, any>,
+> = {
+  /**
+   * Compile-time marker property for typia transformer.
+   *
+   * This phantom property carries tag metadata in the type system. It is never
+   * assigned at runtime - it exists only for the transformer to read during
+   * compilation.
+   */
+  "typia.tag"?: Props;
+};
+export namespace TagBase {
+  /**
+   * Configuration interface for validation tag properties.
+   *
+   * Defines all the metadata a validation tag can specify, including what types
+   * it applies to, how to validate values, and what to output in JSON Schema.
+   *
+   * @template Target Which primitive type(s) this tag can be applied to
+   * @template Kind Unique identifier for this tag type
+   * @template Value The constraint value specified by the user
+   * @template Validate The validation expression to generate
+   * @template Exclusive Whether this tag conflicts with others
+   * @template Schema Additional JSON Schema properties to output
+   */
+  export interface IProps<
+    Target extends
+      | "boolean"
+      | "bigint"
+      | "number"
+      | "string"
+      | "array"
+      | "object",
+    Kind extends string,
+    Value extends boolean | bigint | number | string | undefined,
+    Validate extends
+      | string
+      | {
+          [key in Target]?: string;
+        },
+    Exclusive extends boolean | string[],
+    Schema extends object | undefined,
+  > {
+    /**
+     * Target primitive type(s) this tag applies to.
+     *
+     * The transformer will error if the tag is applied to a property of a
+     * different type. For example, `MinLength` targets `"string"` and cannot be
+     * applied to numbers.
+     */
+    target: Target;
+
+    /**
+     * Unique identifier for this tag type.
+     *
+     * Used internally to identify the constraint kind. Examples: `"minimum"`,
+     * `"maxLength"`, `"format"`, `"pattern"`.
+     */
+    kind: Kind;
+
+    /**
+     * User-configured constraint value.
+     *
+     * The value provided by the user when applying the tag. For `Minimum<5>`,
+     * this would be `5`. For `Format<"email">`, this would be `"email"`.
+     */
+    value: Value;
+
+    /**
+     * Validation expression template.
+     *
+     * JavaScript expression string that validates the input value. Use `$input`
+     * as a placeholder for the actual value. The expression is inserted into
+     * the generated validation function.
+     *
+     * Can be a single string or an object mapping target types to different
+     * expressions (for tags supporting multiple types).
+     *
+     * @example
+     *   `"5 <= $input"`; // For Minimum<5>
+     *
+     * @example
+     *   `"$input.length <= 10"`; // For MaxLength<10>
+     */
+    validate?: Validate;
+
+    /**
+     * Tag exclusivity configuration.
+     *
+     * Controls which other tags cannot be combined with this one:
+     *
+     * - `true`: No duplicate tags of the same kind allowed
+     * - `string[]`: List of incompatible tag kinds
+     * - `false` (default): No exclusivity restrictions
+     *
+     * For example, `Minimum` and `ExclusiveMinimum` are mutually exclusive -
+     * only one can be applied to a property.
+     *
+     * @default false
+     */
+    exclusive?: Exclusive | string[];
+
+    /**
+     * Additional JSON Schema properties to output.
+     *
+     * Object containing schema properties to merge into the generated JSON
+     * Schema for the annotated type. For `Minimum<5>`, this would be `{
+     * minimum: 5 }`.
+     */
+    schema?: Schema;
+  }
+}