json-schema-library 5.3.0 → 7.0.0

package/dist/lib/validation/errors.d.ts

@@ -1,5 +1,3 @@
 import { CreateError } from "../utils/createCustomError";
-declare const errors: {
-    [p: string]: CreateError;
-};
+declare const errors: Record<string, CreateError>;
 export default errors;

package/dist/lib/validation/format.d.ts

@@ -1,11 +1,4 @@
-declare const _default: {
-    "date-time": (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
-    email: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
-    hostname: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
-    ipv4: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
-    ipv6: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
-    regex: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
-    uri: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
-    url: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
-};
-export default _default;
+import { JSONError, JSONSchema } from "../types";
+import { Draft } from "../draft";
+declare const formatValidators: Record<string, (draft: Draft, schema: JSONSchema, value: unknown, pointer: string) => undefined | JSONError | JSONError[]>;
+export default formatValidators;

package/dist/lib/validation/keyword.d.ts

@@ -1,28 +1,3 @@
-declare const KeywordValidation: {
-    additionalProperties: (core: any, schema: any, value: any, pointer: any) => any[];
-    allOf: (core: any, schema: any, value: any, pointer: any) => any[];
-    anyOf: (core: any, schema: any, value: any, pointer: any) => any;
-    dependencies: (core: any, schema: any, value: any, pointer: any) => any[];
-    enum: (core: any, schema: any, value: any, pointer: any) => any;
-    format: (core: any, schema: any, value: any, pointer: any) => any;
-    items: (core: any, schema: any, value: any, pointer: any) => any[];
-    maximum: (core: any, schema: any, value: any, pointer: any) => any;
-    maxItems: (core: any, schema: any, value: any, pointer: any) => any;
-    maxLength: (core: any, schema: any, value: any, pointer: any) => any;
-    maxProperties: (core: any, schema: any, value: any, pointer: any) => any;
-    minLength: (core: any, schema: any, value: any, pointer: any) => any;
-    minimum: (core: any, schema: any, value: any, pointer: any) => any;
-    minItems: (core: any, schema: any, value: any, pointer: any) => any;
-    minProperties: (core: any, schema: any, value: any, pointer: any) => any;
-    multipleOf: (core: any, schema: any, value: any, pointer: any) => any;
-    not: (core: any, schema: any, value: any, pointer: any) => any[];
-    oneOf: (core: any, schema: any, value: any, pointer: any) => any;
-    pattern: (core: any, schema: any, value: any, pointer: any) => any;
-    patternProperties: (core: any, schema: any, value: any, pointer: any) => any[];
-    properties: (core: any, schema: any, value: any, pointer: any) => any[];
-    propertiesRequired: (core: any, schema: any, value: any, pointer: any) => any[];
-    required: (core: any, schema: any, value: any, pointer: any) => any;
-    requiredNotEmpty: (core: any, schema: any, value: any, pointer: any) => any;
-    uniqueItems: (core: any, schema: any, value: any, pointer: any) => any[];
-};
+import { JSONValidator } from "../types";
+declare const KeywordValidation: Record<string, JSONValidator>;
 export default KeywordValidation;

package/dist/lib/validation/type.d.ts

@@ -1,12 +1,4 @@
-declare const _default: {
-    array: (core: any, schema: any, value: any, pointer: any) => any;
-    object: (core: any, schema: any, value: any, pointer: any) => any;
-    string: (core: any, schema: any, value: any, pointer: any) => any;
-    integer: (core: any, schema: any, value: any, pointer: any) => any;
-    number: (core: any, schema: any, value: any, pointer: any) => any;
-    boolean: (core: any, schema: any, value: any, pointer: any) => any;
-    null: (core: any, schema: any, value: any, pointer: any) => any;
-};
+import { JSONTypeValidator } from "../types";
 /**
  * @todo: type is also a keyword, as is properties, items, etc
  *
@@ -14,4 +6,5 @@ declare const _default: {
  * or seven in case of ajv https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type
  * 1 null, 2 boolean, 3 object, 4 array, 5 number, 6 string (7 integer)
  */
-export default _default;
+declare const typeValidators: Record<string, JSONTypeValidator>;
+export default typeValidators;

package/dist/lib/validation/typeKeywordMapping.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Mapping, used in type validation to iterate over type-specific keywords to validate
+ *  - overview https://epoberezkin.github.io/ajv/keywords.html
+ */
 declare const _default: {
     array: string[];
     boolean: string[];
@@ -6,8 +10,4 @@ declare const _default: {
     number: string[];
     null: string[];
 };
-/**
- * Mapping, used in type validation to iterate over type-specific keywords to validate
- *  - overview https://epoberezkin.github.io/ajv/keywords.html
- */
 export default _default;

package/dist/module/index.js

@@ -1,38 +1,29 @@
-import strings from "./lib/config/strings";
-import Interface from "./lib/cores/CoreInterface";
-import Draft04 from "./lib/cores/Draft04";
-import JsonEditor from "./lib/cores/JsonEditor";
-import addSchema from "./lib/addSchema";
-import addValidator from "./lib/addValidator";
-import compileSchema from "./lib/compileSchema";
-import createCustomError from "./lib/utils/createCustomError";
-import createSchemaOf from "./lib/createSchemaOf";
-import each from "./lib/each";
-import eachSchema from "./lib/eachSchema";
-import getChildSchemaSelection from "./lib/getChildSchemaSelection";
-import getSchema from "./lib/getSchema";
-import getTemplate from "./lib/getTemplate";
+import { createError, createCustomError } from "./lib/utils/createCustomError";
 import getTypeOf from "./lib/getTypeOf";
-import isValid from "./lib/isValid";
+import resolveOneOf from "./lib/resolveOneOf.strict";
+import resolveOneOfFuzzy from "./lib/resolveOneOf.fuzzy";
+import resolveRef from "./lib/resolveRef.strict";
+import resolveRefMerge from "./lib/resolveRef.merge";
 import SchemaService from "./lib/SchemaService";
-import step from "./lib/step";
-import validate from "./lib/validate";
-import validateAsync from "./lib/validateAsync";
 import settings from "./lib/config/settings";
+import strings from "./lib/config/strings";
+import validateAsync from "./lib/validateAsync";
+import render from "./lib/utils/render";
+import { Draft } from "./lib/draft";
+import { Draft04, draft04Config } from "./lib/draft04";
+import { Draft06, draft06Config } from "./lib/draft06";
+import { Draft07, draft07Config } from "./lib/draft07";
+import { JsonEditor, draftJsonEditorConfig } from "./lib/jsoneditor";
+import { isJSONError } from "./lib/types";
 const config = { strings };
-export { config, Interface, Draft04, // core implementing draft04 specs
+export { config, Draft, Draft04, // core implementing draft04 specs
+draft04Config, // config implementing draft04 specs
+Draft06, // core implementing draft06 specs
+draft06Config, // config implementing draft06 specs
+Draft07, // core implementing draft07 specs
+draft07Config, // config implementing draft07 specs
 JsonEditor, // adjusted core of draft04 to better support the json-editor
-addSchema, // add a schema to be references via $ref
-addValidator, // add validation for keyword, format, datatype and customize errors
-compileSchema, createCustomError, createSchemaOf, // creates a simple schema based on the given data
-each, // iterate over data, receiving each data-entry with its schema
-eachSchema, // iterates over a json-schemas type definitions
-getChildSchemaSelection, // get available child schemas
-getSchema, // get schema of datapointer
-getTemplate, // create data which is valid to the given schema
-getTypeOf, // returns the javascript datatype
-isValid, // returns a boolean if the schema is valid
-settings, SchemaService, step, // steps into a json-schema, returning the matching child-schema
-validate, // validates data by a schema
-validateAsync // async validation of data by a schema
+draftJsonEditorConfig, // adjusted config of draft04 to better support the json-editor
+createError, createCustomError, getTypeOf, // returns the javascript datatype
+isJSONError, render, resolveRef, resolveRefMerge, resolveOneOf, resolveOneOfFuzzy, settings, SchemaService, validateAsync // async validation of data by a schema
  };

package/dist/module/lib/SchemaService.js

@@ -1,5 +1,5 @@
 import getSchema from "./getSchema";
-import Core from "./cores/JsonEditor";
+import { JsonEditor as Core } from "./jsoneditor";
 import gp from "gson-pointer";
 import copy from "./utils/copy";
 export default class SchemaService {
@@ -19,14 +19,17 @@ export default class SchemaService {
         this.cache = {};
     }
     get(pointer, data) {
-        if (data) { // possibly separate entry point
+        if (data) {
+            // possibly separate entry point
             const schema = getSchema(this.core, pointer, data, this.schema);
             return copy(schema);
         }
-        if (pointer === "#") { // root
+        if (pointer === "#") {
+            // root
             return this.schema;
         }
-        if (this.cache[pointer]) { // return cached result
+        if (this.cache[pointer]) {
+            // return cached result
             return this.cache[pointer];
         }
         const parentPointer = gp.join(pointer, "..");

package/dist/module/lib/{addSchema.js → addRemoteSchema.js}

@@ -1,11 +1,9 @@
-import remotes from "../remotes";
-import compileSchema from "./compileSchema";
 /**
  * register a json-schema to be referenced from another json-schema
  * @param url    base-url of json-schema (aka id)
  * @param schema
  */
-export default function addSchema(url, schema) {
+export default function addRemoteSchema(draft, url, schema) {
     schema.id = schema.id || url;
-    remotes[url] = compileSchema(schema);
+    draft.remotes[url] = draft.compileSchema(schema);
 }

package/dist/module/lib/addValidator.js

@@ -22,11 +22,10 @@ function addFormat(core, formatType, validationFunction) {
     if (typeof validationFunction !== "function") {
         throw new Error(`Validation function expected. Received ${typeof validationFunction}`);
     }
-    if (core.validateFormat[formatType] == null) {
-        core.validateFormat[formatType] = validationFunction;
-        return;
+    if (core.validateFormat[formatType]) {
+        throw new Error(`A format '${formatType}' is already registered to validation`);
     }
-    throw new Error(`A format '${formatType}' is already registered to validation`);
+    core.validateFormat[formatType] = validationFunction;
 }
 /**
  * Adds a custom keyword validation to a specific type. May not override existing keywords.

package/dist/module/lib/compile/getRef.js

@@ -2,7 +2,7 @@ import { get } from "gson-pointer";
 import splitRef from "./splitRef";
 import getTypeOf from "../getTypeOf";
 const suffixes = /(#|\/)+$/g;
-const isObject = val => (getTypeOf(val) === "object");
+const isObject = (val) => getTypeOf(val) === "object";
 // 1. combined is known
 // 2. base or pointer is known
 // 3. base + pointer is known

package/dist/module/lib/compile/index.js

@@ -1,6 +1,5 @@
 /* eslint max-statements-per-line: ["error", { "max": 2 }] */
-import eachSchema from "../eachSchema";
-import remotes from "../../remotes";
+import { eachSchema } from "../eachSchema";
 import joinScope from "./joinScope";
 import getRef from "./getRef";
 const COMPILED = "__compiled";
@@ -8,22 +7,45 @@ const COMPILED_REF = "__ref";
 const GET_REF = "getRef";
 const GET_ROOT = "getRoot";
 const suffixes = /(#|\/)+$/g;
-export default function compile(rootSchema, force = false) {
-    if (rootSchema[COMPILED] !== undefined) {
-        return rootSchema;
-    } // eslint-disable-line
-    const context = { ids: {}, remotes: Object.assign({}, remotes) };
-    const rootSchemaAsString = JSON.stringify(rootSchema);
-    rootSchema = JSON.parse(rootSchemaAsString);
-    Object.defineProperty(rootSchema, COMPILED, { enumerable: false, value: true });
-    Object.defineProperty(rootSchema, GET_REF, { enumerable: false, value: getRef.bind(null, context, rootSchema) });
+/**
+ * compiles the input root schema for `$ref` resolution and returns it again
+ * @attention this modifies input schema but maintains object-structure
+ *
+ * for a compiled json-schema you can call getRef on any contained schema (location of type).
+ * this resolves a $ref target to a valid schema (for a valid $ref)
+ *
+ * @param draft
+ * @param schemaToCompile - json-schema to compile
+ * @param [rootSchema] - compiled root json-schema to use for definitions resolution
+ * @param [force] = false - force compile json-schema
+ * @return compiled copy of input json-schema
+ */
+export default function compileSchema(draft, schemaToCompile, rootSchema = schemaToCompile, force = false) {
+    if (!schemaToCompile || schemaToCompile[COMPILED] !== undefined) {
+        return schemaToCompile;
+    }
+    const context = { ids: {}, remotes: draft.remotes };
+    const rootSchemaAsString = JSON.stringify(schemaToCompile);
+    const compiledSchema = JSON.parse(rootSchemaAsString);
+    Object.defineProperty(compiledSchema, COMPILED, { enumerable: false, value: true });
+    Object.defineProperty(compiledSchema, GET_REF, {
+        enumerable: false,
+        value: getRef.bind(null, context, compiledSchema)
+    });
+    // bail early, when no $refs are defined
     if (force === false && rootSchemaAsString.includes("$ref") === false) {
-        // bail early, when no $refs are defined
-        return rootSchema;
+        return compiledSchema;
+    }
+    // compile this schema under rootSchema, making definitions available to $ref-resolution
+    if (schemaToCompile !== rootSchema) {
+        Object.defineProperty(compiledSchema, "definitions", {
+            enumerable: false,
+            value: Object.assign({}, rootSchema.definitions, rootSchema.$defs, schemaToCompile.definitions, schemaToCompile.$defs)
+        });
     }
     const scopes = {};
-    const getRoot = () => rootSchema;
-    eachSchema(rootSchema, (schema, pointer) => {
+    const getRoot = () => compiledSchema;
+    eachSchema(compiledSchema, (schema, pointer) => {
         if (schema.id) {
             context.ids[schema.id.replace(suffixes, "")] = pointer;
         }
@@ -37,13 +59,16 @@ export default function compile(rootSchema, force = false) {
         if (context.ids[scope] == null) {
             context.ids[scope] = pointer;
         }
-        if (schema.$ref) {
-            Object.defineProperty(schema, COMPILED_REF, { enumerable: false, value: joinScope(scope, schema.$ref) });
+        if (schema.$ref && !schema[COMPILED_REF]) {
+            Object.defineProperty(schema, COMPILED_REF, {
+                enumerable: false,
+                value: joinScope(scope, schema.$ref)
+            });
             // @todo currently not used:
             Object.defineProperty(schema, GET_ROOT, { enumerable: false, value: getRoot });
             // console.log("compiled ref", scope, schema.$ref, "=>", joinScope(scope, schema.$ref));
         }
     });
     // console.log(JSON.stringify(context.ids, null, 2));
-    return rootSchema;
+    return compiledSchema;
 }

package/dist/module/lib/compile/types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/lib/config/strings.js

@@ -5,15 +5,28 @@ export default {
     AdditionalPropertiesError: "Additional property `{{property}}` on `{{pointer}}` does not match schema `{{schema}}`",
     AnyOfError: "Value `{{value}}` at `{{pointer}}` does not match any schema of `{{anyOf}}`",
     AllOfError: "Value `{{value}}` at `{{pointer}}` does not match schema of `{{allOf}}`",
+    ConstError: "Expected value at `{{pointer}}` to be `{{expected}}`, but value given is `{{value}}`",
+    ContainsError: "The array at `{{pointer}}` must contain an element that matches `{{schema}}`",
+    ContainsArrayError: "The property at `{{pointer}}` must not be an array",
+    containsAnyError: "The array at `{{pointer}}` must contain at least one item",
     EnumError: "Expected given value `{{value}}` in `{{pointer}}` to be one of `{{values}}`",
+    FormatDateError: "Value `{{value}}` at `{{pointer}}` is not a valid date",
     FormatDateTimeError: "Value `{{value}}` at `{{pointer}}` is not a valid date-time",
     FormatEmailError: "Value `{{value}}` at `{{pointer}}` is not a valid email",
-    FormatUrlError: "Value `{{value}}` at `{{pointer}}` is not a valid url",
-    FormatUriError: "Value `{{value}}` at `{{pointer}}` is not a valid uri",
+    FormatURLError: "Value `{{value}}` at `{{pointer}}` is not a valid url",
+    FormatURIError: "Value `{{value}}` at `{{pointer}}` is not a valid uri",
+    FormatURIReferenceError: "Value `{{value}}` at `{{pointer}}` is not a valid uri-reference",
+    FormatURITemplateError: "Value `{{value}}` at `{{pointer}}` is not a valid uri-template",
     FormatHostnameError: "Value `{{value}}` at `{{pointer}}` is not a valid hostname",
     FormatIPV4Error: "Value `{{value}}` at `{{pointer}}` is not a valid IPv4 address",
+    FormatIPV4LeadingZeroError: "IPv4 addresses starting with zero are invalid, since they are interpreted as octals",
     FormatIPV6Error: "Value `{{value}}` at `{{pointer}}` is not a valid IPv6 address",
+    FormatIPV6LeadingZeroError: "IPv6 addresses starting with zero are invalid, since they are interpreted as octals",
+    FormatJSONPointerError: "Value `{{value}}` at `{{pointer}}` is not a valid json-pointer",
     FormatRegExError: "Value `{{value}}` at `{{pointer}}` is not a valid regular expression",
+    FormatTimeError: "Value `{{value}}` at `{{pointer}}` is not a valid time",
+    InvalidDataError: "No value may be specified in `{{pointer}}`",
+    InvalidPropertyNameError: "Invalid property name `{{property}}` at `{{pointer}}`",
     MaximumError: "Value in `{{pointer}}` is `{{length}}`, but should be `{{maximum}}` at maximum",
     MaxItemsError: "Too many items in `{{pointer}}`, should be `{{maximum}}` at most, but got `{{length}}`",
     MaxLengthError: "Value `{{pointer}}` should have a maximum length of `{{maxLength}}`, but got `{{length}}`.",

package/dist/module/lib/createSchemaOf.js

@@ -10,7 +10,7 @@ export default function createSchemaOf(data) {
     };
     if (schema.type === "object") {
         schema.properties = {};
-        Object.keys(data).forEach(key => (schema.properties[key] = createSchemaOf(data[key])));
+        Object.keys(data).forEach((key) => (schema.properties[key] = createSchemaOf(data[key])));
     }
     if (schema.type === "array" && data.length === 1) {
         schema.items = createSchemaOf(data[0]);

package/dist/module/lib/draft/index.js

@@ -0,0 +1,133 @@
+export class Draft {
+    constructor(config, schema) {
+        /** cache for remote schemas */
+        this.remotes = {};
+        /** error creators by id */
+        this.errors = {};
+        /** map for valid keywords of a type  */
+        this.typeKeywords = {};
+        /** keyword validators  */
+        this.validateKeyword = {};
+        /** type validators  */
+        this.validateType = {};
+        /** format validators  */
+        this.validateFormat = {};
+        this.config = config;
+        this.typeKeywords = JSON.parse(JSON.stringify(config.typeKeywords));
+        this.validateKeyword = Object.assign({}, config.validateKeyword);
+        this.validateType = Object.assign({}, config.validateType);
+        this.validateFormat = Object.assign({}, config.validateFormat);
+        this.errors = Object.assign({}, config.errors);
+        this.setSchema(schema);
+    }
+    get rootSchema() {
+        return this.__rootSchema;
+    }
+    set rootSchema(rootSchema) {
+        if (rootSchema == null) {
+            return;
+        }
+        this.__rootSchema = this.config.compileSchema(this, rootSchema);
+    }
+    /**
+     * register a json-schema to be referenced from another json-schema
+     * @param url - base-url of json-schema (aka id)
+     * @param schema - json-schema root
+     */
+    addRemoteSchema(url, schema) {
+        this.config.addRemoteSchema(this, url, schema);
+    }
+    compileSchema(schema) {
+        var _a;
+        return this.config.compileSchema(this, schema, (_a = this.rootSchema) !== null && _a !== void 0 ? _a : schema);
+    }
+    createSchemaOf(data) {
+        return this.config.createSchemaOf(data);
+    }
+    /**
+     * Iterates over data, retrieving its schema
+     *
+     * @param data - the data to iterate
+     * @param callback - will be called with (schema, data, pointer) on each item
+     * @param [schema] - the schema matching the data. Defaults to rootSchema
+     * @param [pointer] - pointer to current data. Default to rootPointer
+     */
+    each(data, callback, schema, pointer) {
+        return this.config.each(this, data, callback, schema, pointer);
+    }
+    eachSchema(callback, schema = this.rootSchema) {
+        return this.config.eachSchema(schema, callback);
+    }
+    getChildSchemaSelection(property, schema) {
+        return this.config.getChildSchemaSelection(this, property, schema);
+    }
+    /**
+     * Returns the json-schema of a data-json-pointer.
+     * Notes
+     *   - Uses core.step to walk through data and schema
+     *
+     * @param pointer - json pointer in data to get the json schema for
+     * @param [data] - the data object, which includes the json pointers value. This is optional, as
+     *    long as no oneOf, anyOf, etc statement is part of the pointers schema
+     * @param [schema] - the json schema to iterate. Defaults to core.rootSchema
+     * @return json schema object of the json-pointer or an error
+     */
+    getSchema(pointer = "#", data, schema) {
+        return this.config.getSchema(this, pointer, data, schema);
+    }
+    /**
+     * Create data object matching the given schema
+     *
+     * @param [data] - optional template data
+     * @param [schema] - json schema, defaults to rootSchema
+     * @return created template data
+     */
+    getTemplate(data, schema) {
+        return this.config.getTemplate(this, data, schema);
+    }
+    isValid(data, schema, pointer) {
+        return this.config.isValid(this, data, schema, pointer);
+    }
+    resolveAnyOf(data, schema, pointer) {
+        return this.config.resolveAnyOf(this, data, schema, pointer);
+    }
+    resolveAllOf(data, schema, pointer) {
+        return this.config.resolveAllOf(this, data, schema, pointer);
+    }
+    resolveRef(schema) {
+        return this.config.resolveRef(schema, this.rootSchema);
+    }
+    resolveOneOf(data, schema, pointer) {
+        return this.config.resolveOneOf(this, data, schema, pointer);
+    }
+    setSchema(schema) {
+        this.rootSchema = schema;
+    }
+    /**
+     * Returns the json-schema of the given object property or array item.
+     * e.g. it steps by one key into the data
+     *
+     *  This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
+     *  returns the correct schema.
+     *
+     * @param  key       - property-name or array-index
+     * @param  schema    - json schema of current data
+     * @param  data      - parent of key
+     * @param  [pointer] - pointer to schema and data (parent of key)
+     * @return Schema or Error if failed resolving key
+     */
+    step(key, schema, data, pointer) {
+        return this.config.step(this, key, schema, data, pointer);
+    }
+    /**
+     * Validate data by a json schema
+     *
+     * @param value - value to validate
+     * @param [schema] - json schema, defaults to rootSchema
+     * @param [pointer] - json pointer pointing to value (used for error-messages only)
+     * @return list of errors or empty
+     */
+    validate(data, schema, pointer) {
+        return this.config.validate(this, data, schema, pointer);
+    }
+}

package/dist/module/lib/draft04/index.js

@@ -0,0 +1,90 @@
+import addRemoteSchema from "../addRemoteSchema";
+import compileSchema from "../compileSchema";
+import { each } from "../each";
+import { eachSchema } from "../eachSchema";
+import ERRORS from "../validation/errors";
+import FORMATS from "../validation/format";
+import getSchema from "../getSchema";
+import getTemplate from "../getTemplate";
+import isValid from "../isValid";
+import KEYWORDS from "../validation/keyword";
+import merge from "../utils/merge";
+import resolveAllOf from "../resolveAllOf";
+import resolveAnyOf from "../resolveAnyOf";
+import resolveOneOf from "../resolveOneOf.strict";
+import resolveRef from "../resolveRef.strict";
+import step from "../step";
+import createSchemaOf from "../createSchemaOf";
+import getChildSchemaSelection from "../getChildSchemaSelection";
+import TYPES from "../validation/type";
+import validate from "../validate";
+import { Draft } from "../draft";
+const draft04Config = {
+    typeKeywords: {
+        array: ["enum", "items", "minItems", "maxItems", "uniqueItems", "not"],
+        boolean: ["enum", "not"],
+        object: [
+            "additionalProperties",
+            "dependencies",
+            "enum",
+            "format",
+            "minProperties",
+            "maxProperties",
+            "patternProperties",
+            "properties",
+            "required",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf"
+        ],
+        string: [
+            "enum",
+            "format",
+            "maxLength",
+            "minLength",
+            "pattern",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf"
+        ],
+        number: [
+            "enum",
+            "format",
+            "maximum",
+            "minimum",
+            "multipleOf",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf"
+        ],
+        null: ["enum", "format", "not", "oneOf", "allOf", "anyOf"]
+    },
+    validateKeyword: KEYWORDS,
+    validateType: TYPES,
+    validateFormat: FORMATS,
+    errors: ERRORS,
+    addRemoteSchema,
+    compileSchema,
+    createSchemaOf,
+    each,
+    eachSchema,
+    getChildSchemaSelection,
+    getSchema,
+    getTemplate,
+    isValid,
+    resolveAllOf,
+    resolveAnyOf,
+    resolveOneOf,
+    resolveRef,
+    step,
+    validate
+};
+class Draft04 extends Draft {
+    constructor(schema, config = {}) {
+        super(merge(draft04Config, config), schema);
+    }
+}
+export { Draft04, draft04Config };