json-schema-library 5.3.0 → 7.0.0

package/dist/lib/addValidator.d.ts

@@ -1,5 +1,6 @@
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 import { JSONValidator } from "./types";
+import { CreateError } from "./utils/createCustomError";
 /**
  * @throws Error
  * Adds a custom error. May override existing errors
@@ -8,7 +9,7 @@ import { JSONValidator } from "./types";
  * @param errorId id of error @see /lib/validation/errors
  * @param errorCreator - function returning an error-object @see /lib/utils/createCustomError
  */
-declare function addError(core: Core, errorId: string, errorCreator: any): void;
+declare function addError(core: Core, errorId: string, errorCreator: CreateError): void;
 /**
  * Adds a custom format validator. Existing format may not be overriden (may still be modified manually)
  * @param core

package/dist/lib/compile/getRef.d.ts

@@ -1,2 +1,3 @@
 import { JSONSchema } from "../types";
-export default function getRef(context: any, rootSchema: JSONSchema, $ref: any): any;
+import { Context } from "./types";
+export default function getRef(context: Context, rootSchema: JSONSchema, $ref: string): JSONSchema;

package/dist/lib/compile/index.d.ts

@@ -1,2 +1,16 @@
+import { Draft } from "../draft";
 import { JSONSchema } from "../types";
-export default function compile(rootSchema: JSONSchema, force?: boolean): JSONSchema;
+/**
+ * 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: Draft, schemaToCompile: JSONSchema, rootSchema?: JSONSchema, force?: boolean): JSONSchema;

package/dist/lib/compile/types.d.ts

@@ -0,0 +1,5 @@
+import { JSONSchema, JSONPointer } from "../types";
+export declare type Context = {
+    ids: Record<string, JSONPointer>;
+    remotes: Record<string, JSONSchema>;
+};

package/dist/lib/config/strings.d.ts

@@ -1,40 +1,2 @@
-declare const _default: {
-    AdditionalItemsError: string;
-    AdditionalPropertiesError: string;
-    AnyOfError: string;
-    AllOfError: string;
-    EnumError: string;
-    FormatDateTimeError: string;
-    FormatEmailError: string;
-    FormatUrlError: string;
-    FormatUriError: string;
-    FormatHostnameError: string;
-    FormatIPV4Error: string;
-    FormatIPV6Error: string;
-    FormatRegExError: string;
-    MaximumError: string;
-    MaxItemsError: string;
-    MaxLengthError: string;
-    MaxPropertiesError: string;
-    MinimumError: string;
-    MinItemsError: string;
-    MinLengthError: string;
-    MinPropertiesError: string;
-    MissingOneOfPropertyError: string;
-    MissingDependencyError: string;
-    MultipleOfError: string;
-    MultipleOneOfError: string;
-    NoAdditionalPropertiesError: string;
-    NotError: string;
-    OneOfError: string;
-    OneOfPropertyError: string;
-    PatternError: string;
-    PatternPropertiesError: string;
-    RequiredPropertyError: string;
-    TypeError: string;
-    UndefinedValueError: string;
-    UnknownPropertyError: string;
-    UniqueItemsError: string;
-    ValueNotEmptyError: string;
-};
+declare const _default: Record<string, string>;
 export default _default;

package/dist/lib/draft/index.d.ts

@@ -0,0 +1,132 @@
+import step from "../step";
+import validate from "../validate";
+import resolveOneOf from "../resolveOneOf.strict";
+import resolveRef from "../resolveRef.strict";
+import resolveAllOf from "../resolveAllOf";
+import resolveAnyOf from "../resolveAnyOf";
+import getTemplate from "../getTemplate";
+import getChildSchemaSelection from "../getChildSchemaSelection";
+import getSchema from "../getSchema";
+import { each, EachCallback } from "../each";
+import isValid from "../isValid";
+import { eachSchema, EachSchemaCallback } from "../eachSchema";
+import createSchemaOf from "../createSchemaOf";
+import compileSchema from "../compileSchema";
+import { CreateError } from "../utils/createCustomError";
+import addRemoteSchema from "../addRemoteSchema";
+import { JSONSchema, JSONPointer, JSONValidator, JSONTypeValidator, JSONError } from "../types";
+export declare type DraftConfig = {
+    /** error creators by id */
+    errors: Record<string, CreateError>;
+    /** map for valid keywords of a type  */
+    typeKeywords: Record<string, string[]>;
+    /** keyword validators  */
+    validateKeyword: Record<string, JSONValidator>;
+    /** type validators  */
+    validateType: Record<string, JSONTypeValidator>;
+    /** format validators  */
+    validateFormat: Record<string, JSONValidator>;
+    addRemoteSchema: typeof addRemoteSchema;
+    compileSchema: typeof compileSchema;
+    createSchemaOf: typeof createSchemaOf;
+    each: typeof each;
+    eachSchema: typeof eachSchema;
+    getChildSchemaSelection: typeof getChildSchemaSelection;
+    getSchema: typeof getSchema;
+    getTemplate: typeof getTemplate;
+    isValid: typeof isValid;
+    resolveAllOf: typeof resolveAllOf;
+    resolveAnyOf: typeof resolveAnyOf;
+    resolveOneOf: typeof resolveOneOf;
+    resolveRef: typeof resolveRef;
+    step: typeof step;
+    validate: typeof validate;
+};
+export declare class Draft {
+    readonly config: DraftConfig;
+    /** entry point of schema */
+    private __rootSchema;
+    /** cache for remote schemas */
+    remotes: Record<string, JSONSchema>;
+    /** error creators by id */
+    readonly errors: Record<string, CreateError>;
+    /** map for valid keywords of a type  */
+    readonly typeKeywords: Record<string, string[]>;
+    /** keyword validators  */
+    readonly validateKeyword: Record<string, JSONValidator>;
+    /** type validators  */
+    readonly validateType: Record<string, JSONTypeValidator>;
+    /** format validators  */
+    readonly validateFormat: Record<string, JSONValidator>;
+    constructor(config: DraftConfig, schema?: JSONSchema);
+    get rootSchema(): JSONSchema;
+    set rootSchema(rootSchema: JSONSchema);
+    /**
+     * 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: string, schema: JSONSchema): void;
+    compileSchema(schema: JSONSchema): JSONSchema;
+    createSchemaOf(data: unknown): JSONSchema;
+    /**
+     * 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: any, callback: EachCallback, schema?: JSONSchema, pointer?: JSONPointer): void;
+    eachSchema(callback: EachSchemaCallback, schema?: JSONSchema): void;
+    getChildSchemaSelection(property: string | number, schema?: JSONSchema): JSONError | JSONSchema[];
+    /**
+     * 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?: JSONPointer, data?: any, schema?: JSONSchema): JSONSchema | JSONError;
+    /**
+     * 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?: unknown, schema?: JSONSchema): any;
+    isValid(data: any, schema?: JSONSchema, pointer?: JSONPointer): boolean;
+    resolveAnyOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema;
+    resolveAllOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema;
+    resolveRef(schema: JSONSchema): JSONSchema;
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema;
+    setSchema(schema: JSONSchema): void;
+    /**
+     * 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: string | number, schema: JSONSchema, data: any, pointer?: JSONPointer): JSONSchema;
+    /**
+     * 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: unknown, schema?: JSONSchema, pointer?: JSONPointer): JSONError[];
+}

package/dist/lib/draft04/index.d.ts

@@ -0,0 +1,7 @@
+import { DraftConfig, Draft } from "../draft";
+import { JSONSchema } from "../types";
+declare const draft04Config: DraftConfig;
+declare class Draft04 extends Draft {
+    constructor(schema?: JSONSchema, config?: Partial<DraftConfig>);
+}
+export { Draft04, draft04Config };

package/dist/lib/draft06/compile/index.d.ts

@@ -0,0 +1,16 @@
+import { Draft } from "../../draft";
+import { JSONSchema } from "../../types";
+/**
+ * @draft starting with _draft 06_ keyword `id` has been renamed to `$id`
+ *
+ * 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 rootSchema root json-schema ($id, defs, ... ) to compile
+ * @param [force] = false force compile json-schema
+ * @return compiled json-schema
+ */
+export default function compileSchema(draft: Draft, schemaToCompile: JSONSchema, rootSchema?: JSONSchema, force?: boolean): JSONSchema;

package/dist/lib/draft06/index.d.ts

@@ -0,0 +1,7 @@
+import { DraftConfig, Draft } from "../draft";
+import { JSONSchema } from "../types";
+declare const draft06Config: DraftConfig;
+declare class Draft06 extends Draft {
+    constructor(schema?: JSONSchema, config?: Partial<DraftConfig>);
+}
+export { Draft06, draft06Config };

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

@@ -0,0 +1,3 @@
+import { JSONValidator } from "../../types";
+declare const KeywordValidation: Record<string, JSONValidator>;
+export default KeywordValidation;

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

@@ -0,0 +1,10 @@
+import { JSONTypeValidator } from "../../types";
+/**
+ * @todo: type is also a keyword, as is properties, items, etc
+ *
+ * An instance has one of six primitive types (http://json-schema.org/latest/json-schema-core.html#rfc.section.4.2)
+ * 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)
+ */
+declare const validationType: Record<string, JSONTypeValidator>;
+export default validationType;

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

@@ -0,0 +1,13 @@
+/**
+ * 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[];
+    object: string[];
+    string: string[];
+    number: string[];
+    null: string[];
+};
+export default _default;

package/dist/lib/draft07/index.d.ts

@@ -0,0 +1,7 @@
+import { DraftConfig, Draft } from "../draft";
+import { JSONSchema } from "../types";
+declare const draft07Config: DraftConfig;
+declare class Draft07 extends Draft {
+    constructor(schema?: JSONSchema, config?: Partial<DraftConfig>);
+}
+export { Draft07, draft07Config };

package/dist/lib/each.d.ts

@@ -1,5 +1,6 @@
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 import { JSONSchema, JSONPointer } from "./types";
+export declare type EachCallback = (schema: JSONSchema, data: unknown, pointer: JSONPointer) => void;
 /**
  * Iterates over data, retrieving its schema
  *
@@ -9,4 +10,4 @@ import { JSONSchema, JSONPointer } from "./types";
  * @param [schema] - the schema matching the data. Defaults to rootSchema
  * @param [pointer] - pointer to current data. Default to rootPointer
  */
-export default function each(core: Core, data: any, callback: any, schema?: JSONSchema, pointer?: JSONPointer): void;
+export declare function each(core: Core, data: any, callback: EachCallback, schema?: JSONSchema, pointer?: JSONPointer): void;

package/dist/lib/eachSchema.d.ts

@@ -1,5 +1,3 @@
 import { JSONSchema, JSONPointer } from "./types";
-export interface OnSchema {
-    (schema: JSONSchema, pointer: JSONPointer): void;
-}
-export default function eachSchema(schema: JSONSchema, callback: OnSchema, pointer?: JSONPointer): void;
+export declare type EachSchemaCallback = (schema: JSONSchema, pointer: JSONPointer) => void;
+export declare function eachSchema(schema: JSONSchema, callback: EachSchemaCallback, pointer?: JSONPointer): void;

package/dist/lib/getChildSchemaSelection.d.ts

@@ -1,11 +1,13 @@
+import { Draft } from "./draft";
+import { JSONError, JSONSchema } from "./types";
 /**
  * Returns a list of possible child-schemas for the given property key. In case of a oneOf selection, multiple schemas
  * could be added at the given property (e.g. item-index), thus an array of options is returned. In all other cases
  * a list with a single item will be returned
  *
- * @param  {Core} core          - core to use
- * @param  {String} property    - parent schema of following property
- * @param  {Object} [schema]    - parent schema of following property
- * @return {Object}
+ * @param core        - core to use
+ * @param property    - parent schema of following property
+ * @param [schema]    - parent schema of following property
+ * @return
  */
-export default function getChildSchemaSelection(core: any, property: any, schema?: any): any;
+export default function getChildSchemaSelection(core: Draft, property: string | number, schema?: JSONSchema): JSONSchema[] | JSONError;

package/dist/lib/getSchema.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchema, JSONPointer } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 /**
  * Returns the json-schema of a data-json-pointer.
  *
@@ -13,4 +13,4 @@ import Core from "./cores/CoreInterface";
  * @param [schema] - the json schema to iterate. Defaults to core.rootSchema
  * @return json schema object of the json-pointer or an error
  */
-export default function getSchema(core: Core, pointer: JSONPointer, data?: any, schema?: JSONSchema): JSONSchema;
+export default function getSchema(core: Core, pointer: JSONPointer, data?: unknown, schema?: JSONSchema): JSONSchema;

package/dist/lib/getTemplate.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchema } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 interface TemplateOptions {
     /** Add all properties (required and optional) to the generated data */
     addOptionalProps: boolean;

package/dist/lib/getTypeOf.d.ts

@@ -1 +1,2 @@
-export default function getTypeOf(value: any): any;
+export declare type JSType = "array" | "bigint" | "boolean" | "function" | "null" | "number" | "object" | "string" | "symbol" | "undefined";
+export default function getTypeOf(value: unknown): JSType;

package/dist/lib/isValid.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchema, JSONPointer } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 /**
  * Test if the data is valid according to the given schema
  *

package/dist/lib/jsoneditor/index.d.ts

@@ -0,0 +1,7 @@
+import { Draft, DraftConfig } from "../draft";
+import { JSONSchema } from "../types";
+declare const draftJsonEditorConfig: DraftConfig;
+declare class JsonEditor extends Draft {
+    constructor(schema?: JSONSchema, config?: Partial<DraftConfig>);
+}
+export { JsonEditor, draftJsonEditorConfig };

package/dist/lib/resolveAllOf.d.ts

@@ -1,3 +1,3 @@
 import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 export default function resolveAllOf(core: Core, data: any, schema?: JSONSchema, pointer?: JSONPointer): JSONSchema | JSONError;

package/dist/lib/resolveAnyOf.d.ts

@@ -1,3 +1,3 @@
 import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 export default function resolveAnyOf(core: Core, data: any, schema?: JSONSchema, pointer?: JSONPointer): JSONSchema | JSONError;

package/dist/lib/resolveOneOf.fuzzy.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 /**
  * Selects and returns a oneOf schema for the given data
  *

package/dist/lib/resolveOneOf.strict.d.ts

@@ -1,5 +1,5 @@
-import Core from "./cores/CoreInterface";
-import { JSONSchema, JSONError, JSONPointer } from "./types";
+import { JSONSchema, JSONPointer, JSONError } from "./types";
+import { Draft as Core } from "./draft";
 /**
  * Selects and returns a oneOf schema for the given data
  *

package/dist/lib/schema/getTypeDefs.d.ts

@@ -1,10 +1,12 @@
 import { JSONSchema, JSONPointer } from "../types";
+declare type TypeDef = {
+    pointer: JSONPointer;
+    def: unknown;
+};
 /**
  * Returns a list of all (direct) type definitions from the given schema
  * @param schema
  * @return list of type definition, given as { pointer, def }
  */
-export default function getTypeDefs(schema: JSONSchema): Array<{
-    pointer: JSONPointer;
-    def: any;
-}>;
+export default function getTypeDefs(schema: JSONSchema): TypeDef[];
+export {};

package/dist/lib/schema/getTypeId.d.ts

@@ -6,4 +6,4 @@ import { JSONSchema } from "../types";
  * @param schema
  * @return type id, if found
  */
-export default function getTypeId(schema: JSONSchema): string | undefined;
+export default function getTypeId(schema: JSONSchema): string | string[] | undefined;

package/dist/lib/schema/types.d.ts

@@ -1,58 +1,8 @@
-declare const _default: {
-    $ref: {
-        type: boolean;
-    };
-    allOf: {
-        type: boolean;
-        definitions: string[];
-    };
-    anyOf: {
-        type: boolean;
-        definitions: string[];
-    };
-    array: {
-        type: boolean;
-        definitions: string[];
-        validationKeywords: string[];
-        keywords: string[];
-    };
-    boolean: {
-        type: boolean;
-    };
-    enum: {
-        type: boolean;
-    };
-    integer: {
-        type: boolean;
-        definitions: string[];
-        validationKeywords: string[];
-    };
-    not: {
-        type: boolean;
-        definitions: string[];
-    };
-    number: {
-        type: boolean;
-        definitions: string[];
-        validationKeywords: string[];
-    };
-    null: {
-        type: boolean;
-    };
-    object: {
-        type: boolean;
-        definitions: string[];
-        validationKeywords: string[];
-        keywords: string[];
-    };
-    oneOf: {
-        type: boolean;
-        definitions: string[];
-    };
-    string: {
-        type: boolean;
-        definitions: string[];
-        validationKeywords: string[];
-    };
+export declare type Type = {
+    type: boolean;
+    definitions?: string[];
+    validationKeywords?: string[];
+    keywords?: string[];
 };
-export default _default;
+declare const Types: Record<string, Type>;
+export default Types;

package/dist/lib/step.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 /**
  * Returns the json-schema of the given object property or array item.
  * e.g. it steps by one key into the data
@@ -7,11 +7,11 @@ import Core from "./cores/CoreInterface";
  *  This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
  *  returns the correct schema.
  *
- * @param  core     - validator
- * @param  key      - property-name or array-index
- * @param  schema          - json schema of current data
+ * @param  core      - validator
+ * @param  key       - property-name or array-index
+ * @param  schema    - json schema of current data
  * @param  data      - parent of key
- * @param  [pointer]
+ * @param  [pointer] - pointer to schema and data (parent of key)
  * @return Schema or Error if failed resolving key
  */
 export default function step(core: Core, key: string | number, schema: JSONSchema, data?: any, pointer?: JSONPointer): JSONSchema | JSONError;

package/dist/lib/types.d.ts

@@ -1,10 +1,10 @@
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 export declare type JSONSchema = {
     [p: string]: any;
 };
 export declare type JSONPointer = string;
 export declare type JSONError = {
-    type: "error" | "string";
+    type: "error";
     name: string;
     code: string;
     message: string;
@@ -13,6 +13,14 @@ export declare type JSONError = {
     };
     [p: string]: any;
 };
+/**
+ * ts type guard for json error
+ * @returns true if passed type is a JSONError
+ */
+export declare function isJSONError(error: any): error is JSONError;
 export interface JSONValidator {
-    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): void | undefined | JSONError | Array<JSONError>;
+    (core: Core, schema: JSONSchema, value: unknown, pointer: JSONPointer): void | undefined | JSONError | JSONError[] | JSONError[][];
+}
+export interface JSONTypeValidator {
+    (core: Core, schema: JSONSchema, value: unknown, pointer: JSONPointer): Array<void | undefined | JSONError | JSONError[] | JSONError[][]>;
 }

package/dist/lib/utils/createCustomError.d.ts

@@ -1,17 +1,14 @@
-import { JSONError } from "../types";
-export interface CreateError {
-    (data?: {
-        [p: string]: any;
-    }): JSONError;
-}
-export declare function createError(name: string, data?: {
-    [p: string]: any;
-}): JSONError;
+import { JSONError, JSONPointer } from "../types";
+export declare type ErrorData = {
+    pointer: JSONPointer;
+} & Record<string, unknown>;
+export declare type CreateError = (data: ErrorData) => JSONError;
+export declare function createError(name: string, data: ErrorData): JSONError;
 /**
  * Creates a custom Error-Constructor which instances may be identified by `customError instanceof Error`. Its messages
- * are defined by strings-object __@see config/strings.ts
+ * are defined by strings-object @see config/strings.ts
  *
  * @param name - id of error (camelcased)
  * @return error constructor function
  */
-export default function createCustomError(name: string): CreateError;
+export declare function createCustomError(name: string): CreateError;

package/dist/lib/utils/filter.d.ts

@@ -1,4 +1,4 @@
-export declare function isPromise(obj: any): boolean;
-export declare function isError(obj: any): boolean;
-export declare function errorOrPromise(error: any): boolean;
-export declare function errorsOnly(error: any): boolean;
+import { JSONError } from "../types";
+export declare function isPromise(obj: unknown): obj is Promise<unknown>;
+export declare function errorOrPromise(error: unknown): error is JSONError | Promise<unknown>;
+export declare function errorsOnly(error: unknown): error is JSONError;

package/dist/lib/utils/flattenArray.d.ts

@@ -1 +1 @@
-export default function flattenArray<T = any>(list: Array<any>, result?: any[]): Array<T>;
+export default function flattenArray<T = unknown>(list: unknown[], result?: T[]): T[];

package/dist/lib/utils/merge.d.ts

@@ -1,2 +1,5 @@
+/**
+ * returns a new json-schema, where properties are combined and arrays are replaced
+ */
 declare const _default: <T, K>(a: T, b: K) => T & K;
 export default _default;

package/dist/lib/utils/punycode.ucs2decode.d.ts

@@ -13,4 +13,4 @@
  * @param string The Unicode input string (UCS-2).
  * @returns The new array of code points.
  */
-export default function ucs2decode(string: string): Array<string>;
+export default function ucs2decode(string: string): string[];

package/dist/lib/validate.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 /**
  * Validate data by a json schema
  *
@@ -9,4 +9,4 @@ import Core from "./cores/CoreInterface";
  * @param [pointer] - json pointer pointing to value (used for error-messages only)
  * @return list of errors or empty
  */
-export default function validate(core: Core, value: any, schema?: JSONSchema, pointer?: JSONPointer): Array<JSONError>;
+export default function validate(core: Core, value: unknown, schema?: JSONSchema, pointer?: JSONPointer): Array<JSONError>;

package/dist/lib/validateAsync.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 export interface OnError {
     (error: JSONError): void;
 }