Implement core validator service

src/Generator/ClassGenerator.php

···
         ?MethodGenerator $methodGenerator = null,
         ?DocBlockGenerator $docBlockGenerator = null
     ) {
-        $this->naming = $naming ?? new NamingConverter;
+        $this->naming = $naming ?? new NamingConverter();
         $this->typeMapper = $typeMapper ?? new TypeMapper($this->naming);
-        $this->renderer = $renderer ?? new StubRenderer;
+        $this->renderer = $renderer ?? new StubRenderer();
         $this->methodGenerator = $methodGenerator ?? new MethodGenerator($this->naming, $this->typeMapper, $this->renderer);
         $this->docBlockGenerator = $docBlockGenerator ?? new DocBlockGenerator($this->typeMapper);
     }

src/Generator/ConstructorGenerator.php

···
         ?PropertyGenerator $propertyGenerator = null,
         ?StubRenderer $renderer = null
     ) {
-        $this->propertyGenerator = $propertyGenerator ?? new PropertyGenerator;
-        $this->renderer = $renderer ?? new StubRenderer;
+        $this->propertyGenerator = $propertyGenerator ?? new PropertyGenerator();
+        $this->renderer = $renderer ?? new StubRenderer();
     }
 
     /**

src/Generator/DocBlockGenerator.php

···
      */
     public function __construct(?TypeMapper $typeMapper = null)
     {
-        $this->typeMapper = $typeMapper ?? new TypeMapper;
+        $this->typeMapper = $typeMapper ?? new TypeMapper();
     }
 
     /**

src/Generator/MethodGenerator.php

···
         ?StubRenderer $renderer = null,
         ?ModelMapper $modelMapper = null
     ) {
-        $this->naming = $naming ?? new NamingConverter;
+        $this->naming = $naming ?? new NamingConverter();
         $this->typeMapper = $typeMapper ?? new TypeMapper($this->naming);
-        $this->renderer = $renderer ?? new StubRenderer;
+        $this->renderer = $renderer ?? new StubRenderer();
         $this->modelMapper = $modelMapper ?? new ModelMapper($this->naming, $this->typeMapper);
     }
 

src/Generator/ModelMapper.php

···
      */
     public function __construct(?NamingConverter $naming = null, ?TypeMapper $typeMapper = null)
     {
-        $this->naming = $naming ?? new NamingConverter;
+        $this->naming = $naming ?? new NamingConverter();
         $this->typeMapper = $typeMapper ?? new TypeMapper($this->naming);
     }
 

src/Generator/PropertyGenerator.php

···
      */
     public function __construct(?TypeMapper $typeMapper = null, ?StubRenderer $renderer = null)
     {
-        $this->typeMapper = $typeMapper ?? new TypeMapper;
-        $this->renderer = $renderer ?? new StubRenderer;
+        $this->typeMapper = $typeMapper ?? new TypeMapper();
+        $this->renderer = $renderer ?? new StubRenderer();
     }
 
     /**

src/Generator/TypeMapper.php

···
      */
     public function __construct(?NamingConverter $naming = null)
     {
-        $this->naming = $naming ?? new NamingConverter;
+        $this->naming = $naming ?? new NamingConverter();
     }
 
     /**

src/Validation/Validator.php

···
+<?php
+
+namespace SocialDept\Schema\Validation;
+
+use SocialDept\Schema\Contracts\LexiconValidator as LexiconValidatorContract;
+use SocialDept\Schema\Data\LexiconDocument;
+use SocialDept\Schema\Exceptions\RecordValidationException;
+use SocialDept\Schema\Exceptions\SchemaValidationException;
+use SocialDept\Schema\Parser\SchemaLoader;
+use SocialDept\Schema\Parser\TypeParser;
+
+class Validator implements LexiconValidatorContract
+{
+    /**
+     * Validation mode constants.
+     */
+    public const MODE_STRICT = 'strict';
+
+    public const MODE_OPTIMISTIC = 'optimistic';
+
+    public const MODE_LENIENT = 'lenient';
+
+    /**
+     * Schema loader for loading lexicon documents.
+     */
+    protected SchemaLoader $schemaLoader;
+
+    /**
+     * Type parser for parsing and resolving types.
+     */
+    protected TypeParser $typeParser;
+
+    /**
+     * Validation mode.
+     */
+    protected string $mode = self::MODE_STRICT;
+
+    /**
+     * Collected validation errors.
+     *
+     * @var array<string, array<string>>
+     */
+    protected array $errors = [];
+
+    /**
+     * Create a new Validator.
+     */
+    public function __construct(
+        SchemaLoader $schemaLoader,
+        ?TypeParser $typeParser = null
+    ) {
+        $this->schemaLoader = $schemaLoader;
+        $this->typeParser = $typeParser ?? new TypeParser(schemaLoader: $schemaLoader);
+    }
+
+    /**
+     * Validate data against Lexicon schema.
+     */
+    public function validate(array $data, LexiconDocument $schema): bool
+    {
+        $this->errors = [];
+
+        try {
+            $this->validateData($data, $schema);
+
+            return empty($this->errors);
+        } catch (RecordValidationException|SchemaValidationException) {
+            return false;
+        }
+    }
+
+    /**
+     * Validate and return errors.
+     *
+     * @return array<string, array<string>>
+     */
+    public function validateWithErrors(array $data, LexiconDocument $schema): array
+    {
+        $this->errors = [];
+
+        try {
+            $this->validateData($data, $schema);
+
+            return $this->errors;
+        } catch (RecordValidationException $e) {
+            return ['_root' => [$e->getMessage()]];
+        } catch (SchemaValidationException $e) {
+            return ['_schema' => [$e->getMessage()]];
+        }
+    }
+
+    /**
+     * Validate a specific field.
+     */
+    public function validateField(mixed $value, string $field, LexiconDocument $schema): bool
+    {
+        $this->errors = [];
+
+        try {
+            $mainDef = $schema->getMainDefinition();
+
+            if ($mainDef === null) {
+                return false;
+            }
+
+            $properties = $this->extractProperties($mainDef);
+
+            if (! isset($properties[$field])) {
+                if ($this->mode === self::MODE_STRICT) {
+                    $this->addError($field, "Field '{$field}' is not defined in schema");
+
+                    return false;
+                }
+
+                return true;
+            }
+
+            $this->validateProperty($value, $field, $properties[$field], $schema);
+
+            return empty($this->errors);
+        } catch (RecordValidationException) {
+            return false;
+        }
+    }
+
+    /**
+     * Set validation mode (strict, optimistic, lenient).
+     */
+    public function setMode(string $mode): void
+    {
+        if (! in_array($mode, [self::MODE_STRICT, self::MODE_OPTIMISTIC, self::MODE_LENIENT])) {
+            throw new \InvalidArgumentException("Invalid validation mode: {$mode}");
+        }
+
+        $this->mode = $mode;
+    }
+
+    /**
+     * Get current validation mode.
+     */
+    public function getMode(): string
+    {
+        return $this->mode;
+    }
+
+    /**
+     * Validate data against schema.
+     */
+    protected function validateData(array $data, LexiconDocument $schema): void
+    {
+        $mainDef = $schema->getMainDefinition();
+
+        if ($mainDef === null) {
+            throw SchemaValidationException::invalidStructure(
+                $schema->getNsid(),
+                ['Missing main definition']
+            );
+        }
+
+        $type = $mainDef['type'] ?? null;
+
+        // Only validate if it's a record or object type
+        if ($type !== 'record' && $type !== 'object') {
+            throw SchemaValidationException::invalidStructure(
+                $schema->getNsid(),
+                ['Schema must be a record or object type, got: ' . ($type ?? 'unknown')]
+            );
+        }
+
+        $properties = $this->extractProperties($mainDef);
+        $required = $this->extractRequired($mainDef);
+
+        // Validate required fields
+        $this->validateRequired($data, $required);
+
+        // Validate defined properties
+        foreach ($properties as $name => $propDef) {
+            if (array_key_exists($name, $data)) {
+                $this->validateProperty($data[$name], $name, $propDef, $schema);
+            }
+        }
+
+        // Check for unknown fields
+        if ($this->mode === self::MODE_STRICT) {
+            $this->validateNoUnknownFields($data, array_keys($properties));
+        }
+    }
+
+    /**
+     * Extract properties from definition.
+     *
+     * @param  array<string, mixed>  $definition
+     * @return array<string, array<string, mixed>>
+     */
+    protected function extractProperties(array $definition): array
+    {
+        // Handle record type
+        if (isset($definition['record']) && is_array($definition['record'])) {
+            return $definition['record']['properties'] ?? [];
+        }
+
+        // Handle object type
+        if ($definition['type'] === 'object' || isset($definition['properties'])) {
+            return $definition['properties'] ?? [];
+        }
+
+        return [];
+    }
+
+    /**
+     * Extract required fields from definition.
+     *
+     * @param  array<string, mixed>  $definition
+     * @return array<string>
+     */
+    protected function extractRequired(array $definition): array
+    {
+        // Handle record type
+        if (isset($definition['record']) && is_array($definition['record'])) {
+            return $definition['record']['required'] ?? [];
+        }
+
+        // Handle object type
+        return $definition['required'] ?? [];
+    }
+
+    /**
+     * Validate required fields are present.
+     *
+     * @param  array<string>  $required
+     */
+    protected function validateRequired(array $data, array $required): void
+    {
+        if ($this->mode === self::MODE_LENIENT) {
+            return;
+        }
+
+        foreach ($required as $field) {
+            if (! array_key_exists($field, $data)) {
+                $this->addError($field, "Required field '{$field}' is missing");
+            }
+        }
+    }
+
+    /**
+     * Validate a single property.
+     *
+     * @param  array<string, mixed>  $propDef
+     */
+    protected function validateProperty(mixed $value, string $name, array $propDef, LexiconDocument $schema): void
+    {
+        try {
+            $type = $propDef['type'] ?? 'unknown';
+
+            // Basic type validation
+            $this->validateType($value, $type, $name);
+
+            // Constraint validation (skip in lenient mode)
+            if ($this->mode !== self::MODE_LENIENT) {
+                $this->validateConstraints($value, $propDef, $name);
+            }
+
+            // Nested object validation
+            if ($type === 'object' && is_array($value)) {
+                $this->validateNestedObject($value, $propDef, $name, $schema);
+            }
+
+            // Array validation
+            if ($type === 'array' && is_array($value)) {
+                $this->validateArray($value, $propDef, $name, $schema);
+            }
+        } catch (RecordValidationException $e) {
+            $this->addError($name, $e->getMessage());
+        }
+    }
+
+    /**
+     * Validate value type.
+     */
+    protected function validateType(mixed $value, string $expectedType, string $fieldName): void
+    {
+        $actualType = gettype($value);
+
+        $valid = match ($expectedType) {
+            'string' => is_string($value),
+            'integer' => is_int($value),
+            'boolean' => is_bool($value),
+            'number' => is_numeric($value),
+            'object' => is_array($value),
+            'array' => is_array($value),
+            'null' => is_null($value),
+            default => true, // Unknown types pass in optimistic/lenient modes
+        };
+
+        if (! $valid) {
+            $this->addError($fieldName, "Expected type '{$expectedType}', got '{$actualType}'");
+        }
+    }
+
+    /**
+     * Validate field constraints.
+     *
+     * @param  array<string, mixed>  $propDef
+     */
+    protected function validateConstraints(mixed $value, array $propDef, string $fieldName): void
+    {
+        // String length constraints
+        if (is_string($value)) {
+            if (isset($propDef['maxLength']) && strlen($value) > $propDef['maxLength']) {
+                $this->addError($fieldName, "String exceeds maximum length of {$propDef['maxLength']}");
+            }
+
+            if (isset($propDef['minLength']) && strlen($value) < $propDef['minLength']) {
+                $this->addError($fieldName, "String is shorter than minimum length of {$propDef['minLength']}");
+            }
+
+            if (isset($propDef['maxGraphemes']) && grapheme_strlen($value) > $propDef['maxGraphemes']) {
+                $this->addError($fieldName, "String exceeds maximum graphemes of {$propDef['maxGraphemes']}");
+            }
+
+            if (isset($propDef['minGraphemes']) && grapheme_strlen($value) < $propDef['minGraphemes']) {
+                $this->addError($fieldName, "String has fewer than minimum graphemes of {$propDef['minGraphemes']}");
+            }
+        }
+
+        // Number constraints
+        if (is_numeric($value)) {
+            if (isset($propDef['maximum']) && $value > $propDef['maximum']) {
+                $this->addError($fieldName, "Value exceeds maximum of {$propDef['maximum']}");
+            }
+
+            if (isset($propDef['minimum']) && $value < $propDef['minimum']) {
+                $this->addError($fieldName, "Value is less than minimum of {$propDef['minimum']}");
+            }
+        }
+
+        // Array constraints
+        if (is_array($value)) {
+            $count = count($value);
+
+            if (isset($propDef['maxItems']) && $count > $propDef['maxItems']) {
+                $this->addError($fieldName, "Array exceeds maximum items of {$propDef['maxItems']}");
+            }
+
+            if (isset($propDef['minItems']) && $count < $propDef['minItems']) {
+                $this->addError($fieldName, "Array has fewer than minimum items of {$propDef['minItems']}");
+            }
+        }
+
+        // Enum constraint
+        if (isset($propDef['enum']) && ! in_array($value, $propDef['enum'], true)) {
+            $allowedValues = implode(', ', $propDef['enum']);
+            $this->addError($fieldName, "Value must be one of: {$allowedValues}");
+        }
+
+        // Const constraint
+        if (isset($propDef['const']) && $value !== $propDef['const']) {
+            $expectedValue = json_encode($propDef['const']);
+            $this->addError($fieldName, "Value must be {$expectedValue}");
+        }
+    }
+
+    /**
+     * Validate nested object.
+     *
+     * @param  array<string, mixed>  $propDef
+     */
+    protected function validateNestedObject(array $value, array $propDef, string $fieldName, LexiconDocument $schema): void
+    {
+        $nestedProperties = $propDef['properties'] ?? [];
+        $nestedRequired = $propDef['required'] ?? [];
+
+        // Create temporary document for nested validation
+        $nestedDoc = new LexiconDocument(
+            lexicon: 1,
+            id: $schema->id,
+            defs: ['main' => [
+                'type' => 'object',
+                'properties' => $nestedProperties,
+                'required' => $nestedRequired,
+            ]],
+            description: null,
+            source: null,
+            raw: []
+        );
+
+        $originalErrors = $this->errors;
+        $this->errors = [];
+
+        $this->validateData($value, $nestedDoc);
+
+        // Prefix nested errors with field name
+        foreach ($this->errors as $nestedField => $messages) {
+            foreach ($messages as $message) {
+                $this->addError("{$fieldName}.{$nestedField}", $message);
+            }
+        }
+
+        $this->errors = array_merge($originalErrors, $this->errors);
+    }
+
+    /**
+     * Validate array items.
+     *
+     * @param  array<string, mixed>  $propDef
+     */
+    protected function validateArray(array $value, array $propDef, string $fieldName, LexiconDocument $schema): void
+    {
+        if (! isset($propDef['items'])) {
+            return;
+        }
+
+        $itemDef = $propDef['items'];
+
+        foreach ($value as $index => $item) {
+            $itemFieldName = "{$fieldName}[{$index}]";
+            $this->validateProperty($item, $itemFieldName, $itemDef, $schema);
+        }
+    }
+
+    /**
+     * Validate no unknown fields are present.
+     *
+     * @param  array<string>  $allowedFields
+     */
+    protected function validateNoUnknownFields(array $data, array $allowedFields): void
+    {
+        foreach (array_keys($data) as $field) {
+            if (! in_array($field, $allowedFields)) {
+                $this->addError($field, "Unknown field '{$field}' is not allowed");
+            }
+        }
+    }
+
+    /**
+     * Add a validation error.
+     */
+    protected function addError(string $field, string $message): void
+    {
+        if (! isset($this->errors[$field])) {
+            $this->errors[$field] = [];
+        }
+
+        $this->errors[$field][] = $message;
+    }
+}

tests/Unit/Generator/ClassGeneratorTest.php

···
     {
         parent::setUp();
 
-        $this->generator = new ClassGenerator;
+        $this->generator = new ClassGenerator();
     }
 
     public function test_it_generates_simple_record_class(): void

tests/Unit/Generator/ConstructorGeneratorTest.php

···
     {
         parent::setUp();
 
-        $this->generator = new ConstructorGenerator;
+        $this->generator = new ConstructorGenerator();
     }
 
     public function test_it_generates_constructor_with_promoted_properties(): void

tests/Unit/Generator/DocBlockGeneratorTest.php

···
     {
         parent::setUp();
 
-        $this->generator = new DocBlockGenerator;
+        $this->generator = new DocBlockGenerator();
     }
 
     public function test_it_generates_class_docblock_with_description(): void

tests/Unit/Generator/MethodGeneratorTest.php

···
     {
         parent::setUp();
 
-        $this->generator = new MethodGenerator;
+        $this->generator = new MethodGenerator();
     }
 
     public function test_it_generates_get_lexicon_method(): void

tests/Unit/Generator/ModelMapperTest.php

···
     {
         parent::setUp();
 
-        $this->mapper = new ModelMapper;
+        $this->mapper = new ModelMapper();
     }
 
     public function test_it_generates_to_model_body_for_simple_properties(): void
···
         foreach ($lines as $line) {
             if (str_contains($line, 'last:')) {
                 $lastPropertyLine = $line;
+
                 break;
             }
         }

tests/Unit/Generator/PropertyGeneratorTest.php

···
     {
         parent::setUp();
 
-        $this->generator = new PropertyGenerator;
+        $this->generator = new PropertyGenerator();
     }
 
     public function test_it_generates_required_string_property(): void

tests/Unit/Validation/ValidatorTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Validation;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Data\LexiconDocument;
+use SocialDept\Schema\Parser\Nsid;
+use SocialDept\Schema\Parser\SchemaLoader;
+use SocialDept\Schema\Validation\Validator;
+
+class ValidatorTest extends TestCase
+{
+    protected Validator $validator;
+
+    protected SchemaLoader $loader;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $fixturesPath = __DIR__.'/../../fixtures';
+        $this->loader = new SchemaLoader([$fixturesPath], false);
+        $this->validator = new Validator($this->loader);
+    }
+
+    public function test_it_validates_valid_data(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                    'age' => ['type' => 'integer'],
+                ],
+            ],
+        ]);
+
+        $data = ['name' => 'John', 'age' => 30];
+
+        $this->assertTrue($this->validator->validate($data, $document));
+    }
+
+    public function test_it_rejects_missing_required_field(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name', 'email'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                    'email' => ['type' => 'string'],
+                ],
+            ],
+        ]);
+
+        $data = ['name' => 'John'];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('email', $errors);
+        $this->assertStringContainsString('Required', $errors['email'][0]);
+    }
+
+    public function test_it_validates_type_mismatch(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['age'],
+                'properties' => [
+                    'age' => ['type' => 'integer'],
+                ],
+            ],
+        ]);
+
+        $data = ['age' => 'not a number'];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('age', $errors);
+    }
+
+    public function test_it_validates_string_max_length(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['text'],
+                'properties' => [
+                    'text' => [
+                        'type' => 'string',
+                        'maxLength' => 10,
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['text' => 'This is way too long'];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('text', $errors);
+        $this->assertStringContainsString('maximum length', $errors['text'][0]);
+    }
+
+    public function test_it_validates_string_min_length(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['text'],
+                'properties' => [
+                    'text' => [
+                        'type' => 'string',
+                        'minLength' => 5,
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['text' => 'Hi'];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('text', $errors);
+        $this->assertStringContainsString('minimum length', $errors['text'][0]);
+    }
+
+    public function test_it_validates_grapheme_constraints(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['text'],
+                'properties' => [
+                    'text' => [
+                        'type' => 'string',
+                        'maxGraphemes' => 5,
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['text' => '😀😁😂😃😄😅']; // 6 graphemes
+
+        $this->assertFalse($this->validator->validate($data, $document));
+    }
+
+    public function test_it_validates_number_maximum(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['count'],
+                'properties' => [
+                    'count' => [
+                        'type' => 'integer',
+                        'maximum' => 100,
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['count' => 150];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('count', $errors);
+        $this->assertStringContainsString('maximum', $errors['count'][0]);
+    }
+
+    public function test_it_validates_number_minimum(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['count'],
+                'properties' => [
+                    'count' => [
+                        'type' => 'integer',
+                        'minimum' => 10,
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['count' => 5];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('count', $errors);
+        $this->assertStringContainsString('minimum', $errors['count'][0]);
+    }
+
+    public function test_it_validates_array_max_items(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['items'],
+                'properties' => [
+                    'items' => [
+                        'type' => 'array',
+                        'maxItems' => 3,
+                        'items' => ['type' => 'string'],
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['items' => ['a', 'b', 'c', 'd']];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('items', $errors);
+        $this->assertStringContainsString('maximum items', $errors['items'][0]);
+    }
+
+    public function test_it_validates_array_min_items(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['items'],
+                'properties' => [
+                    'items' => [
+                        'type' => 'array',
+                        'minItems' => 2,
+                        'items' => ['type' => 'string'],
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['items' => ['a']];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('items', $errors);
+        $this->assertStringContainsString('minimum items', $errors['items'][0]);
+    }
+
+    public function test_it_validates_enum_constraint(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['status'],
+                'properties' => [
+                    'status' => [
+                        'type' => 'string',
+                        'enum' => ['active', 'inactive', 'pending'],
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['status' => 'unknown'];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('status', $errors);
+        $this->assertStringContainsString('one of:', $errors['status'][0]);
+    }
+
+    public function test_it_validates_const_constraint(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['type'],
+                'properties' => [
+                    'type' => [
+                        'type' => 'string',
+                        'const' => 'post',
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['type' => 'comment'];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('type', $errors);
+    }
+
+    public function test_it_validates_nested_objects(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['author'],
+                'properties' => [
+                    'author' => [
+                        'type' => 'object',
+                        'required' => ['name'],
+                        'properties' => [
+                            'name' => ['type' => 'string'],
+                            'email' => ['type' => 'string'],
+                        ],
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['author' => ['email' => '[e-mail]']];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('author.name', $errors);
+    }
+
+    public function test_it_validates_array_items(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['tags'],
+                'properties' => [
+                    'tags' => [
+                        'type' => 'array',
+                        'items' => [
+                            'type' => 'string',
+                            'maxLength' => 10,
+                        ],
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['tags' => ['short', 'this is way too long']];
+
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('tags[1]', $errors);
+    }
+
+    public function test_strict_mode_rejects_unknown_fields(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                ],
+            ],
+        ]);
+
+        $data = ['name' => 'John', 'unknown' => 'value'];
+
+        $this->validator->setMode(Validator::MODE_STRICT);
+        $this->assertFalse($this->validator->validate($data, $document));
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertArrayHasKey('unknown', $errors);
+    }
+
+    public function test_optimistic_mode_allows_unknown_fields(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                ],
+            ],
+        ]);
+
+        $data = ['name' => 'John', 'unknown' => 'value'];
+
+        $this->validator->setMode(Validator::MODE_OPTIMISTIC);
+        $this->assertTrue($this->validator->validate($data, $document));
+    }
+
+    public function test_lenient_mode_skips_required_validation(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name', 'email'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                    'email' => ['type' => 'string'],
+                ],
+            ],
+        ]);
+
+        $data = ['name' => 'John'];
+
+        $this->validator->setMode(Validator::MODE_LENIENT);
+        $this->assertTrue($this->validator->validate($data, $document));
+    }
+
+    public function test_lenient_mode_skips_constraint_validation(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['text'],
+                'properties' => [
+                    'text' => [
+                        'type' => 'string',
+                        'maxLength' => 5,
+                    ],
+                ],
+            ],
+        ]);
+
+        $data = ['text' => 'This is way too long'];
+
+        $this->validator->setMode(Validator::MODE_LENIENT);
+        $this->assertTrue($this->validator->validate($data, $document));
+    }
+
+    public function test_it_validates_specific_field(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => [
+                        'type' => 'string',
+                        'maxLength' => 50,
+                    ],
+                    'age' => ['type' => 'integer'],
+                ],
+            ],
+        ]);
+
+        $this->assertTrue($this->validator->validateField('John', 'name', $document));
+        $this->assertFalse($this->validator->validateField('not a number', 'age', $document));
+    }
+
+    public function test_it_validates_field_constraints(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => [
+                        'type' => 'string',
+                        'maxLength' => 5,
+                    ],
+                ],
+            ],
+        ]);
+
+        $this->assertFalse($this->validator->validateField('John Doe', 'name', $document));
+    }
+
+    public function test_it_rejects_invalid_validation_mode(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+
+        $this->validator->setMode('invalid');
+    }
+
+    public function test_it_returns_current_mode(): void
+    {
+        $this->assertEquals(Validator::MODE_STRICT, $this->validator->getMode());
+
+        $this->validator->setMode(Validator::MODE_LENIENT);
+        $this->assertEquals(Validator::MODE_LENIENT, $this->validator->getMode());
+    }
+
+    public function test_it_returns_empty_errors_for_valid_data(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                ],
+            ],
+        ]);
+
+        $data = ['name' => 'John'];
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertEmpty($errors);
+    }
+
+    public function test_it_validates_object_type_definition(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'object',
+            'required' => ['name'],
+            'properties' => [
+                'name' => ['type' => 'string'],
+            ],
+        ]);
+
+        $data = ['name' => 'John'];
+
+        $this->assertTrue($this->validator->validate($data, $document));
+    }
+
+    public function test_it_validates_multiple_errors(): void
+    {
+        $document = $this->createDocument([
+            'type' => 'record',
+            'record' => [
+                'type' => 'object',
+                'required' => ['name', 'age', 'email'],
+                'properties' => [
+                    'name' => ['type' => 'string'],
+                    'age' => ['type' => 'integer'],
+                    'email' => ['type' => 'string'],
+                ],
+            ],
+        ]);
+
+        $data = ['name' => 'John'];
+
+        $errors = $this->validator->validateWithErrors($data, $document);
+        $this->assertCount(2, $errors); // Missing age and email
+        $this->assertArrayHasKey('age', $errors);
+        $this->assertArrayHasKey('email', $errors);
+    }
+
+    /**
+     * Helper to create a test document.
+     *
+     * @param  array<string, mixed>  $mainDef
+     */
+    protected function createDocument(array $mainDef): LexiconDocument
+    {
+        return new LexiconDocument(
+            lexicon: 1,
+            id: Nsid::parse('com.example.test'),
+            defs: ['main' => $mainDef],
+            description: null,
+            source: null,
+            raw: []
+        );
+    }
+}