@twin.org/data-core 0.0.1-next.35 → 0.0.1-next.36

package/dist/cjs/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
 var core = require('@twin.org/core');
+var browser = require('@hyperjump/browser');
+var draft202012 = require('@hyperjump/json-schema/draft-2020-12');
 var web = require('@twin.org/web');
-var Ajv = require('ajv');
-var addFormats = require('ajv-formats');
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -66,6 +66,16 @@ class JsonSchemaHelper {
      * The schema version.
      */
     static SCHEMA_VERSION = "https://json-schema.org/draft/2020-12/schema";
+    /**
+     * The private prefix for the type.
+     * @internal
+     */
+    static _PRIVATE_PREFIX = "https://twindev.org/private/";
+    /**
+     * The private type.
+     * @internal
+     */
+    static _PRIVATE_TYPE = "https://twindev.org/private/ValidationType";
     /**
      * The class name.
      * @internal
@@ -79,50 +89,77 @@ class JsonSchemaHelper {
      * @returns Result containing errors if there are any.
      */
     static async validate(schema, data, additionalTypes) {
-        const ajv = new Ajv({
-            allowUnionTypes: true,
-            // Disable strict tuples as it causes issues with the schema validation when
-            // you have an array with fixed elements e.g. myType: [string, ...string[]]
-            // https://github.com/ajv-validator/ajv/issues/1417
-            strictTuples: false,
-            loadSchema: async (uri) => {
+        const httpSchemePlugin = {
+            retrieve: async (uri) => {
+                let loadedSchema;
                 const subTypeHandler = DataTypeHandlerFactory.getIfExists(uri);
                 if (core.Is.function(subTypeHandler?.jsonSchema)) {
                     const subSchema = await subTypeHandler.jsonSchema();
                     if (core.Is.object(subSchema)) {
-                        return subSchema;
+                        loadedSchema = subSchema;
                     }
                 }
-                try {
-                    // We don't have the type in our local data types, so we try to fetch it from the web
-                    return web.FetchHelper.fetchJson(JsonSchemaHelper._CLASS_NAME, uri, web.HttpMethod.GET, undefined, {
-                        // Cache for an hour
-                        cacheTtlMs: 3600000
-                    });
-                }
-                catch {
-                    // Failed to load remotely so return an empty object
-                    // so the schema validation doesn't completely fail
-                    return {};
+                if (!core.Is.object(loadedSchema)) {
+                    try {
+                        // We don't have the type in our local data types, so we try to fetch it from the web
+                        schema = await web.FetchHelper.fetchJson(JsonSchemaHelper._CLASS_NAME, uri, web.HttpMethod.GET, undefined, {
+                            headers: {
+                                Accept: browser.acceptableMediaTypes()
+                            },
+                            // Cache for an hour
+                            cacheTtlMs: 3600000
+                        });
+                    }
+                    catch { }
                 }
+                // Failed to load remotely so return an empty object
+                // so the schema validation doesn't completely fail
+                loadedSchema ??= {};
+                return {
+                    status: 200,
+                    statusText: "OK",
+                    ok: true,
+                    url: uri,
+                    headers: new Headers({
+                        "Content-Type": "application/schema+json"
+                    }),
+                    json: Promise.resolve(loadedSchema)
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                };
             }
-        });
-        addFormats(ajv);
+        };
+        browser.addUriSchemePlugin("https", httpSchemePlugin);
+        browser.addUriSchemePlugin("http", httpSchemePlugin);
         // Add the additional types provided by the user
         if (core.Is.objectValue(additionalTypes)) {
             for (const key in additionalTypes) {
-                ajv.addSchema(additionalTypes[key], key);
+                additionalTypes[key].$schema =
+                    additionalTypes[key].$schema ?? JsonSchemaHelper.SCHEMA_VERSION;
+                const additionalType = key.startsWith("http")
+                    ? key
+                    : `${JsonSchemaHelper._PRIVATE_PREFIX}${key}`;
+                draft202012.registerSchema(additionalTypes[key], additionalType);
             }
         }
-        const compiled = await ajv.compileAsync(schema);
-        const result = await compiled(data);
-        const output = {
-            result
-        };
-        if (!output.result) {
-            output.error = compiled.errors;
+        schema.$schema = schema.$schema ?? JsonSchemaHelper.SCHEMA_VERSION;
+        draft202012.registerSchema(schema, JsonSchemaHelper._PRIVATE_TYPE);
+        const output = await draft202012.validate(JsonSchemaHelper._PRIVATE_TYPE, data, "DETAILED");
+        await this.cleanupOutput(output);
+        await this.formatErrors(output, data);
+        draft202012.unregisterSchema(JsonSchemaHelper._PRIVATE_TYPE);
+        // Remove the additional types provided by the user
+        if (core.Is.objectValue(additionalTypes)) {
+            for (const key in additionalTypes) {
+                const additionalType = key.startsWith("http")
+                    ? key
+                    : `${JsonSchemaHelper._PRIVATE_PREFIX}${key}`;
+                draft202012.unregisterSchema(additionalType);
+            }
         }
-        return output;
+        return {
+            result: output.valid,
+            errors: output.errors
+        };
     }
     /**
      * Get the property type from a schema.
@@ -131,9 +168,12 @@ class JsonSchemaHelper {
      * @returns The types of the property.
      */
     static getPropertyType(schema, propertyName) {
+        if (core.Is.boolean(schema)) {
+            return undefined;
+        }
         if (schema.type === "object" && core.Is.objectValue(schema.properties)) {
             const propertySchema = schema.properties[propertyName];
-            if (core.Is.object(propertySchema)) {
+            if (!core.Is.boolean(propertySchema) && !core.Is.empty(propertySchema)) {
                 if (core.Is.stringValue(propertySchema.$ref)) {
                     return propertySchema.$ref;
                 }
@@ -199,6 +239,41 @@ class JsonSchemaHelper {
             additionalProperties: false
         };
     }
+    /**
+     * Cleanup the errors from the schema validation.
+     * @param outputUnit The errors to format.
+     * @param data The data that was validated.
+     * @returns The formatted errors.
+     */
+    static async formatErrors(outputUnit, data) {
+        if (outputUnit.keyword === "https://json-schema.org/keyword/required") {
+            outputUnit.message = `The property '${outputUnit.instanceLocation}' is required but was not found.`;
+        }
+        else {
+            outputUnit.message = `"${outputUnit.instanceLocation}" fails schema constraint ${outputUnit.absoluteKeywordLocation}`;
+        }
+        if (core.Is.arrayValue(outputUnit.errors)) {
+            for (const subError of outputUnit.errors) {
+                await this.formatErrors(subError, data);
+            }
+        }
+    }
+    /**
+     * Cleanup the errors from the schema validation.
+     * @param outputUnit The errors to format.
+     * @returns The formatted errors.
+     * @internal
+     */
+    static async cleanupOutput(outputUnit) {
+        if (outputUnit.absoluteKeywordLocation?.startsWith(JsonSchemaHelper._PRIVATE_TYPE)) {
+            outputUnit.absoluteKeywordLocation = outputUnit.absoluteKeywordLocation.replace(JsonSchemaHelper._PRIVATE_TYPE, "");
+        }
+        if (core.Is.arrayValue(outputUnit.errors)) {
+            for (const subError of outputUnit.errors) {
+                await this.cleanupOutput(subError);
+            }
+        }
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -242,14 +317,14 @@ class DataTypeHelper {
                     const schema = await handler.jsonSchema();
                     if (core.Is.object(schema)) {
                         const validationResult = await JsonSchemaHelper.validate(schema, data);
-                        if (core.Is.arrayValue(validationResult.error)) {
+                        if (core.Is.arrayValue(validationResult.errors)) {
                             validationFailures.push({
                                 property: propertyName,
                                 reason: "validation.schema.failedValidation",
                                 properties: {
                                     value: data,
-                                    schemaErrors: validationResult.error,
-                                    message: validationResult.error.map(e => e.message).join(", ")
+                                    schemaErrors: validationResult.errors,
+                                    message: validationResult.errors.map(e => e.message).join("\n")
                                 }
                             });
                         }

package/dist/esm/index.mjs

@@ -1,7 +1,7 @@
 import { Factory, Urn, Is, StringHelper } from '@twin.org/core';
+import { addUriSchemePlugin, acceptableMediaTypes } from '@hyperjump/browser';
+import { registerSchema, validate, unregisterSchema } from '@hyperjump/json-schema/draft-2020-12';
 import { FetchHelper, HttpMethod } from '@twin.org/web';
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -64,6 +64,16 @@ class JsonSchemaHelper {
      * The schema version.
      */
     static SCHEMA_VERSION = "https://json-schema.org/draft/2020-12/schema";
+    /**
+     * The private prefix for the type.
+     * @internal
+     */
+    static _PRIVATE_PREFIX = "https://twindev.org/private/";
+    /**
+     * The private type.
+     * @internal
+     */
+    static _PRIVATE_TYPE = "https://twindev.org/private/ValidationType";
     /**
      * The class name.
      * @internal
@@ -77,50 +87,77 @@ class JsonSchemaHelper {
      * @returns Result containing errors if there are any.
      */
     static async validate(schema, data, additionalTypes) {
-        const ajv = new Ajv({
-            allowUnionTypes: true,
-            // Disable strict tuples as it causes issues with the schema validation when
-            // you have an array with fixed elements e.g. myType: [string, ...string[]]
-            // https://github.com/ajv-validator/ajv/issues/1417
-            strictTuples: false,
-            loadSchema: async (uri) => {
+        const httpSchemePlugin = {
+            retrieve: async (uri) => {
+                let loadedSchema;
                 const subTypeHandler = DataTypeHandlerFactory.getIfExists(uri);
                 if (Is.function(subTypeHandler?.jsonSchema)) {
                     const subSchema = await subTypeHandler.jsonSchema();
                     if (Is.object(subSchema)) {
-                        return subSchema;
+                        loadedSchema = subSchema;
                     }
                 }
-                try {
-                    // We don't have the type in our local data types, so we try to fetch it from the web
-                    return FetchHelper.fetchJson(JsonSchemaHelper._CLASS_NAME, uri, HttpMethod.GET, undefined, {
-                        // Cache for an hour
-                        cacheTtlMs: 3600000
-                    });
-                }
-                catch {
-                    // Failed to load remotely so return an empty object
-                    // so the schema validation doesn't completely fail
-                    return {};
+                if (!Is.object(loadedSchema)) {
+                    try {
+                        // We don't have the type in our local data types, so we try to fetch it from the web
+                        schema = await FetchHelper.fetchJson(JsonSchemaHelper._CLASS_NAME, uri, HttpMethod.GET, undefined, {
+                            headers: {
+                                Accept: acceptableMediaTypes()
+                            },
+                            // Cache for an hour
+                            cacheTtlMs: 3600000
+                        });
+                    }
+                    catch { }
                 }
+                // Failed to load remotely so return an empty object
+                // so the schema validation doesn't completely fail
+                loadedSchema ??= {};
+                return {
+                    status: 200,
+                    statusText: "OK",
+                    ok: true,
+                    url: uri,
+                    headers: new Headers({
+                        "Content-Type": "application/schema+json"
+                    }),
+                    json: Promise.resolve(loadedSchema)
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                };
             }
-        });
-        addFormats(ajv);
+        };
+        addUriSchemePlugin("https", httpSchemePlugin);
+        addUriSchemePlugin("http", httpSchemePlugin);
         // Add the additional types provided by the user
         if (Is.objectValue(additionalTypes)) {
             for (const key in additionalTypes) {
-                ajv.addSchema(additionalTypes[key], key);
+                additionalTypes[key].$schema =
+                    additionalTypes[key].$schema ?? JsonSchemaHelper.SCHEMA_VERSION;
+                const additionalType = key.startsWith("http")
+                    ? key
+                    : `${JsonSchemaHelper._PRIVATE_PREFIX}${key}`;
+                registerSchema(additionalTypes[key], additionalType);
             }
         }
-        const compiled = await ajv.compileAsync(schema);
-        const result = await compiled(data);
-        const output = {
-            result
-        };
-        if (!output.result) {
-            output.error = compiled.errors;
+        schema.$schema = schema.$schema ?? JsonSchemaHelper.SCHEMA_VERSION;
+        registerSchema(schema, JsonSchemaHelper._PRIVATE_TYPE);
+        const output = await validate(JsonSchemaHelper._PRIVATE_TYPE, data, "DETAILED");
+        await this.cleanupOutput(output);
+        await this.formatErrors(output, data);
+        unregisterSchema(JsonSchemaHelper._PRIVATE_TYPE);
+        // Remove the additional types provided by the user
+        if (Is.objectValue(additionalTypes)) {
+            for (const key in additionalTypes) {
+                const additionalType = key.startsWith("http")
+                    ? key
+                    : `${JsonSchemaHelper._PRIVATE_PREFIX}${key}`;
+                unregisterSchema(additionalType);
+            }
         }
-        return output;
+        return {
+            result: output.valid,
+            errors: output.errors
+        };
     }
     /**
      * Get the property type from a schema.
@@ -129,9 +166,12 @@ class JsonSchemaHelper {
      * @returns The types of the property.
      */
     static getPropertyType(schema, propertyName) {
+        if (Is.boolean(schema)) {
+            return undefined;
+        }
         if (schema.type === "object" && Is.objectValue(schema.properties)) {
             const propertySchema = schema.properties[propertyName];
-            if (Is.object(propertySchema)) {
+            if (!Is.boolean(propertySchema) && !Is.empty(propertySchema)) {
                 if (Is.stringValue(propertySchema.$ref)) {
                     return propertySchema.$ref;
                 }
@@ -197,6 +237,41 @@ class JsonSchemaHelper {
             additionalProperties: false
         };
     }
+    /**
+     * Cleanup the errors from the schema validation.
+     * @param outputUnit The errors to format.
+     * @param data The data that was validated.
+     * @returns The formatted errors.
+     */
+    static async formatErrors(outputUnit, data) {
+        if (outputUnit.keyword === "https://json-schema.org/keyword/required") {
+            outputUnit.message = `The property '${outputUnit.instanceLocation}' is required but was not found.`;
+        }
+        else {
+            outputUnit.message = `"${outputUnit.instanceLocation}" fails schema constraint ${outputUnit.absoluteKeywordLocation}`;
+        }
+        if (Is.arrayValue(outputUnit.errors)) {
+            for (const subError of outputUnit.errors) {
+                await this.formatErrors(subError, data);
+            }
+        }
+    }
+    /**
+     * Cleanup the errors from the schema validation.
+     * @param outputUnit The errors to format.
+     * @returns The formatted errors.
+     * @internal
+     */
+    static async cleanupOutput(outputUnit) {
+        if (outputUnit.absoluteKeywordLocation?.startsWith(JsonSchemaHelper._PRIVATE_TYPE)) {
+            outputUnit.absoluteKeywordLocation = outputUnit.absoluteKeywordLocation.replace(JsonSchemaHelper._PRIVATE_TYPE, "");
+        }
+        if (Is.arrayValue(outputUnit.errors)) {
+            for (const subError of outputUnit.errors) {
+                await this.cleanupOutput(subError);
+            }
+        }
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -240,14 +315,14 @@ class DataTypeHelper {
                     const schema = await handler.jsonSchema();
                     if (Is.object(schema)) {
                         const validationResult = await JsonSchemaHelper.validate(schema, data);
-                        if (Is.arrayValue(validationResult.error)) {
+                        if (Is.arrayValue(validationResult.errors)) {
                             validationFailures.push({
                                 property: propertyName,
                                 reason: "validation.schema.failedValidation",
                                 properties: {
                                     value: data,
-                                    schemaErrors: validationResult.error,
-                                    message: validationResult.error.map(e => e.message).join(", ")
+                                    schemaErrors: validationResult.errors,
+                                    message: validationResult.errors.map(e => e.message).join("\n")
                                 }
                             });
                         }

package/dist/types/index.d.ts

@@ -2,7 +2,8 @@ export * from "./factories/dataTypeHandlerFactory";
 export * from "./factories/identifierHandlerFactory";
 export * from "./models/IDataTypeHandler";
 export * from "./models/IIdentifierHandler";
-export * from "./models/ISchemaValidationError";
+export * from "./models/IJsonSchema";
+export * from "./models/ISchemaValidationErrors";
 export * from "./models/ISchemaValidationResult";
 export * from "./models/validationMode";
 export * from "./utils/dataTypeHelper";

package/dist/types/models/IDataTypeHandler.d.ts

@@ -1,5 +1,5 @@
 import type { IValidationFailure } from "@twin.org/core";
-import type { JSONSchema7 } from "json-schema";
+import type { IJsonSchema } from "./IJsonSchema";
 /**
  * Interface describing a type which can handle a specific data type.
  */
@@ -20,7 +20,7 @@ export interface IDataTypeHandler {
      * Get the JSON schema for the data type.
      * @returns The JSON schema for the data type.
      */
-    jsonSchema?(): Promise<JSONSchema7 | undefined>;
+    jsonSchema?(): Promise<IJsonSchema | undefined>;
     /**
      * A method for validating the data type.
      * @param propertyName The name of the property being validated.

package/dist/types/models/IJsonSchema.d.ts

@@ -0,0 +1,5 @@
+import type { JsonSchemaDraft202012Object } from "@hyperjump/json-schema/draft-2020-12";
+/**
+ * Default schema type.
+ */
+export type IJsonSchema = JsonSchemaDraft202012Object;

package/dist/types/models/ISchemaValidationErrors.d.ts

@@ -0,0 +1,7 @@
+import type { OutputUnit } from "@hyperjump/json-schema";
+/**
+ * Schema validation error.
+ */
+export type ISchemaValidationErrors = (OutputUnit & {
+    message?: string;
+})[];

package/dist/types/models/ISchemaValidationResult.d.ts

@@ -1,4 +1,4 @@
-import type { ISchemaValidationError } from "./ISchemaValidationError";
+import type { ISchemaValidationErrors } from "./ISchemaValidationErrors";
 /**
  * Validation result.
  */
@@ -10,5 +10,5 @@ export interface ISchemaValidationResult {
     /**
      * The error.
      */
-    error?: ISchemaValidationError;
+    errors?: ISchemaValidationErrors;
 }

package/dist/types/utils/jsonSchemaHelper.d.ts

@@ -1,5 +1,6 @@
+import { type OutputUnit } from "@hyperjump/json-schema/draft-2020-12";
 import type { IEntitySchema } from "@twin.org/entity";
-import type { JSONSchema7 } from "json-schema";
+import type { IJsonSchema } from "../models/IJsonSchema";
 import type { ISchemaValidationResult } from "../models/ISchemaValidationResult";
 /**
  * A helper for JSON schemas.
@@ -16,8 +17,8 @@ export declare class JsonSchemaHelper {
      * @param additionalTypes Additional types to add for reference, not already in DataTypeHandlerFactory.
      * @returns Result containing errors if there are any.
      */
-    static validate<T = unknown>(schema: JSONSchema7, data: T, additionalTypes?: {
-        [id: string]: JSONSchema7;
+    static validate<T = unknown>(schema: IJsonSchema, data: T, additionalTypes?: {
+        [id: string]: IJsonSchema;
     }): Promise<ISchemaValidationResult>;
     /**
      * Get the property type from a schema.
@@ -25,12 +26,21 @@ export declare class JsonSchemaHelper {
      * @param propertyName The name of the property to get the type for.
      * @returns The types of the property.
      */
-    static getPropertyType(schema: JSONSchema7, propertyName: string): string | undefined;
+    static getPropertyType(schema: IJsonSchema, propertyName: string): string | undefined;
     /**
      * Convert an entity schema to JSON schema e.g https://example.com/schemas/.
      * @param entitySchema The entity schema to convert.
      * @param baseDomain The base domain for local schemas e.g. https://example.com/
      * @returns The JSON schema for the entity.
      */
-    static entitySchemaToJsonSchema(entitySchema: IEntitySchema | undefined, baseDomain?: string): JSONSchema7;
+    static entitySchemaToJsonSchema(entitySchema: IEntitySchema | undefined, baseDomain?: string): IJsonSchema;
+    /**
+     * Cleanup the errors from the schema validation.
+     * @param outputUnit The errors to format.
+     * @param data The data that was validated.
+     * @returns The formatted errors.
+     */
+    static formatErrors<T>(outputUnit: OutputUnit & {
+        message?: string;
+    }, data: T): Promise<void>;
 }

package/docs/changelog.md

@@ -1,5 +1,12 @@
 # @twin.org/data-core - Changelog
 
+## [0.0.1-next.36](https://github.com/twinfoundation/data/compare/data-core-v0.0.1-next.35...data-core-v0.0.1-next.36) (2025-06-10)
+
+
+### Features
+
+* expand Json LD Keyword ([70632d1](https://github.com/twinfoundation/data/commit/70632d1e11ad85cf3c57e118476b125a673f1681))
+
 ## [0.0.1-next.35](https://github.com/twinfoundation/data/compare/data-core-v0.0.1-next.34...data-core-v0.0.1-next.35) (2025-06-03)
 
 

package/docs/reference/classes/JsonSchemaHelper.md

@@ -38,7 +38,7 @@ Validates data against the schema.
 
 ##### schema
 
-`JSONSchema7`
+`JsonSchemaDraft202012Object`
 
 The schema to validate the data with.
 
@@ -70,7 +70,7 @@ Get the property type from a schema.
 
 ##### schema
 
-`JSONSchema7`
+`JsonSchemaDraft202012Object`
 
 The schema to extract the types from.
 
@@ -90,7 +90,7 @@ The types of the property.
 
 ### entitySchemaToJsonSchema()
 
-> `static` **entitySchemaToJsonSchema**(`entitySchema`, `baseDomain?`): `JSONSchema7`
+> `static` **entitySchemaToJsonSchema**(`entitySchema`, `baseDomain?`): `JsonSchemaDraft202012Object`
 
 Convert an entity schema to JSON schema e.g https://example.com/schemas/.
 
@@ -110,6 +110,40 @@ The base domain for local schemas e.g. https://example.com/
 
 #### Returns
 
-`JSONSchema7`
+`JsonSchemaDraft202012Object`
 
 The JSON schema for the entity.
+
+***
+
+### formatErrors()
+
+> `static` **formatErrors**\<`T`\>(`outputUnit`, `data`): `Promise`\<`void`\>
+
+Cleanup the errors from the schema validation.
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+#### Parameters
+
+##### outputUnit
+
+`OutputUnit` & `object`
+
+The errors to format.
+
+##### data
+
+`T`
+
+The data that was validated.
+
+#### Returns
+
+`Promise`\<`void`\>
+
+The formatted errors.

package/docs/reference/index.md

@@ -13,7 +13,8 @@
 
 ## Type Aliases
 
-- [ISchemaValidationError](type-aliases/ISchemaValidationError.md)
+- [IJsonSchema](type-aliases/IJsonSchema.md)
+- [ISchemaValidationErrors](type-aliases/ISchemaValidationErrors.md)
 - [ValidationMode](type-aliases/ValidationMode.md)
 
 ## Variables

package/docs/reference/interfaces/IDataTypeHandler.md

@@ -30,13 +30,13 @@ The default value for the item to use when constructing a new object.
 
 ### jsonSchema()?
 
-> `optional` **jsonSchema**(): `Promise`\<`undefined` \| `JSONSchema7`\>
+> `optional` **jsonSchema**(): `Promise`\<`undefined` \| `JsonSchemaDraft202012Object`\>
 
 Get the JSON schema for the data type.
 
 #### Returns
 
-`Promise`\<`undefined` \| `JSONSchema7`\>
+`Promise`\<`undefined` \| `JsonSchemaDraft202012Object`\>
 
 The JSON schema for the data type.
 

package/docs/reference/interfaces/ISchemaValidationResult.md

@@ -12,8 +12,8 @@ The result.
 
 ***
 
-### error?
+### errors?
 
-> `optional` **error**: [`ISchemaValidationError`](../type-aliases/ISchemaValidationError.md)
+> `optional` **errors**: [`ISchemaValidationErrors`](../type-aliases/ISchemaValidationErrors.md)
 
 The error.

package/docs/reference/type-aliases/IJsonSchema.md

@@ -0,0 +1,5 @@
+# Type Alias: IJsonSchema
+
+> **IJsonSchema** = `JsonSchemaDraft202012Object`
+
+Default schema type.

package/docs/reference/type-aliases/ISchemaValidationErrors.md

@@ -0,0 +1,5 @@
+# Type Alias: ISchemaValidationErrors
+
+> **ISchemaValidationErrors** = `OutputUnit` & `object`[]
+
+Schema validation error.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/data-core",
-	"version": "0.0.1-next.35",
+	"version": "0.0.1-next.36",
 	"description": "Definitions and helpers for using with data and schemas",
 	"repository": {
 		"type": "git",
@@ -14,13 +14,12 @@
 		"node": ">=20.0.0"
 	},
 	"dependencies": {
+		"@hyperjump/browser": "1.3.0",
+		"@hyperjump/json-schema": "1.15.0",
 		"@twin.org/core": "next",
 		"@twin.org/entity": "next",
 		"@twin.org/nameof": "next",
-		"@twin.org/web": "next",
-		"@types/json-schema": "7.0.15",
-		"ajv": "8.17.1",
-		"ajv-formats": "3.0.1"
+		"@twin.org/web": "next"
 	},
 	"main": "./dist/cjs/index.cjs",
 	"module": "./dist/esm/index.mjs",

package/dist/types/models/ISchemaValidationError.d.ts

@@ -1,5 +0,0 @@
-import type { ErrorObject } from "ajv";
-/**
- * Schema validation error.
- */
-export type ISchemaValidationError = ErrorObject[];

package/docs/reference/type-aliases/ISchemaValidationError.md

@@ -1,5 +0,0 @@
-# Type Alias: ISchemaValidationError
-
-> **ISchemaValidationError** = `ErrorObject`[]
-
-Schema validation error.