justus 0.5.3 → 0.5.5

package/dist/validators/string.cjs.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../src/validators/string.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA+C;AAC/C,mBAAwD;AAqBjD,IAAM,qBAAN,cAAiC,+BAA0B;AAAA,EAChE,SAAS,OAAwB;AAC/B,wCAAiB,OAAO,SAAS,UAAU,yBAAyB;AACpE,WAAO;AAAA,EACT;AACF;AAGO,IAAM,kBAAN,cAAqE,+BAAwB;AAAA,EACzF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,cAAiC,CAAC,GAAG;AAC/C,UAAM;AAEN,UAAM;AAAA,MACJ,YAAY;AAAA,MACZ,YAAY,OAAO;AAAA,MACnB;AAAA,IACF,IAAI;AAEJ,QAAI,WAAW;AAAa,WAAK,QAAe,YAAa;AAE7D,oCAAa,aAAa,GAAG,2BAA2B,SAAS,wBAAwB;AACzF,oCAAa,aAAa,GAAG,2BAA2B,SAAS,wBAAwB;AACzF,oCAAa,aAAa,WAAW,2BAA2B,SAAS,kCAAkC,SAAS,GAAG;AAEvH,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,SAAS,OAAmB;AAC1B,wCAAiB,OAAO,SAAS,UAAU,yBAAyB;AAEpE;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK,SAAS;AAAA,IAAE;AAE5D;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK,SAAS;AAAA,IAAE;AAE5D;AAAA,MAAiB,KAAK,UAAU,KAAK,QAAQ,KAAK,KAAK,IAAI;AAAA,MACvD,0CAA0C,KAAK,OAAO;AAAA,IAAE;AAE5D,WAAO;AAAA,EACT;AACF;AAKO,SAAS,cAAc,aAAmD;AAC/E,SAAO,IAAI,gBAAgB,WAAW;AACxC;AAGO,IAAM,aAAS,mCAAqB,IAAI,mBAAmB,GAAG,aAAa;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA+C;AAC/C,mBAAwD;AAqBjD,IAAM,qBAAN,cAAiC,+BAA0B;AAAA,EAChE,SAAS,OAAwB;AAC/B,wCAAiB,OAAO,UAAU,UAAU,yBAAyB;AACrE,WAAO;AAAA,EACT;AACF;AAGO,IAAM,kBAAN,cAAqE,+BAAwB;AAAA,EACzF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,cAAiC,CAAC,GAAG;AAC/C,UAAM;AAEN,UAAM;AAAA,MACJ,YAAY;AAAA,MACZ,YAAY,OAAO;AAAA,MACnB;AAAA,IACF,IAAI;AAEJ,QAAI,WAAW;AAAa,WAAK,QAAe,YAAa;AAE7D,oCAAa,aAAa,GAAG,2BAA2B,SAAS,wBAAwB;AACzF,oCAAa,aAAa,GAAG,2BAA2B,SAAS,wBAAwB;AACzF,oCAAa,aAAa,WAAW,2BAA2B,SAAS,kCAAkC,SAAS,GAAG;AAEvH,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,SAAS,OAAmB;AAC1B,wCAAiB,OAAO,UAAU,UAAU,yBAAyB;AAErE;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK,SAAS;AAAA,IAAE;AAE5D;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK,SAAS;AAAA,IAAE;AAE5D;AAAA,MAAiB,KAAK,UAAU,KAAK,QAAQ,KAAK,KAAK,IAAI;AAAA,MACvD,0CAA0C,KAAK,OAAO;AAAA,IAAE;AAE5D,WAAO;AAAA,EACT;AACF;AAKO,SAAS,uBAAuB,aAAmD;AACxF,SAAO,IAAI,gBAAgB,WAAW;AACxC;AAGO,IAAM,aAAS,mCAAqB,IAAI,mBAAmB,GAAG,sBAAsB;",
   "names": []
 }

package/dist/validators/string.d.ts

@@ -27,8 +27,8 @@ export declare class StringValidator<S extends string = string, I = string> exte
     constructor(constraints?: StringConstraints);
     validate(value: unknown): S;
 }
-export declare function stringFactory(constraints: StringConstraints): StringValidator<string>;
-export declare function stringFactory<S extends string>(constraints: StringConstraints): StringValidator<S>;
-export declare function stringFactory<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>;
+export declare function stringValidatorFactory(constraints: StringConstraints): StringValidator<string>;
+export declare function stringValidatorFactory<S extends string>(constraints: StringConstraints): StringValidator<S>;
+export declare function stringValidatorFactory<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>;
 /** Validate `string`s. */
-export declare const string: typeof stringFactory & AnyStringValidator;
+export declare const string: typeof stringValidatorFactory & AnyStringValidator;

package/dist/validators/string.mjs

@@ -3,7 +3,7 @@ import { assertSchema, assertValidation } from "../errors.mjs";
 import { AbstractValidator, makeValidatorFactory } from "../types.mjs";
 var AnyStringValidator = class extends AbstractValidator {
   validate(value) {
-    assertValidation(typeof value == "string", 'Value is not a "string"');
+    assertValidation(typeof value === "string", 'Value is not a "string"');
     return value;
   }
 };
@@ -29,7 +29,7 @@ var StringValidator = class extends AbstractValidator {
     this.pattern = pattern;
   }
   validate(value) {
-    assertValidation(typeof value == "string", 'Value is not a "string"');
+    assertValidation(typeof value === "string", 'Value is not a "string"');
     assertValidation(
       value.length >= this.minLength,
       `String must have a minimum length of ${this.minLength}`
@@ -45,14 +45,14 @@ var StringValidator = class extends AbstractValidator {
     return value;
   }
 };
-function stringFactory(constraints) {
+function stringValidatorFactory(constraints) {
   return new StringValidator(constraints);
 }
-var string = makeValidatorFactory(new AnyStringValidator(), stringFactory);
+var string = makeValidatorFactory(new AnyStringValidator(), stringValidatorFactory);
 export {
   AnyStringValidator,
   StringValidator,
   string,
-  stringFactory
+  stringValidatorFactory
 };
 //# sourceMappingURL=string.mjs.map

package/dist/validators/string.mjs.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../src/validators/string.ts"],
-  "mappings": ";AAAA,SAAS,cAAc,wBAAwB;AAC/C,SAAS,mBAAmB,4BAA4B;AAqBjD,IAAM,qBAAN,cAAiC,kBAA0B;AAAA,EAChE,SAAS,OAAwB;AAC/B,qBAAiB,OAAO,SAAS,UAAU,yBAAyB;AACpE,WAAO;AAAA,EACT;AACF;AAGO,IAAM,kBAAN,cAAqE,kBAAwB;AAAA,EACzF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,cAAiC,CAAC,GAAG;AAC/C,UAAM;AAEN,UAAM;AAAA,MACJ,YAAY;AAAA,MACZ,YAAY,OAAO;AAAA,MACnB;AAAA,IACF,IAAI;AAEJ,QAAI,WAAW;AAAa,WAAK,QAAe,YAAa;AAE7D,iBAAa,aAAa,GAAG,2BAA2B,SAAS,wBAAwB;AACzF,iBAAa,aAAa,GAAG,2BAA2B,SAAS,wBAAwB;AACzF,iBAAa,aAAa,WAAW,2BAA2B,SAAS,kCAAkC,SAAS,GAAG;AAEvH,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,SAAS,OAAmB;AAC1B,qBAAiB,OAAO,SAAS,UAAU,yBAAyB;AAEpE;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK,SAAS;AAAA,IAAE;AAE5D;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK,SAAS;AAAA,IAAE;AAE5D;AAAA,MAAiB,KAAK,UAAU,KAAK,QAAQ,KAAK,KAAK,IAAI;AAAA,MACvD,0CAA0C,KAAK,OAAO;AAAA,IAAE;AAE5D,WAAO;AAAA,EACT;AACF;AAKO,SAAS,cAAc,aAAmD;AAC/E,SAAO,IAAI,gBAAgB,WAAW;AACxC;AAGO,IAAM,SAAS,qBAAqB,IAAI,mBAAmB,GAAG,aAAa;",
+  "mappings": ";AAAA,SAAS,cAAc,wBAAwB;AAC/C,SAAS,mBAAmB,4BAA4B;AAqBjD,IAAM,qBAAN,cAAiC,kBAA0B;AAAA,EAChE,SAAS,OAAwB;AAC/B,qBAAiB,OAAO,UAAU,UAAU,yBAAyB;AACrE,WAAO;AAAA,EACT;AACF;AAGO,IAAM,kBAAN,cAAqE,kBAAwB;AAAA,EACzF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,cAAiC,CAAC,GAAG;AAC/C,UAAM;AAEN,UAAM;AAAA,MACJ,YAAY;AAAA,MACZ,YAAY,OAAO;AAAA,MACnB;AAAA,IACF,IAAI;AAEJ,QAAI,WAAW;AAAa,WAAK,QAAe,YAAa;AAE7D,iBAAa,aAAa,GAAG,2BAA2B,SAAS,wBAAwB;AACzF,iBAAa,aAAa,GAAG,2BAA2B,SAAS,wBAAwB;AACzF,iBAAa,aAAa,WAAW,2BAA2B,SAAS,kCAAkC,SAAS,GAAG;AAEvH,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,SAAS,OAAmB;AAC1B,qBAAiB,OAAO,UAAU,UAAU,yBAAyB;AAErE;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK,SAAS;AAAA,IAAE;AAE5D;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK,SAAS;AAAA,IAAE;AAE5D;AAAA,MAAiB,KAAK,UAAU,KAAK,QAAQ,KAAK,KAAK,IAAI;AAAA,MACvD,0CAA0C,KAAK,OAAO;AAAA,IAAE;AAE5D,WAAO;AAAA,EACT;AACF;AAKO,SAAS,uBAAuB,aAAmD;AACxF,SAAO,IAAI,gBAAgB,WAAW;AACxC;AAGO,IAAM,SAAS,qBAAqB,IAAI,mBAAmB,GAAG,sBAAsB;",
   "names": []
 }

package/dist/validators/union.d.ts

@@ -2,7 +2,7 @@ import { AbstractValidator } from '../types';
 import type { InferInput, InferValidation, Validation, ValidationOptions, Validator } from '../types';
 export type OneOfArguments = readonly Validation[];
 export type InferOneOfValidation<A extends OneOfArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends OneOfArguments ? InferValidation<First> | InferOneOfValidation<Rest> : InferValidation<First> : never : A extends readonly (infer Type)[] ? Type extends Validation ? InferValidation<Type> : never : never;
-export type InferOneOfInput<A extends OneOfArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends OneOfArguments ? InferInput<First> | InferOneOfValidation<Rest> : InferInput<First> : never : A extends readonly (infer Type)[] ? Type extends Validation ? InferInput<Type> : never : never;
+export type InferOneOfInput<A extends OneOfArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends OneOfArguments ? InferInput<First> | InferOneOfInput<Rest> : InferInput<First> : never : A extends readonly (infer Type)[] ? Type extends Validation ? InferInput<Type> : never : never;
 /** A `Validator` validating a value as _one of_ the specified arguments. */
 export declare class OneOfValidator<A extends OneOfArguments> extends AbstractValidator<InferOneOfValidation<A>, InferOneOfInput<A>> {
     readonly validators: readonly Validator[];
@@ -13,7 +13,7 @@ export declare class OneOfValidator<A extends OneOfArguments> extends AbstractVa
 export declare function oneOf<A extends OneOfArguments>(...args: A): OneOfValidator<A>;
 export type AllOfArguments = readonly [Validation, ...Validation[]];
 export type InferAllOfValidation<A extends AllOfArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends AllOfArguments ? InferValidation<First> & InferAllOfValidation<Rest> : InferValidation<First> : never : never;
-export type InferAllOfInput<A extends AllOfArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends AllOfArguments ? InferInput<First> & InferAllOfValidation<Rest> : InferInput<First> : never : never;
+export type InferAllOfInput<A extends AllOfArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends AllOfArguments ? InferInput<First> & InferAllOfInput<Rest> : InferInput<First> : never : never;
 /** A `Validator` validating a value as _all of_ the specified arguments. */
 export declare class AllOfValidator<A extends AllOfArguments> extends AbstractValidator<InferAllOfValidation<A>, InferAllOfInput<A>> {
     readonly validators: readonly Validator[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "justus",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "A JavaScript validation library, with types!",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -78,10 +78,8 @@
   "author": "Juit Developers <developers@juit.com>",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@plugjs/build": "^0.5.7",
-    "@plugjs/tsd": "^0.5.7",
-    "@types/chai": "^4.3.9",
-    "chai": "^4.3.10",
+    "@plugjs/build": "^0.5.10",
+    "@plugjs/tsd": "^0.5.10",
     "typescript": "^5.2.2"
   },
   "directories": {

package/src/dts-generator.ts

@@ -7,6 +7,7 @@ import { UUIDValidator } from './extra/uuid'
 import { getValidator } from './utilities'
 import { AnyValidator } from './validators/any'
 import { AnyArrayValidator, ArrayValidator } from './validators/array'
+import { AnyBigIntValidator, BigIntValidator } from './validators/bigint'
 import { BooleanValidator } from './validators/boolean'
 import { ConstantValidator } from './validators/constant'
 import { DateValidator } from './validators/date'
@@ -29,8 +30,8 @@ import type { Validation, Validator } from './types'
 /** Check that two of our generated types are equal */
 function typeEqual(a: TypeNode, b: TypeNode): boolean {
   function eq(a: any, b: any): boolean {
-    if ((typeof a == 'object' && a != null) &&
-        (typeof b == 'object' && b != null) ) {
+    if ((typeof a === 'object' && a != null) &&
+        (typeof b === 'object' && b != null) ) {
       for (const key in a) {
         if (! eq(a[key], b[key])) return false
       }
@@ -426,6 +427,7 @@ function generateTypeNode(
 
 const anyType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
 const anyArrayType = ts.factory.createArrayTypeNode(anyType)
+const bigintType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.BigIntKeyword)
 const booleanType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)
 const dateType = ts.factory.createTypeReferenceNode('Date')
 const numberType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
@@ -453,6 +455,7 @@ const readonlyModifiers = [ ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyw
 
 registerTypeGenerator(AnyValidator, () => anyType)
 registerTypeGenerator(AnyArrayValidator, () => anyArrayType)
+registerTypeGenerator(AnyBigIntValidator, () => bigintType)
 registerTypeGenerator(AnyNumberValidator, () => numberType)
 registerTypeGenerator(AnyObjectValidator, () => recordType)
 registerTypeGenerator(AnyStringValidator, () => stringType)
@@ -467,6 +470,21 @@ registerTypeGenerator(ArrayValidator, (validator, references, isInput) => {
   return ts.factory.createArrayTypeNode(itemType)
 })
 
+registerTypeGenerator(BigIntValidator, (validator: BigIntValidator, _references, isInput) => {
+  if (isInput) {
+    const types: ts.TypeNode[] = [ bigintType ]
+    if (validator.fromNumber) types.push(numberType)
+    if (validator.fromString) types.push(stringType)
+    return types.length === 1 ? types[0] : ts.factory.createUnionTypeNode(types)
+  }
+
+  if (! validator.brand) return bigintType
+
+  const signature = ts.factory.createPropertySignature(undefined, `__brand_${validator.brand}`, undefined, neverType)
+  const literal = ts.factory.createTypeLiteralNode([ signature ])
+  return ts.factory.createIntersectionTypeNode([ bigintType, literal ])
+})
+
 registerTypeGenerator(BooleanValidator, (validator, _references, isInput) => {
   return (isInput && validator.fromString) ?
       ts.factory.createUnionTypeNode([
@@ -481,6 +499,7 @@ registerTypeGenerator(ConstantValidator, (validator) => {
   const literal =
     typeof validator.constant === 'number' ? ts.factory.createNumericLiteral(validator.constant) :
     typeof validator.constant === 'string' ? ts.factory.createStringLiteral(validator.constant) :
+    typeof validator.constant === 'bigint' ? ts.factory.createBigIntLiteral(`${validator.constant}n`) :
     validator.constant === false ? ts.factory.createFalse() :
     validator.constant === true ? ts.factory.createTrue() :
     validator.constant === null ? ts.factory.createNull() :
@@ -611,7 +630,7 @@ registerTypeGenerator(ObjectValidator, (validator, references, isInput) => {
         propertyType, // type
         undefined) // members
 
-    if (properties.length == 0) return extra
+    if (properties.length === 0) return extra
 
     const type = ts.factory.createTypeLiteralNode(properties)
     return ts.factory.createIntersectionTypeNode([ type, extra ])

package/src/extra/arn.ts

@@ -42,7 +42,7 @@ function parse<Service extends string, ResourceType extends string>(
     service?: Service,
     type?: ResourceType,
 ): ParsedArn<Service, ResourceType> {
-  assertValidation(typeof value == 'string', 'Value is not a "string"')
+  assertValidation(typeof value === 'string', 'Value is not a "string"')
 
   const segments = value.split(':')
 

package/src/index.ts

@@ -11,6 +11,7 @@ export * from './utilities'
 // Validators
 export { AnyValidator, any } from './validators/any'
 export { AnyArrayValidator, ArrayValidator, array, arrayOf } from './validators/array'
+export { AnyBigIntValidator, BigIntValidator, bigint } from './validators/bigint'
 export { BooleanValidator, boolean } from './validators/boolean'
 export { ConstantValidator, constant } from './validators/constant'
 export { DateValidator, date } from './validators/date'
@@ -23,19 +24,19 @@ export { TupleValidator, tuple } from './validators/tuple'
 export { AllOfValidator, OneOfValidator, allOf, oneOf } from './validators/union'
 
 // Validator Types
-export type { ArrayConstraints, arrayFactory } from './validators/array'
-export type { BooleanConstraints, booleanFactory } from './validators/boolean'
-export type { DateConstraints, dateFactory } from './validators/date'
-export type { BrandedNumberConstraints, numberFactory } from './validators/number'
-export type { objectFactory } from './validators/object'
-export type { BrandedStringConstraints, StringConstraints, stringFactory } from './validators/string'
+export type { ArrayConstraints, arrayValidatorFactory } from './validators/array'
+export type { BrandedBigIntConstraints, bigintValidatorFactory } from './validators/bigint'
+export type { BooleanConstraints, booleanValidatorFactory } from './validators/boolean'
+export type { DateConstraints, dateValidatorFactory } from './validators/date'
+export type { BrandedNumberConstraints, numberValidatorFactory } from './validators/number'
+export type { objectValidatorFactory } from './validators/object'
+export type { BrandedStringConstraints, StringConstraints, stringValidatorFactory } from './validators/string'
 export type { TupleMember } from './validators/tuple'
 
 /* ========================================================================== *
  * VALIDATE FUNCTION (our main entry point)                                   *
  * ========================================================================== */
 
-import { defaultValidationOptions } from './types'
 import { getValidator } from './utilities'
 
 import type { InferValidation, Validation, ValidationOptions } from './types'
@@ -51,7 +52,7 @@ export function validate<V extends Validation>(
     value: any,
     options?: ValidationOptions,
 ): InferValidation<V> {
-  const opts: ValidationOptions = { ...defaultValidationOptions, ...options }
+  const opts: ValidationOptions = { ...options }
   return getValidator(validation).validate(value, opts)
 }
 
@@ -83,3 +84,20 @@ export function strip<V extends Validation>(
 
   return getValidator(validation).validate(value, opts)
 }
+
+/**
+ * Validate a _value_ using the specified `Validation`, automatically stripping
+ * additional properties and optional `null`s (but not forbidden ones), and
+ * treating all properties as optional.
+ *
+ * This is equivalent to setting the `partialValidation` option to `true` in
+ * `validate(...)`, but this function correctly represents the returned type as
+ * a `Partial<...>` type.
+ */
+export function partial<V extends Validation>(
+    validation: V,
+    value: any,
+    options?: ValidationOptions,
+): Partial<InferValidation<V>> {
+  return getValidator(validation).validate(value, { ...options, partialValidation: true })
+}

package/src/types.ts

@@ -34,15 +34,8 @@ export interface ValidationOptions {
   stripOptionalNulls?: boolean,
   /** Ignore and strip forbidden (`never`) properties from objects (default: `false`) */
   stripForbiddenProperties?: boolean,
-}
-
-/**
- * Default validation options.
- */
-export const defaultValidationOptions: Readonly<Required<ValidationOptions>> = {
-  stripAdditionalProperties: false,
-  stripForbiddenProperties: false,
-  stripOptionalNulls: false,
+  /**  Perform a _partial_ validation, treating all properties as optional (default: `false`) */
+  partialValidation?: boolean,
 }
 
 /**
@@ -117,13 +110,13 @@ implements Validator<T, I>, Iterable<TupleRestParameter<T, I>> {
  * Those are:
  *
  * * A `Validator` instance or a _zero-arguments_ function returning one
- * * A `Tuple` or a `Schema`, validated as arrays or object
- * * Either `null`, a `boolean`, a `number` or a `string` for constants
+ * * A `Tuple` or a `Schema`, validated as arrays or objects
+ * * Either `null`, a `boolean`, a `number`, a `bigint` or a `string` for constants
  */
 export type Validation =
   Validator | // Validator instances
   Tuple | Schema | // Tuples or schemas (arrays, objects)
-  null | boolean | number | string // Primitives, mapped as constants
+  null | boolean | bigint | number | string // Primitives, mapped as constants
 
 /**
  * Infer the type returned by a `Validation` when validating.
@@ -135,6 +128,7 @@ export type InferValidation<V> =
   // Primitives are returned as constants
   V extends undefined ? V :
   V extends boolean ? V :
+  V extends bigint ? V :
   V extends number ? V :
   V extends string ? V :
   V extends null ? V :
@@ -155,6 +149,7 @@ export type InferInput<V> =
   // Primitives are returned as constants
   V extends undefined ? V :
   V extends boolean ? V :
+  V extends bigint ? V :
   V extends number ? V :
   V extends string ? V :
   V extends null ? V :

package/src/utilities.ts

@@ -1,13 +1,14 @@
 import { assertSchema } from './errors'
 import { registry } from './registry'
 
-import type { Schema, Validation, Validator } from './types'
+import type { InferInput, InferValidation, Schema, Validation, Validator } from './types'
 
 /* ========================================================================== *
  * UTILITY FUNCTIONS                                                          *
  * ========================================================================== */
 
 /** Return the `Validator` for the given `Validation` */
+export function getValidator<V extends Validation>(validation: V): Validator<InferValidation<V>, InferInput<V>>
 export function getValidator(validation: Validation): Validator {
   assertSchema(validation !== undefined, 'No validator for undefined validation')
 
@@ -23,6 +24,7 @@ export function getValidator(validation: Validation): Validator {
   switch (typeof validation) {
     // constants
     case 'boolean':
+    case 'bigint':
     case 'string':
     case 'number':
       return new (registry.get('constant'))(validation)

package/src/validators/array.ts

@@ -3,7 +3,7 @@ import { AbstractValidator, makeValidatorFactory } from '../types'
 import { getValidator } from '../utilities'
 import { any } from './any'
 
-import type { InferValidation, Validation, ValidationOptions, Validator } from '../types'
+import type { InferInput, InferValidation, Validation, ValidationOptions, Validator } from '../types'
 
 /* ========================================================================== *
  * ARRAYS VALIDATION                                                           *
@@ -22,7 +22,7 @@ export interface ArrayConstraints<V extends Validation> {
 }
 
 /** Basic validator for `Array` instances. */
-export class AnyArrayValidator<T = any> extends AbstractValidator<T[], T[]> {
+export class AnyArrayValidator<T = any> extends AbstractValidator<T[]> {
   validate(value: unknown): T[] {
     assertValidation(Array.isArray(value), 'Value is not an "array"')
     return [ ...value ]
@@ -30,7 +30,7 @@ export class AnyArrayValidator<T = any> extends AbstractValidator<T[], T[]> {
 }
 
 /** A validator for `Array` instances with constraints. */
-export class ArrayValidator<T> extends AbstractValidator<T[]> {
+export class ArrayValidator<T, I = T> extends AbstractValidator<T[], I[]> {
   readonly maxItems: number
   readonly minItems: number
   readonly uniqueItems: boolean
@@ -89,15 +89,17 @@ export class ArrayValidator<T> extends AbstractValidator<T[]> {
 
 /* -------------------------------------------------------------------------- */
 
-export function arrayFactory<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>> {
+export function arrayValidatorFactory<V extends Validation>(
+    constraints: ArrayConstraints<V>,
+): ArrayValidator<InferValidation<V>, InferInput<V>> {
   const items = constraints.items ? getValidator(constraints.items) : any
-  return new ArrayValidator({ ...constraints, items })
+  return new ArrayValidator<any>({ ...constraints, items })
 }
 
 /** Validate `Array`s. */
-export const array = makeValidatorFactory(new AnyArrayValidator(), arrayFactory)
+export const array = makeValidatorFactory(new AnyArrayValidator(), arrayValidatorFactory)
 
 /** Validate `Array`s containing only the specified elements. */
-export function arrayOf<V extends Validation>(validation: V): Validator<InferValidation<V>[]> {
+export function arrayOf<V extends Validation>(validation: V): Validator<InferValidation<V>[], InferInput<V>[]> {
   return new ArrayValidator({ items: getValidator(validation) })
 }

package/src/validators/bigint.ts

@@ -0,0 +1,147 @@
+import { assertSchema, assertValidation, ValidationError } from '../errors'
+import { AbstractValidator, makeValidatorFactory } from '../types'
+
+import type { Branding, Validator } from '../types'
+
+/* ========================================================================== */
+
+/** Constraints to validate a `bigint` with. */
+export interface BigIntConstraints {
+  /** The value for which a `bigint` must be multiple of for it to be valid */
+  multipleOf?: bigint | number,
+  /** The _inclusive_ maximum value for a valid `bigint`: `value <= maximum` */
+  maximum?: bigint | number,
+  /** The _inclusive_ minimum value for a valid `bigint`: `value >= minimum` */
+  minimum?: bigint | number,
+  /** The _exclusive_ maximum value for a valid `bigint`: `value < exclusiveMaximum` */
+  exclusiveMaximum?: bigint | number,
+  /** The _exclusive_ minimum value for a valid `bigint`: `value > exclusiveMaximum` */
+  exclusiveMinimum?: bigint | number,
+  /** Allow bigints to be parsed from strings (e.g. `123.456` or `0x0CAFE`, default: `false`) */
+  fromString?: boolean,
+  /** Allow bigints to be parsed from numbers (default: `true`) */
+  fromNumber?: boolean,
+}
+
+/** Constraints to validate a `bigint` with extra branding information. */
+export interface BrandedBigIntConstraints<B extends string> extends BigIntConstraints {
+  /** The _brand_ of the string (will generate a `__brand_${B}` type property */
+  brand: B
+}
+
+/** A `Validator` validating any `bigint`. */
+export class AnyBigIntValidator extends AbstractValidator<bigint> {
+  validate(value: unknown): bigint {
+    if (typeof value === 'number') {
+      try {
+        value = BigInt(value)
+      } catch (error) {
+        throw new ValidationError('BigInt can not be parsed from number')
+      }
+    }
+    assertValidation(typeof value === 'bigint', 'Value is not a "bigint"')
+    return value
+  }
+}
+
+/** A `Validator` validating `bigint`s with constaints. */
+export class BigIntValidator<N extends bigint = bigint> extends AbstractValidator<N, bigint> {
+  readonly fromString: boolean
+  readonly fromNumber: boolean
+  readonly exclusiveMaximum?: bigint
+  readonly exclusiveMinimum?: bigint
+  readonly maximum?: bigint
+  readonly minimum?: bigint
+  readonly multipleOf?: bigint
+  readonly brand?: string
+
+  constructor(constraints: BigIntConstraints = {}) {
+    super()
+
+    const {
+      exclusiveMaximum,
+      exclusiveMinimum,
+      maximum,
+      minimum,
+      multipleOf,
+      fromString = false,
+      fromNumber = true,
+    } = constraints
+
+    if ('brand' in constraints) this.brand = (<any> constraints).brand
+    this.fromString = fromString
+    this.fromNumber = fromNumber
+
+    const _exclusiveMaximum = exclusiveMaximum === undefined ? undefined : BigInt(exclusiveMaximum)
+    const _exclusiveMinimum = exclusiveMinimum === undefined ? undefined : BigInt(exclusiveMinimum)
+    const _maximum = maximum === undefined ? undefined : BigInt(maximum)
+    const _minimum = minimum === undefined ? undefined : BigInt(minimum)
+    const _multipleOf = multipleOf === undefined ? undefined : BigInt(multipleOf)
+
+    if ((_maximum !== undefined) && (_minimum !== undefined)) {
+      assertSchema(_maximum >= _minimum, `Constraint "minimum" (${_minimum}) is greater than "maximum" (${_maximum})`)
+    }
+
+    if ((_exclusiveMaximum !== undefined) && (_minimum !== undefined)) {
+      assertSchema(_exclusiveMaximum > _minimum,
+          `Constraint "exclusiveMaximum" (${_exclusiveMaximum}) must be greater than "minimum" (${_minimum})`)
+    }
+
+    if ((_exclusiveMinimum !== undefined) && (_maximum != undefined)) {
+      assertSchema(_maximum > _exclusiveMinimum,
+          `Constraint "maximum" (${_maximum}) must be greater than "exclusiveMinimum" (${_exclusiveMinimum})`)
+    }
+
+    if ((_exclusiveMinimum != undefined) && (_exclusiveMaximum !== undefined)) {
+      assertSchema(_exclusiveMaximum > _exclusiveMinimum,
+          `Constraint "exclusiveMaximum" (${_exclusiveMaximum}) must be greater than "exclusiveMinimum" (${_exclusiveMinimum})`)
+    }
+
+    if (_multipleOf !== undefined) {
+      assertSchema(_multipleOf > 0, `Constraint "multipleOf" (${_multipleOf}) must be greater than zero`)
+    }
+
+    this.exclusiveMaximum = _exclusiveMaximum
+    this.exclusiveMinimum = _exclusiveMinimum
+    this.maximum = _maximum
+    this.minimum = _minimum
+    this.multipleOf = _multipleOf
+  }
+
+  validate(value: unknown): N {
+    // Allow parsing from strings or numbers
+    if (((typeof value === 'string') && (this.fromString)) ||
+        ((typeof value === 'number') && (this.fromNumber))) {
+      try {
+        value = BigInt(value)
+      } catch (error) {
+        throw new ValidationError('BigInt can not be parsed from ' + typeof value)
+      }
+    }
+
+    assertValidation(typeof value === 'bigint', 'Value is not a "bigint"')
+
+    assertValidation(((this.minimum === undefined) || (value >= this.minimum)),
+        `BigInt is less than ${this.minimum}`)
+    assertValidation(((this.maximum === undefined) || (value <= this.maximum)),
+        `BigInt is greater than ${this.maximum}`)
+    assertValidation((this.exclusiveMinimum === undefined) || (value > this.exclusiveMinimum),
+        `BigInt is less than or equal to ${this.exclusiveMinimum}`)
+    assertValidation((this.exclusiveMaximum === undefined) || (value < this.exclusiveMaximum),
+        `BigInt is greater than or equal to ${this.exclusiveMaximum}`)
+    assertValidation((this.multipleOf === undefined) || (!(value % this.multipleOf)),
+        `BigInt is not a multiple of ${this.multipleOf}`)
+
+    return value as N
+  }
+}
+
+export function bigintValidatorFactory(constraints: BigIntConstraints): BigIntValidator<bigint>
+export function bigintValidatorFactory<N extends bigint>(constraints: BigIntConstraints): BigIntValidator<N>
+export function bigintValidatorFactory<B extends string>(constraints: BrandedBigIntConstraints<B>): BigIntValidator<bigint & Branding<B>>
+export function bigintValidatorFactory(constraints: BigIntConstraints): Validator<bigint> {
+  return new BigIntValidator(constraints)
+}
+
+/** Validate `bigint`s. */
+export const bigint = makeValidatorFactory(new AnyBigIntValidator(), bigintValidatorFactory)

package/src/validators/boolean.ts

@@ -25,7 +25,7 @@ export class BooleanValidator extends AbstractValidator<boolean> {
 
   validate(value: unknown): boolean {
     // Allow parsing from strings
-    if ((typeof value == 'string') && (this.fromString)) {
+    if ((typeof value === 'string') && (this.fromString)) {
       const string = value.toLowerCase()
       const parsed = string === 'true' ? true : string === 'false' ? false : undefined
       assertValidation(parsed !== undefined, 'Boolean can not be parsed from string')
@@ -37,9 +37,9 @@ export class BooleanValidator extends AbstractValidator<boolean> {
   }
 }
 
-export function booleanFactory(constraints: BooleanConstraints): BooleanValidator {
+export function booleanValidatorFactory(constraints: BooleanConstraints): BooleanValidator {
   return new BooleanValidator(constraints)
 }
 
 /** The `Validator` for `boolean`s. */
-export const boolean = makeValidatorFactory(new BooleanValidator(), booleanFactory)
+export const boolean = makeValidatorFactory(new BooleanValidator(), booleanValidatorFactory)

package/src/validators/constant.ts

@@ -5,7 +5,7 @@ import { AbstractValidator } from '../types'
 import type { Validator } from '../types'
 
 /** A `Validator` for _constants_. */
-export class ConstantValidator<T extends string | number | boolean | null> extends AbstractValidator<T> {
+export class ConstantValidator<T extends string | number | boolean | bigint | null> extends AbstractValidator<T> {
   readonly constant: T
 
   constructor(constant: T) {
@@ -14,13 +14,14 @@ export class ConstantValidator<T extends string | number | boolean | null> exten
   }
 
   validate(value: unknown): T {
-    assertValidation(value === this.constant, `Value does not match constant "${this.constant}"`)
+    const extra = this.constant === null ? '' : ` (${typeof this.constant})`
+    assertValidation(value === this.constant, `Value does not match constant "${this.constant}"${extra}`)
     return value as T
   }
 }
 
 /** Validate _constants_. */
-export function constant<T extends string | number | boolean | null>(constant: T): Validator<T> {
+export function constant<T extends string | number | boolean | bigint | null>(constant: T): Validator<T> {
   return new ConstantValidator(constant)
 }
 

package/src/validators/date.ts

@@ -64,9 +64,9 @@ export class DateValidator extends AbstractValidator<Date, Date | string | numbe
   }
 }
 
-export function dateFactory(constraints: DateConstraints): DateValidator {
+export function dateValidatorFactory(constraints: DateConstraints): DateValidator {
   return new DateValidator(constraints)
 }
 
 /** Validate dates and convert them to `Date` instances. */
-export const date = makeValidatorFactory(new DateValidator(), dateFactory)
+export const date = makeValidatorFactory(new DateValidator(), dateValidatorFactory)

package/src/validators/never.ts

@@ -1,5 +1,5 @@
 import { ValidationError } from '../errors'
-import { AbstractValidator, defaultValidationOptions } from '../types'
+import { AbstractValidator } from '../types'
 
 import type { ValidationOptions } from '../types'
 
@@ -7,7 +7,7 @@ import type { ValidationOptions } from '../types'
 export class NeverValidator extends AbstractValidator<never> {
   optional: true = true
 
-  validate(value: unknown, options: ValidationOptions = defaultValidationOptions): never {
+  validate(value: unknown, options: ValidationOptions = {}): never {
     const { stripForbiddenProperties } = options
 
     // @ts-expect-error