`typia.validate()` — collect every error at once

signature


function validate<T>(input: T): IValidation<T>;
function validate<T>(input: unknown): IValidation<T>;

typia.validate<T> walks the entire structure and reports every field that doesn’t match T, instead of stopping at the first one like assert.

Scenario	Pick
Need to render every field error to the user (form, request body)	`validate` (you are here)
One field is wrong → throw an exception	`assert`
LLM function-calling feedback loop (“tell the model all its mistakes”)	`validate` + `LlmJson.stringify`
Just a yes/no answer	`is`

First example

hello-validate.ts


import typia, { tags } from "typia";
 
interface User {
  id: string & tags.Format<"uuid">;
  age: number & tags.Type<"uint32">;
}
 
const result = typia.validate<User>(input);
 
if (result.success) {
  // result.data is User
  console.log(result.data.id);
} else {
  // result.errors is IValidation.IError[]
  for (const e of result.errors) {
    console.log(`${e.path}: expected ${e.expected}, got`, e.value);
  }
}

If id is the literal 5 and age is 20.75, you get:


$input.id : expected "string & Format<\"uuid\">", got 5
$input.age: expected "number & Type<\"uint32\">", got 20.75

Both errors arrive in a single pass. assert would have thrown on id and stopped.

TypeScript Source

examples/src/validators/validate.ts


import typia, { tags } from "typia";
 
const res: typia.IValidation<IMember> = typia.validate<IMember>({
  id: 5, // wrong, must be string (uuid)
  age: 20.75, // wrong, not integer
  email: "samchon.github@gmail.com",
});
if (res.success === false) console.log(res.errors);
 
interface IMember {
  id: string & tags.Format<"uuid">;
  email: string & tags.Format<"email">;
  age: number &
    tags.Type<"uint32"> &
    tags.ExclusiveMinimum<19> &
    tags.Maximum<100>;
}

Compiled JavaScript

examples/bin/validators/validate.js


/* @ttsc-rewritten */
const {
  _isFormatEmail: __typia_transform__isFormatEmail,
} = require("typia/lib/internal/_isFormatEmail");
const {
  _isFormatUuid: __typia_transform__isFormatUuid,
} = require("typia/lib/internal/_isFormatUuid");
const {
  _isTypeUint32: __typia_transform__isTypeUint32,
} = require("typia/lib/internal/_isTypeUint32");
const {
  _validateReport: __typia_transform__validateReport,
} = require("typia/lib/internal/_validateReport");
const res = (() => {
  const _io0 = (input) =>
    "string" === typeof input.id &&
    __typia_transform__isFormatUuid(input.id) &&
    "string" === typeof input.email &&
    __typia_transform__isFormatEmail(input.email) &&
    "number" === typeof input.age &&
    __typia_transform__isTypeUint32(input.age) &&
    19 < input.age &&
    input.age <= 100;
  const _vo0 = (input, _path, _exceptionable = true) =>
    [
      ("string" === typeof input.id &&
        (__typia_transform__isFormatUuid(input.id) ||
          _report(_exceptionable, {
            path: _path + ".id",
            expected: 'string & Format<"uuid">',
            value: input.id,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".id",
          expected: '(string & Format<"uuid">)',
          value: input.id,
        }),
      ("string" === typeof input.email &&
        (__typia_transform__isFormatEmail(input.email) ||
          _report(_exceptionable, {
            path: _path + ".email",
            expected: 'string & Format<"email">',
            value: input.email,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".email",
          expected: '(string & Format<"email">)',
          value: input.email,
        }),
      ("number" === typeof input.age &&
        (__typia_transform__isTypeUint32(input.age) ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: 'number & Type<"uint32">',
            value: input.age,
          })) &&
        (19 < input.age ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: "number & ExclusiveMinimum<19>",
            value: input.age,
          })) &&
        (input.age <= 100 ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: "number & Maximum<100>",
            value: input.age,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".age",
          expected:
            '(number & Type<"uint32"> & ExclusiveMinimum<19> & Maximum<100>)',
          value: input.age,
        }),
    ].every((flag) => flag);
  const __is = (input) =>
    "object" === typeof input && null !== input && _io0(input);
  let errors;
  let _report;
  return (input) => {
    if (false === __is(input)) {
      errors = [];
      _report = __typia_transform__validateReport(errors);
      ((input, _path, _exceptionable = true) =>
        ((("object" === typeof input && null !== input) ||
          _report(true, {
            path: _path + "",
            expected: "IMember",
            value: input,
          })) &&
          _vo0(input, _path + "", true)) ||
        _report(true, {
          path: _path + "",
          expected: "IMember",
          value: input,
        }))(input, "$input", true);
      const success = 0 === errors.length;
      return success
        ? {
            success,
            data: input,
          }
        : {
            success,
            errors,
            data: input,
          };
    }
    return {
      success: true,
      data: input,
    };
  };
})()({
  id: 5,
  age: 20.75,
  email: "samchon.github@gmail.com",
});
if (res.success === false) console.log(res.errors);

The `IValidation<T>` shape


type IValidation<T> = IValidation.ISuccess<T> | IValidation.IFailure;
 
namespace IValidation {
  interface ISuccess<T> {
    success: true;
    data: T;
  }
  interface IFailure {
    success: false;
    data: unknown;
    errors: IError[];
  }
  interface IError {
    path: string;       // "$input.user.age"
    expected: string;   // "number & Minimum<19>"
    value: unknown;     // the bad value
    description?: string;
  }
}

undefined


export function validate<T>(input: T): IValidation<T>;
export function validate<T>(input: unknown): IValidation<T>;

undefined

@typia/interface


/**
 * Validation result type with detailed error information.
 *
 * `IValidation<T>` is the return type of `typia.validate<T>()` and related
 * validation functions. Unlike `typia.is<T>()` which returns a boolean, or
 * `typia.assert<T>()` which throws exceptions, `typia.validate<T>()` returns
 * this structured result with full error details.
 *
 * Check the {@link IValidation.success | success} discriminator:
 *
 * - `true` → {@link IValidation.ISuccess} with validated
 *   {@link IValidation.ISuccess.data | data}
 * - `false` → {@link IValidation.IFailure} with
 *   {@link IValidation.IFailure.errors | errors} array
 *
 * This is the recommended validation function when you need to report
 * validation errors to users or log them for debugging.
 *
 * @author Jeongho Nam - https://github.com/samchon
 * @example
 *   const result = typia.validate<User>(input);
 *   if (result.success) {
 *     return result.data; // User type
 *   } else {
 *     result.errors.forEach((e) => console.log(e.path, e.expected));
 *   }
 *
 * @template T The expected type after successful validation
 */
export type IValidation<T = unknown> =
  | IValidation.ISuccess<T>
  | IValidation.IFailure;
 
export namespace IValidation {
  /**
   * Successful validation result.
   *
   * Indicates the input matches the expected type. The validated data is
   * available in {@link data} with full type information.
   *
   * @template T The validated type
   */
  export interface ISuccess<T = unknown> {
    /**
     * Success discriminator.
     *
     * Always `true` for successful validations. Use this to narrow the type
     * before accessing {@link data}.
     */
    success: true;
 
    /**
     * The validated data with correct type.
     *
     * The original input after successful validation. TypeScript will narrow
     * this to type `T` when {@link success} is `true`.
     */
    data: T;
  }
 
  /**
   * Failed validation result with error details.
   *
   * Indicates the input did not match the expected type. Contains the original
   * data and an array of all validation errors found.
   */
  export interface IFailure {
    /**
     * Success discriminator.
     *
     * Always `false` for failed validations. Use this to narrow the type before
     * accessing {@link errors}.
     */
    success: false;
 
    /**
     * The original input that failed validation.
     *
     * Preserved as `unknown` type since it didn't match the expected type.
     * Useful for debugging or logging the actual value.
     */
    data: unknown;
 
    /**
     * Array of validation errors.
     *
     * Contains one entry for each validation failure found. Multiple errors may
     * exist if the input has multiple type mismatches.
     */
    errors: IError[];
  }
 
  /**
   * Detailed information about a single validation error.
   *
   * Describes exactly what went wrong during validation, including the
   * location, expected type, and actual value.
   */
  export interface IError {
    /**
     * Property path to the error location.
     *
     * A dot-notation path from the root input to the failing property. Uses
     * `$input` as the root. Example: `"$input.user.email"` or
     * `"$input.items[0].price"`.
     */
    path: string;
 
    /**
     * Expected type expression.
     *
     * A human-readable description of what type was expected at this location.
     * Examples: `"string"`, `"number & ExclusiveMinimum<0>"`, `"(\"active\" |
     * \"inactive\")"`.
     */
    expected: string;
 
    /**
     * The actual value that failed validation.
     *
     * The value found at the error path. May be `undefined` if the property was
     * missing. Useful for debugging type mismatches.
     */
    value: unknown;
 
    /**
     * Human-readable error description.
     *
     * Optional additional context about the validation failure, such as
     * constraint violations or custom error messages.
     */
    description?: string;
  }
}

The two halves of the union share a success boolean — TypeScript narrows the rest accordingly when you check it:


const result: IValidation<string> = typia.validate<string>(something);
 
if (result.success) {
  result.data;   // string
} else {
  result.errors; // IValidation.IError[]
}

This pattern is called a discriminated union , and it’s the cleanest way to consume validate’s return value.

Strict (`validateEquals`)

validate allows extra properties on objects. validateEquals reports each one as its own error:


const r = typia.validateEquals<User>({ id: "uuid…", age: 25, sex: 1 });
// r.success === false
// r.errors[0] = { path: "$input.sex", expected: "undefined", value: 1 }

TypeScript Source

examples/src/validators/validateEquals.ts


import typia, { tags } from "typia";
 
const res: typia.IValidation<IMember> = typia.validateEquals<IMember>({
  age: 30,
  email: "samchon.github@gmail.com",
  id: "something", // wrong, must be string (uuid)
  sex: 1, // extra property
});
if (res.success === false) console.log(res.errors);
 
interface IMember {
  id: string & tags.Format<"uuid">;
  email: string & tags.Format<"email">;
  age: number &
    tags.Type<"uint32"> &
    tags.ExclusiveMinimum<19> &
    tags.Maximum<100>;
}

Compiled JavaScript

examples/bin/validators/validateEquals.js


/* @ttsc-rewritten */
const {
  _isFormatEmail: __typia_transform__isFormatEmail,
} = require("typia/lib/internal/_isFormatEmail");
const {
  _isFormatUuid: __typia_transform__isFormatUuid,
} = require("typia/lib/internal/_isFormatUuid");
const {
  _isTypeUint32: __typia_transform__isTypeUint32,
} = require("typia/lib/internal/_isTypeUint32");
const {
  _accessExpressionAsString: __typia_transform__accessExpressionAsString,
} = require("typia/lib/internal/_accessExpressionAsString");
const {
  _validateReport: __typia_transform__validateReport,
} = require("typia/lib/internal/_validateReport");
const res = (() => {
  const _io0 = (input, _exceptionable = true) =>
    "string" === typeof input.id &&
    __typia_transform__isFormatUuid(input.id) &&
    "string" === typeof input.email &&
    __typia_transform__isFormatEmail(input.email) &&
    "number" === typeof input.age &&
    __typia_transform__isTypeUint32(input.age) &&
    19 < input.age &&
    input.age <= 100 &&
    (3 === Object.keys(input).length ||
      Object.keys(input).every((key) => {
        if (["id", "email", "age"].some((prop) => key === prop)) return true;
        const value = input[key];
        if (undefined === value) return true;
        return false;
      }));
  const _vo0 = (input, _path, _exceptionable = true) =>
    [
      ("string" === typeof input.id &&
        (__typia_transform__isFormatUuid(input.id) ||
          _report(_exceptionable, {
            path: _path + ".id",
            expected: 'string & Format<"uuid">',
            value: input.id,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".id",
          expected: '(string & Format<"uuid">)',
          value: input.id,
        }),
      ("string" === typeof input.email &&
        (__typia_transform__isFormatEmail(input.email) ||
          _report(_exceptionable, {
            path: _path + ".email",
            expected: 'string & Format<"email">',
            value: input.email,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".email",
          expected: '(string & Format<"email">)',
          value: input.email,
        }),
      ("number" === typeof input.age &&
        (__typia_transform__isTypeUint32(input.age) ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: 'number & Type<"uint32">',
            value: input.age,
          })) &&
        (19 < input.age ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: "number & ExclusiveMinimum<19>",
            value: input.age,
          })) &&
        (input.age <= 100 ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: "number & Maximum<100>",
            value: input.age,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".age",
          expected:
            '(number & Type<"uint32"> & ExclusiveMinimum<19> & Maximum<100>)',
          value: input.age,
        }),
      3 === Object.keys(input).length ||
        false === _exceptionable ||
        Object.keys(input)
          .map((key) => {
            if (["id", "email", "age"].some((prop) => key === prop))
              return true;
            const value = input[key];
            if (undefined === value) return true;
            return _report(_exceptionable, {
              path: _path + __typia_transform__accessExpressionAsString(key),
              expected: "undefined",
              value: value,
              description: [
                `The property \`${key}\` is not defined in the object type.`,
                "",
                "Please remove the property next time.",
              ].join("\n"),
            });
          })
          .every((flag) => flag),
    ].every((flag) => flag);
  const __is = (input, _exceptionable = true) =>
    "object" === typeof input && null !== input && _io0(input, true);
  let errors;
  let _report;
  return (input) => {
    if (false === __is(input)) {
      errors = [];
      _report = __typia_transform__validateReport(errors);
      ((input, _path, _exceptionable = true) =>
        ((("object" === typeof input && null !== input) ||
          _report(true, {
            path: _path + "",
            expected: "IMember",
            value: input,
          })) &&
          _vo0(input, _path + "", true)) ||
        _report(true, {
          path: _path + "",
          expected: "IMember",
          value: input,
        }))(input, "$input", true);
      const success = 0 === errors.length;
      return success
        ? {
            success,
            data: input,
          }
        : {
            success,
            errors,
            data: input,
          };
    }
    return {
      success: true,
      data: input,
    };
  };
})()({
  age: 30,
  email: "samchon.github@gmail.com",
  id: "something",
  sex: 1,
});
if (res.success === false) console.log(res.errors);

Reusable factories


const validateUser = typia.createValidate<User>();
const validateUserEquals = typia.createValidateEquals<User>();

Each factory returns a function (input: unknown) => IValidation<T> that you can call from anywhere — the per-type code is emitted once at the factory call site.

createValidate and createValidateEquals go a step further: the returned function also implements the Standard Schema interface (StandardSchemaV1<T, T>). That makes the validator a drop-in for any library that accepts Standard Schema, like up-fetch :


import typia from "typia";
import { up } from "up-fetch";
 
interface ISmallTodo {
  userId: number;
  /** @maximum 5 */
  id: number;
  title: string;
  completed: boolean;
}
 
const upfetch = up(fetch);
const schema = typia.createValidate<ISmallTodo>();
 
// id ≤ 5 → success
await upfetch("https://jsonplaceholder.typicode.com/todos/1", { schema });
 
// id = 10 → validation failure surfaced by up-fetch
await upfetch("https://jsonplaceholder.typicode.com/todos/10", { schema });

TypeScript Source

examples/src/validators/createValidate.ts


import typia, { tags } from "typia";
 
export const validateMember = typia.createValidate<IMember>();
 
interface IMember {
  id: string & tags.Format<"uuid">;
  email: string & tags.Format<"email">;
  age: number &
    tags.Type<"uint32"> &
    tags.ExclusiveMinimum<19> &
    tags.Maximum<100>;
}

Compiled JavaScript

examples/bin/validators/createValidate.js


import { _createStandardSchema as __typia_transform__createStandardSchema } from "typia/lib/internal/_createStandardSchema";
import { _isFormatEmail as __typia_transform__isFormatEmail } from "typia/lib/internal/_isFormatEmail";
import { _isFormatUuid as __typia_transform__isFormatUuid } from "typia/lib/internal/_isFormatUuid";
import { _isTypeUint32 as __typia_transform__isTypeUint32 } from "typia/lib/internal/_isTypeUint32";
import { _validateReport as __typia_transform__validateReport } from "typia/lib/internal/_validateReport";
 
/* @ttsc-rewritten */
export const validateMember = (() => {
  const _io0 = (input) =>
    "string" === typeof input.id &&
    __typia_transform__isFormatUuid(input.id) &&
    "string" === typeof input.email &&
    __typia_transform__isFormatEmail(input.email) &&
    "number" === typeof input.age &&
    __typia_transform__isTypeUint32(input.age) &&
    19 < input.age &&
    input.age <= 100;
  const _vo0 = (input, _path, _exceptionable = true) =>
    [
      ("string" === typeof input.id &&
        (__typia_transform__isFormatUuid(input.id) ||
          _report(_exceptionable, {
            path: _path + ".id",
            expected: 'string & Format<"uuid">',
            value: input.id,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".id",
          expected: '(string & Format<"uuid">)',
          value: input.id,
        }),
      ("string" === typeof input.email &&
        (__typia_transform__isFormatEmail(input.email) ||
          _report(_exceptionable, {
            path: _path + ".email",
            expected: 'string & Format<"email">',
            value: input.email,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".email",
          expected: '(string & Format<"email">)',
          value: input.email,
        }),
      ("number" === typeof input.age &&
        (__typia_transform__isTypeUint32(input.age) ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: 'number & Type<"uint32">',
            value: input.age,
          })) &&
        (19 < input.age ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: "number & ExclusiveMinimum<19>",
            value: input.age,
          })) &&
        (input.age <= 100 ||
          _report(_exceptionable, {
            path: _path + ".age",
            expected: "number & Maximum<100>",
            value: input.age,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".age",
          expected:
            '(number & Type<"uint32"> & ExclusiveMinimum<19> & Maximum<100>)',
          value: input.age,
        }),
    ].every((flag) => flag);
  const __is = (input) =>
    "object" === typeof input && null !== input && _io0(input);
  let errors;
  let _report;
  return __typia_transform__createStandardSchema((input) => {
    if (false === __is(input)) {
      errors = [];
      _report = __typia_transform__validateReport(errors);
      ((input, _path, _exceptionable = true) =>
        ((("object" === typeof input && null !== input) ||
          _report(true, {
            path: _path + "",
            expected: "IMember",
            value: input,
          })) &&
          _vo0(input, _path + "", true)) ||
        _report(true, {
          path: _path + "",
          expected: "IMember",
          value: input,
        }))(input, "$input", true);
      const success = 0 === errors.length;
      return success
        ? {
            success,
            data: input,
          }
        : {
            success,
            errors,
            data: input,
          };
    }
    return {
      success: true,
      data: input,
    };
  });
})();

What it doesn’t check

Same rules as the rest of the validator family — see is § What it doesn’t check. User-defined classes are walked by property, function types are skipped unless functional is on, native classes (Date, Set, Map, Uint8Array) are inspected end-to-end.

TypeScript Source

examples/src/validators/validate-map.ts


import typia from "typia";
 
typia.createIs<Map<string, boolean | number | string>>();

Constraints

Intersect type tags (formats, ranges, lengths) into the type. The error expected field repeats the same intersection syntax, so users see exactly what was required:

TypeScript Source

examples/src/validators/validate-custom-tags.ts


import typia, { tags } from "typia";
 
export const validateSomething = typia.createValidate<Something>();
 
//----
// DEFINE CUSTOM TYPE TAGS
//----
type Dollar = tags.TagBase<{
  kind: "dollar";
  target: "string";
  value: undefined;
  validate: `$input[0] === "$" && !isNaN(Number($input.substring(1).split(",").join("")))`;
}>;
 
type Postfix<Value extends string> = tags.TagBase<{
  kind: "postfix";
  target: "string";
  value: Value;
  validate: `$input.endsWith("${Value}")`;
}>;
 
type IsEven<Value extends number | bigint> = tags.TagBase<{
  kind: "isEven";
  target: Value extends number ? "number" : "bigint";
  value: undefined;
  validate: `$input % ${Numeric<2>} === ${Numeric<0>}`;
}>;
 
type Numeric<Value extends number | bigint> = Value extends number
  ? Value
  : `BigInt(${Value})`;
 
//----
// VALIDATION
//----
interface Something {
  dollar: string & Dollar;
  postfix: string & Postfix<"!!!">;
  isEven: number & IsEven<number>;
}

Compiled JavaScript

examples/bin/validators/validate-custom-tags.js


import { _createStandardSchema as __typia_transform__createStandardSchema } from "typia/lib/internal/_createStandardSchema";
import { _validateReport as __typia_transform__validateReport } from "typia/lib/internal/_validateReport";
 
/* @ttsc-rewritten */
export const validateSomething = (() => {
  const _io0 = (input) =>
    "string" === typeof input.dollar &&
    input.dollar[0] === "$" &&
    !isNaN(Number(input.dollar.substring(1).split(",").join(""))) &&
    "string" === typeof input.postfix &&
    input.postfix.endsWith("!!!") &&
    "number" === typeof input.isEven &&
    input.isEven % 2 === 0;
  const _vo0 = (input, _path, _exceptionable = true) =>
    [
      ("string" === typeof input.dollar &&
        ((input.dollar[0] === "$" &&
          !isNaN(Number(input.dollar.substring(1).split(",").join("")))) ||
          _report(_exceptionable, {
            path: _path + ".dollar",
            expected: "string & Dollar",
            value: input.dollar,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".dollar",
          expected: "(string & Dollar)",
          value: input.dollar,
        }),
      ("string" === typeof input.postfix &&
        (input.postfix.endsWith("!!!") ||
          _report(_exceptionable, {
            path: _path + ".postfix",
            expected: 'string & Postfix<"!!!">',
            value: input.postfix,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".postfix",
          expected: '(string & Postfix<"!!!">)',
          value: input.postfix,
        }),
      ("number" === typeof input.isEven &&
        (input.isEven % 2 === 0 ||
          _report(_exceptionable, {
            path: _path + ".isEven",
            expected: "number & IsEven<number>",
            value: input.isEven,
          }))) ||
        _report(_exceptionable, {
          path: _path + ".isEven",
          expected: "(number & IsEven<number>)",
          value: input.isEven,
        }),
    ].every((flag) => flag);
  const __is = (input) =>
    "object" === typeof input && null !== input && _io0(input);
  let errors;
  let _report;
  return __typia_transform__createStandardSchema((input) => {
    if (false === __is(input)) {
      errors = [];
      _report = __typia_transform__validateReport(errors);
      ((input, _path, _exceptionable = true) =>
        ((("object" === typeof input && null !== input) ||
          _report(true, {
            path: _path + "",
            expected: "Something",
            value: input,
          })) &&
          _vo0(input, _path + "", true)) ||
        _report(true, {
          path: _path + "",
          expected: "Something",
          value: input,
        }))(input, "$input", true);
      const success = 0 === errors.length;
      return success
        ? {
            success,
            data: input,
          }
        : {
            success,
            errors,
            data: input,
          };
    }
    return {
      success: true,
      data: input,
    };
  });
})();

Performance

validate does the most work — it walks the entire structure even after finding errors, and collects each one with path and expected-type strings. It’s still up to 20,000× faster than the JS-ecosystem alternatives on union-heavy types, and still the only one that handles arbitrary unions. The full structural feature matrix is on is § Performance — same coverage, since validate extends is with error collection.

validate Function Benchmark

Measured on AMD Ryzen 9 7940HS, Rog Flow x13

Where to go next

Throw on first failure → assert
Yes/no check → is
Constraints (formats, ranges, lengths) → Special Tags
LLM auto-correction loop → LlmJson.stringify

typia.validate() — collect every error at once

First example

TypeScript Source

Compiled JavaScript

The IValidation<T> shape

undefined

undefined

Strict (validateEquals)

TypeScript Source

Compiled JavaScript

Reusable factories

TypeScript Source

Compiled JavaScript

What it doesn’t check

TypeScript Source

Compiled JavaScript

Constraints

TypeScript Source

Compiled JavaScript

Performance

Where to go next

`typia.validate()` — collect every error at once

The `IValidation<T>` shape

Strict (`validateEquals`)