bguard 0.0.8 → 0.1.0

package/README.md

@@ -4,7 +4,6 @@
 
 ![Coveralls branch](https://img.shields.io/coverallsCoverage/github/NBlasko/bguard) ![npm](https://img.shields.io/npm/dt/bguard) ![Known Vulnerabilities](https://snyk.io/test/github/NBlasko/bguard/badge.svg)
 
-
 ### Features
 
 - **Type Inference**: Automatically infer TypeScript types from your validation schemas.
@@ -31,7 +30,7 @@ Let's define a schema for a Student object:
 
 ```typeScript
 
-import { parseSchema, InferType, string, number, array, object, boolean } from 'bguard';
+import { InferType, string, number, array, object, boolean } from 'bguard';
 import { email } from 'bguard/string/email';
 import { min } from 'bguard/number/min';
 import { max } from 'bguard/number/max';
@@ -58,9 +57,7 @@ const studentSchema = object({
 Using the InferType utility, you can infer the TypeScript type of the schema:
 
 ```typescript
-
 type StudentSchema = InferType<typeof studentSchema>;
-
 ```
 
 This will generate the following type:
@@ -81,13 +78,91 @@ type StudentSchema = {
 
 ```
 
-#### Validating Data
 
-To validate data against the defined schema, use the parseSchema function:
+#### Generating TypeScript Types with `codeGen`
+
+
+If you prefer to generate TypeScript types as a string, you can use the `codeGen` function:
+
+```typeScript
+import { codeGen } from 'bguard/codeGen';
+```
+
+The `codeGen` function takes a schema and returns a string representing the inferred TypeScript type. This string can be written to a file or used in other ways where a static type definition is needed.
+
+Example
+
+```typeScript
+const typeString = codeGen(studentSchema);
+console.log(typeString);
+```
+
+This would output a string:
 
 ```typeScript
+{
+  email?: string | undefined;
+  age: number;
+  address: string | null;
+  classes: ({
+      name: string;
+      mandatory: boolean;
+      rooms: number[];
+    } | undefined)[];
+  verified?: boolean | undefined;
+}
+```
+Note: The returned string does not include a type name or the `=` symbol. You would need to add these manually if you want a complete type definition.
+
+#### Generating Named TypeScript Types with `codeGenWithName`
+
+For convenience, if you want to generate a complete type definition including a name, use the `codeGenWithName` function:
+
+```typeScript
+import { codeGenWithName } from 'bguard/codeGen';
+```
+
+This function takes two parameters: the name of the type and the schema.
+
+Example:
+
+```typeScript
+const namedTypeString = codeGenWithName('StudentSchema', studentSchema);
+console.log(namedTypeString);
+```
+
+This would output a string:
+
+
+```typeScript
+type StudentSchema = {
+  email?: string | undefined;
+  age: number;
+  address: string | null;
+  classes: ({
+      name: string;
+      mandatory: boolean;
+      rooms: number[];
+    } | undefined)[];
+  verified?: boolean | undefined;
+}
+```
+#### Summary:
+
+`codeGen(schema: CommonSchema): string` - Generates a string of the TypeScript type based on the schema. You need to manually add a type name and assignment if needed.
+
+`codeGenWithName(typeName: string, schema: CommonSchema): string` - Generates a complete TypeScript type definition string, including the type keyword and type name.
+
+
+### Validating Data
 
-const studentData = {
+This library provides two methods to parse data against schemas: `parse` and `parseOrFail`. These methods help in validating the data and obtaining structured errors if any issues are found during validation.
+
+Let's use above mentioned `studentSchema` and:
+
+```typescript
+// example of valid received data
+const validStudentData = {
   age: 21,
   address: '123 Main St',
   classes: [
@@ -100,49 +175,458 @@ const studentData = {
   email: 'student@example.com',
 };
 
-const validatedData = parseSchema(studentSchema, studentData);
+// example of invalid received data with multiple errors
+const invalidStudentData = {
+  age: -5,
+  address: undefined,
+  classes: [
+    {
+      name: true,
+      mandatory: 'true',
+      rooms: null,
+    },
+  ],
+  email: 'invalid-example',
+};
+
+```
+
+
+#### `parse` Method
+
+The `parse` method validates the data and returns a tuple containing errors and the parsed value. This method allows you to choose whether to collect all errors or stop at the first error using an options flag.
+
+
+**Syntax:**
+
+```typescript
+import { parse } from 'bguard';
+// import other dependencies
+
+const [errors, parsedValue] = parse(studentSchema, validStudentData, { getAllErrors: true });
+```
+
+Returns:
+
+- If validation succeeds: `[undefined, parsedValue]`
+- If there are validation errors: `[ValidationErrorData[], undefined]`
+
+Options:
+
+- `lng`: Specifies the language for error messages. Default is `'default'`.
+- `getAllErrors`: If `true`, collects all validation errors. If `false` or `undefined`, stops at the first error. Turning off `getAllErrors` provides a runtime optimization, as it stops validation at the first error, avoiding unnecessary checks for the remaining received value.
 
+#### `parseOrFail` Method
 
+The `parseOrFail` method validates the data and throws an error on the first validation failure. It is useful when you want to halt processing immediately upon encountering an error.
+
+**Syntax:**
+
+```typeScript
+import { parseOrFail } from 'bguard';
+// import other dependencies
+
+try {
+  // Attempt to parse and validate the studentData using the studentSchema
+  const validatedData = parseOrFail(studentSchema, validStudentData);
+  // If the data is valid, validatedData will contain the parsed value with inferred TypeScript types
+} catch (error) {
+  // If the data does not conform to the schema, an error will be thrown
+  console.error(error.message); // Logs the first validation error message, if any
+}
 ```
+Throws:
+- `ValidationError`: If any validation rule fails, this error is thrown with details of the first encountered error.
+
+Options:
+- `lng`: Specifies the language for error messages. Default is `'default'`.
+
 
-If the data does not conform to the schema, an error will be thrown.
+####
 
+### Explanation
 
+- **`parse` Method**: This method returns a tuple where the first element is an array of validation errors (if any), and the second element is the successfully parsed value (or `undefined` if errors exist). It allows collecting all errors by setting the `getAllErrors` flag.
+
+- **`parseOrFail` Method**: This method throws a `ValidationError` when the first validation rule fails, making it suitable for scenarios where early termination of validation is desired.
+
+- **Options**: Both methods accept options for language settings and error collection, enhancing flexibility in handling validation processes.
 
 ### Chaining Methods
 
- - `nullable()`: Allows the value to be null.
- - `optional()`: Allows the value to be undefined.
+- `nullable()`: Allows the value to be null.
+- `optional()`: Allows the value to be undefined.
 
- Example:
+Example:
 
- ```typeScript
+```typeScript
 
 const schema = string().nullable().optional();
 ```
 
- - String Literals: 
-   `string().equalTo('myStringValue')` will infer 'myStringValue' as the type.
- 
- - Number Literals: 
-   `number().equalTo(42)` will infer 42 as the type.
- 
- - Boolean Literals:
-   `boolean().onlyTrue()` will infer true as the type.
-   `boolean().onlyFalse()` will infer false as the type.
+- String Literals:
+  `string().equalTo('myStringValue')` will infer <b>'myStringValue'</b> as the type.
+  `string().oneOfValues(['foo', 'bar'])` will infer <b>'foo' | 'bar'</b> as the type.
 
+- Number Literals:
+  `number().equalTo(42)` will infer <b>42</b> as the type.
+  `number().oneOfValues([3, 5])` will infer <b>3 | 5</b> as the type.
 
+- Boolean Literals:
+  `boolean().onlyTrue()` will infer <b>true</b> as the type.
+  `boolean().onlyFalse()` will infer <b>false</b> as the type.
 
 ### Custom Assertions
+
 You can extend the validation with custom assertions:
 
- ```typeScript
+```typeScript
 import { min } from 'bguard/number/min';
 import { max } from 'bguard/number/max';
 
 const ageSchema = number().custom(min(18), max(120));
 ```
+
 Assertions are imported from specific paths for better tree-shaking and smaller bundle sizes.
 
+
+### Translation
+
+Bguard provides default translations for error messages, but you can customize them as needed. Each potential error has an `errorKey` and `errorMessage`.
+
+Example:
+
+Consider the schema:
+
+```typeScript
+const testSchema = object({ foo: number().custom(min(5)) });
+```
+
+The `min` function has:
+
+```typeScript
+const minErrorMessage = 'The received value is less than expected'; // Default error message
+const minErrorKey = 'n:min'; // Error key
+```
+
+If you want to change the error message for `min`, you can do so by importing the `setLocale` function and setting your custom message:
+
+```typeScript
+import { setLocale } from 'bguard/translationMap';
+
+setLocale('SR', {
+  'n:min': 'The received value {{r}} found on path {{p}} is less than expected value {{e}}',
+  // ... continue adding other translations
+});
+```
+With this setup, in the translation namespace 'SR', if the received value is 4, you'll get an error message like:
+
+`'The received value 4 found on path .foo is less than expected value 5'`
+
+ - `{{r}}` - Replaced with the received value.
+ - `{{p}}` - Replaced with the path to the error.
+ - `{{e}}` - Replaced with the expected value.
+
+
+> **Notice:** Do not overwrite the 'default' namespace. If a translation is missing, it will fall back to the 'default' translation.
+
+
+
+#### Using Translations
+
+To apply the new translation, both `parse` and `parseOrFail` functions accept a lng property in the options object provided as the third parameter:
+
+```typeScript
+parseOrFail(testSchema, { foo: 4 }, { lng: 'SR' });
+// or
+parse(testSchema, { foo: 4 }, { lng: 'SR' });
+```
+
+
+#### Common and Custom Translations
+
+We have two sets of translations: common errors and specific assertions.
+
+<b>Common Error Translations</b>:
+
+```
+'c:optional': 'The required value is missing',
+'c:nullable': 'Value should not be null',
+'c:array': 'Expected an array but received a different type',
+'c:objectType': 'Expected an object but received a different type',
+'c:objectTypeAsArray': 'Expected an object but received an array. Invalid type of data',
+'c:unrecognizedProperty': 'This property is not allowed in the object',
+'c:requiredProperty': 'Missing required property in the object',
+'c:invalidType': 'Invalid type of data',
+'c:isBoolean': 'The received value is not {{e}}',
+```
+
+<b>Custom Assertion Translations</b>:
+
+For custom assertions, each key and message are located in separate files for better code splitting. There are multiple ways to identify a key:
+
+1. Key Construction:
+Keys are constructed as `'{typeId}:{functionName}'`, where `typeId` represents:
+
+- c - common
+- n - numbers
+- s - strings
+- b - boolean
+- a - array
+- o - object
+- sy - symbol
+- f - function
+- bi - bigint
+- m - mixed
+
+Each `typeId` maps to the folder from which custom assertions are retrieved (except 'common', as explained above).
+
+Example:
+
+```typeScript
+import { maxLength } from 'bguard/string/maxLength';
+```
+The function located in `'bguard/string/maxLength'` will have the key `'s:maxLength'`.
+
+2. Assertion Function Properties:
+
+Each assert function has two additional properties: `key` and `message`.
+
+```typeScript
+import { maxLength } from 'bguard/string/maxLength';
+
+console.log(maxLength.key); // Output: 's:maxLength'
+console.log(maxLength.message); // Output: 'The received value length is greater than expected'
+```
+> **Notice:** Do not directly change these values.
+
+3. IDE Support:
+Each key and message will be visible in text editors that support JSDoc IntelliSense.### Custom Assert Documentation 
+
+#### mix
+        
+##### equalTo (mix)
+        
+```typescript
+import { equalTo } from 'bguard/mix/equalTo';
+```
+        
+* _Description_ Creates a custom assertion that checks if a value is equal to the expected value.
+* > **Notice:** It has already been implemented in the number and string schema. There is no need to use it as a custom assert.
+* _Param_ {unknown} expected The value that the received value is expected to match.
+* _Throws_ {ValidationError} If the received value does not match the expected value.
+* _Example_
+```typescript
+ const schema = number().custom(equalTo(5)); // Define a schema with a custom assertion
+ parseOrFail(schema, 5); // Valid
+ parseOrFail(schema, 3); // Throws an error: 'The received value is not equal to expected'
+```
+* _See_ Error Translation Key = 'm:equalTo'
+        
+        
+##### oneOfValues (mix)
+        
+```typescript
+import { oneOfValues } from 'bguard/mix/oneOfValues';
+```
+        
+* _Description_ Creates a custom assertion that checks if a value is equal to the one of expected values.
+* > **Notice:** It has already been implemented in the number and string schema. There is no need to use it as a custom assert.
+* _Param_ {unknown} expected The value that the received value is expected to match.
+* _Throws_ {ValidationError} If the received value does not match at least one of the expected values.
+* _Example_
+```typescript
+ const schema = number().custom(oneOfValues([5, 4])); // Define a schema with a custom assertion
+ parseOrFail(schema, 5); // Valid
+ parseOrFail(schema, 4); // Valid
+ parseOrFail(schema, 3); // Throws an error: 'The received value is not equal to expected'
+```
+* _See_ Error Translation Key = 'm:oneOfValues'
+        
+#### number
+        
+##### max (number)
+        
+```typescript
+import { max } from 'bguard/number/max';
+```
+        
+* _Description_ Asserts that a number value does not exceed a specified maximum value.
+* _Param_ {number} expected The maximum allowable value.
+* _Throws_ {ValidationError} if the received value exceeds the expected maximum value.
+* _Example_
+```typescript
+ const schema = number().custom(max(100));
+ parseOrFail(schema, 99);  // Valid
+ parseOrFail(schema, 100); // Valid
+ parseOrFail(schema, 101); // Throws an error: 'The received value is greater than expected'
+```
+* _See_ Error Translation Key = 'n:max'
+        
+        
+##### maxExcluded (number)
+        
+```typescript
+import { maxExcluded } from 'bguard/number/maxExcluded';
+```
+        
+* _Description_ - Asserts that a number value is strictly less than a specified maximum value (i.e., the maximum value is excluded).
+* _Param_ {number} expected - The maximum allowable value, which is excluded.
+* _Throws_ {ValidationError} if the received value is greater than or equal to the expected maximum value.
+* _Example_
+```typescript
+ const schema = number().custom(maxExcluded(100));
+ parseOrFail(schema, 99);  // Valid
+ parseOrFail(schema, 100); // Throws an error: 'The received value is greater than or equal to expected'
+ parseOrFail(schema, 101); // Throws an error: 'The received value is greater than or equal to expected'
+```
+* _See_ Error Translation Key = 'n:maxExcluded'
+        
+        
+##### min (number)
+        
+```typescript
+import { min } from 'bguard/number/min';
+```
+        
+* _Description_ Asserts that a number value is not less than a specified minimum value.
+* _Param_ {number} expected The minimum allowable value.
+* _Throws_ {ValidationError} if the received value is less than the expected minimum value.
+* _Example_
+```typescript
+ const schema = number().custom(min(10));
+ parseOrFail(schema, 11);  // Valid
+ parseOrFail(schema, 10);  // Valid
+ parseOrFail(schema, 9);   // Throws an error: 'The received value is less than expected'
+```
+* _See_ Error Translation Key = 'n:min'
+        
+        
+##### minExcluded (number)
+        
+```typescript
+import { minExcluded } from 'bguard/number/minExcluded';
+```
+        
+* _Description_ Asserts that a number value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).
+* _Param_ {number} expected The minimum allowable value, which is excluded.
+* _Throws_ {ValidationError} if the received value is less than or equal to the expected minimum value.
+* _Example_
+```typescript
+ const schema = number().custom(minExcluded(10));
+ parseOrFail(schema, 11);  // Valid
+ parseOrFail(schema, 10); // Throws an error: 'The received value is less than or equal to expected'
+ parseOrFail(schema, 9);  // Throws an error: 'The received value is less than or equal to expected'
+```
+* _See_ Error Translation Key = 'n:minExcluded'
+        
+        
+##### negative (number)
+        
+```typescript
+import { negative } from 'bguard/number/negative';
+```
+        
+* _Description_ Asserts that a number value is negative (less than zero).
+* _Throws_ {ValidationError} if the received value is not negative.
+* _Example_
+```typescript
+ const schema = number().custom(negative());
+ parseOrFail(schema, -10); // Valid
+ parseOrFail(schema, 0);  // Throws an error: 'The received value is not a negative number'
+ parseOrFail(schema, 5);  // Throws an error: 'The received value is not a negative number'
+```
+* _See_ - Error Translation Key = 'n:negative'
+        
+        
+##### positive (number)
+        
+```typescript
+import { positive } from 'bguard/number/positive';
+```
+        
+* _Description_ Asserts that a number value is positive (greater than zero).
+* _Throws_ {ValidationError} if the received value is not positive.
+* _Example_
+```typescript
+ const schema = number().custom(positive());
+ parseOrFail(schema, 10);  // Valid
+ parseOrFail(schema, 0);  // Throws an error: 'The received value is not a positive number'
+ parseOrFail(schema, -5); // Throws an error: 'The received value is not a positive number'
+```
+* _See_ Error Translation Key = 'n:positive'
+        
+#### string
+        
+##### email (string)
+        
+```typescript
+import { email } from 'bguard/string/email';
+```
+        
+* _Description_ Asserts that a string value matches the email pattern. The pattern checks for a basic email format.
+* _Throws_ {ValidationError} if the received value does not match the email pattern.
+* _Example_
+```typescript
+ const schema = string().custom(email());
+ parseOrFail(schema, 'example@example.com'); // Valid
+ parseOrFail(schema, 'invalid-email');      // Throws an error: 'The received value does not match the required email pattern'
+```
+* _See_ - Error Translation Key = 's:email'
+        
+        
+##### maxLength (string)
+        
+```typescript
+import { maxLength } from 'bguard/string/maxLength';
+```
+        
+* _Description_ Asserts that the length of a string value is not greater than a specified maximum length.
+* _Param_ {number} expected The maximum allowed length for the string.
+* _Throws_ {ValidationError} if the length of the received value is greater than the expected length.
+* _Example_
+```typescript
+ const schema = string().custom(maxLength(10));
+ parseOrFail(schema, 'short');   // Valid
+ parseOrFail(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'
+```
+* _See_ Error Translation Key = 's:maxLength'
+        
+        
+##### minLength (string)
+        
+```typescript
+import { minLength } from 'bguard/string/minLength';
+```
+        
+* _Description_ Asserts that the length of a string value is not less than a specified minimum length.
+* _Param_ {number} expected The minimum required length for the string.
+* _Throws_ {ValidationError} if the length of the received value is less than the expected length.
+* _Example_
+```typescript
+ const schema = string().custom(minLength(5));
+ parseOrFail(schema, 'short');    // Throws an error: 'The received value length is less than expected'
+ parseOrFail(schema, 'adequate'); // Valid
+```
+* _See_ Error Translation Key = 's:minLength'
+        
+        
+##### regExp (string)
+        
+```typescript
+import { regExp } from 'bguard/string/regExp';
+```
+        
+* _Description_ Asserts that a string value matches a specified regular expression pattern.
+* _Param_ {RegExp} expected The regular expression pattern that the string value should match.
+* _Throws_ {ValidationError} if the received value does not match the expected pattern.
+* _Example_
+```typescript
+ const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern
+ parseOrFail(schema, 'valid123');   // Valid
+ parseOrFail(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'
+```
+* _See_ Error Translation Key = 's:regExp'
+        
 ### Contributing
 Contributions are welcome! Please open an issue or submit a pull request for any bugs or feature requests.

package/lib/{CommonSchema-BIe85W_A.d.mts → CommonSchema-BbGNki0L.d.ts}

@@ -1,10 +1,10 @@
+import { ExceptionContext, PrimitiveType, RequiredValidation } from './commonTypes.js';
+
 declare const ctxSymbol: unique symbol;
 
-declare function innerCheck(schema: CommonSchema, receivedValue: unknown, pathToError: string): {} | null | undefined;
+declare function innerCheck(schema: CommonSchema, receivedValue: unknown, exCtx: ExceptionContext): void | {} | null;
 
-type RequiredValidation = (received: any, pathToError: string) => void;
 type ObjectShapeSchemaType = Record<string, CommonSchema>;
-type PrimitiveType = 'number' | 'string' | 'boolean' | 'undefined' | 'object' | 'function' | 'symbol' | 'bigint';
 interface ValidatorContext {
     type: PrimitiveType[];
     isNullable?: boolean;
@@ -12,6 +12,9 @@ interface ValidatorContext {
     requiredValidations: RequiredValidation[];
     array?: CommonSchema;
     object?: ObjectShapeSchemaType;
+    allowUnrecognizedObjectProps?: boolean;
+    strictType?: boolean;
+    strictTypeValue?: unknown;
 }
 declare class CommonSchema {
     [ctxSymbol]: ValidatorContext;
@@ -56,4 +59,4 @@ type WithMix<Y = unknown> = CommonSchema & {
 type ExtractFromMix<T> = T extends WithMix<infer X> ? X : never;
 type MapMixTypes<T extends PrimitiveType[]> = T extends (infer U)[] ? U extends keyof TypeMapping ? TypeMapping[U] : never : never;
 
-export { CommonSchema as C, type ExtractFromMix as E, type MapMixTypes as M, type ObjectShapeSchemaType as O, type PrimitiveType as P, type RequiredValidation as R, type ValidatorContext as V, type WithUndefined as W, type WithNull as a, type WithMix as b, ctxSymbol as c, innerCheck as i };
+export { CommonSchema as C, type ExtractFromMix as E, type MapMixTypes as M, type ObjectShapeSchemaType as O, type ValidatorContext as V, type WithUndefined as W, type WithNull as a, type WithMix as b, ctxSymbol as c, innerCheck as i };

package/lib/{CommonSchema-BIe85W_A.d.ts → CommonSchema-CjsYE4dC.d.mts}

@@ -1,10 +1,10 @@
+import { ExceptionContext, PrimitiveType, RequiredValidation } from './commonTypes.mjs';
+
 declare const ctxSymbol: unique symbol;
 
-declare function innerCheck(schema: CommonSchema, receivedValue: unknown, pathToError: string): {} | null | undefined;
+declare function innerCheck(schema: CommonSchema, receivedValue: unknown, exCtx: ExceptionContext): void | {} | null;
 
-type RequiredValidation = (received: any, pathToError: string) => void;
 type ObjectShapeSchemaType = Record<string, CommonSchema>;
-type PrimitiveType = 'number' | 'string' | 'boolean' | 'undefined' | 'object' | 'function' | 'symbol' | 'bigint';
 interface ValidatorContext {
     type: PrimitiveType[];
     isNullable?: boolean;
@@ -12,6 +12,9 @@ interface ValidatorContext {
     requiredValidations: RequiredValidation[];
     array?: CommonSchema;
     object?: ObjectShapeSchemaType;
+    allowUnrecognizedObjectProps?: boolean;
+    strictType?: boolean;
+    strictTypeValue?: unknown;
 }
 declare class CommonSchema {
     [ctxSymbol]: ValidatorContext;
@@ -56,4 +59,4 @@ type WithMix<Y = unknown> = CommonSchema & {
 type ExtractFromMix<T> = T extends WithMix<infer X> ? X : never;
 type MapMixTypes<T extends PrimitiveType[]> = T extends (infer U)[] ? U extends keyof TypeMapping ? TypeMapping[U] : never : never;
 
-export { CommonSchema as C, type ExtractFromMix as E, type MapMixTypes as M, type ObjectShapeSchemaType as O, type PrimitiveType as P, type RequiredValidation as R, type ValidatorContext as V, type WithUndefined as W, type WithNull as a, type WithMix as b, ctxSymbol as c, innerCheck as i };
+export { CommonSchema as C, type ExtractFromMix as E, type MapMixTypes as M, type ObjectShapeSchemaType as O, type ValidatorContext as V, type WithUndefined as W, type WithNull as a, type WithMix as b, ctxSymbol as c, innerCheck as i };

package/lib/InferType.d.mts

@@ -1,9 +1,10 @@
 import { ArraySchema, ExtractFromArray } from './schemas/ArraySchema.mjs';
 import { WithBoolean, BooleanSchema, ExtractFromBoolean } from './schemas/BooleanSchema.mjs';
-import { W as WithUndefined, a as WithNull, b as WithMix, E as ExtractFromMix, C as CommonSchema } from './CommonSchema-BIe85W_A.mjs';
+import { W as WithUndefined, a as WithNull, b as WithMix, E as ExtractFromMix, C as CommonSchema } from './CommonSchema-CjsYE4dC.mjs';
 import { WithNumber, NumberSchema, ExtractFromNumber } from './schemas/NumberSchema.mjs';
 import { ObjectSchema, WithObject } from './schemas/ObjectSchema.mjs';
 import { WithString, StringSchema, ExtractFromString } from './schemas/StringSchema.mjs';
+import './commonTypes.mjs';
 
 type InferType<T> = T extends WithUndefined<WithNull<WithString<StringSchema>>> ? ExtractFromString<T> | null | undefined : T extends WithUndefined<WithString<StringSchema>> ? ExtractFromString<T> | undefined : T extends WithNull<WithString<StringSchema>> ? ExtractFromString<T> | null : T extends WithString<StringSchema> ? ExtractFromString<T> : T extends WithUndefined<WithNull<StringSchema>> ? string | null | undefined : T extends WithUndefined<StringSchema> ? string | undefined : T extends WithNull<StringSchema> ? string | null : T extends StringSchema ? string : T extends WithUndefined<WithNull<WithNumber<NumberSchema>>> ? ExtractFromNumber<T> | null | undefined : T extends WithUndefined<WithNumber<NumberSchema>> ? ExtractFromNumber<T> | undefined : T extends WithNull<WithNumber<NumberSchema>> ? ExtractFromNumber<T> | null : T extends WithNumber<NumberSchema> ? ExtractFromNumber<T> : T extends WithUndefined<WithNull<NumberSchema>> ? number | null | undefined : T extends WithUndefined<NumberSchema> ? number | undefined : T extends WithNull<NumberSchema> ? number | null : T extends NumberSchema ? number : T extends WithUndefined<WithNull<WithBoolean<BooleanSchema>>> ? ExtractFromBoolean<T> | null | undefined : T extends WithUndefined<WithBoolean<BooleanSchema>> ? ExtractFromBoolean<T> | undefined : T extends WithNull<WithBoolean<BooleanSchema>> ? ExtractFromBoolean<T> | null : T extends WithBoolean<BooleanSchema> ? ExtractFromBoolean<T> : T extends WithUndefined<WithNull<BooleanSchema>> ? boolean | null | undefined : T extends WithUndefined<BooleanSchema> ? boolean | undefined : T extends WithNull<BooleanSchema> ? boolean | null : T extends BooleanSchema ? boolean : T extends WithUndefined<WithNull<ArraySchema>> ? InferType<ExtractFromArray<T>>[] | null | undefined : T extends WithUndefined<ArraySchema> ? InferType<ExtractFromArray<T>>[] | undefined : T extends WithNull<ArraySchema> ? InferType<ExtractFromArray<T>>[] | null : T extends ArraySchema ? InferType<ExtractFromArray<T>>[] : T extends WithUndefined<WithNull<ObjectSchema>> ? ExtractFromObject<T> | null | undefined : T extends WithUndefined<ObjectSchema> ? ExtractFromObject<T> | undefined : T extends WithNull<ObjectSchema> ? ExtractFromObject<T> | null : T extends ObjectSchema ? ExtractFromObject<T> : T extends WithUndefined<WithNull<WithMix>> ? ExtractFromMix<T> | null | undefined : T extends WithUndefined<WithMix> ? ExtractFromMix<T> | undefined : T extends WithNull<WithMix> ? ExtractFromMix<T> | null : T extends WithMix ? ExtractFromMix<T> : unknown;
 type Merge<T> = T extends infer U ? {