@typia/interface 12.0.0-dev.20260225

package/lib/tags/MinLength.d.ts

@@ -0,0 +1,36 @@
+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/lib/tags/MinLength.js

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

package/lib/tags/MinLength.js.map

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

package/lib/tags/Minimum.d.ts

@@ -0,0 +1,41 @@
+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;
+export {};

package/lib/tags/Minimum.js

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

package/lib/tags/Minimum.js.map

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

package/lib/tags/MultipleOf.d.ts

@@ -0,0 +1,49 @@
+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;
+export {};

package/lib/tags/MultipleOf.js

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

package/lib/tags/MultipleOf.js.map

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

package/lib/tags/Pattern.d.ts

@@ -0,0 +1,51 @@
+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";
+};
+export {};

package/lib/tags/Pattern.js

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

package/lib/tags/Pattern.js.map

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

package/lib/tags/Sequence.d.ts

@@ -0,0 +1,42 @@
+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/lib/tags/Sequence.js

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

package/lib/tags/Sequence.js.map

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

package/lib/tags/TagBase.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 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 declare 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
+     */
+    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;
+    }
+}

package/lib/tags/TagBase.js

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

package/lib/tags/TagBase.js.map

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

package/lib/tags/Type.d.ts

@@ -0,0 +1,53 @@
+import { TagBase } from "./TagBase";
+/**
+ * Numeric precision and bit-width type constraint.
+ *
+ * `Type<Value>` is a type tag that constrains numeric values to specific
+ * bit-width representations. This is essential for Protocol Buffers
+ * serialization and ensures values fit within their specified ranges.
+ *
+ * Available types:
+ *
+ * - `"int32"`: Signed 32-bit integer (-2,147,483,648 to 2,147,483,647)
+ * - `"uint32"`: Unsigned 32-bit integer (0 to 4,294,967,295)
+ * - `"int64"`: Signed 64-bit integer (for `number` or `bigint`)
+ * - `"uint64"`: Unsigned 64-bit integer (for `number` or `bigint`)
+ * - `"float"`: 32-bit floating point
+ * - `"double"`: 64-bit floating point (default JavaScript number)
+ *
+ * For Protocol Buffers, integer types also determine the wire encoding. The
+ * constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates appropriate `type` in JSON Schema.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Message {
+ *     // 32-bit unsigned integer
+ *     id: number & Type<"uint32">;
+ *     // 64-bit signed integer as bigint
+ *     timestamp: bigint & Type<"int64">;
+ *     // 32-bit float for memory efficiency
+ *     score: number & Type<"float">;
+ *   }
+ *
+ * @template Value Numeric type identifier
+ */
+export type Type<Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double"> = TagBase<{
+    target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
+    kind: "type";
+    value: Value;
+    validate: Value extends "int32" ? `$importInternal("isTypeInt32")($input)` : Value extends "uint32" ? `$importInternal("isTypeUint32")($input)` : Value extends "int64" ? {
+        number: `$importInternal("isTypeInt64")($input)`;
+        bigint: `true`;
+    } : Value extends "uint64" ? {
+        number: `$importInternal("isTypeUint64")($input)`;
+        bigint: `BigInt(0) <= $input`;
+    } : Value extends "float" ? `$importInternal("isTypeFloat")($input)` : `true`;
+    exclusive: true;
+    schema: Value extends "uint32" | "uint64" ? {
+        type: "integer";
+        minimum: 0;
+    } : {
+        type: Value extends "int32" | "uint32" | "int64" | "uint64" ? "integer" : "number";
+    };
+}>;

package/lib/tags/Type.js

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

package/lib/tags/Type.js.map

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

package/lib/tags/UniqueItems.d.ts

@@ -0,0 +1,41 @@
+import { TagBase } from "./TagBase";
+/**
+ * Array unique elements constraint.
+ *
+ * `UniqueItems` is a type tag that validates all elements in an array are
+ * unique (no duplicates). Apply it to array properties using TypeScript
+ * intersection types.
+ *
+ * Uniqueness is determined by:
+ *
+ * - **Primitives**: Strict equality (`===`)
+ * - **Objects**: Deep structural comparison
+ *
+ * This constraint is commonly combined with {@link MinItems} and {@link MaxItems}
+ * for comprehensive array validation. It's useful for modeling set-like data
+ * that must be represented as arrays in JSON.
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `uniqueItems: true` in JSON Schema.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Preferences {
+ *     // No duplicate tags allowed
+ *     tags: (string & UniqueItems)[];
+ *     // Unique user IDs
+ *     favoriteUserIds: (number & UniqueItems)[];
+ *   }
+ *
+ * @template Value Boolean flag, defaults to `true` (enable constraint)
+ */
+export type UniqueItems<Value extends boolean = true> = TagBase<{
+    target: "array";
+    kind: "uniqueItems";
+    value: Value;
+    validate: Value extends true ? `$importInternal("isUniqueItems")($input)` : undefined;
+    exclusive: true;
+    schema: {
+        uniqueItems: true;
+    };
+}>;

package/lib/tags/UniqueItems.js

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

package/lib/tags/UniqueItems.js.map

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

package/lib/tags/index.d.ts

@@ -0,0 +1,21 @@
+export * from "./Constant";
+export * from "./ContentMediaType";
+export * from "./Default";
+export * from "./Example";
+export * from "./Examples";
+export * from "./ExclusiveMaximum";
+export * from "./ExclusiveMinimum";
+export * from "./Format";
+export * from "./JsonSchemaPlugin";
+export * from "./Maximum";
+export * from "./MaxItems";
+export * from "./MaxLength";
+export * from "./Minimum";
+export * from "./MinItems";
+export * from "./MinLength";
+export * from "./MultipleOf";
+export * from "./Pattern";
+export * from "./Sequence";
+export * from "./TagBase";
+export * from "./Type";
+export * from "./UniqueItems";

package/lib/tags/index.js

@@ -0,0 +1,38 @@
+"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("./Constant"), exports);
+__exportStar(require("./ContentMediaType"), exports);
+__exportStar(require("./Default"), exports);
+__exportStar(require("./Example"), exports);
+__exportStar(require("./Examples"), exports);
+__exportStar(require("./ExclusiveMaximum"), exports);
+__exportStar(require("./ExclusiveMinimum"), exports);
+__exportStar(require("./Format"), exports);
+__exportStar(require("./JsonSchemaPlugin"), exports);
+__exportStar(require("./Maximum"), exports);
+__exportStar(require("./MaxItems"), exports);
+__exportStar(require("./MaxLength"), exports);
+__exportStar(require("./Minimum"), exports);
+__exportStar(require("./MinItems"), exports);
+__exportStar(require("./MinLength"), exports);
+__exportStar(require("./MultipleOf"), exports);
+__exportStar(require("./Pattern"), exports);
+__exportStar(require("./Sequence"), exports);
+__exportStar(require("./TagBase"), exports);
+__exportStar(require("./Type"), exports);
+__exportStar(require("./UniqueItems"), exports);
+//# sourceMappingURL=index.js.map

package/lib/tags/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tags/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,qDAAmC;AACnC,4CAA0B;AAC1B,4CAA0B;AAC1B,6CAA2B;AAC3B,qDAAmC;AACnC,qDAAmC;AACnC,2CAAyB;AACzB,qDAAmC;AACnC,4CAA0B;AAC1B,6CAA2B;AAC3B,8CAA4B;AAC5B,4CAA0B;AAC1B,6CAA2B;AAC3B,8CAA4B;AAC5B,+CAA6B;AAC7B,4CAA0B;AAC1B,6CAA2B;AAC3B,4CAA0B;AAC1B,yCAAuB;AACvB,gDAA8B"}

package/lib/typings/AssertionGuard.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Type for assertion guard functions that narrow input type.
+ *
+ * `AssertionGuard<T>` is a function type that validates input at runtime and
+ * asserts it as type `T`. Unlike regular assertions that return the value,
+ * assertion guards return void but narrow the input parameter's type.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to assert
+ * @throws {TypeGuardError} When validation fails
+ */
+export type AssertionGuard<T> = (input: unknown) => asserts input is T;

package/lib/typings/AssertionGuard.js

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

package/lib/typings/AssertionGuard.js.map

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

package/lib/typings/Atomic.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Atomic (primitive) type utilities for typia's type system.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare namespace Atomic {
+    /** Union of JavaScript primitive value types. */
+    type Type = boolean | number | string | bigint;
+    /** String literal names for atomic types. */
+    type Literal = "boolean" | "integer" | "number" | "string" | "bigint";
+    /** Maps literal type names to their corresponding value types. */
+    type Mapper = {
+        boolean: boolean;
+        integer: number;
+        number: number;
+        string: string;
+        bigint: bigint;
+    };
+}

package/lib/typings/Atomic.js

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

package/lib/typings/Atomic.js.map

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

package/lib/typings/CamelCase.d.ts

@@ -0,0 +1,26 @@
+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 camelCase.
+ *
+ * `CamelCase<T>` transforms object property names to camelCase 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 CamelCase<T> = Equal<T, CamelizeMain<T>> extends true ? T : CamelizeMain<T>;
+type CamelizeMain<T> = T extends [never] ? never : T extends {
+    valueOf(): boolean | bigint | number | string;
+} ? ValueOf<T> : T extends Function ? never : T extends object ? CamelizeObject<T> : T;
+type CamelizeObject<T extends object> = T extends Array<infer U> ? IsTuple<T> extends true ? CamelizeTuple<T> : CamelizeMain<U>[] : T extends Set<infer U> ? Set<CamelizeMain<U>> : T extends Map<infer K, infer V> ? Map<CamelizeMain<K>, CamelizeMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends NativeClass ? T : {
+    [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<T[Key]>;
+};
+type CamelizeTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [CamelizeMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [CamelizeMain<F>, ...CamelizeTuple<Rest>] : T extends [(infer F)?] ? [CamelizeMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [CamelizeMain<F>?, ...CamelizeTuple<Rest>] : [];
+type CamelizeString<Key extends string> = Key extends `_${infer R}` ? `_${CamelizeString<R>}` : Key extends `${infer _F}_${infer _R}` ? CamelizeSnakeString<Key> : Key extends Uppercase<Key> ? Lowercase<Key> : CamelizePascalString<Key>;
+type CamelizePascalString<Key extends string> = Key extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : Key;
+type CamelizeSnakeString<Key extends string> = Key extends `_${infer R}` ? CamelizeSnakeString<R> : Key extends `${infer F}_${infer M}${infer R}` ? M extends "_" ? CamelizeSnakeString<`${F}_${R}`> : `${Lowercase<F>}${Uppercase<M>}${CamelizeSnakeString<R>}` : Lowercase<Key>;
+export {};

package/lib/typings/CamelCase.js

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

package/lib/typings/CamelCase.js.map

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