@typia/interface 12.0.0-dev.20260225

package/lib/typings/ClassProperties.d.ts

@@ -0,0 +1,14 @@
+import { OmitNever } from "./OmitNever";
+/**
+ * Extracts non-function properties from a class type.
+ *
+ * `ClassProperties<T>` filters out all method properties from a class, keeping
+ * only data properties. Useful for serialization where methods should be
+ * excluded.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target class type
+ */
+export type ClassProperties<T extends object> = OmitNever<{
+    [K in keyof T]: T[K] extends Function ? never : T[K];
+}>;

package/lib/typings/ClassProperties.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ClassProperties.js.map

package/lib/typings/ClassProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassProperties.js","sourceRoot":"","sources":["../../src/typings/ClassProperties.ts"],"names":[],"mappings":""}

package/lib/typings/OmitNever.d.ts

@@ -0,0 +1,11 @@
+import { SpecialFields } from "./SpecialFields";
+/**
+ * Omits properties with `never` type from an object type.
+ *
+ * `OmitNever<T>` removes all properties whose value type is `never`, producing
+ * a cleaner type without impossible properties.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target object type
+ */
+export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;

package/lib/typings/OmitNever.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=OmitNever.js.map

package/lib/typings/OmitNever.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OmitNever.js","sourceRoot":"","sources":["../../src/typings/OmitNever.ts"],"names":[],"mappings":""}

package/lib/typings/PascalCase.d.ts

@@ -0,0 +1,25 @@
+import { Equal } from "./internal/Equal";
+import { IsTuple } from "./internal/IsTuple";
+import { NativeClass } from "./internal/NativeClass";
+import { ValueOf } from "./internal/ValueOf";
+/**
+ * Converts all object keys to PascalCase.
+ *
+ * `PascalCase<T>` transforms object property names to PascalCase format and
+ * erases methods like {@link Resolved}. Recursively processes nested
+ * structures.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to transform
+ */
+export type PascalCase<T> = Equal<T, PascalizeMain<T>> extends true ? T : PascalizeMain<T>;
+type PascalizeMain<T> = T extends [never] ? never : T extends {
+    valueOf(): boolean | bigint | number | string;
+} ? ValueOf<T> : T extends Function ? never : T extends object ? PascalizeObject<T> : T;
+type PascalizeObject<T extends object> = T extends Array<infer U> ? IsTuple<T> extends true ? PascalizeTuple<T> : PascalizeMain<U>[] : T extends Set<infer U> ? Set<PascalizeMain<U>> : T extends Map<infer K, infer V> ? Map<PascalizeMain<K>, PascalizeMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends NativeClass ? T : {
+    [Key in keyof T as PascalizeString<Key & string>]: PascalizeMain<T[Key]>;
+};
+type PascalizeTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [PascalizeMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [PascalizeMain<F>, ...PascalizeTuple<Rest>] : T extends [(infer F)?] ? [PascalizeMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [PascalizeMain<F>?, ...PascalizeTuple<Rest>] : [];
+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;
+export {};

package/lib/typings/PascalCase.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PascalCase.js.map

package/lib/typings/PascalCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PascalCase.js","sourceRoot":"","sources":["../../src/typings/PascalCase.ts"],"names":[],"mappings":""}

package/lib/typings/Primitive.d.ts

@@ -0,0 +1,29 @@
+import { Format } from "../tags/Format";
+import { Equal } from "./internal/Equal";
+import { IsTuple } from "./internal/IsTuple";
+import { NativeClass } from "./internal/NativeClass";
+import { ValueOf } from "./internal/ValueOf";
+/**
+ * Converts a type to its JSON-serializable primitive form.
+ *
+ * `Primitive<T>` transforms types for JSON serialization: boxed primitives
+ * become primitives (Boolean→boolean), classes become plain objects with
+ * methods removed, Date becomes `string & Format<"date-time">`, and types with
+ * `toJSON()` use their return type. Native classes (except Date) and bigint
+ * become `never` as they're not JSON-serializable.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ * @author Michael - https://github.com/8471919
+ * @template T Target type to convert
+ */
+export type Primitive<T> = Equal<T, PrimitiveMain<T>> extends true ? T : PrimitiveMain<T>;
+type PrimitiveMain<Instance> = Instance extends [never] ? never : ValueOf<Instance> extends bigint ? never : ValueOf<Instance> extends boolean | number | string ? ValueOf<Instance> : Instance extends Function ? never : ValueOf<Instance> extends object ? Instance extends object ? Instance extends Date ? string & Format<"date-time"> : Instance extends IJsonable<infer Raw> ? ValueOf<Raw> extends object ? Raw extends object ? PrimitiveObject<Raw> : never : ValueOf<Raw> : Instance extends Exclude<NativeClass, Date> ? never : PrimitiveObject<Instance> : never : ValueOf<Instance>;
+type PrimitiveObject<Instance extends object> = Instance extends Array<infer T> ? IsTuple<Instance> extends true ? PrimitiveTuple<Instance> : PrimitiveMain<T>[] : {
+    [P in keyof Instance]: PrimitiveMain<Instance[P]>;
+};
+type PrimitiveTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [PrimitiveMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [PrimitiveMain<F>, ...PrimitiveTuple<Rest>] : T extends [(infer F)?] ? [PrimitiveMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [PrimitiveMain<F>?, ...PrimitiveTuple<Rest>] : [];
+interface IJsonable<T> {
+    toJSON(): T;
+}
+export {};

package/lib/typings/Primitive.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Primitive.js.map

package/lib/typings/Primitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Primitive.js","sourceRoot":"","sources":["../../src/typings/Primitive.ts"],"names":[],"mappings":""}

package/lib/typings/ProtobufAtomic.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Protocol Buffers atomic (scalar) type names.
+ *
+ * Union of all primitive type identifiers used in Protocol Buffers wire format
+ * encoding/decoding.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type ProtobufAtomic = "bool" | "int32" | "uint32" | "int64" | "uint64" | "float" | "double" | "string";
+export declare namespace ProtobufAtomic {
+    /** Numeric protobuf types (integers and floats). */
+    type Numeric = "int32" | "uint32" | "int64" | "uint64" | "float" | "double";
+    /** 64-bit integer types that map to JavaScript `bigint`. */
+    type BigNumeric = "int64" | "uint64";
+}

package/lib/typings/ProtobufAtomic.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProtobufAtomic.js.map

package/lib/typings/ProtobufAtomic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufAtomic.js","sourceRoot":"","sources":["../../src/typings/ProtobufAtomic.ts"],"names":[],"mappings":""}

package/lib/typings/Resolved.d.ts

@@ -0,0 +1,23 @@
+import { Equal } from "./internal/Equal";
+import { IsTuple } from "./internal/IsTuple";
+import { NativeClass } from "./internal/NativeClass";
+import { ValueOf } from "./internal/ValueOf";
+/**
+ * Converts a type to its resolved form by erasing all methods.
+ *
+ * `Resolved<T>` transforms classes to plain objects, extracts primitive values
+ * from boxed types (Boolean→boolean, Number→number, String→string), and
+ * recursively processes nested structures. Native classes (Date, Set, Map,
+ * etc.) are preserved unchanged.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ * @template T Target type to resolve
+ */
+export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true ? T : ResolvedMain<T>;
+type ResolvedMain<T> = T extends [never] ? never : ValueOf<T> extends boolean | number | bigint | string ? ValueOf<T> : T extends Function ? never : T extends object ? ResolvedObject<T> : ValueOf<T>;
+type ResolvedObject<T extends object> = T extends Array<infer U> ? IsTuple<T> extends true ? ResolvedTuple<T> : ResolvedMain<U>[] : T extends Set<infer U> ? Set<ResolvedMain<U>> : T extends Map<infer K, infer V> ? Map<ResolvedMain<K>, ResolvedMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends NativeClass ? T : {
+    [P in keyof T]: ResolvedMain<T[P]>;
+};
+type ResolvedTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [ResolvedMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [ResolvedMain<F>, ...ResolvedTuple<Rest>] : T extends [(infer F)?] ? [ResolvedMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>] : [];
+export {};

package/lib/typings/Resolved.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Resolved.js.map

package/lib/typings/Resolved.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resolved.js","sourceRoot":"","sources":["../../src/typings/Resolved.ts"],"names":[],"mappings":""}

package/lib/typings/SnakeCase.d.ts

@@ -0,0 +1,31 @@
+import { Equal } from "./internal/Equal";
+import { NativeClass } from "./internal/NativeClass";
+import { ValueOf } from "./internal/ValueOf";
+/**
+ * Converts all object keys to snake_case.
+ *
+ * `SnakeCase<T>` transforms object property names to snake_case format and
+ * erases methods like {@link Resolved}. Recursively processes nested
+ * structures.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to transform
+ */
+export type SnakeCase<T> = Equal<T, SnakageMain<T>> extends true ? T : SnakageMain<T>;
+type SnakageMain<T> = T extends [never] ? never : T extends {
+    valueOf(): boolean | bigint | number | string;
+} ? ValueOf<T> : T extends Function ? never : T extends object ? SnakageObject<T> : T;
+type SnakageObject<T extends object> = T extends Array<infer U> ? IsTuple<T> extends true ? SnakageTuple<T> : SnakageMain<U>[] : T extends Set<infer U> ? Set<SnakageMain<U>> : T extends Map<infer K, infer V> ? Map<SnakageMain<K>, SnakageMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends NativeClass ? T : {
+    [Key in keyof T as SnakageString<Key & string>]: SnakageMain<T[Key]>;
+};
+type IsTuple<T extends readonly any[] | {
+    length: number;
+}> = [T] extends [
+    never
+] ? false : T extends readonly any[] ? number extends T["length"] ? false : true : false;
+type SnakageTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [SnakageMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [SnakageMain<F>, ...SnakageTuple<Rest>] : T extends [(infer F)?] ? [SnakageMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [SnakageMain<F>?, ...SnakageTuple<Rest>] : [];
+type SnakageString<Key extends string> = Key extends `${infer _}` ? SnakageStringRepeatedly<Key, ""> : Key;
+type SnakageStringRepeatedly<S extends string, Previous extends string> = S extends `${infer First}${infer Second}${infer Rest}` ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<First, Second>}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}` : S extends `${infer First}` ? `${Underscore<Previous, First>}${Lowercase<First>}` : "";
+type Underscore<First extends string, Second extends string> = First extends UpperAlphabetic | "" | "_" ? "" : Second extends UpperAlphabetic ? "_" : "";
+type UpperAlphabetic = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+export {};

package/lib/typings/SnakeCase.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SnakeCase.js.map

package/lib/typings/SnakeCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnakeCase.js","sourceRoot":"","sources":["../../src/typings/SnakeCase.ts"],"names":[],"mappings":""}

package/lib/typings/SpecialFields.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Extracts property keys whose value type extends the target type.
+ *
+ * `SpecialFields<Instance, Target>` returns a union of property names from
+ * `Instance` where the property value extends `Target`.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template Instance Source object type
+ * @template Target Target value type to match
+ */
+export type SpecialFields<Instance extends object, Target> = {
+    [P in keyof Instance]: Instance[P] extends Target ? P : never;
+}[keyof Instance & string];

package/lib/typings/SpecialFields.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SpecialFields.js.map

package/lib/typings/SpecialFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecialFields.js","sourceRoot":"","sources":["../../src/typings/SpecialFields.ts"],"names":[],"mappings":""}

package/lib/typings/ValidationPipe.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Discriminated union for validation results.
+ *
+ * `ValidationPipe<T, E>` represents either a successful validation with data of
+ * type `T`, or a failed validation with an array of errors of type `E`. Use the
+ * `success` discriminant to narrow the type.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Success data type
+ * @template E Error type
+ */
+export type ValidationPipe<T, E> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    errors: E[];
+};

package/lib/typings/ValidationPipe.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ValidationPipe.js.map

package/lib/typings/ValidationPipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationPipe.js","sourceRoot":"","sources":["../../src/typings/ValidationPipe.ts"],"names":[],"mappings":""}

package/lib/typings/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./AssertionGuard";
+export * from "./CamelCase";
+export * from "./PascalCase";
+export * from "./Primitive";
+export * from "./Resolved";
+export * from "./SnakeCase";
+export * from "./Atomic";
+export * from "./ClassProperties";
+export * from "./OmitNever";
+export * from "./ProtobufAtomic";
+export * from "./SpecialFields";
+export * from "./ValidationPipe";

package/lib/typings/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AssertionGuard"), exports);
+__exportStar(require("./CamelCase"), exports);
+__exportStar(require("./PascalCase"), exports);
+__exportStar(require("./Primitive"), exports);
+__exportStar(require("./Resolved"), exports);
+__exportStar(require("./SnakeCase"), exports);
+__exportStar(require("./Atomic"), exports);
+__exportStar(require("./ClassProperties"), exports);
+__exportStar(require("./OmitNever"), exports);
+__exportStar(require("./ProtobufAtomic"), exports);
+__exportStar(require("./SpecialFields"), exports);
+__exportStar(require("./ValidationPipe"), exports);
+//# sourceMappingURL=index.js.map

package/lib/typings/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/typings/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mDAAiC;AACjC,8CAA4B;AAC5B,+CAA6B;AAC7B,8CAA4B;AAC5B,6CAA2B;AAC3B,8CAA4B;AAE5B,2CAAyB;AACzB,oDAAkC;AAClC,8CAA4B;AAC5B,mDAAiC;AACjC,kDAAgC;AAChC,mDAAiC"}

package/lib/typings/internal/Equal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks if two types are exactly equal.
+ *
+ * `Equal<X, Y>` returns `true` if types X and Y are identical, `false`
+ * otherwise. Works with any TypeScript types including unions.
+ *
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ * @template X First type to compare
+ * @template Y Second type to compare
+ */
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;

package/lib/typings/internal/Equal.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Equal.js.map

package/lib/typings/internal/Equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Equal.js","sourceRoot":"","sources":["../../../src/typings/internal/Equal.ts"],"names":[],"mappings":""}

package/lib/typings/internal/IsTuple.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks if an array type is a tuple (fixed length) or regular array.
+ *
+ * Returns `true` for tuple types like `[string, number]` where length is fixed,
+ * and `false` for array types like `string[]` where length is variable.
+ *
+ * @template T Array or tuple type to check
+ */
+export type IsTuple<T extends readonly any[] | {
+    length: number;
+}> = [
+    T
+] extends [never] ? false : T extends readonly any[] ? number extends T["length"] ? false : true : false;

package/lib/typings/internal/IsTuple.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IsTuple.js.map

package/lib/typings/internal/IsTuple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsTuple.js","sourceRoot":"","sources":["../../../src/typings/internal/IsTuple.ts"],"names":[],"mappings":""}

package/lib/typings/internal/NativeClass.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Union of JavaScript built-in class types.
+ *
+ * `NativeClass` includes Date, collections (Set, Map, WeakSet, WeakMap), typed
+ * arrays (Uint8Array, Int32Array, etc.), binary data types (ArrayBuffer,
+ * DataView, Blob, File), and RegExp. These types receive special handling in
+ * typia's serialization and validation.
+ */
+export type NativeClass = Date | Set<any> | Map<any, any> | WeakSet<any> | WeakMap<any, any> | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array | ArrayBuffer | SharedArrayBuffer | DataView | Blob | File | RegExp;

package/lib/typings/internal/NativeClass.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=NativeClass.js.map

package/lib/typings/internal/NativeClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeClass.js","sourceRoot":"","sources":["../../../src/typings/internal/NativeClass.ts"],"names":[],"mappings":""}

package/lib/typings/internal/ValueOf.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Extracts the primitive value type from boxed primitives.
+ *
+ * `ValueOf<Instance>` converts boxed primitive types (Boolean, Number, String)
+ * to their primitive equivalents (boolean, number, string). Non-boxed types are
+ * returned unchanged.
+ *
+ * @template Instance Type to extract primitive from
+ */
+export type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true ? boolean : IsValueOf<Instance, Number> extends true ? number : IsValueOf<Instance, String> extends true ? string : Instance;
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object ? Object extends IValueOf<infer Primitive> ? Instance extends Primitive ? false : true : false : false;
+interface IValueOf<T> {
+    valueOf(): T;
+}
+export {};

package/lib/typings/internal/ValueOf.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ValueOf.js.map

package/lib/typings/internal/ValueOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueOf.js","sourceRoot":"","sources":["../../../src/typings/internal/ValueOf.ts"],"names":[],"mappings":""}

package/lib/utils/IRandomGenerator.d.ts

@@ -0,0 +1,68 @@
+import { OpenApi } from "../openapi/OpenApi";
+/**
+ * Random value generator interface for typia.
+ *
+ * `IRandomGenerator` defines methods for generating random values of various
+ * types. Used by `typia.random<T>()` for mock data generation.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export interface IRandomGenerator {
+    /** Generates a random boolean. */
+    boolean(): boolean | undefined;
+    /** Generates a random number within schema constraints. */
+    number(schema: OpenApi.IJsonSchema.INumber): number;
+    /** Generates a random integer within schema constraints. */
+    integer(schema: OpenApi.IJsonSchema.IInteger): number;
+    /** Generates a random bigint within schema constraints. */
+    bigint(schema: OpenApi.IJsonSchema.IInteger): bigint;
+    /** Generates a random string within schema constraints. */
+    string(schema: OpenApi.IJsonSchema.IString): string;
+    /** Generates a random array with elements from the generator function. */
+    array<T>(schema: Omit<OpenApi.IJsonSchema.IArray, "items"> & {
+        element: (index: number, count: number) => T;
+    }): T[];
+    /** Generates a random string matching the regex pattern. */
+    pattern(regex: RegExp): string;
+    byte(): string;
+    password(): string;
+    regex(): string;
+    uuid(): string;
+    email(): string;
+    hostname(): string;
+    idnEmail(): string;
+    idnHostname(): string;
+    iri(): string;
+    iriReference(): string;
+    ipv4(): string;
+    ipv6(): string;
+    uri(): string;
+    uriReference(): string;
+    uriTemplate(): string;
+    url(): string;
+    datetime(props?: {
+        minimum?: number;
+        maximum?: number;
+    }): string;
+    date(props?: {
+        minimum?: number;
+        maximum?: number;
+    }): string;
+    time(): string;
+    duration(): string;
+    jsonPointer(): string;
+    relativeJsonPointer(): string;
+}
+export declare namespace IRandomGenerator {
+    /** Custom generators for specific schema properties. */
+    interface CustomMap {
+        string?: (schema: OpenApi.IJsonSchema.IString & Record<string, any>) => string;
+        number?: (schema: OpenApi.IJsonSchema.INumber & Record<string, any>) => number;
+        integer?: (schema: OpenApi.IJsonSchema.IInteger & Record<string, any>) => number;
+        bigint?: (schema: OpenApi.IJsonSchema.IInteger & Record<string, any>) => bigint;
+        boolean?: (schema: Record<string, any>) => boolean | undefined;
+        array?: <T>(schema: Omit<OpenApi.IJsonSchema.IArray, "items"> & {
+            element: (index: number, count: number) => T;
+        } & Record<string, any>) => T[];
+    }
+}

package/lib/utils/IRandomGenerator.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IRandomGenerator.js.map

package/lib/utils/IRandomGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IRandomGenerator.js","sourceRoot":"","sources":["../../src/utils/IRandomGenerator.ts"],"names":[],"mappings":""}

package/lib/utils/IReadableURLSearchParams.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Minimal interface for reading URL query parameters.
+ *
+ * `IReadableURLSearchParams` is a subset of the standard {@link URLSearchParams}
+ * interface, containing only the read operations needed for query parameter
+ * parsing. This interface was designed specifically for compatibility with the
+ * [Hono.js](https://hono.dev/) web framework, which provides its own query
+ * parameter implementation.
+ *
+ * The interface exposes:
+ *
+ * - {@link URLSearchParams.size | size}: Number of parameters
+ * - {@link URLSearchParams.get | get}: Retrieve first value for a key
+ * - {@link URLSearchParams.getAll | getAll}: Retrieve all values for a key
+ *
+ * Use this interface when implementing query parameter handling that needs to
+ * work with both standard `URLSearchParams` and framework-specific
+ * implementations.
+ *
+ * @author https://github.com/miyaji255
+ */
+export type IReadableURLSearchParams = Pick<URLSearchParams, "size" | "get" | "getAll">;

package/lib/utils/IReadableURLSearchParams.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IReadableURLSearchParams.js.map

package/lib/utils/IReadableURLSearchParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IReadableURLSearchParams.js","sourceRoot":"","sources":["../../src/utils/IReadableURLSearchParams.ts"],"names":[],"mappings":""}

package/lib/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IRandomGenerator";
+export * from "./IReadableURLSearchParams";

package/lib/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IRandomGenerator"), exports);
+__exportStar(require("./IReadableURLSearchParams"), exports);
+//# sourceMappingURL=index.js.map

package/lib/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qDAAmC;AACnC,6DAA2C"}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@typia/interface",
+  "version": "12.0.0-dev.20260225",
+  "description": "Superfast runtime validators with only one line",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samchon/typia"
+  },
+  "author": "Jeongho Nam",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/samchon/typia/issues"
+  },
+  "homepage": "https://typia.io",
+  "devDependencies": {
+    "rimraf": "^6.1.2",
+    "typescript": "~5.9.3"
+  },
+  "sideEffects": false,
+  "files": [
+    "LICENSE",
+    "README.md",
+    "package.json",
+    "lib",
+    "src"
+  ],
+  "keywords": [
+    "fast",
+    "json",
+    "stringify",
+    "typescript",
+    "transform",
+    "ajv",
+    "io-ts",
+    "zod",
+    "schema",
+    "json-schema",
+    "generator",
+    "assert",
+    "clone",
+    "is",
+    "validate",
+    "equal",
+    "runtime",
+    "type",
+    "typebox",
+    "checker",
+    "validator",
+    "safe",
+    "parse",
+    "prune",
+    "random",
+    "protobuf",
+    "llm",
+    "llm-function-calling",
+    "structured-output",
+    "openai",
+    "chatgpt",
+    "claude",
+    "gemini",
+    "llama"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf lib && tsc",
+    "dev": "rimraf lib && tsc --watch"
+  },
+  "types": "lib/index.d.ts"
+}