Projects sharing features with Jsonschema

AWS Powertools for Python is a utility framework designed for building production-ready Python functions on AWS Lambda. It provides a comprehensive suite of tools for observability, event parsing, routing, and idempotency management to streamline the development of serverless applications. The project distinguishes itself through specialized capabilities for event-driven architectures and AI agent orchestration. It enables the implementation of AI agents by exposing functions as tools via OpenAPI schemas and managing conversation states. Additionally, it features an idempotency library that p

This library is a Ruby-based validation engine designed to verify JSON data structures against official schema specifications. It ensures data integrity by confirming that objects, strings, and files conform to defined structural constraints, while also validating the integrity of the schema definitions themselves against official metaschema standards. The project distinguishes itself through a highly modular architecture that allows for deep customization. Users can register custom validation rules and format handlers to enforce project-specific business logic that extends beyond standard sp

This library is a Java-based tool for enforcing data structure constraints and verifying technical formats against defined schema specifications. It functions as a processing utility that parses complex data structures while managing external schema references and circular dependencies. The engine distinguishes itself through an immutable processor design that enables thread-safe, concurrent validation without requiring external synchronization. It employs arbitrary-precision arithmetic to evaluate numeric constraints, preventing common floating-point rounding errors, and utilizes character-l

Valibot is a modular, type-safe schema library for validating and parsing structural data in TypeScript environments.

Yup is a JavaScript schema validation library used to define data shapes and validate runtime values. It functions as an object schema validator and a data coercion engine, allowing developers to transform raw input values into desired types before performing validation checks. The library is distinguished by its support for dynamic schema validation, where rules can be adjusted at runtime based on sibling field values or external context. It also enables recursive data structuring for polymorphic fields and provides a system for extracting static TypeScript interfaces from runtime schema def

Joi is a JavaScript data validation library used to define schemas that validate, cast, and sanitize data objects. It functions as an object schema validator and parser, ensuring that input data matches specific types and formats before it is processed by an application. The library features a conditional validation engine capable of dynamic schema enforcement, where validation logic and dependencies change based on the values of other keys within an object. It also serves as a data casting and sanitization tool, transforming input values into target types and removing sensitive keys from the

Ajv is a JSON Schema validator and schema compilation engine used to verify that JavaScript objects conform to specific JSON Schema definitions. It functions as a data coercer and localization tool, allowing for the application of default values and the translation of validation error messages into different languages. The project converts declarative JSON Schema definitions into optimized JavaScript functions to increase validation speed. It supports the extension of validation logic through custom keywords and the generation of standalone validation code that executes without external depen

Joi is a JavaScript data validation library used to define schemas that ensure the structure and data types of objects remain consistent. It functions as a schema-based validator and object schema definition tool, preventing invalid information from entering an application by checking data against predefined constraints and rules. The library employs a chainable fluent interface and a constraint-based validation engine to build complex validation pipelines. It utilizes recursive tree traversal to validate nested data structures and a type-coercion pipeline to transform input values into the t

async-validator is a JavaScript schema validation library and asynchronous data validation engine. It verifies complex object structures and nested arrays by applying recursive rules and non-blocking, promise-based execution to ensure data integrity. The library functions as both an object constraint validator and a data transformation pipeline. It allows for the sanitization, coercion, and formatting of input values through a sequence of functions that run before and after the primary validation process. The engine covers a range of capabilities including recursive nested validation, the en

Pandera is a data pipeline validation framework and statistical type validation tool. It functions as a library for defining and enforcing schemas on datasets to ensure data quality and consistency, specifically providing validation capabilities for Pandas dataframes. The project includes a schema inference tool that automates setup by analyzing existing dataset samples to generate validation schemas. It also serves as a synthetic data generator, creating artificial datasets based on predefined schemas to verify data-producing functions. The framework covers data engineering quality assuranc

This PHP assertion library is a runtime data validator used to verify method inputs and outputs. It provides a toolkit for validating data types, numeric ranges, and string patterns during program execution to prevent invalid states. The project serves as a static analysis helper by providing type hints and annotations that improve the accuracy of formal verification tools. It includes a collection validation utility for applying rules across arrays or iterable collections, and a filesystem validation tool to verify path existence and read or write permissions. The library covers a broad ran

v8n is a JavaScript data validation library used to verify that values, objects, and arrays meet specific criteria. It functions as a schema-based validator and an asynchronous validation engine, utilizing a fluent API to construct sequences of chainable rules and constraints. The framework is distinguished by its ability to execute promises and network requests during the validation process to determine if a value is valid. It allows for the creation of reusable validation schemas and provides a customizable rule framework where users can define their own logic and configure how error result

is.js is a JavaScript validation library and data type checker. It provides a suite of utilities to verify whether variables are primitives, arrays, functions, or specific object types. The project allows for the implementation of custom validation logic and the use of naming namespaces to override default rules and regular expressions. It covers a broad range of validation capabilities, including numeric arithmetic properties, date and time analysis for relative and absolute ranges, and string format verification for patterns such as emails, URLs, and IP addresses. The library also includes

This project is a protocol buffer validation plugin and code generator that creates consistent validation logic across multiple programming languages. It functions as a compiler extension for the Protocol Buffer toolchain, allowing developers to define semantic constraints directly within schema files to ensure data consistency. The tool uses custom options to embed validation rules into message definitions, mapping these schema constraints to language-specific implementation patterns. It employs predicate-based constraint checking and recursive traversal to enforce rules across nested messag

Zod is a TypeScript-first schema declaration and validation library designed to ensure end-to-end data integrity. It functions as a runtime type guard, allowing developers to define complex data structures through a declarative, chainable syntax. By using these schema definitions, the library automatically derives static TypeScript types, eliminating the need for manual type duplication and ensuring that runtime data matches expected application contracts. The library distinguishes itself through functional schema composition, which enables the creation of hierarchical structures by nesting a

Express-openapi-validator is an ExpressJS middleware that enforces API contract compliance by validating incoming requests and outgoing responses against OpenAPI 3.0 and 3.1 specifications. It acts as a gatekeeper for web services, ensuring that all traffic adheres to defined schemas before reaching application logic. The framework distinguishes itself by automating data integrity tasks, including the automatic coercion of request parameters and body content into typed objects. It provides comprehensive security enforcement by validating authentication and authorization headers against define

This project provides a standardized data format for representing professional work history and skills using structured objects. It serves as a formal specification for verifying that career information conforms to required fields and structural constraints, ensuring consistent representation across digital platforms and services. By decoupling raw professional information from its visual presentation, the schema enables the programmatic generation of resumes in multiple formats from a single source. This approach allows for the creation of machine-readable files that can be parsed and render

Pydantic is a data validation library and parsing framework for Python. It functions as a type-based schema validator that uses standard Python type annotations to ensure input data conforms to predefined structural schemas. The project provides capabilities for parsing raw data into typed objects through automatic type conversion and validation. This includes the serialization of data and the validation of data structures to enforce correctness. The framework covers several application areas, including the verification of API requests and the management of application configurations. It all

CUE is a constraint-based configuration language designed for data validation, schema definition, and code generation. At its core, it unifies types and values into a single concept, enabling compile-time validation that catches structural and value errors before runtime. The language treats data and constraints as the same thing, allowing a single definition to serve as both a schema and concrete configuration data. CUE distinguishes itself through its constraint-based unification engine, which combines multiple configuration sources into a single coherent result by merging their constraints

This project provides the JSON Schema Specification, a standard for annotating and validating JSON documents to ensure consistent data structures across different systems. It serves as a data validation standard and an interoperability standard, establishing a common language for exchanging data definitions between different programming languages and platforms. The specification includes a machine-readable framework for defining JSON vocabularies, which describes the expected types, formats, and structures of data objects. It enables the creation of standardized, machine-readable documentatio

Dataclasses-json is a library designed to facilitate the bidirectional conversion between Python data classes and JSON formats. It serves as a serialization tool that populates structured objects from raw data and transforms object instances into JSON strings, utilizing Python type hints to automate the mapping process. The library distinguishes itself by providing mechanisms for schema validation and runtime type coercion, ensuring that incoming data adheres to predefined model structures. It supports complex data requirements through recursive object traversal, which allows for the processi

fastjson2 is a high-performance Java library used for serializing and deserializing Java objects to and from JSON strings and byte arrays. It functions as a binary JSON serializer for encoding objects into optimized binary formats to reduce payload size and increase processing speed. The project includes a JSONPath query engine for extracting specific data and fields from JSON documents using standardized path expressions and filters. It also serves as a JSON schema validator, providing utilities to generate data contracts and validate JSON input against defined schemas to ensure structural c

Generate Java types from JSON or JSON Schema and annotate those types for data-binding with Jackson, Gson, etc

This project is a data validation framework for the Go programming language that enforces integrity by applying declarative constraints to struct fields. It utilizes reflection to inspect data structures at runtime, mapping field-level requirements defined in struct tags to specific validation logic. The library distinguishes itself through its ability to handle complex object graphs by recursively traversing nested structures and slices. It supports context-aware validation, allowing developers to switch between different rule sets for the same data structure based on application state or sp

This library provides a comprehensive system for defining data schemas and enforcing structural integrity within JavaScript applications. It enables developers to construct declarative rules for complex, nested objects, ensuring that data conforms to expected types and constraints before it is processed or stored. By integrating directly with the Meteor framework, it serves as a central tool for maintaining consistent data structures across collections and remote procedure calls. The project distinguishes itself through its deep integration with reactive data systems, allowing validation stat

Spectral is a programmable linting engine and validation tool designed to enforce style guidelines and schema correctness within OpenAPI specifications and JSON configuration files. It functions as a rule-based validator that analyzes structured text files to ensure data consistency and adherence to predefined constraints. The engine utilizes a configuration-driven execution model, allowing users to manage pluggable rule sets and integrate JSON Schema definitions. It supports the creation of custom function-based rules to define complex validation logic beyond static declarations. The projec

Superstruct is a JavaScript and TypeScript data validation library used to verify that data structures match defined shapes and types. It functions as a composable schema builder and a TypeScript schema validator, ensuring that runtime data checks remain synchronized with static type definitions. The library features a data coercion engine that transforms input values or injects default values before the validation process is executed. It enables the creation of complex validation rules by nesting, merging, or omitting properties from existing structures. Its capabilities cover the validatio