@kravc/schema 2.7.6 → 2.8.0-alpha.1

package/dist/Validator.js

@@ -0,0 +1,570 @@
+"use strict";
+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 got_1 = __importDefault(require("./helpers/got"));
+const cleanupNulls_1 = __importDefault(require("./helpers/cleanupNulls"));
+const getReferenceIds_1 = __importDefault(require("./helpers/getReferenceIds"));
+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');
+ * ```
+ */
+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]);
+     * ```
+     */
+    constructor(schemas) {
+        if (!schemas) {
+            throw new Error('No schemas provided');
+        }
+        const groupsById = (0, lodash_1.groupBy)(schemas, 'id');
+        for (const id in groupsById) {
+            const schemas = groupsById[id];
+            const hasDuplicates = schemas.length > 1;
+            if (hasDuplicates) {
+                throw new Error(`Multiple schemas provided for ID: ${id}`);
+            }
+        }
+        this._engine = new z_schema_1.default({
+            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);
+            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.
+     *   }
+     * }
+     * ```
+     */
+    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);
+        let result = JSON.parse(objectJson);
+        if (shouldCleanupNulls) {
+            result = (0, cleanupNulls_1.default)(result);
+        }
+        try {
+            // NOTE: Drop attributes from objects that are not defined in schema.
+            //       This is bad for FE developers, as they continue to send some
+            //       trash to endpoints, but good for integrations with third party
+            //       services, e.g. Telegram, when you do not want to define schema
+            //       for the full payload. This method currently fails for cases when
+            //       attribute is defined as object or array in schema, but value is
+            //       a string. In this case validation method below would catch that.
+            (0, cleanupAttributes_1.default)(result, jsonSchema, this._jsonSchemasMap);
+            // NOTE: Normalize method helps to integrate objects built from URLs,
+            //       where types are not defined, e.g. booleans are '1', 'yes' string
+            //       or numbers are '1', '2'... strings.
+            (0, normalizeAttributes_1.default)(result, jsonSchema, this._jsonSchemasMap);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (error) {
+            // 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) {
+            return result;
+        }
+        const validationErrors = this._engine.getLastErrors();
+        if (!shouldNullifyEmptyValues) {
+            throw new ValidationError_1.default(schemaId, result, validationErrors);
+        }
+        const [nullifiedResult, updatedValidationErrors] = (0, nullifyEmptyValues_1.default)(result, validationErrors);
+        const hasValidationErrors = updatedValidationErrors.length > 0;
+        if (hasValidationErrors) {
+            throw new ValidationError_1.default(schemaId, result, updatedValidationErrors);
+        }
+        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
+     * ```
+     */
+    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`);
+     * });
+     * ```
+     */
+    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)
+     * ```
+     */
+    getReferenceIds(schemaId) {
+        const schema = (0, got_1.default)(this.schemasMap, schemaId, 'Schema "$PATH" not found');
+        return (0, getReferenceIds_1.default)(schema, this._schemasMap);
+    }
+}
+exports.default = Validator;
+//# sourceMappingURL=Validator.js.map

package/dist/Validator.js.map

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

package/dist/helpers/JsonSchema.d.ts

@@ -0,0 +1,99 @@
+export type EnumSchema = {
+    id?: string;
+    enum: string[] | number[];
+    type?: 'string' | 'number';
+    default?: string | number;
+    example?: string | number;
+    required?: boolean;
+    'x-title'?: string;
+    description?: string;
+    'x-required'?: boolean;
+};
+export type ReferencePropertySchema = {
+    $ref: string;
+    default?: string | number | Record<string, unknown>;
+    example?: string | number | Record<string, unknown>;
+    required?: boolean;
+    'x-title'?: string;
+    description?: string;
+    'x-required'?: boolean;
+};
+export type StringPropertySchema = {
+    '@type'?: string;
+    type?: 'string';
+    format?: 'date' | 'date-time' | 'url' | 'email';
+    default?: string;
+    example?: string;
+    pattern?: string;
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    'x-title'?: string;
+    description?: string;
+    'x-required'?: boolean;
+};
+export type NumberPropertySchema = {
+    type: 'number';
+    minimum?: number;
+    maximum?: number;
+    default?: number;
+    example?: number;
+    required?: boolean;
+    'x-title'?: string;
+    description?: string;
+    'x-required'?: boolean;
+};
+export type IntegerPropertySchema = {
+    type: 'integer';
+    minimum?: number;
+    maximum?: number;
+    default?: number;
+    example?: number;
+    required?: boolean;
+    'x-title'?: string;
+    description?: string;
+    'x-required'?: boolean;
+};
+export type BooleanPropertySchema = {
+    type: 'boolean';
+    default?: boolean;
+    example?: boolean;
+    required?: boolean;
+    'x-title'?: string;
+    description?: string;
+    'x-required'?: boolean;
+};
+export type ObjectPropertySchema = {
+    type?: 'object';
+    default?: Record<string, unknown>;
+    example?: unknown;
+    required?: boolean;
+    properties?: PropertiesSchema;
+    'x-title'?: string;
+    description?: string;
+    'x-required'?: boolean;
+};
+export type ArrayPropertySchema = {
+    type?: 'array';
+    items?: (ReferencePropertySchema | ObjectPropertySchema | StringPropertySchema | EnumSchema) & {
+        minItems?: number;
+        maxItems?: number;
+    };
+    default?: unknown[];
+    example?: unknown[];
+    required?: boolean;
+    'x-title'?: string;
+    description?: string;
+    'x-required'?: boolean;
+};
+export type PropertySchema = EnumSchema | ReferencePropertySchema | ObjectPropertySchema | ArrayPropertySchema | StringPropertySchema | NumberPropertySchema | IntegerPropertySchema | BooleanPropertySchema;
+export type PropertiesSchema = Record<string, PropertySchema>;
+export type ObjectSchema = {
+    id: string;
+    required?: string[];
+    properties: PropertiesSchema;
+};
+export type JsonSchema = EnumSchema | ObjectSchema;
+export type JsonSchemasMap = Record<string, JsonSchema>;
+export type TargetObject = Record<string, unknown>;
+//# sourceMappingURL=JsonSchema.d.ts.map

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

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

package/dist/helpers/JsonSchema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=JsonSchema.js.map