bguard 0.5.0 → 0.6.0

package/lib/core.d.mts

@@ -0,0 +1,200 @@
+import { BaseType, TranslationErrorMap, ValidationErrorData, MetaContext, TransformCallback, WithNull, WithUndefined } from './commonTypes.mjs';
+import { InferType } from './InferType.mjs';
+import { ctxSymbol } from './helpers/constants.mjs';
+
+declare class ExceptionContext {
+    readonly initialReceived: unknown;
+    readonly t: TranslationErrorMap;
+    readonly pathToError: string;
+    readonly errors?: ValidationErrorData[] | undefined;
+    readonly meta?: MetaContext | undefined;
+    constructor(initialReceived: unknown, t: TranslationErrorMap, pathToError: string, errors?: ValidationErrorData[] | undefined, meta?: MetaContext | undefined);
+    createChild(childPathToError: string, childMeta?: MetaContext): ExceptionContext;
+    ref(path: string): unknown;
+    addIssue(expected: unknown, received: unknown, messageKey: string): never | void;
+}
+type RequiredValidation = (received: any, ctx: ExceptionContext) => void;
+type ObjectShapeSchemaType = Record<string, CommonSchema>;
+interface ValidatorContext {
+    type: BaseType[];
+    isNullable?: boolean;
+    isOptional?: boolean;
+    requiredValidations: RequiredValidation[];
+    array?: CommonSchema;
+    object?: ObjectShapeSchemaType;
+    allowUnrecognizedObjectProps?: boolean;
+    strictType?: boolean;
+    strictTypeValue?: unknown;
+    date?: boolean;
+    defaultValue?: unknown;
+    meta?: MetaContext;
+    transformListBefore?: TransformCallback<any, any>[];
+}
+declare class CommonSchema {
+    [ctxSymbol]: ValidatorContext;
+    constructor(ctx: ValidatorContext);
+    /**
+     * @param validators - One or more custom validation functions.
+     * @returns {this} The schema instance with the added custom validation.
+     */
+    custom(...validators: RequiredValidation[]): this;
+    /**
+     * Marks the schema as nullable, allowing the value to be `null`.
+     *
+     * @returns {WithNull<this>} The schema instance marked as nullable.
+     */
+    nullable(): WithNull<this>;
+    /**
+     * Marks the schema as optional, allowing the value to be `undefined`.
+     *
+     * @returns {WithUndefined<this>} The schema instance marked as optional.
+     */
+    optional(): WithUndefined<this>;
+    /**
+     * Marks the schema as optional, allowing the value to be `undefined`.
+     *
+     * @returns {this} The schema instance. This method should be used as a last one because it does the check of previous methods and
+     */
+    default(defaultValue: InferType<this>): this;
+    /**
+     * Applies a transformation to the input value before any validation occurs.
+     * The transformation should return a value of the same type as the inferred type of the schema,
+     * ensuring that the overall type is not altered.
+     *
+     * @template In - The type of the input value before transformation (defaults to `unknown`).
+     * @param {TransformCallback<In, InferType<this>>} cb - The callback function that performs the transformation.
+     * @returns {this} The updated schema with the applied transformation.
+     *
+     * @example
+     * const schema = string()
+     *   .nullable()
+     *   .transformBeforeValidation((val) => val + '') // Ensure the value is a string
+     *   .transformBeforeValidation((val: string) => (val === '' ? null : val)); // Convert empty strings to null
+     *
+     * // Parse 'test' will pass as 'test' is a valid string longer than 3 characters.
+     * parseOrFail(schema, 'test');
+     *
+     * // Parsing '' will be transformed to null and will pass due to .nullable().
+     * parseOrFail(schema, '');
+     */
+    transformBeforeValidation<In>(cb: TransformCallback<In, InferType<this>>): this;
+    /**
+     * Assigns a unique identifier to the schema.
+     * This ID can be used to track or map validation errors back to specific fields
+     * in a form or other structures.
+     *
+     * @param {string} value - The unique identifier for the schema.
+     * @returns {this} The updated schema with the assigned ID.
+     *
+     * @example
+     * const schema = string().id('username');
+     */
+    id(value: string): this;
+    /**
+     * Provides a description for the schema, offering additional context or information.
+     * The description can be used when displaying validation errors or for documentation purposes.
+     *
+     * @param {string} value - The description for the schema.
+     * @returns {this} The updated schema with the added description.
+     *
+     * @example
+     * const schema = string().description('The username of the account holder.');
+     */
+    description(value: string): this;
+    private meta;
+    protected defaultValueCheck(): void;
+}
+/**
+ * Parses and validates a value against the provided schema, returning a type-safe result.
+ *
+ * This function will throw a `ValidationError` if the value does not conform to the schema.
+ * The inferred TypeScript type of the returned value will match the structure defined by the schema.
+ *
+ * @template T
+ * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.
+ * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.
+ * @param {ParseOptions} options - Options
+ * @param {ParseOptions.lng} options.lng -  Set language keyword to map Error message
+ * @returns {InferType<T>} The validated value, with its TypeScript type inferred from the schema.
+ *
+ * @throws {ValidationError} If the received value does not match the schema, a `ValidationError` will be thrown.
+ * @throws {Error} If an unexpected error occurs during validation, an error will be thrown with a generic message.
+ *
+ * @example
+ * const schema = object({
+ *   name: string(),
+ *   age: number(),
+ * });
+ *
+ * const result = parseOrFail(schema, { name: 'Alice', age: 30 });
+ * // result will be inferred as { name: string; age: number }
+ *
+ * parseOrFail(schema, { name: 'Alice', age: '30' });
+ * // Throws ValidationError because 'age' should be a number, not a string.
+ */
+declare function parseOrFail<T extends CommonSchema>(schema: T, receivedValue: unknown, options?: ParseOptions): InferType<T>;
+interface ParseOptions {
+    /**
+     * Set language keyword to map error messages.
+     * @default 'default'
+     * @example 'sr' or 'Serbia' or any string to identify language
+     */
+    lng?: string;
+}
+interface ParseOptions {
+    /**
+     * Set language keyword to map error messages.
+     * @default 'default'
+     * @example 'sr' or 'Serbia' or any string to identify language
+     */
+    lng?: string;
+    /**
+     * If true, collects all validation errors and returns them.
+     * If false or undefined, returns the first validation error it can find and stops looking,
+     * which provides a small runtime optimization.
+     * @default undefined
+     */
+    getAllErrors?: boolean;
+}
+/**
+ * Parses and validates a value against the provided schema, returning a type-safe parsedValue.
+ *
+ * This function will throw a `ValidationError` if the value does not conform to the schema.
+ * The inferred TypeScript type of the returned value will match the structure defined by the schema.
+ *
+ * @template T
+ * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.
+ * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.
+ * @param {ParseOptions} options - Options
+ * @param {ParseOptions.lng} options.lng -  Set language keyword to map Error messages
+ * @param {ParseOptions.lng} options.getAllErrors - If `false` or `undefined` - returns the first validation error it can find and stops looking, which provides a small runtime optimization.
+ * @returns {[undefined, InferType<T>]} A tuple of [undefined, InferType<T>] if parsing is successful.
+ * @returns {[ValidationErrorData[], undefined]} A tuple of [ValidationErrorData[], undefined]] if errors occur.
+ *
+ * @example
+ * const schema = object({
+ *   name: string(),
+ *   age: number(),
+ * });
+ *
+ * const [errors, parsedValue]  = parse(schema, { name: 'Alice', age: 30 });
+ * // parsedValue will be inferred as { name: string; age: number }
+ *
+ *
+ *  const [errors, parsedValue] = parse(schema, { name: 'Alice', age: '30' });
+ * // First element in array "errors" will have an error because 'age' should be a number, not a string.
+ * // Array 'errors' returns only one element.
+ *
+ *
+ *  const [errors, parsedValue] = parse(schema, { name: true, age: '30' }, { getAllErrors: true});
+ * // Returns array "errors" with multiple errors because 'age' should be a number and 'name' a string.
+ * // With provided options { getAllErrors: true}, we can expecte more than one error in 'errors' array.
+ *
+ *
+ *  const [errors, parsedValue] = parse(schema, { name: true, age: '30' }, { lng: 'SR'});
+ * // First element in array "errors" will have an error because 'age' should be a number, not a string.
+ * // With provided options { lng: 'SR'}, errors will be translated to a language mapped with keyword 'SR'
+ */
+declare function parse<T extends CommonSchema>(schema: T, receivedValue: unknown, options?: ParseOptions): [ValidationErrorData[], undefined] | [undefined, InferType<T>];
+
+export { CommonSchema, ExceptionContext, type ObjectShapeSchemaType, type RequiredValidation, type ValidatorContext, parse, parseOrFail };

package/lib/core.d.ts

@@ -0,0 +1,200 @@
+import { BaseType, TranslationErrorMap, ValidationErrorData, MetaContext, TransformCallback, WithNull, WithUndefined } from './commonTypes.js';
+import { InferType } from './InferType.js';
+import { ctxSymbol } from './helpers/constants.js';
+
+declare class ExceptionContext {
+    readonly initialReceived: unknown;
+    readonly t: TranslationErrorMap;
+    readonly pathToError: string;
+    readonly errors?: ValidationErrorData[] | undefined;
+    readonly meta?: MetaContext | undefined;
+    constructor(initialReceived: unknown, t: TranslationErrorMap, pathToError: string, errors?: ValidationErrorData[] | undefined, meta?: MetaContext | undefined);
+    createChild(childPathToError: string, childMeta?: MetaContext): ExceptionContext;
+    ref(path: string): unknown;
+    addIssue(expected: unknown, received: unknown, messageKey: string): never | void;
+}
+type RequiredValidation = (received: any, ctx: ExceptionContext) => void;
+type ObjectShapeSchemaType = Record<string, CommonSchema>;
+interface ValidatorContext {
+    type: BaseType[];
+    isNullable?: boolean;
+    isOptional?: boolean;
+    requiredValidations: RequiredValidation[];
+    array?: CommonSchema;
+    object?: ObjectShapeSchemaType;
+    allowUnrecognizedObjectProps?: boolean;
+    strictType?: boolean;
+    strictTypeValue?: unknown;
+    date?: boolean;
+    defaultValue?: unknown;
+    meta?: MetaContext;
+    transformListBefore?: TransformCallback<any, any>[];
+}
+declare class CommonSchema {
+    [ctxSymbol]: ValidatorContext;
+    constructor(ctx: ValidatorContext);
+    /**
+     * @param validators - One or more custom validation functions.
+     * @returns {this} The schema instance with the added custom validation.
+     */
+    custom(...validators: RequiredValidation[]): this;
+    /**
+     * Marks the schema as nullable, allowing the value to be `null`.
+     *
+     * @returns {WithNull<this>} The schema instance marked as nullable.
+     */
+    nullable(): WithNull<this>;
+    /**
+     * Marks the schema as optional, allowing the value to be `undefined`.
+     *
+     * @returns {WithUndefined<this>} The schema instance marked as optional.
+     */
+    optional(): WithUndefined<this>;
+    /**
+     * Marks the schema as optional, allowing the value to be `undefined`.
+     *
+     * @returns {this} The schema instance. This method should be used as a last one because it does the check of previous methods and
+     */
+    default(defaultValue: InferType<this>): this;
+    /**
+     * Applies a transformation to the input value before any validation occurs.
+     * The transformation should return a value of the same type as the inferred type of the schema,
+     * ensuring that the overall type is not altered.
+     *
+     * @template In - The type of the input value before transformation (defaults to `unknown`).
+     * @param {TransformCallback<In, InferType<this>>} cb - The callback function that performs the transformation.
+     * @returns {this} The updated schema with the applied transformation.
+     *
+     * @example
+     * const schema = string()
+     *   .nullable()
+     *   .transformBeforeValidation((val) => val + '') // Ensure the value is a string
+     *   .transformBeforeValidation((val: string) => (val === '' ? null : val)); // Convert empty strings to null
+     *
+     * // Parse 'test' will pass as 'test' is a valid string longer than 3 characters.
+     * parseOrFail(schema, 'test');
+     *
+     * // Parsing '' will be transformed to null and will pass due to .nullable().
+     * parseOrFail(schema, '');
+     */
+    transformBeforeValidation<In>(cb: TransformCallback<In, InferType<this>>): this;
+    /**
+     * Assigns a unique identifier to the schema.
+     * This ID can be used to track or map validation errors back to specific fields
+     * in a form or other structures.
+     *
+     * @param {string} value - The unique identifier for the schema.
+     * @returns {this} The updated schema with the assigned ID.
+     *
+     * @example
+     * const schema = string().id('username');
+     */
+    id(value: string): this;
+    /**
+     * Provides a description for the schema, offering additional context or information.
+     * The description can be used when displaying validation errors or for documentation purposes.
+     *
+     * @param {string} value - The description for the schema.
+     * @returns {this} The updated schema with the added description.
+     *
+     * @example
+     * const schema = string().description('The username of the account holder.');
+     */
+    description(value: string): this;
+    private meta;
+    protected defaultValueCheck(): void;
+}
+/**
+ * Parses and validates a value against the provided schema, returning a type-safe result.
+ *
+ * This function will throw a `ValidationError` if the value does not conform to the schema.
+ * The inferred TypeScript type of the returned value will match the structure defined by the schema.
+ *
+ * @template T
+ * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.
+ * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.
+ * @param {ParseOptions} options - Options
+ * @param {ParseOptions.lng} options.lng -  Set language keyword to map Error message
+ * @returns {InferType<T>} The validated value, with its TypeScript type inferred from the schema.
+ *
+ * @throws {ValidationError} If the received value does not match the schema, a `ValidationError` will be thrown.
+ * @throws {Error} If an unexpected error occurs during validation, an error will be thrown with a generic message.
+ *
+ * @example
+ * const schema = object({
+ *   name: string(),
+ *   age: number(),
+ * });
+ *
+ * const result = parseOrFail(schema, { name: 'Alice', age: 30 });
+ * // result will be inferred as { name: string; age: number }
+ *
+ * parseOrFail(schema, { name: 'Alice', age: '30' });
+ * // Throws ValidationError because 'age' should be a number, not a string.
+ */
+declare function parseOrFail<T extends CommonSchema>(schema: T, receivedValue: unknown, options?: ParseOptions): InferType<T>;
+interface ParseOptions {
+    /**
+     * Set language keyword to map error messages.
+     * @default 'default'
+     * @example 'sr' or 'Serbia' or any string to identify language
+     */
+    lng?: string;
+}
+interface ParseOptions {
+    /**
+     * Set language keyword to map error messages.
+     * @default 'default'
+     * @example 'sr' or 'Serbia' or any string to identify language
+     */
+    lng?: string;
+    /**
+     * If true, collects all validation errors and returns them.
+     * If false or undefined, returns the first validation error it can find and stops looking,
+     * which provides a small runtime optimization.
+     * @default undefined
+     */
+    getAllErrors?: boolean;
+}
+/**
+ * Parses and validates a value against the provided schema, returning a type-safe parsedValue.
+ *
+ * This function will throw a `ValidationError` if the value does not conform to the schema.
+ * The inferred TypeScript type of the returned value will match the structure defined by the schema.
+ *
+ * @template T
+ * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.
+ * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.
+ * @param {ParseOptions} options - Options
+ * @param {ParseOptions.lng} options.lng -  Set language keyword to map Error messages
+ * @param {ParseOptions.lng} options.getAllErrors - If `false` or `undefined` - returns the first validation error it can find and stops looking, which provides a small runtime optimization.
+ * @returns {[undefined, InferType<T>]} A tuple of [undefined, InferType<T>] if parsing is successful.
+ * @returns {[ValidationErrorData[], undefined]} A tuple of [ValidationErrorData[], undefined]] if errors occur.
+ *
+ * @example
+ * const schema = object({
+ *   name: string(),
+ *   age: number(),
+ * });
+ *
+ * const [errors, parsedValue]  = parse(schema, { name: 'Alice', age: 30 });
+ * // parsedValue will be inferred as { name: string; age: number }
+ *
+ *
+ *  const [errors, parsedValue] = parse(schema, { name: 'Alice', age: '30' });
+ * // First element in array "errors" will have an error because 'age' should be a number, not a string.
+ * // Array 'errors' returns only one element.
+ *
+ *
+ *  const [errors, parsedValue] = parse(schema, { name: true, age: '30' }, { getAllErrors: true});
+ * // Returns array "errors" with multiple errors because 'age' should be a number and 'name' a string.
+ * // With provided options { getAllErrors: true}, we can expecte more than one error in 'errors' array.
+ *
+ *
+ *  const [errors, parsedValue] = parse(schema, { name: true, age: '30' }, { lng: 'SR'});
+ * // First element in array "errors" will have an error because 'age' should be a number, not a string.
+ * // With provided options { lng: 'SR'}, errors will be translated to a language mapped with keyword 'SR'
+ */
+declare function parse<T extends CommonSchema>(schema: T, receivedValue: unknown, options?: ParseOptions): [ValidationErrorData[], undefined] | [undefined, InferType<T>];
+
+export { CommonSchema, ExceptionContext, type ObjectShapeSchemaType, type RequiredValidation, type ValidatorContext, parse, parseOrFail };

package/lib/core.js

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkVN4GLOENjs = require('./chunk-VN4GLOEN.js');
+require('./chunk-VBTWYDEM.js');
+require('./chunk-TJQ5NVL4.js');
+require('./chunk-FIDPCCCW.js');
+require('./chunk-AXKX5BGH.js');
+
+
+
+
+
+exports.CommonSchema = _chunkVN4GLOENjs.CommonSchema; exports.ExceptionContext = _chunkVN4GLOENjs.ExceptionContext; exports.parse = _chunkVN4GLOENjs.parse; exports.parseOrFail = _chunkVN4GLOENjs.parseOrFail;
+//# sourceMappingURL=core.js.map

package/lib/core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/core.js"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACF,sDAA4B;AAC5B,+BAA4B;AAC5B,+BAA4B;AAC5B,+BAA4B;AAC5B,+BAA4B;AAC5B;AACE;AACA;AACA;AACA;AACF,+MAAC","file":"/home/runner/work/bguard/bguard/lib/core.js"}

package/lib/core.mjs

@@ -0,0 +1,17 @@
+import {
+  CommonSchema,
+  ExceptionContext,
+  parse,
+  parseOrFail
+} from "./chunk-QIPGUTIG.mjs";
+import "./chunk-YBVMP4EI.mjs";
+import "./chunk-OE3L7EKN.mjs";
+import "./chunk-ZTCXXAKD.mjs";
+import "./chunk-2ANPCB4O.mjs";
+export {
+  CommonSchema,
+  ExceptionContext,
+  parse,
+  parseOrFail
+};
+//# sourceMappingURL=core.mjs.map

package/lib/helpers/constants.d.mts

@@ -1,3 +1,4 @@
 declare const ONLY_ONCE = "It is allowed to call either 'equalTo' or 'oneOfValues,' but only one of them, and only once.";
+declare const ctxSymbol: unique symbol;
 
-export { ONLY_ONCE };
+export { ONLY_ONCE, ctxSymbol };

package/lib/helpers/constants.d.ts

@@ -1,3 +1,4 @@
 declare const ONLY_ONCE = "It is allowed to call either 'equalTo' or 'oneOfValues,' but only one of them, and only once.";
+declare const ctxSymbol: unique symbol;
 
-export { ONLY_ONCE };
+export { ONLY_ONCE, ctxSymbol };

package/lib/helpers/constants.js

@@ -1,7 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk42J6CHIOjs = require('../chunk-42J6CHIO.js');
 
+var _chunkAXKX5BGHjs = require('../chunk-AXKX5BGH.js');
 
-exports.ONLY_ONCE = _chunk42J6CHIOjs.ONLY_ONCE;
+
+
+exports.ONLY_ONCE = _chunkAXKX5BGHjs.ONLY_ONCE; exports.ctxSymbol = _chunkAXKX5BGHjs.ctxSymbol;
 //# sourceMappingURL=constants.js.map

package/lib/helpers/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/helpers/constants.js"],"names":[],"mappings":"AAAA;AACE;AACF,uDAA6B;AAC7B;AACE;AACF,+CAAC","file":"/home/runner/work/bguard/bguard/lib/helpers/constants.js"}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/helpers/constants.js"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,uDAA6B;AAC7B;AACE;AACA;AACF,+FAAC","file":"/home/runner/work/bguard/bguard/lib/helpers/constants.js"}

package/lib/helpers/constants.mjs

@@ -1,7 +1,9 @@
 import {
-  ONLY_ONCE
-} from "../chunk-ASZW6XRM.mjs";
+  ONLY_ONCE,
+  ctxSymbol
+} from "../chunk-2ANPCB4O.mjs";
 export {
-  ONLY_ONCE
+  ONLY_ONCE,
+  ctxSymbol
 };
 //# sourceMappingURL=constants.mjs.map

package/lib/helpers/setStrictType.d.mts

@@ -1,7 +1,7 @@
-import { C as CommonSchema } from '../CommonSchema-BIfYCtcQ.mjs';
-import '../ExceptionContext.mjs';
+import { CommonSchema } from '../core.mjs';
 import '../commonTypes.mjs';
 import '../InferType.mjs';
+import './constants.mjs';
 
 declare function _setStrictType(that: CommonSchema, val: unknown): void;
 

package/lib/helpers/setStrictType.d.ts

@@ -1,7 +1,7 @@
-import { C as CommonSchema } from '../CommonSchema-DIDMH9R7.js';
-import '../ExceptionContext.js';
+import { CommonSchema } from '../core.js';
 import '../commonTypes.js';
 import '../InferType.js';
+import './constants.js';
 
 declare function _setStrictType(that: CommonSchema, val: unknown): void;
 

package/lib/helpers/setStrictType.js

@@ -1,9 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk3ZQ4ORQHjs = require('../chunk-3ZQ4ORQH.js');
-require('../chunk-PE55R4KH.js');
-require('../chunk-VBTWYDEM.js');
+var _chunkXDVSL5B6js = require('../chunk-XDVSL5B6.js');
+require('../chunk-AXKX5BGH.js');
 
 
-exports._setStrictType = _chunk3ZQ4ORQHjs._setStrictType;
+exports._setStrictType = _chunkXDVSL5B6js._setStrictType;
 //# sourceMappingURL=setStrictType.js.map

package/lib/helpers/setStrictType.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/helpers/setStrictType.js"],"names":[],"mappings":"AAAA;AACE;AACF,uDAA6B;AAC7B,gCAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACF,yDAAC","file":"/home/runner/work/bguard/bguard/lib/helpers/setStrictType.js"}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/helpers/setStrictType.js"],"names":[],"mappings":"AAAA;AACE;AACF,uDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACF,yDAAC","file":"/home/runner/work/bguard/bguard/lib/helpers/setStrictType.js"}

package/lib/helpers/setStrictType.mjs

@@ -1,8 +1,7 @@
 import {
   _setStrictType
-} from "../chunk-YSCVE4PJ.mjs";
-import "../chunk-MQRXWXHP.mjs";
-import "../chunk-YBVMP4EI.mjs";
+} from "../chunk-THU5VBSO.mjs";
+import "../chunk-2ANPCB4O.mjs";
 export {
   _setStrictType
 };

package/lib/index.d.mts

@@ -1,8 +1,55 @@
 export { InferType } from './InferType.mjs';
-export { parse } from './parse.mjs';
-export { parseOrFail } from './parseOrFail.mjs';
+export { ExceptionContext, parse, parseOrFail } from './core.mjs';
 export { BuildSchemaError, ValidationError } from './exceptions.mjs';
 export { clearLocales, setLocale, setToDefaultLocale } from './translationMap.mjs';
+export { codeGen, codeGenWithName } from './codeGen.mjs';
+export { array } from './asserts/array/index.mjs';
+export { maxArrayLength } from './asserts/array/maxArrayLength.mjs';
+export { minArrayLength } from './asserts/array/minArrayLength.mjs';
+export { bigint } from './asserts/bigint/index.mjs';
+export { bigintMax } from './asserts/bigint/bigintMax.mjs';
+export { bigintMaxExcluded } from './asserts/bigint/bigintMaxExcluded.mjs';
+export { bigintMin } from './asserts/bigint/bigintMin.mjs';
+export { bigintMinExcluded } from './asserts/bigint/bigintMinExcluded.mjs';
+export { boolean } from './asserts/boolean/index.mjs';
+export { date } from './asserts/date/index.mjs';
+export { dateMax } from './asserts/date/dateMax.mjs';
+export { dateMin } from './asserts/date/dateMin.mjs';
+export { oneOfTypes } from './asserts/mix/index.mjs';
+export { equalTo } from './asserts/mix/equalTo.mjs';
+export { oneOfValues } from './asserts/mix/oneOfValues.mjs';
+export { number } from './asserts/number/index.mjs';
+export { max } from './asserts/number/max.mjs';
+export { maxExcluded } from './asserts/number/maxExcluded.mjs';
+export { min } from './asserts/number/min.mjs';
+export { minExcluded } from './asserts/number/minExcluded.mjs';
+export { positive } from './asserts/number/positive.mjs';
+export { negative } from './asserts/number/negative.mjs';
+export { object } from './asserts/object/index.mjs';
+export { maxKeys } from './asserts/object/maxKeys.mjs';
+export { string } from './asserts/string/index.mjs';
+export { atLeastOneDigit } from './asserts/string/atLeastOneDigit.mjs';
+export { atLeastOneLowerChar } from './asserts/string/atLeastOneLowerChar.mjs';
+export { atLeastOneSpecialChar } from './asserts/string/atLeastOneSpecialChar.mjs';
+export { atLeastOneUpperChar } from './asserts/string/atLeastOneUpperChar.mjs';
+export { contains } from './asserts/string/contains.mjs';
+export { email } from './asserts/string/email.mjs';
+export { endsWith } from './asserts/string/endsWith.mjs';
+export { isValidDate } from './asserts/string/isValidDate.mjs';
+export { isValidDateTime } from './asserts/string/isValidDateTime.mjs';
+export { isValidTime } from './asserts/string/isValidTime.mjs';
+export { lowerCase } from './asserts/string/lowerCase.mjs';
+export { maxLength } from './asserts/string/maxLength.mjs';
+export { minLength } from './asserts/string/minLength.mjs';
+export { regExp } from './asserts/string/regExp.mjs';
+export { startsWith } from './asserts/string/startsWith.mjs';
+export { upperCase } from './asserts/string/upperCase.mjs';
+export { uuid } from './asserts/string/uuid.mjs';
+export { uuidV1 } from './asserts/string/uuidV1.mjs';
+export { uuidV2 } from './asserts/string/uuidV2.mjs';
+export { uuidV3 } from './asserts/string/uuidV3.mjs';
+export { uuidV4 } from './asserts/string/uuidV4.mjs';
+export { uuidV5 } from './asserts/string/uuidV5.mjs';
+export { validUrl } from './asserts/string/validUrl.mjs';
 import './commonTypes.mjs';
-import './CommonSchema-BIfYCtcQ.mjs';
-import './ExceptionContext.mjs';
+import './helpers/constants.mjs';