@kravc/schema 2.8.0-alpha.7 → 2.8.0-alpha.8

package/dist/Validator.js

@@ -1,10 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const z_schema_1 = __importDefault(require("z-schema"));
 const lodash_1 = require("lodash");
+const z_schema_1 = __importStar(require("z-schema"));
 const got_1 = __importDefault(require("./helpers/got"));
 const cleanupNulls_1 = __importDefault(require("./helpers/cleanupNulls"));
 const getReferenceIds_1 = __importDefault(require("./helpers/getReferenceIds"));
@@ -12,245 +45,12 @@ const ValidationError_1 = __importDefault(require("./ValidationError"));
 const cleanupAttributes_1 = __importDefault(require("./helpers/cleanupAttributes"));
 const nullifyEmptyValues_1 = __importDefault(require("./helpers/nullifyEmptyValues"));
 const normalizeAttributes_1 = __importDefault(require("./helpers/normalizeAttributes"));
-/**
- * Validator for validating and normalizing objects against JSON schemas.
- *
- * **Intent:**
- * The Validator class provides a comprehensive solution for validating objects against JSON schemas
- * with built-in normalization, cleanup, and error handling capabilities. It serves as the primary
- * interface for ensuring data integrity and consistency in applications that work with structured
- * data, particularly in API endpoints, data transformation pipelines, and credential systems.
- *
- * The validator performs several key operations:
- * - Validates objects against registered schemas using JSON Schema validation
- * - Removes attributes not defined in the schema (cleanup)
- * - Normalizes attribute types (e.g., string '1' → boolean true, string '180' → number 180)
- * - Handles empty values by optionally nullifying them for non-required fields
- * - Provides detailed validation errors with structured error information
- *
- * **Use Cases:**
- *
- * 1. **API Request/Response Validation:**
- *    - Validate incoming API requests against defined schemas
- *    - Ensure API responses conform to expected structure
- *    - Clean up extra fields sent by clients
- *    - Normalize data from query parameters or form submissions
- *
- * 2. **Data Integration & Third-Party Services:**
- *    - Integrate with external APIs that send loosely-typed data
- *    - Normalize data from URLs where types are strings (e.g., 'true', '1', '180')
- *    - Clean up payloads before sending to third-party services (e.g., Telegram, webhooks)
- *    - Handle data from systems that don't enforce strict typing
- *
- * 3. **Credential & Identity Systems:**
- *    - Validate verifiable credentials against schema definitions
- *    - Ensure credential subjects conform to expected schemas
- *    - Normalize credential data from various sources
- *
- * 4. **Data Transformation Pipelines:**
- *    - Normalize data types without full validation
- *    - Clean up data structures before processing
- *    - Transform data between different formats while maintaining schema compliance
- *
- * 5. **Form & User Input Processing:**
- *    - Validate and normalize form submissions
- *    - Handle empty values gracefully (nullify empty strings for optional fields)
- *    - Clean up null values from nested objects
- *
- * **Example - Basic Validation:**
- * ```typescript
- * const userSchema = new Schema({
- *   name: { type: 'string', required: true },
- *   email: { type: 'string', format: 'email', required: true },
- *   age: { type: 'number', minimum: 0 }
- * }, 'User');
- *
- * const validator = new Validator([userSchema]);
- *
- * const validUser = validator.validate({
- *   name: 'John Doe',
- *   email: 'john@example.com',
- *   age: 30
- * }, 'User');
- * // Returns: { name: 'John Doe', email: 'john@example.com', age: 30 }
- * ```
- *
- * **Example - Normalization (String to Type Conversion):**
- * ```typescript
- * // Useful when receiving data from URLs or forms where types are strings
- * const preferencesSchema = new Schema({
- *   height: { type: 'number' },
- *   isNotificationEnabled: { type: 'boolean' }
- * }, 'Preferences');
- *
- * const validator = new Validator([preferencesSchema]);
- *
- * const normalized = validator.validate({
- *   height: '180',              // String '180' → number 180
- *   isNotificationEnabled: '1'  // String '1' → boolean true
- * }, 'Preferences');
- * // Returns: { height: 180, isNotificationEnabled: true }
- * ```
- *
- * **Example - Cleanup (Remove Extra Attributes):**
- * ```typescript
- * const profileSchema = new Schema({
- *   name: { type: 'string', required: true },
- *   email: { type: 'string', required: true }
- * }, 'Profile');
- *
- * const validator = new Validator([profileSchema]);
- *
- * const cleaned = validator.validate({
- *   name: 'John',
- *   email: 'john@example.com',
- *   extraField: 'should be removed',
- *   _internalId: 'should be removed'
- * }, 'Profile', false, true);
- * // Returns: { name: 'John', email: 'john@example.com' }
- * // extraField and _internalId are removed
- * ```
- *
- * **Example - Nullify Empty Values:**
- * ```typescript
- * const profileSchema = new Schema({
- *   name: { type: 'string', required: true },
- *   gender: { enum: ['Male', 'Female', 'Other'] },  // Optional
- *   mobileNumber: { type: 'string', pattern: '^\\d+$' }  // Optional
- * }, 'Profile');
- *
- * const validator = new Validator([profileSchema]);
- *
- * const result = validator.validate({
- *   name: 'John',
- *   gender: '',           // Empty string for optional enum
- *   mobileNumber: ''      // Empty string for optional pattern field
- * }, 'Profile', true);    // shouldNullifyEmptyValues = true
- * // Returns: { name: 'John', gender: null, mobileNumber: null }
- * // Empty values are converted to null for non-required fields
- * ```
- *
- * **Example - Normalization Only (Without Validation):**
- * ```typescript
- * const preferencesSchema = new Schema({
- *   height: { type: 'number' },
- *   isNotificationEnabled: { type: 'boolean', default: false }
- * }, 'Preferences');
- *
- * const validator = new Validator([preferencesSchema]);
- *
- * // Normalize without validation - useful for partial data
- * const normalized = validator.normalize({
- *   height: '180'
- * }, 'Preferences');
- * // Returns: { height: 180, isNotificationEnabled: false }
- * // Applies normalization and defaults without validation
- * ```
- *
- * **Example - Error Handling:**
- * ```typescript
- * const validator = new Validator([userSchema]);
- *
- * try {
- *   validator.validate({
- *     name: '',  // Empty required field
- *     email: 'invalid-email'  // Invalid format
- *   }, 'User');
- * } catch (error) {
- *   if (error instanceof ValidationError) {
- *     const errorDetails = error.toJSON();
- *     console.error(errorDetails.schemaId);  // 'User'
- *     console.error(errorDetails.validationErrors);
- *     // [
- *     //   { path: '#/name', code: 'MIN_LENGTH', message: '...' },
- *     //   { path: '#/email', code: 'INVALID_FORMAT', message: '...' }
- *     // ]
- *   }
- * }
- * ```
- *
- * **Example - Schema References:**
- * ```typescript
- * const addressSchema = new Schema({
- *   street: { type: 'string', required: true },
- *   city: { type: 'string', required: true }
- * }, 'Address');
- *
- * const userSchema = new Schema({
- *   name: { type: 'string', required: true },
- *   address: { $ref: 'Address' }
- * }, 'User');
- *
- * const validator = new Validator([addressSchema, userSchema]);
- *
- * // Get all schemas referenced by User schema
- * const referencedIds = validator.getReferenceIds('User');
- * // Returns: ['Address']
- * ```
- *
- * **Example - Multiple Schemas:**
- * ```typescript
- * const statusSchema = new Schema({ enum: ['ACTIVE', 'INACTIVE'] }, 'Status');
- * const profileSchema = new Schema({
- *   name: { type: 'string', required: true },
- *   status: { $ref: 'Status' }
- * }, 'Profile');
- *
- * const validator = new Validator([statusSchema, profileSchema]);
- *
- * const result = validator.validate({
- *   name: 'John',
- *   status: 'ACTIVE'
- * }, 'Profile');
- * ```
- */
+/** Validator for validating and normalizing objects against JSON schemas. */
 class Validator {
     _engine;
     _schemasMap;
     _jsonSchemasMap;
-    /**
-     * Creates a validator instance for a collection of schemas.
-     *
-     * **Intent:** Initialize a validator with a set of schemas that can be used for validation
-     * and normalization. The constructor validates that all schemas are valid JSON schemas and
-     * that there are no duplicate schema IDs.
-     *
-     * **Use Cases:**
-     * - Initialize a validator with all schemas needed for an application
-     * - Set up a validator for a specific domain or module
-     * - Create validators for different environments (dev, staging, production)
-     *
-     * @param schemas - Array of Schema instances to register with this validator.
-     *                  All schemas must have unique IDs and valid JSON Schema structure.
-     *                  Referenced schemas (via $ref) must be included in this array.
-     *
-     * @throws Error if no schemas are provided
-     * @throws Error if multiple schemas have the same ID
-     * @throws Error if any schema has invalid JSON Schema structure or missing references
-     *
-     * **Example:**
-     * ```typescript
-     * const userSchema = new Schema({ name: { type: 'string' } }, 'User');
-     * const statusSchema = new Schema({ enum: ['ACTIVE', 'INACTIVE'] }, 'Status');
-     *
-     * const validator = new Validator([userSchema, statusSchema]);
-     * ```
-     *
-     * **Example - With Schema References:**
-     * ```typescript
-     * const addressSchema = new Schema({
-     *   street: { type: 'string' }
-     * }, 'Address');
-     *
-     * const userSchema = new Schema({
-     *   name: { type: 'string' },
-     *   address: { $ref: 'Address' }  // References Address schema
-     * }, 'User');
-     *
-     * // Both schemas must be provided
-     * const validator = new Validator([addressSchema, userSchema]);
-     * ```
-     */
+    /** Creates a validator instance for a collection of schemas. */
     constructor(schemas) {
         if (!schemas) {
             throw new Error('No schemas provided');
@@ -263,108 +63,23 @@ class Validator {
                 throw new Error(`Multiple schemas provided for ID: ${id}`);
             }
         }
-        this._engine = new z_schema_1.default({
+        this._engine = z_schema_1.default.create({
             reportPathAsArray: false,
             ignoreUnknownFormats: true,
         });
         const jsonSchemas = schemas.map(({ jsonSchema }) => jsonSchema);
-        const isValid = this._engine.validateSchema(jsonSchemas);
-        if (!isValid) {
-            const { errors } = this._engine.lastReport;
-            const errorsJson = JSON.stringify(errors, null, 2);
+        try {
+            this._engine.validateSchema(jsonSchemas);
+        }
+        catch (error) {
+            const details = error instanceof z_schema_1.ValidateError && error.details ? error.details : [];
+            const errorsJson = JSON.stringify(details, null, 2);
             throw new Error(`Schemas validation failed, errors: ${errorsJson}`);
         }
         this._schemasMap = (0, lodash_1.keyBy)(schemas, 'id');
         this._jsonSchemasMap = (0, lodash_1.keyBy)(jsonSchemas, 'id');
     }
-    /**
-     * Validates, cleans, and normalizes an object against a registered schema.
-     *
-     * **Intent:** Perform comprehensive validation and transformation of objects to ensure they
-     * conform to schema definitions. This method combines validation, attribute cleanup, type
-     * normalization, and optional empty value handling in a single operation.
-     *
-     * **Use Cases:**
-     * - Validate API request payloads before processing
-     * - Clean up objects by removing undefined attributes
-     * - Normalize data types from loosely-typed sources (URLs, forms, external APIs)
-     * - Handle empty values gracefully for optional fields
-     * - Prepare data for storage or transmission
-     *
-     * **Processing Pipeline:**
-     * 1. Deep clones the input object
-     * 2. Optionally removes null values (if `shouldCleanupNulls` is true)
-     * 3. Removes attributes not defined in the schema
-     * 4. Normalizes attribute types (string → number/boolean, etc.)
-     * 5. Validates against JSON Schema
-     * 6. Optionally nullifies empty values for non-required fields
-     * 7. Returns validated and normalized object, or throws ValidationError
-     *
-     * @param object - The object to validate and normalize
-     * @param schemaId - The ID of the schema to validate against (must be registered in constructor)
-     * @param shouldNullifyEmptyValues - If true, converts empty strings to null for non-required
-     *                                   fields that fail format/pattern/enum validation. Useful for
-     *                                   handling form submissions where empty fields are sent as ''.
-     * @param shouldCleanupNulls - If true, removes null values from the object before processing.
-     *                            Useful for cleaning up data structures.
-     *
-     * @returns The validated, cleaned, and normalized object
-     *
-     * @throws Error if schema with `schemaId` is not found
-     * @throws ValidationError if validation fails (contains detailed error information)
-     *
-     * **Example - Basic Validation:**
-     * ```typescript
-     * const validator = new Validator([userSchema]);
-     *
-     * const result = validator.validate({
-     *   name: 'John',
-     *   email: 'john@example.com'
-     * }, 'User');
-     * ```
-     *
-     * **Example - With Cleanup:**
-     * ```typescript
-     * const result = validator.validate({
-     *   name: 'John',
-     *   extraField: 'removed',
-     *   nullField: null
-     * }, 'User', false, true);
-     * // extraField and nullField are removed
-     * ```
-     *
-     * **Example - With Normalization:**
-     * ```typescript
-     * const result = validator.validate({
-     *   name: 'John',
-     *   age: '30',              // String → number
-     *   isActive: 'true'        // String → boolean
-     * }, 'User');
-     * // age becomes 30, isActive becomes true
-     * ```
-     *
-     * **Example - Nullify Empty Values:**
-     * ```typescript
-     * const result = validator.validate({
-     *   name: 'John',
-     *   optionalEmail: '',      // Empty string
-     *   optionalPhone: ''       // Empty string
-     * }, 'User', true);
-     * // optionalEmail and optionalPhone become null (if not required)
-     * ```
-     *
-     * **Example - Error Handling:**
-     * ```typescript
-     * try {
-     *   validator.validate({ name: '' }, 'User');
-     * } catch (error) {
-     *   if (error instanceof ValidationError) {
-     *     const details = error.toJSON();
-     *     // Access error.schemaId, error.validationErrors, etc.
-     *   }
-     * }
-     * ```
-     */
+    /** Validates, cleans, and normalizes an object against a registered schema. */
     validate(object, schemaId, shouldNullifyEmptyValues = false, shouldCleanupNulls = false) {
         const jsonSchema = (0, got_1.default)(this._jsonSchemasMap, schemaId, 'Schema "$PATH" not found');
         const objectJson = JSON.stringify(object);
@@ -391,11 +106,11 @@ class Validator {
             // NOTE: Skip errors in cleanup and normalize attributes methods.
             //       Validation would fail below for objects with invalid value types.
         }
-        const isValid = this._engine.validate(result, jsonSchema);
-        if (isValid) {
+        const validationResult = this._engine.validateSafe(result, jsonSchema);
+        if (validationResult.valid) {
             return result;
         }
-        const validationErrors = this._engine.getLastErrors();
+        const validationErrors = validationResult.err?.details ?? [];
         if (!shouldNullifyEmptyValues) {
             throw new ValidationError_1.default(schemaId, result, validationErrors);
         }
@@ -406,161 +121,18 @@ class Validator {
         }
         return nullifiedResult;
     }
-    /**
-     * Normalizes object attributes using a schema without performing validation.
-     *
-     * **Intent:** Apply type normalization and default values to an object without the strictness
-     * of full validation. This is useful when you want to transform data types but don't need
-     * complete schema compliance, or when working with partial/incomplete data.
-     *
-     * **Use Cases:**
-     * - Normalize data types from loosely-typed sources (URLs, query parameters, forms)
-     * - Apply default values from schemas to partial objects
-     * - Transform data before validation in a separate step
-     * - Prepare data for display or processing without strict validation
-     * - Handle partial updates where not all fields are present
-     *
-     * **What It Does:**
-     * - Deep clones the input object
-     * - Normalizes attribute types (string '1' → boolean true, string '180' → number 180)
-     * - Applies default values from schema definitions
-     * - Does NOT validate required fields, formats, patterns, or enums
-     * - Does NOT remove undefined attributes
-     *
-     * @param object - The object to normalize
-     * @param schemaId - The ID of the schema to use for normalization (must be registered)
-     *
-     * @returns A new object with normalized types and applied defaults
-     *
-     * @throws Error if schema with `schemaId` is not found
-     *
-     * **Example - Type Normalization:**
-     * ```typescript
-     * const preferencesSchema = new Schema({
-     *   height: { type: 'number' },
-     *   isNotificationEnabled: { type: 'boolean', default: false }
-     * }, 'Preferences');
-     *
-     * const validator = new Validator([preferencesSchema]);
-     *
-     * const normalized = validator.normalize({
-     *   height: '180',              // String → number
-     *   isNotificationEnabled: '1'  // String '1' → boolean true
-     * }, 'Preferences');
-     * // Returns: { height: 180, isNotificationEnabled: true }
-     * ```
-     *
-     * **Example - Apply Defaults:**
-     * ```typescript
-     * const userSchema = new Schema({
-     *   name: { type: 'string', required: true },
-     *   status: { enum: ['ACTIVE', 'INACTIVE'], default: 'ACTIVE' },
-     *   role: { enum: ['USER', 'ADMIN'], default: 'USER' }
-     * }, 'User');
-     *
-     * const validator = new Validator([userSchema]);
-     *
-     * const normalized = validator.normalize({
-     *   name: 'John'
-     *   // status and role are not provided
-     * }, 'User');
-     * // Returns: { name: 'John', status: 'ACTIVE', role: 'USER' }
-     * ```
-     *
-     * **Example - Partial Data:**
-     * ```typescript
-     * // Useful for partial updates where validation might fail
-     * const partial = validator.normalize({
-     *   age: '25'  // Only updating age, other fields missing
-     * }, 'User');
-     * // Normalizes age to number without requiring other fields
-     * ```
-     */
+    /** Normalizes object attributes using a schema without performing validation. */
     normalize(object, schemaId) {
         const jsonSchema = (0, got_1.default)(this._jsonSchemasMap, schemaId, 'Schema "$PATH" not found');
         const result = JSON.parse(JSON.stringify(object));
         (0, normalizeAttributes_1.default)(result, jsonSchema, this._jsonSchemasMap);
         return result;
     }
-    /**
-     * Returns a map of all registered schemas by their IDs.
-     *
-     * **Intent:** Provide access to all schemas registered with this validator, enabling
-     * inspection, iteration, or programmatic access to schema definitions.
-     *
-     * **Use Cases:**
-     * - Inspect all available schemas
-     * - Iterate over schemas for bulk operations
-     * - Access schema metadata or properties
-     * - Build UI components that list available schemas
-     * - Debug schema registration
-     *
-     * @returns A record mapping schema IDs to Schema instances
-     *
-     * **Example:**
-     * ```typescript
-     * const validator = new Validator([userSchema, statusSchema]);
-     *
-     * const schemas = validator.schemasMap;
-     * // { 'User': Schema instance, 'Status': Schema instance }
-     *
-     * // Access a specific schema
-     * const userSchema = schemas['User'];
-     *
-     * // Iterate over all schemas
-     * Object.keys(schemas).forEach(id => {
-     *   console.log(`Schema ${id} is registered`);
-     * });
-     * ```
-     */
+    /** Returns a map of all registered schemas by their IDs. */
     get schemasMap() {
         return this._schemasMap;
     }
-    /**
-     * Returns the IDs of all schemas referenced by the specified schema.
-     *
-     * **Intent:** Discover schema dependencies by finding all schemas referenced via `$ref`
-     * in a given schema. This is useful for understanding schema relationships and building
-     * dependency graphs.
-     *
-     * **Use Cases:**
-     * - Build schema dependency graphs
-     * - Validate that all referenced schemas are available
-     * - Generate documentation showing schema relationships
-     * - Determine which schemas need to be loaded together
-     * - Debug schema reference issues
-     *
-     * @param schemaId - The ID of the schema to analyze for references
-     *
-     * @returns An array of schema IDs that are referenced by the specified schema
-     *
-     * @throws Error if schema with `schemaId` is not found
-     *
-     * **Example:**
-     * ```typescript
-     * const addressSchema = new Schema({
-     *   street: { type: 'string' }
-     * }, 'Address');
-     *
-     * const userSchema = new Schema({
-     *   name: { type: 'string' },
-     *   address: { $ref: 'Address' },
-     *   status: { $ref: 'Status' }
-     * }, 'User');
-     *
-     * const validator = new Validator([addressSchema, statusSchema, userSchema]);
-     *
-     * const references = validator.getReferenceIds('User');
-     * // Returns: ['Address', 'Status']
-     * ```
-     *
-     * **Example - Nested References:**
-     * ```typescript
-     * // If Address schema also references Country schema
-     * const references = validator.getReferenceIds('User');
-     * // Returns: ['Address', 'Status', 'Country'] (includes nested references)
-     * ```
-     */
+    /** Returns the IDs of all schemas referenced by the specified schema. */
     getReferenceIds(schemaId) {
         const schema = (0, got_1.default)(this.schemasMap, schemaId, 'Schema "$PATH" not found');
         return (0, getReferenceIds_1.default)(schema, this._schemasMap);

package/dist/Validator.js.map

@@ -1 +1 @@
-{"version":3,"file":"Validator.js","sourceRoot":"","sources":["../src/Validator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Validator.js","sourceRoot":"","sources":["../src/Validator.ts"],"names":[],"mappings":"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"}

package/dist/helpers/cleanupAttributes.d.ts

@@ -1,34 +1,5 @@
-import type { JsonSchema, TargetObject, JsonSchemasMap } from './JsonSchema';
-/**
- * Removes properties from an object that are not defined in the JSON schema.
- *
- * **Intent:**
- * This function ensures that objects conform to their schema definition by removing
- * any properties that are not explicitly defined in the schema. It performs a deep
- * cleanup, recursively processing nested objects, arrays, and schema references.
- *
- * **Use Cases:**
- * - **Third-party API integrations**: When integrating with external services (e.g., Telegram)
- *   that may send additional fields you don't want to process, this function allows you
- *   to define a minimal schema and automatically strip unwanted properties.
- * - **Data sanitization**: Clean up objects received from external sources or user input
- *   before validation or processing, ensuring only expected fields are present.
- * - **Schema enforcement**: Enforce strict schema compliance by removing any properties
- *   that don't match the defined schema structure.
- * - **Pre-validation cleanup**: Remove extraneous properties before schema validation to
- *   prevent validation errors from unexpected fields.
- *
- * **Behavior:**
- * - Mutates the input object in-place (does not return a new object)
- * - Recursively processes nested objects, arrays, and schema references ($ref)
- * - Skips enum schemas (returns early without modification)
- * - Only processes object values (skips null, undefined, and primitive values)
- * - Handles array items by cleaning each object item according to the array's item schema
- *
- * @param object - The target object to clean up (mutated in-place)
- * @param jsonSchema - The JSON schema defining allowed properties
- * @param schemasMap - Optional map of schema IDs to schema definitions for resolving $ref references
- */
-declare const cleanupAttributes: (object: TargetObject, jsonSchema: JsonSchema, schemasMap?: JsonSchemasMap) => void;
+import { type JsonSchema } from 'z-schema';
+/** Removes properties from an object that are not defined in the JSON schema. */
+declare const cleanupAttributes: (object: TargetObject, jsonSchema: JsonSchema, schemasMap?: Record<string, JsonSchema>) => void;
 export default cleanupAttributes;
 //# sourceMappingURL=cleanupAttributes.d.ts.map

package/dist/helpers/cleanupAttributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cleanupAttributes.d.ts","sourceRoot":"","sources":["../../src/helpers/cleanupAttributes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,UAAU,EAEV,YAAY,EAEZ,cAAc,EAIf,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,QAAA,MAAM,iBAAiB,GACrB,QAAQ,YAAY,EACpB,YAAY,UAAU,EACtB,aAAY,cAAmB,SAqGhC,CAAC;AAEF,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"cleanupAttributes.d.ts","sourceRoot":"","sources":["../../src/helpers/cleanupAttributes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAI3C,iFAAiF;AACjF,QAAA,MAAM,iBAAiB,GACrB,QAAQ,YAAY,EACpB,YAAY,UAAU,EACtB,aAAY,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,SAqG5C,CAAC;AAEF,eAAe,iBAAiB,CAAC"}