Class Typer

Class representing a type checker. Version: 3.2.3

Author

Michael Lavigna - https://michaellavigna.com - michael.lavigna@hotmail.it

Since

3.2.3

Constructors

constructor

new Typer(): Typer
creates the types mapping type-->function

Returns Typer
- Defined in Typer.ts:43

Methods

asArray

asArray<T = unknown>(value: unknown): T[]
Validates and returns an array
Type Parameters
- T = unknown
  The expected element type
Parameters
- value: unknown
  The value to validate
Returns T[]
The validated array

Throws
If not an array
- Defined in Typer.ts:923

asBoolean

asBoolean(value: unknown): boolean
Validates and returns a boolean
Parameters
- value: unknown
  The value to validate
Returns boolean
The validated boolean

Throws
If not a boolean
- Defined in Typer.ts:912

asNumber

asNumber(value: unknown): number
Validates and returns a number
Parameters
- value: unknown
  The value to validate
Returns number
The validated number

Throws
If not a number
- Defined in Typer.ts:902

asObject

asObject<T extends Record<string, unknown> = Record<string, unknown>>(
value: unknown,
): T
Validates and returns an object
Type Parameters
- T extends Record<string, unknown> = Record<string, unknown>
  The expected object type
Parameters
- value: unknown
  The value to validate
Returns T
The validated object

Throws
If not an object
- Defined in Typer.ts:934

assert

assert(value: unknown, expectedType: string | string[]): void
Assert that a value is of a specific type. Logs a warning if incorrect.
Parameters
- value: unknown
  The value to check.
- expectedType: string | string[]
  The expected type(s).
Returns void
Example
```
Typer.assert(42, "number"); // No output
Typer.assert("hello", "number"); // Warning in console
```
- Defined in Typer.ts:2066

asString

asString(value: unknown): string
Validates and returns a string
Parameters
- value: unknown
  The value to validate
Returns string
The validated string

Throws
If not a string
- Defined in Typer.ts:892

checkStructure

checkStructure(
    schema: Record<string, unknown>,
    obj: Record<string, unknown>,
    path?: string,
    strictMode?: boolean,
): StructureValidationReturn
Recursively validates an object against a nested schema.
Parameters
- schema: Record<string, unknown>
  The expected structure definition.
- obj: Record<string, unknown>
  The object to validate.
- path: string = ''
  The current path for error reporting (internal use).
- strictMode: boolean = false
  Whether to reject extra keys not in schema.
Returns StructureValidationReturn
- Validation result with errors array.
Example
```
const schema = {
   name: "string",
   age: "number",
   hobbies: ["string"],
   address: {
     street: "string",
     city: "string?"
   }
};
const obj = { name: "John", age: 25, hobbies: ["reading"] };
console.log(Typer.checkStructure(schema, obj)); // { isValid: true, errors: [] }
```
- Defined in Typer.ts:1876

expect

expect(funct: Function, types: TyperExpectTypes): (...args: unknown[]) => any
Expects a function to conform to specified input and output types.
Parameters
- funct: Function
  The function to type-check.
- types: TyperExpectTypes
  The expected types for the function's parameters and return value.
  
  Defines the expected input and output types for a function.
  - paramTypes: string[]
    The expected type(s) of the function's parameters
  - returnType: string[]
    The expected return type(s) of the function
Returns (...args: unknown[]) => any
A new function that type-checks its arguments and return value.
Throws
If the types object does not contain exactly 3 keys or the required type properties.

Throws
If the function or types object does not conform to the expected types.
Example
```
const typedFunction = Typer.expect(
   (x: number) => x * 2, 
   { paramTypes: ["number"], returnType: ["number"] }
);
console.log(typedFunction(3)); // 6
```
- Defined in Typer.ts:2089

exportTypes

exportTypes(): string
Exports all registered types as a JSON string.

Returns string
The serialized types.
Example
```
console.log(Typer.exportTypes()); // '["array","number","string","boolean"]'
```
- Defined in Typer.ts:274

importTypes

importTypes(json: string): void
Imports types from a JSON string.
Parameters
- json: string
  The JSON string containing type names.
Returns void
Example
```
Typer.importTypes('["customType"]');
```
- Defined in Typer.ts:284

is

is<K extends keyof TypeMap>(
value: unknown,
types: K | readonly K[],
): value is TypeMap[K]
Checks if the provided value matches one or more specified types.

Overloads:
- When called with a known built-in alias, the type guard is automatically inferred from TypeMap (e.g. "number" narrows to number).
- For custom registered types, an explicit generic T may be supplied.
Type Parameters
- K extends keyof TypeMap
Parameters
- value: unknown
  The value to check.
- types: K | readonly K[]
  One or more types to check against.
Returns value is TypeMap[K]
Returns true if the value matches any type, false otherwise.
Example
```
if (typer.is(value, "string")) {
  // value is now narrowed to string by the type guard
  console.log(value.toUpperCase());
}
typer.is(42, "number"); // true
typer.is("hello", ["string", "number"]); // true
typer.is<MyShape>(payload, "my_custom_type"); // explicit generic for custom types
```
- Defined in Typer.ts:1036
is<T = unknown>(value: unknown, types: string | readonly string[]): value is T
Checks if the provided value matches one or more specified types.

Overloads:
- When called with a known built-in alias, the type guard is automatically inferred from TypeMap (e.g. "number" narrows to number).
- For custom registered types, an explicit generic T may be supplied.
Type Parameters
- T = unknown
  The expected type for better TypeScript inference
Parameters
- value: unknown
  The value to check.
- types: string | readonly string[]
  One or more types to check against.
Returns value is T
Returns true if the value matches any type, false otherwise.
Example
```
if (typer.is(value, "string")) {
  // value is now narrowed to string by the type guard
  console.log(value.toUpperCase());
}
typer.is(42, "number"); // true
typer.is("hello", ["string", "number"]); // true
typer.is<MyShape>(payload, "my_custom_type"); // explicit generic for custom types
```
- Defined in Typer.ts:1037

isArray

isArray<T = unknown>(value: unknown): value is T[]
Type-safe array validation
Type Parameters
- T = unknown
  The expected element type
Parameters
- value: unknown
  The value to check
Returns value is T[]
Type guard for array
- Defined in Typer.ts:862

isArrayOf

isArrayOf<T = unknown>(elementType: string, p: unknown): T[]
Checks if the provided parameter is an array of a specified type.
Type Parameters
- T = unknown
  The expected element type
Parameters
- elementType: string
  The type of elements that the array should contain.
- p: unknown
  The parameter to check.
Returns T[]
Typed array of elements
Throws
Throws if the parameter is not an array of the specified type.
Example
```
const numbers = typer.isArrayOf<number>("number", [1, 2, 3]); // numbers: number[]
const strings = typer.isArrayOf<string>("string", ["a", "b"]); // strings: string[]
```
- Defined in Typer.ts:587

isBase64

isBase64(
p: unknown,
opts?: { requirePadding?: boolean; urlSafe?: boolean },
): string
Checks that the parameter is a syntactically valid Base64 string. Supports both standard and URL-safe variants. Padding is required when requirePadding is true (default).
Parameters
- p: unknown
  The parameter to check
- Optionalopts: { requirePadding?: boolean; urlSafe?: boolean } = {}
  Options
Returns string
The validated Base64 string

Throws
If p is not a valid Base64 string
- Defined in Typer.ts:1843

isBoolean

isBoolean(value: unknown): value is boolean
Type-safe boolean validation
Parameters
- value: unknown
  The value to check
Returns value is boolean
Type guard for boolean
- Defined in Typer.ts:847

isEmail

isEmail(p: unknown): string
Checks if the provided parameter is a valid email address.
Parameters
- p: unknown
  The parameter to check.
Returns string
The validated email string
Throws
Throws if the parameter is not a valid email address.
Example
```
const email = typer.isEmail("test@example.com"); // email: string
```
- Defined in Typer.ts:602

isEmpty

isEmpty(p: unknown): unknown
Checks that the parameter is "empty": empty string (after trim), empty array, empty Map/Set, or object with no own enumerable keys.
Parameters
- p: unknown
  The parameter to check
Returns unknown
The validated empty value

Throws
If p is not empty or not a supported container
- Defined in Typer.ts:1677

isFiniteNumber

isFiniteNumber(p: unknown): number
Checks that the parameter is a finite number (rejects NaN and Infinity). Stricter than isType("number", x), which accepts NaN for compatibility with typeof x === "number".
Parameters
- p: unknown
  The parameter to check
Returns number
The validated finite number

Throws
If p is not a finite number
- Defined in Typer.ts:1546

isHexColor

isHexColor(p: unknown): string
Checks that the parameter is a valid CSS hex color (#RGB, #RGBA, #RRGGBB, or #RRGGBBAA).
Parameters
- p: unknown
  The parameter to check
Returns string
The validated hex color

Throws
If p is not a valid hex color
- Defined in Typer.ts:1802

isInRange

isInRange(min: number, max: number, p: unknown): number
Checks if the provided parameter is a number within a specified range.
Parameters
- min: number
  The minimum value.
- max: number
  The maximum value.
- p: unknown
  The parameter to check.
Returns number
The validated number
Throws
Throws if the parameter is not a number within the specified range.
Example
```
const age = typer.isInRange(18, 65, 25); // age: number
```
- Defined in Typer.ts:622

isInstanceOf

isInstanceOf<T>(ctor: new (...args: never[]) => T, p: unknown): T
Checks that the parameter is an instance of the given constructor. Type-safe alternative to writing value instanceof MyClass everywhere.
Type Parameters
- T
  The instance type produced by the constructor
Parameters
- ctor: new (...args: never[]) => T
  The constructor to check against
- p: unknown
  The parameter to check
Returns T
The validated instance

Throws
If p is not an instance of ctor
- Defined in Typer.ts:1619

isInteger

isInteger(p: unknown): number
Checks if the provided parameter is an integer.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated integer
Throws
Throws if the parameter is not an integer.
Example
```
const count = typer.isInteger(42); // count: number
```
- Defined in Typer.ts:639

isIPv4

isIPv4(p: unknown): string
Checks that the parameter is a valid IPv4 address (dotted-quad notation).
Parameters
- p: unknown
  The parameter to check
Returns string
The validated IPv4 address

Throws
If p is not a valid IPv4 address
- Defined in Typer.ts:1749

isIPv6

isIPv6(p: unknown): string
Checks that the parameter is a valid IPv6 address. Uses the URL constructor as a permissive parser: any string accepted as the host portion of http://[<addr>]/ is considered valid.
Parameters
- p: unknown
  The parameter to check
Returns string
The validated IPv6 address

Throws
If p is not a valid IPv6 address
- Defined in Typer.ts:1777

isISODate

isISODate(p: unknown): Date
Checks that the parameter is a valid ISO 8601 date string and returns the parsed Date. Accepts the formats produced by Date#toISOString plus reasonable variants (e.g. with timezone offsets).
Parameters
- p: unknown
  The parameter to check
Returns Date
The parsed date (always valid)

Throws
If p is not a valid ISO 8601 date string
- Defined in Typer.ts:1819

isLength

isLength<T extends string | readonly unknown[]>(
bounds: { max?: number; min?: number },
p: unknown,
): T
Checks that the length of a string or array falls within the given bounds.
Type Parameters
- T extends string | readonly unknown[]
  Either string or an array type
Parameters
- bounds: { max?: number; min?: number }
  Inclusive length bounds
- p: unknown
  The parameter to check (string or array)
Returns T
The validated value

Throws
If p is not a string/array or its length is out of range
- Defined in Typer.ts:1651

isNegativeInteger

isNegativeInteger(p: unknown): number
Checks if the provided parameter is a negative integer.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated negative integer
Throws
Throws if the parameter is not a negative integer.
Example
```
const count = typer.isNegativeInteger(-42); // count: number
```
- Defined in Typer.ts:806

isNegativeNumber

isNegativeNumber(p: unknown): number
Checks if the provided parameter is a negative number.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated negative number
Throws
Throws if the parameter is not a negative number.
Example
```
const value = typer.isNegativeNumber(-10); // value: number
```
- Defined in Typer.ts:789

isNonEmpty

isNonEmpty<T = unknown>(p: unknown): T
Inverse of isEmpty: checks the parameter is a non-empty string, array, Map, Set, or object.
Type Parameters
- T = unknown
  Caller-supplied container type for narrower inference
Parameters
- p: unknown
  The parameter to check
Returns T
The validated non-empty value

Throws
If p is empty or not a supported container
- Defined in Typer.ts:1706

isNonEmptyArray

isNonEmptyArray<T = unknown>(p: unknown): T[]
Checks if the provided parameter is a non-empty array.
Type Parameters
- T = unknown
  The expected element type
Parameters
- p: unknown
  The parameter to check.
Returns T[]
The validated non-empty array
Throws
Throws if the parameter is not a non-empty array.
Example
```
const items = typer.isNonEmptyArray<string>(["a", "b"]); // items: string[]
```
- Defined in Typer.ts:657

isNonEmptyString

isNonEmptyString(p: unknown): string
Checks if the provided parameter is a non-empty string.
Parameters
- p: unknown
  The parameter to check.
Returns string
The validated non-empty string
Throws
Throws if the parameter is not a non-empty string.
Example
```
const name = typer.isNonEmptyString("Hello"); // name: string
```
- Defined in Typer.ts:674

isNumber

isNumber(value: unknown): value is number
Type-safe number validation
Parameters
- value: unknown
  The value to check
Returns value is number
Type guard for number
- Defined in Typer.ts:833

isObject

isObject<T extends Record<string, unknown> = Record<string, unknown>>(
value: unknown,
): value is T
Type-safe object validation
Type Parameters
- T extends Record<string, unknown> = Record<string, unknown>
  The expected object type
Parameters
- value: unknown
  The value to check
Returns value is T
Type guard for object
- Defined in Typer.ts:877

isOneOf

isOneOf<T>(values: readonly T[], p: unknown): T
Checks if the provided parameter is one of the specified values.
Type Parameters
- T
  The expected type of the values
Parameters
- values: readonly T[]
  The values to check against.
- p: unknown
  The parameter to check.
Returns T
The validated value
Throws
Throws if the parameter is not one of the specified values.
Example
```
const color = typer.isOneOf(["red", "blue", "green"] as const, "blue"); // color: "red" | "blue" | "green"
```
- Defined in Typer.ts:693

isPhoneNumber

isPhoneNumber(p: unknown): string
Checks if the provided parameter is a valid phone number.
Parameters
- p: unknown
  The parameter to check.
Returns string
The validated phone number string
Throws
Throws if the parameter is not a valid phone number.
Example
```
const phone = typer.isPhoneNumber("+1234567890"); // phone: string
const phone2 = typer.isPhoneNumber("(555) 123-4567"); // phone2: string
```
- Defined in Typer.ts:710

isPlainObject

isPlainObject<T extends Record<string, unknown> = Record<string, unknown>>(
p: unknown,
): T
Checks that the parameter is a plain object (object literal or Object.create(null)). Rejects class instances, arrays, dates, maps, etc.
Type Parameters
- T extends Record<string, unknown> = Record<string, unknown>
  The expected plain object shape
Parameters
- p: unknown
  The parameter to check
Returns T
The validated plain object

Throws
If p is not a plain object
- Defined in Typer.ts:1579

isPositiveInteger

isPositiveInteger(p: unknown): number
Checks if the provided parameter is a positive integer.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated positive integer
Throws
Throws if the parameter is not a positive integer.
Example
```
const count = typer.isPositiveInteger(42); // count: number
```
- Defined in Typer.ts:772

isPositiveNumber

isPositiveNumber(p: unknown): number
Checks if the provided parameter is a positive number.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated positive number
Throws
Throws if the parameter is not a positive number.
Example
```
const value = typer.isPositiveNumber(10); // value: number
```
- Defined in Typer.ts:755

isPromise

isPromise<T = unknown>(p: unknown): Promise<T>
Checks that the parameter is a Promise (or a thenable).
Type Parameters
- T = unknown
  The resolved promise type (caller-supplied)
Parameters
- p: unknown
  The parameter to check
Returns Promise<T>
The validated promise

Throws
If p is not a Promise/thenable
- Defined in Typer.ts:1598

isSafeInteger

isSafeInteger(p: unknown): number
Checks that the parameter is a safe integer (within Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER).
Parameters
- p: unknown
  The parameter to check
Returns number
The validated safe integer

Throws
If p is not a safe integer
- Defined in Typer.ts:1562

isString

isString(value: unknown): value is string
Type-safe string validation
Parameters
- value: unknown
  The value to check
Returns value is string
Type guard for string
- Defined in Typer.ts:819

isType

isType<K extends keyof TypeMap>(types: K | readonly K[], p: unknown): TypeMap[K]
Check if the parameter matches one of the specified types.

Overloads:
- When called with a known built-in type alias (or array of aliases), the return type is inferred from TypeMap (e.g. "string" → string).
- Otherwise the caller can supply an explicit generic T, which falls back to unknown.
Type Parameters
- K extends keyof TypeMap
Parameters
- types: K | readonly K[]
  The types to check against.
- p: unknown
  The parameter to check.
Returns TypeMap[K]
Returns the value cast to the expected type
Throws
Throws if the parameter does not match any of the specified types.
Example
```
const value = typer.isType("string", "Hello"); // value is typed as string (no generic needed)
const arr = typer.isType(["number", "boolean"], 42); // typed as number | boolean
typer.isType<MyShape>("my_custom_type", payload); // explicit generic for custom types
```
- Defined in Typer.ts:977
isType<T = unknown>(types: string | readonly string[], p: unknown): T
Check if the parameter matches one of the specified types.

Overloads:
- When called with a known built-in type alias (or array of aliases), the return type is inferred from TypeMap (e.g. "string" → string).
- Otherwise the caller can supply an explicit generic T, which falls back to unknown.
Type Parameters
- T = unknown
  The expected type for better TypeScript inference
Parameters
- types: string | readonly string[]
  The types to check against.
- p: unknown
  The parameter to check.
Returns T
Returns the value cast to the expected type
Throws
Throws if the parameter does not match any of the specified types.
Example
```
const value = typer.isType("string", "Hello"); // value is typed as string (no generic needed)
const arr = typer.isType(["number", "boolean"], 42); // typed as number | boolean
typer.isType<MyShape>("my_custom_type", payload); // explicit generic for custom types
```
- Defined in Typer.ts:978

isURL

isURL(p: unknown): string
Checks if the provided parameter is a valid URL.
Parameters
- p: unknown
  The parameter to check.
Returns string
Throws
Throws if the parameter is not a valid URL.
Example
```
console.log(Typer.isURL("https://example.com")); // true
console.log(Typer.isURL("invalid-url")); // false
```
- Defined in Typer.ts:948

isUUID

isUUID(p: unknown): string
Checks that the parameter is a valid UUID (versions 1-5, RFC 4122).
Parameters
- p: unknown
  The parameter to check
Returns string
The validated UUID

Throws
If p is not a valid UUID
- Defined in Typer.ts:1733

listTypes

listTypes(): string[]
Get all registered types.

Returns string[]
An array of registered type names.
Example
```
console.log(Typer.listTypes()); // ["array", "number", "string", "boolean"]
```
- Defined in Typer.ts:264

matches

matches(regex: RegExp, p: unknown): string
Checks that the parameter is a string matching the given regular expression.
Parameters
- regex: RegExp
  The pattern to match against
- p: unknown
  The parameter to check
Returns string
The validated string

Throws
If p is not a string or does not match
- Defined in Typer.ts:1634

nullable

nullable<T>(validator: Validator<T>): Validator<T | null>
Wraps an existing validator so that null is also accepted and returned as-is. Useful as a building block for nullable schema fields.
Type Parameters
- T
  The type produced by the underlying validator on success
Parameters
- validator: Validator<T>
  The validator to make nullable
Returns Validator<T | null>
A new validator that accepts T or null
Example
```
const maybeStr = typer.nullable(v => typer.asString(v));
maybeStr(null); // null
maybeStr("hi"); // "hi"
```
- Defined in Typer.ts:1479

optional

optional<T>(validator: Validator<T>): Validator<T | undefined>
Wraps an existing validator so that undefined is also accepted. Useful for optional schema fields.
Type Parameters
- T
  The type produced by the underlying validator on success
Parameters
- validator: Validator<T>
  The validator to make optional
Returns Validator<T | undefined>
A new validator that accepts T or undefined
Example
```
const maybeNum = typer.optional(v => typer.asNumber(v));
maybeNum(undefined); // undefined
maybeNum(42); // 42
```
- Defined in Typer.ts:1498

parse

parse<K extends keyof TypeMap>(
types: K | readonly K[],
value: unknown,
): TypeMap[K]
Universal "parse" entry point. Validates value against either:
- a built-in type alias ("string", "number", ...),
- an array of aliases (["string", "number"] → union),
- a Validator<T> function,
- or a Schema object.
Returns the value typed correctly. Throws a TypeError on failure.

No as const is needed when calling with a literal schema thanks to the <const S> parameter — the inferred type matches the schema.
Type Parameters
- K extends keyof TypeMap
Parameters
- types: K | readonly K[]
- value: unknown
Returns TypeMap[K]
Example
```
const user = typer.parse(
  { id: 'number', name: 'string', email: 'string?' },
  payload,
);
// user is typed as { id: number; name: string; email?: string | null }
```
- Defined in Typer.ts:1088
parse<T>(validator: Validator<T>, value: unknown): T
Universal "parse" entry point. Validates value against either:
- a built-in type alias ("string", "number", ...),
- an array of aliases (["string", "number"] → union),
- a Validator<T> function,
- or a Schema object.
Returns the value typed correctly. Throws a TypeError on failure.

No as const is needed when calling with a literal schema thanks to the <const S> parameter — the inferred type matches the schema.
Type Parameters
- T
Parameters
- validator: Validator<T>
- value: unknown
Returns T
Example
```
const user = typer.parse(
  { id: 'number', name: 'string', email: 'string?' },
  payload,
);
// user is typed as { id: number; name: string; email?: string | null }
```
- Defined in Typer.ts:1089
parse<const S extends Schema>(
    schema: S,
    value: unknown,
): {
    [K in string | number | symbol]: (
        { [K in string
        | number
        | symbol]: ResolveSchemaValue<S[K]> } & {
            [K in string | number | symbol]?: ResolveSchemaValue<S[K]>
        }
    )[K]
}
Universal "parse" entry point. Validates value against either:
- a built-in type alias ("string", "number", ...),
- an array of aliases (["string", "number"] → union),
- a Validator<T> function,
- or a Schema object.
Returns the value typed correctly. Throws a TypeError on failure.

No as const is needed when calling with a literal schema thanks to the <const S> parameter — the inferred type matches the schema.
Type Parameters
- const S extends Schema
Parameters
- schema: S
- value: unknown
Returns {
    [K in string | number | symbol]: (
        { [K in string
        | number
        | symbol]: ResolveSchemaValue<S[K]> } & {
            [K in string | number | symbol]?: ResolveSchemaValue<S[K]>
        }
    )[K]
}
Example
```
const user = typer.parse(
  { id: 'number', name: 'string', email: 'string?' },
  payload,
);
// user is typed as { id: number; name: string; email?: string | null }
```
- Defined in Typer.ts:1090
parse<T>(types: string | readonly string[], value: unknown): T
Universal "parse" entry point. Validates value against either:
- a built-in type alias ("string", "number", ...),
- an array of aliases (["string", "number"] → union),
- a Validator<T> function,
- or a Schema object.
Returns the value typed correctly. Throws a TypeError on failure.

No as const is needed when calling with a literal schema thanks to the <const S> parameter — the inferred type matches the schema.
Type Parameters
- T
Parameters
- types: string | readonly string[]
- value: unknown
Returns T
Example
```
const user = typer.parse(
  { id: 'number', name: 'string', email: 'string?' },
  payload,
);
// user is typed as { id: number; name: string; email?: string | null }
```
- Defined in Typer.ts:1091

registerType

registerType<T = unknown, R = T>(
    name: string,
    validator: (value: T) => R,
    override?: boolean,
): void
Register a new type in the typesMap.
Type Parameters
- T = unknown
  The input type that the validator expects
- R = T
  The return type that the validator produces
Parameters
- name: string
  The name of the new type.
- validator: (value: T) => R
  The function to validate the type.
- override: boolean = false
  Whether to override the original configuration
Returns void
Throws
If the type name is already registered.
Example
```
// Register a positive number validator
typer.registerType<unknown, number>("positive", (value) => {
   if (typeof value !== "number" || value <= 0) throw new TypeError("Must be positive");
   return value;
});

// Register a string length validator
typer.registerType<unknown, string>("longString", (value) => {
   if (typeof value !== "string" || value.length < 10) throw new TypeError("Must be long string");
   return value;
});
```
- Defined in Typer.ts:230

safeParse

safeParse<K extends keyof TypeMap>(
types: K | readonly K[],
value: unknown,
): ParseResult<TypeMap[K]>
Validates value without throwing. Same input shapes as parse. Returns a discriminated union: { success: true, data } or { success: false, error }.
Type Parameters
- K extends keyof TypeMap
Parameters
- types: K | readonly K[]
- value: unknown
Returns ParseResult<TypeMap[K]>
Example
```
const result = typer.safeParse(
  { id: 'number', name: 'string' },
  payload,
);
if (result.success) {
  // result.data is { id: number; name: string }
} else {
  console.error(result.error.message);
}
```
- Defined in Typer.ts:1129
safeParse<T>(validator: Validator<T>, value: unknown): ParseResult<T>
Validates value without throwing. Same input shapes as parse. Returns a discriminated union: { success: true, data } or { success: false, error }.
Type Parameters
- T
Parameters
- validator: Validator<T>
- value: unknown
Returns ParseResult<T>
Example
```
const result = typer.safeParse(
  { id: 'number', name: 'string' },
  payload,
);
if (result.success) {
  // result.data is { id: number; name: string }
} else {
  console.error(result.error.message);
}
```
- Defined in Typer.ts:1130
safeParse<const S extends Schema>(
    schema: S,
    value: unknown,
): ParseResult<
    {
        [K in string
        | number
        | symbol]: (
            { [K in string
            | number
            | symbol]: ResolveSchemaValue<S[K]> } & {
                [K in string | number | symbol]?: ResolveSchemaValue<S[K]>
            }
        )[K]
    },
>
Validates value without throwing. Same input shapes as parse. Returns a discriminated union: { success: true, data } or { success: false, error }.
Type Parameters
- const S extends Schema
Parameters
- schema: S
- value: unknown
Returns ParseResult<
    {
        [K in string
        | number
        | symbol]: (
            { [K in string
            | number
            | symbol]: ResolveSchemaValue<S[K]> } & {
                [K in string | number | symbol]?: ResolveSchemaValue<S[K]>
            }
        )[K]
    },
>
Example
```
const result = typer.safeParse(
  { id: 'number', name: 'string' },
  payload,
);
if (result.success) {
  // result.data is { id: number; name: string }
} else {
  console.error(result.error.message);
}
```
- Defined in Typer.ts:1131
safeParse<T>(types: string | readonly string[], value: unknown): ParseResult<T>
Validates value without throwing. Same input shapes as parse. Returns a discriminated union: { success: true, data } or { success: false, error }.
Type Parameters
- T
Parameters
- types: string | readonly string[]
- value: unknown
Returns ParseResult<T>
Example
```
const result = typer.safeParse(
  { id: 'number', name: 'string' },
  payload,
);
if (result.success) {
  // result.data is { id: number; name: string }
} else {
  console.error(result.error.message);
}
```
- Defined in Typer.ts:1132

schema

schema<const S extends Schema>(definition: S): S
Identity helper that preserves literal types of a schema declared as a variable. Use it when you want to declare the schema once, derive Infer<typeof schema>, and then call parse(schema, value) with full type inference — without sprinkling as const.
Type Parameters
- const S extends Schema
Parameters
- definition: S
Returns S
Example
```
const userSchema = typer.schema({
  id: 'number',
  name: 'string',
  email: 'string?',
});
type User = Infer<typeof userSchema>;
const user = typer.parse(userSchema, payload); // typed
```
- Defined in Typer.ts:1065

union

union<T extends readonly unknown[]>(
...validators: { [K in string | number | symbol]: Validator<T[K]> },
): Validator<T[number]>
Combines multiple validators into one that succeeds if any of them succeeds. The first matching validator's result is returned.
Type Parameters
- T extends readonly unknown[]
  Tuple of types produced by each validator
Parameters
- ...validators: { [K in string | number | symbol]: Validator<T[K]> }
  Validators to try in order
Returns Validator<T[number]>
A new validator that returns the first matching result
Throws
If none of the validators accepts the value
Example
```
const stringOrNumber = typer.union(
  v => typer.asString(v),
  v => typer.asNumber(v),
);
stringOrNumber(42); // 42
stringOrNumber("hi"); // "hi"
```
- Defined in Typer.ts:1521

unregisterType

unregisterType(name: string): void
Unregister a type from the typesMap.
Parameters
- name: string
  The name of the type to remove.
Returns void
Throws
If the type does not exist.
Example
```
Typer.unregisterType("positive");
```
- Defined in Typer.ts:249

validate

validate(
schema: Record<string, string | string[]>,
obj: Record<string, unknown>,
): string[]
Validates an object against a schema.
Parameters
- schema: Record<string, string | string[]>
  The expected types for each key.
- obj: Record<string, unknown>
  The object to validate.
Returns string[]
- An array of validation errors, or an empty array if valid.
Example
```
const schema = { name: "string", age: "number" };
const obj = { name: "John", age: "25" };
console.log(Typer.validate(schema, obj)); // ["Expected 'age' to be of type number, got string"]
```
- Defined in Typer.ts:2043

Class Typer

Author

Since

Index

Constructors

Methods

Constructors

constructor

Returns Typer

Methods

asArray

Type Parameters

Parameters

Returns T[]

Throws

asBoolean

Parameters

Returns boolean

Throws

asNumber

Parameters

Returns number

Throws

asObject

Type Parameters

Parameters

Returns T

Throws

assert

Parameters

Returns void

Example

asString

Parameters

Returns string

Throws

checkStructure

Parameters

Returns StructureValidationReturn

Example

expect

Parameters

paramTypes: string[]

returnType: string[]

Returns (...args: unknown[]) => any

Throws

Throws

Example

exportTypes

Returns string

Example

importTypes

Parameters

Returns void

Example

is

Type Parameters

Parameters

Returns value is TypeMap[K]

Example

Type Parameters

Parameters

Returns value is T

Example

isArray

Type Parameters

Parameters

Returns value is T[]

isArrayOf

Type Parameters

Parameters

Returns T[]

Throws

Example

isBase64

Parameters

Returns string

Throws

isBoolean

Parameters