bguard 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Nikola Blagojevic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# bguard
+
+**bguard** is a powerful, flexible, and type-safe validation library for TypeScript. It allows developers to define validation schemas for their data structures and ensures that data conforms to the expected types and constraints.
+
+### Features
+
+- **Type Inference**: Automatically infer TypeScript types from your validation schemas.
+- **Custom Assertions**: Add custom validation logic for your schemas.
+- **Chaining Methods**: Easily chain methods for complex validations.
+- **Nested Validation**: Supports complex data structures, including arrays and objects.
+- **Optional and Nullable Support**: Fine-grained control over optional and nullable fields.
+- **Small Bundle Size**: Each assertion is in its own file, minimizing your final bundle size.
+- **Lightweight**: No dependencies and optimized for performance.
+
+### Installation
+
+```bash
+npm install bguard
+```
+
+### Usage
+
+Here’s a basic example of how to use `bguard` to define and validate a schema.
+
+#### Defining a Schema
+
+Let's define a schema for a Student object:
+
+```typeScript
+
+import { parseSchema, InferType, string, number, array, object, boolean } from 'bguard';
+import { email } from 'bguard/asserts/string/email';
+import { min } from 'bguard/asserts/number/min';
+import { max } from 'bguard/asserts/number/max';
+
+// Example: Student Schema
+const studentSchema = object({
+  email: string().optional().custom(email()),
+  age: number().custom(min(18), max(120)),
+  address: string().nullable(),
+  classes: array(
+    object({
+      name: string(),
+      mandatory: boolean(),
+      rooms: array(number()),
+    }).optional()
+  ),
+  verified: boolean().optional(),
+});
+
+```
+
+#### Inferring TypeScript Types
+
+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:
+
+```typeScript
+
+type StudentSchema = {
+  age: number;
+  address: string | null;
+  classes: ({
+    name: string;
+    mandatory: boolean;
+    rooms: number[];
+  } | undefined)[];
+  email?: string | undefined;
+  verified?: boolean | undefined;
+}
+
+```
+
+#### Validating Data
+
+To validate data against the defined schema, use the parseSchema function:
+
+```typeScript
+
+const studentData = {
+  age: 21,
+  address: '123 Main St',
+  classes: [
+    {
+      name: 'Math 101',
+      mandatory: true,
+      rooms: [101, 102],
+    },
+  ],
+  email: 'student@example.com',
+};
+
+const validatedData = parseSchema(studentSchema, studentData);
+
+
+```
+
+If the data does not conform to the schema, an error will be thrown.
+
+
+
+### Chaining Methods
+
+ - `nullable()`: Allows the value to be null.
+ - `optional()`: Allows the value to be undefined.
+
+ Example:
+
+ ```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.
+
+
+
+### Custom Assertions
+You can extend the validation with custom assertions:
+
+ ```typeScript
+import { min } from 'bguard/asserts/number/min';
+import { max } from 'bguard/asserts/number/max';
+
+const ageSchema = number().custom(min(18), max(120));
+```
+Assertions are imported from specific paths for better tree-shaking and smaller bundle sizes.
+
+### Contributing
+Contributions are welcome! Please open an issue or submit a pull request for any bugs or feature requests.

package/lib/index.d.mts

@@ -0,0 +1,254 @@
+declare const ctxSymbol: unique symbol;
+
+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;
+    isOptional?: boolean;
+    requiredValidations: RequiredValidation[];
+    array?: CommonSchema;
+    object?: ObjectShapeSchemaType;
+}
+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>;
+}
+type WithNull<T extends CommonSchema> = T & {
+    validation_null: true;
+};
+type WithUndefined<T extends CommonSchema> = T & {
+    validation_undefined: true;
+};
+type TypeMapping = {
+    number: number;
+    string: string;
+    boolean: boolean;
+    undefined: undefined;
+    object: object;
+    function: Function;
+    symbol: symbol;
+    bigint: bigint;
+};
+type WithMix<Y = unknown> = CommonSchema & {
+    validation_mix: Y;
+};
+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;
+
+declare class ArraySchema extends CommonSchema {
+    _array: number;
+    constructor(ctx: ValidatorContext, arraySchema: CommonSchema);
+    private validateArrayEntry;
+}
+type WithArray<Y extends CommonSchema> = ArraySchema & {
+    validation_array: Y;
+};
+type ExtractFromArray<T> = T extends WithArray<infer X> ? X : never;
+
+declare class BooleanSchema extends CommonSchema {
+    _boolean: number;
+    /**
+     * Restricts the schema to exactly match the boolean value true and infers the true value as the TypeScript type.
+     *
+     * @returns - The schema instance restricted to the value true, with the true value inferred as the TypeScript type
+     *
+     * @example - boolean().onlyTrue(); // Infers the type true
+     */
+    onlyTrue(): WithBoolean<this, true>;
+    /**
+     * Restricts the schema to exactly match the boolean value false and infers the false value as the TypeScript type.
+     *
+     * @returns - The schema instance restricted to the value false, with the false value inferred as the TypeScript type
+     *
+     * @example - boolean().onlyFalse(); // Infers the type false
+     */
+    onlyFalse(): WithBoolean<this, false>;
+}
+type WithBoolean<T extends BooleanSchema, Y = boolean> = T & {
+    validation_boolean: Y;
+};
+type ExtractFromBoolean<T> = T extends WithBoolean<BooleanSchema, infer Y> ? Y : never;
+
+declare class NumberSchema extends CommonSchema {
+    _number: number;
+    /**
+     * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+     *
+     * @param expectedValue - The value that the schema must exactly match.
+     * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+     *
+     * @example - number().equalTo(42); // Infers the type 42
+     */
+    equalTo<Y extends number>(expectedValue: Y): WithNumber<this, Y>;
+}
+type WithNumber<T extends NumberSchema, Y = number> = T & {
+    validation_number: Y;
+};
+type ExtractFromNumber<T> = T extends WithNumber<NumberSchema, infer Y> ? Y : never;
+
+declare class ObjectSchema extends CommonSchema {
+    _object: number;
+    constructor(ctx: ValidatorContext, shapeSchema: ObjectShapeSchemaType);
+    private validateObjectEntry;
+}
+type WithObject<Y extends ObjectShapeSchemaType> = ObjectSchema & {
+    validation_object: Y;
+};
+
+declare class StringSchema extends CommonSchema {
+    _string: number;
+    /**
+     * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+     *
+     * @param expectedValue - The value that the schema must exactly match.
+     * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+     *
+     * @example - string().equalTo('hello'); // Infers the type 'hello'
+     */
+    equalTo<Y extends string>(expectedValue: Y): WithString<this, Y>;
+}
+type WithString<T extends StringSchema, Y = string> = T & {
+    validation_string: Y;
+};
+type ExtractFromString<T> = T extends WithString<StringSchema, infer Y> ? Y : never;
+
+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 ? {
+    [K in keyof U]: U[K];
+} : never;
+type ExtractFromObject<T extends ObjectSchema> = T extends WithObject<infer X> ? Merge<{
+    [K in keyof X as X[K] extends WithUndefined<CommonSchema> ? never : K]: InferType<X[K]>;
+} & {
+    [K in keyof X as X[K] extends WithUndefined<CommonSchema> ? K : never]?: InferType<X[K]>;
+}> : unknown;
+
+/**
+ * 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.
+ * @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 = parseSchema(schema, { name: 'Alice', age: 30 });
+ * // result will be inferred as { name: string; age: number }
+ *
+ * parseSchema(schema, { name: 'Alice', age: '30' });
+ * // Throws ValidationError because 'age' should be a number, not a string.
+ */
+declare function parseSchema<T extends CommonSchema>(schema: T, receivedValue: unknown): InferType<T>;
+
+/**
+ * Creates a new schema for validating number values.
+ *
+ * @returns {NumberSchema} A new instance of `NumberSchema` for validating numbers.
+ *
+ * @example
+ * const schema = number();
+ * parseSchema(schema, 42); // Validates successfully
+ * parseSchema(schema, '42'); // Throws a validation error
+ */
+declare function number(): NumberSchema;
+
+/**
+ * Creates a new schema for validating string values.
+ *
+ * @returns {StringSchema} A new instance of `StringSchema` for validating strings.
+ *
+ * @example
+ * const schema = string();
+ * parseSchema(schema, 'hello'); // Validates successfully
+ * parseSchema(schema, 123); // Throws a validation error
+ */
+declare function string(): StringSchema;
+
+/**
+ * Creates a new schema for validating boolean values.
+ *
+ * @returns {BooleanSchema} A new instance of `BooleanSchema` for validating booleans.
+ *
+ * @example
+ * const schema = boolean();
+ * parseSchema(schema, true); // Validates successfully
+ * parseSchema(schema, 'true'); // Throws a validation error
+ */
+declare function boolean(): BooleanSchema;
+
+/**
+ * Creates a new schema for validating arrays where each element must match the specified schema.
+ *
+ * @template T
+ * @param {T} arraySchema - The schema that each element of the array must match.
+ * @returns {WithArray<T>} A new instance of `ArraySchema` for validating arrays of elements that match the specified schema.
+ *
+ * @example
+ * const schema = array(string());
+ * parseSchema(schema, ['hello', 'world']); // Validates successfully
+ * parseSchema(schema, ['hello', 123]); // Throws a validation error
+ */
+declare function array<T extends CommonSchema>(arraySchema: T): WithArray<T>;
+
+/**
+ * Creates a new schema for validating objects where each property must match the specified schema.
+ *
+ * @template T
+ * @param {T} shapeSchema - The schema that each property of the object must match.
+ * @returns {WithObject<T>} A new instance of `ObjectSchema` for validating objects with properties matching the specified schema.
+ *
+ * @example
+ * const schema = object({
+ *   name: string(),
+ *   age: number()
+ * });
+ * parseSchema(schema, { name: 'John', age: 30 }); // Validates successfully
+ * parseSchema(schema, { name: 'John', age: '30' }); // Throws a validation error
+ */
+declare function object<T extends ObjectShapeSchemaType>(shapeSchema: T): WithObject<T>;
+
+/**
+ * Creates a new schema for validating values that can match any one of the specified primitive types.
+ *
+ * @template T
+ * @param {T} valueTypes - An array of primitive types that the value can match.
+ * @returns {WithMix<MapMixTypes<T>>} A new schema for validating values that can match any of the specified types.
+ *
+ * @example
+ * const schema = oneOfTypes(['string', 'number']);
+ * parseSchema(schema, 'hello'); // Validates successfully
+ * parseSchema(schema, 42); // Validates successfully
+ * parseSchema(schema, true); // Throws a validation error
+ */
+declare function oneOfTypes<T extends PrimitiveType[]>(valueTypes: T): WithMix<MapMixTypes<T>>;
+
+export { type InferType, array, boolean, number, object, oneOfTypes, parseSchema, string };

package/lib/index.d.ts

@@ -0,0 +1,254 @@
+declare const ctxSymbol: unique symbol;
+
+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;
+    isOptional?: boolean;
+    requiredValidations: RequiredValidation[];
+    array?: CommonSchema;
+    object?: ObjectShapeSchemaType;
+}
+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>;
+}
+type WithNull<T extends CommonSchema> = T & {
+    validation_null: true;
+};
+type WithUndefined<T extends CommonSchema> = T & {
+    validation_undefined: true;
+};
+type TypeMapping = {
+    number: number;
+    string: string;
+    boolean: boolean;
+    undefined: undefined;
+    object: object;
+    function: Function;
+    symbol: symbol;
+    bigint: bigint;
+};
+type WithMix<Y = unknown> = CommonSchema & {
+    validation_mix: Y;
+};
+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;
+
+declare class ArraySchema extends CommonSchema {
+    _array: number;
+    constructor(ctx: ValidatorContext, arraySchema: CommonSchema);
+    private validateArrayEntry;
+}
+type WithArray<Y extends CommonSchema> = ArraySchema & {
+    validation_array: Y;
+};
+type ExtractFromArray<T> = T extends WithArray<infer X> ? X : never;
+
+declare class BooleanSchema extends CommonSchema {
+    _boolean: number;
+    /**
+     * Restricts the schema to exactly match the boolean value true and infers the true value as the TypeScript type.
+     *
+     * @returns - The schema instance restricted to the value true, with the true value inferred as the TypeScript type
+     *
+     * @example - boolean().onlyTrue(); // Infers the type true
+     */
+    onlyTrue(): WithBoolean<this, true>;
+    /**
+     * Restricts the schema to exactly match the boolean value false and infers the false value as the TypeScript type.
+     *
+     * @returns - The schema instance restricted to the value false, with the false value inferred as the TypeScript type
+     *
+     * @example - boolean().onlyFalse(); // Infers the type false
+     */
+    onlyFalse(): WithBoolean<this, false>;
+}
+type WithBoolean<T extends BooleanSchema, Y = boolean> = T & {
+    validation_boolean: Y;
+};
+type ExtractFromBoolean<T> = T extends WithBoolean<BooleanSchema, infer Y> ? Y : never;
+
+declare class NumberSchema extends CommonSchema {
+    _number: number;
+    /**
+     * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+     *
+     * @param expectedValue - The value that the schema must exactly match.
+     * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+     *
+     * @example - number().equalTo(42); // Infers the type 42
+     */
+    equalTo<Y extends number>(expectedValue: Y): WithNumber<this, Y>;
+}
+type WithNumber<T extends NumberSchema, Y = number> = T & {
+    validation_number: Y;
+};
+type ExtractFromNumber<T> = T extends WithNumber<NumberSchema, infer Y> ? Y : never;
+
+declare class ObjectSchema extends CommonSchema {
+    _object: number;
+    constructor(ctx: ValidatorContext, shapeSchema: ObjectShapeSchemaType);
+    private validateObjectEntry;
+}
+type WithObject<Y extends ObjectShapeSchemaType> = ObjectSchema & {
+    validation_object: Y;
+};
+
+declare class StringSchema extends CommonSchema {
+    _string: number;
+    /**
+     * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+     *
+     * @param expectedValue - The value that the schema must exactly match.
+     * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+     *
+     * @example - string().equalTo('hello'); // Infers the type 'hello'
+     */
+    equalTo<Y extends string>(expectedValue: Y): WithString<this, Y>;
+}
+type WithString<T extends StringSchema, Y = string> = T & {
+    validation_string: Y;
+};
+type ExtractFromString<T> = T extends WithString<StringSchema, infer Y> ? Y : never;
+
+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 ? {
+    [K in keyof U]: U[K];
+} : never;
+type ExtractFromObject<T extends ObjectSchema> = T extends WithObject<infer X> ? Merge<{
+    [K in keyof X as X[K] extends WithUndefined<CommonSchema> ? never : K]: InferType<X[K]>;
+} & {
+    [K in keyof X as X[K] extends WithUndefined<CommonSchema> ? K : never]?: InferType<X[K]>;
+}> : unknown;
+
+/**
+ * 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.
+ * @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 = parseSchema(schema, { name: 'Alice', age: 30 });
+ * // result will be inferred as { name: string; age: number }
+ *
+ * parseSchema(schema, { name: 'Alice', age: '30' });
+ * // Throws ValidationError because 'age' should be a number, not a string.
+ */
+declare function parseSchema<T extends CommonSchema>(schema: T, receivedValue: unknown): InferType<T>;
+
+/**
+ * Creates a new schema for validating number values.
+ *
+ * @returns {NumberSchema} A new instance of `NumberSchema` for validating numbers.
+ *
+ * @example
+ * const schema = number();
+ * parseSchema(schema, 42); // Validates successfully
+ * parseSchema(schema, '42'); // Throws a validation error
+ */
+declare function number(): NumberSchema;
+
+/**
+ * Creates a new schema for validating string values.
+ *
+ * @returns {StringSchema} A new instance of `StringSchema` for validating strings.
+ *
+ * @example
+ * const schema = string();
+ * parseSchema(schema, 'hello'); // Validates successfully
+ * parseSchema(schema, 123); // Throws a validation error
+ */
+declare function string(): StringSchema;
+
+/**
+ * Creates a new schema for validating boolean values.
+ *
+ * @returns {BooleanSchema} A new instance of `BooleanSchema` for validating booleans.
+ *
+ * @example
+ * const schema = boolean();
+ * parseSchema(schema, true); // Validates successfully
+ * parseSchema(schema, 'true'); // Throws a validation error
+ */
+declare function boolean(): BooleanSchema;
+
+/**
+ * Creates a new schema for validating arrays where each element must match the specified schema.
+ *
+ * @template T
+ * @param {T} arraySchema - The schema that each element of the array must match.
+ * @returns {WithArray<T>} A new instance of `ArraySchema` for validating arrays of elements that match the specified schema.
+ *
+ * @example
+ * const schema = array(string());
+ * parseSchema(schema, ['hello', 'world']); // Validates successfully
+ * parseSchema(schema, ['hello', 123]); // Throws a validation error
+ */
+declare function array<T extends CommonSchema>(arraySchema: T): WithArray<T>;
+
+/**
+ * Creates a new schema for validating objects where each property must match the specified schema.
+ *
+ * @template T
+ * @param {T} shapeSchema - The schema that each property of the object must match.
+ * @returns {WithObject<T>} A new instance of `ObjectSchema` for validating objects with properties matching the specified schema.
+ *
+ * @example
+ * const schema = object({
+ *   name: string(),
+ *   age: number()
+ * });
+ * parseSchema(schema, { name: 'John', age: 30 }); // Validates successfully
+ * parseSchema(schema, { name: 'John', age: '30' }); // Throws a validation error
+ */
+declare function object<T extends ObjectShapeSchemaType>(shapeSchema: T): WithObject<T>;
+
+/**
+ * Creates a new schema for validating values that can match any one of the specified primitive types.
+ *
+ * @template T
+ * @param {T} valueTypes - An array of primitive types that the value can match.
+ * @returns {WithMix<MapMixTypes<T>>} A new schema for validating values that can match any of the specified types.
+ *
+ * @example
+ * const schema = oneOfTypes(['string', 'number']);
+ * parseSchema(schema, 'hello'); // Validates successfully
+ * parseSchema(schema, 42); // Validates successfully
+ * parseSchema(schema, true); // Throws a validation error
+ */
+declare function oneOfTypes<T extends PrimitiveType[]>(valueTypes: T): WithMix<MapMixTypes<T>>;
+
+export { type InferType, array, boolean, number, object, oneOfTypes, parseSchema, string };

package/lib/index.js

@@ -0,0 +1,294 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  array: () => array,
+  boolean: () => boolean,
+  number: () => number,
+  object: () => object,
+  oneOfTypes: () => oneOfTypes,
+  parseSchema: () => parseSchema,
+  string: () => string
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+var BuildSchemaError = class extends Error {
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/core.ts
+var ctxSymbol = Symbol("contextSymbol");
+function innerCheck(schema, receivedValue, pathToError) {
+  const ctx = schema[ctxSymbol];
+  if (receivedValue === void 0) {
+    if (!ctx.isOptional) throwException("Required", receivedValue, pathToError, "The required value is missing");
+    return receivedValue;
+  }
+  if (receivedValue === null) {
+    if (!ctx.isNullable) throwException("Not null", receivedValue, pathToError, "Value should not be null");
+    return receivedValue;
+  }
+  if (ctx.array) {
+    if (!Array.isArray(receivedValue))
+      throwException("Array", receivedValue, pathToError, "Expected an array but received a different type");
+    const schema2 = ctx.array;
+    receivedValue.forEach((elem, i) => {
+      innerCheck(schema2, elem, `${pathToError}[${i}]`);
+    });
+    return receivedValue;
+  }
+  const typeOfVal = typeof receivedValue;
+  if (ctx.object) {
+    if (typeOfVal !== "object")
+      throwException("Object", receivedValue, pathToError, "Expected an object but received a different type");
+    if (Array.isArray(receivedValue))
+      throwException(
+        "Object",
+        receivedValue,
+        pathToError,
+        "Expected an object but received an array. Invalid type of data"
+      );
+    const shapeSchema = ctx.object;
+    for (const keyPerReceivedValue of Object.keys(receivedValue)) {
+      if (shapeSchema[keyPerReceivedValue] === void 0)
+        throwException("Not allowed", keyPerReceivedValue, pathToError, "This key is not allowed in the object");
+    }
+    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {
+      const receivedObjectValuePropery = receivedValue[keyOfSchema];
+      if (receivedObjectValuePropery === void 0) {
+        if (!valueOfSchema[ctxSymbol].isOptional)
+          throwException(
+            "Required",
+            receivedObjectValuePropery,
+            pathToError,
+            "Missing required property in the object"
+          );
+      }
+      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);
+    }
+    return receivedValue;
+  }
+  if (ctx.type.length) {
+    if (!ctx.type.includes(typeOfVal)) throwException(ctx.type, typeOfVal, pathToError, "Invalid type of data");
+  }
+  ctx.requiredValidations.forEach((requiredValidation) => {
+    requiredValidation(receivedValue, pathToError);
+  });
+  return receivedValue;
+}
+
+// src/parseSchema.ts
+function parseSchema(schema, receivedValue) {
+  try {
+    return innerCheck(schema, receivedValue, "");
+  } catch (e) {
+    if (e instanceof ValidationError) throw e;
+    throw new Error("Something unexpected happened");
+  }
+}
+
+// src/asserts/common/equalTo.ts
+var equalTo = (expected) => (received, pathToError) => {
+  if (expected !== received)
+    throwException(expected, received, pathToError, "The received value is not equal to expected");
+};
+
+// src/schemas/CommonSchema.ts
+var CommonSchema = class {
+  [ctxSymbol];
+  constructor(ctx) {
+    this[ctxSymbol] = ctx;
+  }
+  /**
+   * @param validators - One or more custom validation functions.
+   * @returns {this} The schema instance with the added custom validation.
+   */
+  custom(...validators) {
+    this[ctxSymbol].requiredValidations.push(...validators);
+    return this;
+  }
+  /**
+   * Marks the schema as nullable, allowing the value to be `null`.
+   *
+   * @returns {WithNull<this>} The schema instance marked as nullable.
+   */
+  nullable() {
+    this[ctxSymbol].isNullable = true;
+    return this;
+  }
+  /**
+   * Marks the schema as optional, allowing the value to be `undefined`.
+   *
+   * @returns {WithUndefined<this>}} The schema instance marked as optional.
+   */
+  optional() {
+    this[ctxSymbol].isOptional = true;
+    return this;
+  }
+};
+
+// src/schemas/NumberSchema.ts
+var NumberSchema = class extends CommonSchema {
+  _number = 1;
+  /**
+   * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+   *
+   * @param expectedValue - The value that the schema must exactly match.
+   * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   *
+   * @example - number().equalTo(42); // Infers the type 42
+   */
+  equalTo(expectedValue) {
+    return this.custom(equalTo(expectedValue));
+  }
+};
+
+// src/asserts/number/index.ts
+function number() {
+  return new NumberSchema({ type: ["number"], requiredValidations: [] });
+}
+
+// src/schemas/StringSchema.ts
+var StringSchema = class extends CommonSchema {
+  _string = 1;
+  /**
+   * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+   *
+   * @param expectedValue - The value that the schema must exactly match.
+   * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   *
+   * @example - string().equalTo('hello'); // Infers the type 'hello'
+   */
+  equalTo(expectedValue) {
+    return this.custom(equalTo(expectedValue));
+  }
+};
+
+// src/asserts/string/index.ts
+function string() {
+  return new StringSchema({ type: ["string"], requiredValidations: [] });
+}
+
+// src/schemas/BooleanSchema.ts
+var isBoolean = (expected) => (received, pathToError) => {
+  if (received !== expected) throwException(expected, received, pathToError, `The received value is not ${expected}`);
+};
+var BooleanSchema = class extends CommonSchema {
+  _boolean = 1;
+  /**
+   * Restricts the schema to exactly match the boolean value true and infers the true value as the TypeScript type.
+   *
+   * @returns - The schema instance restricted to the value true, with the true value inferred as the TypeScript type
+   *
+   * @example - boolean().onlyTrue(); // Infers the type true
+   */
+  onlyTrue() {
+    return this.custom(isBoolean(true));
+  }
+  /**
+   * Restricts the schema to exactly match the boolean value false and infers the false value as the TypeScript type.
+   *
+   * @returns - The schema instance restricted to the value false, with the false value inferred as the TypeScript type
+   *
+   * @example - boolean().onlyFalse(); // Infers the type false
+   */
+  onlyFalse() {
+    return this.custom(isBoolean(false));
+  }
+};
+
+// src/asserts/boolean/index.ts
+function boolean() {
+  return new BooleanSchema({ type: ["boolean"], requiredValidations: [] });
+}
+
+// src/schemas/ArraySchema.ts
+var ArraySchema = class extends CommonSchema {
+  _array = 1;
+  constructor(ctx, arraySchema) {
+    super(ctx);
+    this.validateArrayEntry(arraySchema);
+    this[ctxSymbol].array = arraySchema;
+  }
+  validateArrayEntry(arraySchema) {
+    if (!arraySchema) throw new BuildSchemaError("Missing schema in array method");
+    if (!(arraySchema instanceof CommonSchema)) throw new BuildSchemaError("Invalid schema in array method");
+  }
+};
+
+// src/asserts/array/index.ts
+function array(arraySchema) {
+  return new ArraySchema({ type: [], requiredValidations: [] }, arraySchema);
+}
+
+// src/schemas/ObjectSchema.ts
+var ObjectSchema = class extends CommonSchema {
+  _object = 1;
+  constructor(ctx, shapeSchema) {
+    super(ctx);
+    this.validateObjectEntry(shapeSchema);
+    this[ctxSymbol].object = shapeSchema;
+  }
+  validateObjectEntry(shapeSchema) {
+    if (!shapeSchema) throw new BuildSchemaError("Missing schema in object method");
+    if (shapeSchema instanceof CommonSchema) throw new BuildSchemaError("Invalid schema in object");
+    for (const [key, value] of Object.entries(shapeSchema)) {
+      if (!(value instanceof CommonSchema))
+        throw new BuildSchemaError(`Invalid schema in object method for property '${key}'`);
+    }
+  }
+};
+
+// src/asserts/object/index.ts
+function object(shapeSchema) {
+  return new ObjectSchema({ type: [], requiredValidations: [] }, shapeSchema);
+}
+
+// src/asserts/common/index.ts
+function oneOfTypes(valueTypes) {
+  return new CommonSchema({ type: valueTypes, requiredValidations: [] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  array,
+  boolean,
+  number,
+  object,
+  oneOfTypes,
+  parseSchema,
+  string
+});

package/lib/index.mjs

@@ -0,0 +1,261 @@
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+var BuildSchemaError = class extends Error {
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/core.ts
+var ctxSymbol = Symbol("contextSymbol");
+function innerCheck(schema, receivedValue, pathToError) {
+  const ctx = schema[ctxSymbol];
+  if (receivedValue === void 0) {
+    if (!ctx.isOptional) throwException("Required", receivedValue, pathToError, "The required value is missing");
+    return receivedValue;
+  }
+  if (receivedValue === null) {
+    if (!ctx.isNullable) throwException("Not null", receivedValue, pathToError, "Value should not be null");
+    return receivedValue;
+  }
+  if (ctx.array) {
+    if (!Array.isArray(receivedValue))
+      throwException("Array", receivedValue, pathToError, "Expected an array but received a different type");
+    const schema2 = ctx.array;
+    receivedValue.forEach((elem, i) => {
+      innerCheck(schema2, elem, `${pathToError}[${i}]`);
+    });
+    return receivedValue;
+  }
+  const typeOfVal = typeof receivedValue;
+  if (ctx.object) {
+    if (typeOfVal !== "object")
+      throwException("Object", receivedValue, pathToError, "Expected an object but received a different type");
+    if (Array.isArray(receivedValue))
+      throwException(
+        "Object",
+        receivedValue,
+        pathToError,
+        "Expected an object but received an array. Invalid type of data"
+      );
+    const shapeSchema = ctx.object;
+    for (const keyPerReceivedValue of Object.keys(receivedValue)) {
+      if (shapeSchema[keyPerReceivedValue] === void 0)
+        throwException("Not allowed", keyPerReceivedValue, pathToError, "This key is not allowed in the object");
+    }
+    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {
+      const receivedObjectValuePropery = receivedValue[keyOfSchema];
+      if (receivedObjectValuePropery === void 0) {
+        if (!valueOfSchema[ctxSymbol].isOptional)
+          throwException(
+            "Required",
+            receivedObjectValuePropery,
+            pathToError,
+            "Missing required property in the object"
+          );
+      }
+      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);
+    }
+    return receivedValue;
+  }
+  if (ctx.type.length) {
+    if (!ctx.type.includes(typeOfVal)) throwException(ctx.type, typeOfVal, pathToError, "Invalid type of data");
+  }
+  ctx.requiredValidations.forEach((requiredValidation) => {
+    requiredValidation(receivedValue, pathToError);
+  });
+  return receivedValue;
+}
+
+// src/parseSchema.ts
+function parseSchema(schema, receivedValue) {
+  try {
+    return innerCheck(schema, receivedValue, "");
+  } catch (e) {
+    if (e instanceof ValidationError) throw e;
+    throw new Error("Something unexpected happened");
+  }
+}
+
+// src/asserts/common/equalTo.ts
+var equalTo = (expected) => (received, pathToError) => {
+  if (expected !== received)
+    throwException(expected, received, pathToError, "The received value is not equal to expected");
+};
+
+// src/schemas/CommonSchema.ts
+var CommonSchema = class {
+  [ctxSymbol];
+  constructor(ctx) {
+    this[ctxSymbol] = ctx;
+  }
+  /**
+   * @param validators - One or more custom validation functions.
+   * @returns {this} The schema instance with the added custom validation.
+   */
+  custom(...validators) {
+    this[ctxSymbol].requiredValidations.push(...validators);
+    return this;
+  }
+  /**
+   * Marks the schema as nullable, allowing the value to be `null`.
+   *
+   * @returns {WithNull<this>} The schema instance marked as nullable.
+   */
+  nullable() {
+    this[ctxSymbol].isNullable = true;
+    return this;
+  }
+  /**
+   * Marks the schema as optional, allowing the value to be `undefined`.
+   *
+   * @returns {WithUndefined<this>}} The schema instance marked as optional.
+   */
+  optional() {
+    this[ctxSymbol].isOptional = true;
+    return this;
+  }
+};
+
+// src/schemas/NumberSchema.ts
+var NumberSchema = class extends CommonSchema {
+  _number = 1;
+  /**
+   * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+   *
+   * @param expectedValue - The value that the schema must exactly match.
+   * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   *
+   * @example - number().equalTo(42); // Infers the type 42
+   */
+  equalTo(expectedValue) {
+    return this.custom(equalTo(expectedValue));
+  }
+};
+
+// src/asserts/number/index.ts
+function number() {
+  return new NumberSchema({ type: ["number"], requiredValidations: [] });
+}
+
+// src/schemas/StringSchema.ts
+var StringSchema = class extends CommonSchema {
+  _string = 1;
+  /**
+   * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+   *
+   * @param expectedValue - The value that the schema must exactly match.
+   * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   *
+   * @example - string().equalTo('hello'); // Infers the type 'hello'
+   */
+  equalTo(expectedValue) {
+    return this.custom(equalTo(expectedValue));
+  }
+};
+
+// src/asserts/string/index.ts
+function string() {
+  return new StringSchema({ type: ["string"], requiredValidations: [] });
+}
+
+// src/schemas/BooleanSchema.ts
+var isBoolean = (expected) => (received, pathToError) => {
+  if (received !== expected) throwException(expected, received, pathToError, `The received value is not ${expected}`);
+};
+var BooleanSchema = class extends CommonSchema {
+  _boolean = 1;
+  /**
+   * Restricts the schema to exactly match the boolean value true and infers the true value as the TypeScript type.
+   *
+   * @returns - The schema instance restricted to the value true, with the true value inferred as the TypeScript type
+   *
+   * @example - boolean().onlyTrue(); // Infers the type true
+   */
+  onlyTrue() {
+    return this.custom(isBoolean(true));
+  }
+  /**
+   * Restricts the schema to exactly match the boolean value false and infers the false value as the TypeScript type.
+   *
+   * @returns - The schema instance restricted to the value false, with the false value inferred as the TypeScript type
+   *
+   * @example - boolean().onlyFalse(); // Infers the type false
+   */
+  onlyFalse() {
+    return this.custom(isBoolean(false));
+  }
+};
+
+// src/asserts/boolean/index.ts
+function boolean() {
+  return new BooleanSchema({ type: ["boolean"], requiredValidations: [] });
+}
+
+// src/schemas/ArraySchema.ts
+var ArraySchema = class extends CommonSchema {
+  _array = 1;
+  constructor(ctx, arraySchema) {
+    super(ctx);
+    this.validateArrayEntry(arraySchema);
+    this[ctxSymbol].array = arraySchema;
+  }
+  validateArrayEntry(arraySchema) {
+    if (!arraySchema) throw new BuildSchemaError("Missing schema in array method");
+    if (!(arraySchema instanceof CommonSchema)) throw new BuildSchemaError("Invalid schema in array method");
+  }
+};
+
+// src/asserts/array/index.ts
+function array(arraySchema) {
+  return new ArraySchema({ type: [], requiredValidations: [] }, arraySchema);
+}
+
+// src/schemas/ObjectSchema.ts
+var ObjectSchema = class extends CommonSchema {
+  _object = 1;
+  constructor(ctx, shapeSchema) {
+    super(ctx);
+    this.validateObjectEntry(shapeSchema);
+    this[ctxSymbol].object = shapeSchema;
+  }
+  validateObjectEntry(shapeSchema) {
+    if (!shapeSchema) throw new BuildSchemaError("Missing schema in object method");
+    if (shapeSchema instanceof CommonSchema) throw new BuildSchemaError("Invalid schema in object");
+    for (const [key, value] of Object.entries(shapeSchema)) {
+      if (!(value instanceof CommonSchema))
+        throw new BuildSchemaError(`Invalid schema in object method for property '${key}'`);
+    }
+  }
+};
+
+// src/asserts/object/index.ts
+function object(shapeSchema) {
+  return new ObjectSchema({ type: [], requiredValidations: [] }, shapeSchema);
+}
+
+// src/asserts/common/index.ts
+function oneOfTypes(valueTypes) {
+  return new CommonSchema({ type: valueTypes, requiredValidations: [] });
+}
+export {
+  array,
+  boolean,
+  number,
+  object,
+  oneOfTypes,
+  parseSchema,
+  string
+};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "bguard",
+  "private": false,
+  "license": "MIT",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.ts",
+  "files": [
+    "/lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NBlasko/bguard.git"
+  },
+  "bugs": {
+    "url": "https://github.com/NBlasko/bguard/issues"
+  },
+  "keywords": [
+    "typescript",
+    "validation",
+    "schema",
+    "validators",
+    "type-safety",
+    "data-validation",
+    "custom-validators",
+    "input-validation",
+    "type-inference",
+    "bguard",
+    "assertions",
+    "data-schemas",
+    "runtime-validation",
+    "type-checking",
+    "typescript-schema"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:package": "tsup src/index.ts --format cjs,esm --dts --out-dir ./lib",
+    "watch": "tsc -w",
+    "start": "node build/src/index.js",
+    "test": "jest --config=./jest/config.ts",
+    "test:watch": "jest --watch --config=./jest/config.ts",
+    "test:coverage": "jest --watchAll=false --runInBand --config=./jest/config.ts --coverage",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "prettier": "prettier --check src",
+    "prettier:fix": "prettier --write src",
+    "lint:check": "npm run prettier && npm run lint",
+    "release:package": "npm run build:package && changeset publish",
+    "change:start": "changeset",
+    "change:version": "changeset version",
+    "change:publish": "changeset publish"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.7",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.8.0",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.1",
+    "@typescript-eslint/parser": "^8.0.1",
+    "eslint": "^9.8.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-jest": "^28.8.0",
+    "globals": "^15.9.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.4",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4"
+  }
+}