@modern-js/utils 2.12.1-alpha.2 → 2.13.0

package/dist/esm-node/compiled/ajv/types/compile/errors.d.ts

@@ -1,13 +0,0 @@
-import type { KeywordErrorCxt, KeywordErrorDefinition } from '../types';
-import { CodeGen, Code, Name } from './codegen';
-export declare const keywordError: KeywordErrorDefinition;
-export declare const keyword$DataError: KeywordErrorDefinition;
-export interface ErrorPaths {
-    instancePath?: Code;
-    schemaPath?: string;
-    parentSchema?: boolean;
-}
-export declare function reportError(cxt: KeywordErrorCxt, error?: KeywordErrorDefinition, errorPaths?: ErrorPaths, overrideAllErrors?: boolean): void;
-export declare function reportExtraError(cxt: KeywordErrorCxt, error?: KeywordErrorDefinition, errorPaths?: ErrorPaths): void;
-export declare function resetErrorsCount(gen: CodeGen, errsCount: Name): void;
-export declare function extendErrors({ gen, keyword, schemaValue, data, errsCount, it, }: KeywordErrorCxt): void;

package/dist/esm-node/compiled/ajv/types/compile/index.d.ts

@@ -1,80 +0,0 @@
-import type { AnySchema, AnySchemaObject, AnyValidateFunction, EvaluatedProperties, EvaluatedItems } from '../types';
-import type Ajv from '../core';
-import type { InstanceOptions } from '../core';
-import { CodeGen, Name, Code, ValueScopeName } from './codegen';
-import { LocalRefs } from './resolve';
-import { JSONType } from './rules';
-export declare type SchemaRefs = {
-    [Ref in string]?: SchemaEnv | AnySchema;
-};
-export interface SchemaCxt {
-    readonly gen: CodeGen;
-    readonly allErrors?: boolean;
-    readonly data: Name;
-    readonly parentData: Name;
-    readonly parentDataProperty: Code | number;
-    readonly dataNames: Name[];
-    readonly dataPathArr: (Code | number)[];
-    readonly dataLevel: number;
-    dataTypes: JSONType[];
-    definedProperties: Set<string>;
-    readonly topSchemaRef: Code;
-    readonly validateName: Name;
-    evaluated?: Name;
-    readonly ValidationError?: Name;
-    readonly schema: AnySchema;
-    readonly schemaEnv: SchemaEnv;
-    readonly rootId: string;
-    baseId: string;
-    readonly schemaPath: Code;
-    readonly errSchemaPath: string;
-    readonly errorPath: Code;
-    readonly propertyName?: Name;
-    readonly compositeRule?: boolean;
-    props?: EvaluatedProperties | Name;
-    items?: EvaluatedItems | Name;
-    jtdDiscriminator?: string;
-    jtdMetadata?: boolean;
-    readonly createErrors?: boolean;
-    readonly opts: InstanceOptions;
-    readonly self: Ajv;
-}
-export interface SchemaObjCxt extends SchemaCxt {
-    readonly schema: AnySchemaObject;
-}
-interface SchemaEnvArgs {
-    readonly schema: AnySchema;
-    readonly schemaId?: "$id" | "id";
-    readonly root?: SchemaEnv;
-    readonly baseId?: string;
-    readonly schemaPath?: string;
-    readonly localRefs?: LocalRefs;
-    readonly meta?: boolean;
-}
-export declare class SchemaEnv implements SchemaEnvArgs {
-    readonly schema: AnySchema;
-    readonly schemaId?: "$id" | "id";
-    readonly root: SchemaEnv;
-    baseId: string;
-    schemaPath?: string;
-    localRefs?: LocalRefs;
-    readonly meta?: boolean;
-    readonly $async?: boolean;
-    readonly refs: SchemaRefs;
-    readonly dynamicAnchors: {
-        [Ref in string]?: true;
-    };
-    validate?: AnyValidateFunction;
-    validateName?: ValueScopeName;
-    serialize?: (data: unknown) => string;
-    serializeName?: ValueScopeName;
-    parse?: (data: string) => unknown;
-    parseName?: ValueScopeName;
-    constructor(env: SchemaEnvArgs);
-}
-export declare function compileSchema(this: Ajv, sch: SchemaEnv): SchemaEnv;
-export declare function resolveRef(this: Ajv, root: SchemaEnv, baseId: string, ref: string): AnySchema | SchemaEnv | undefined;
-export declare function getCompilingSchema(this: Ajv, schEnv: SchemaEnv): SchemaEnv | void;
-export declare function resolveSchema(this: Ajv, root: SchemaEnv, // root object with properties schema, refs TODO below SchemaEnv is assigned to it
-ref: string): SchemaEnv | undefined;
-export {};

package/dist/esm-node/compiled/ajv/types/compile/ref_error.d.ts

@@ -1,6 +0,0 @@
-import type { UriResolver } from '../types';
-export default class MissingRefError extends Error {
-    readonly missingRef: string;
-    readonly missingSchema: string;
-    constructor(resolver: UriResolver, baseId: string, ref: string, msg?: string);
-}

package/dist/esm-node/compiled/ajv/types/compile/resolve.d.ts

@@ -1,12 +0,0 @@
-import type { AnySchema, AnySchemaObject, UriResolver } from '../types';
-import type Ajv from '../ajv';
-import type { URIComponents } from '../../uri-js';
-export declare type LocalRefs = {
-    [Ref in string]?: AnySchemaObject;
-};
-export declare function inlineRef(schema: AnySchema, limit?: boolean | number): boolean;
-export declare function getFullPath(resolver: UriResolver, id?: string, normalize?: boolean): string;
-export declare function _getFullPath(resolver: UriResolver, p: URIComponents): string;
-export declare function normalizeId(id: string | undefined): string;
-export declare function resolveUrl(resolver: UriResolver, baseId: string, id: string): string;
-export declare function getSchemaRefs(this: Ajv, schema: AnySchema, baseId: string): LocalRefs;

package/dist/esm-node/compiled/ajv/types/compile/rules.d.ts

@@ -1,28 +0,0 @@
-import type { AddedKeywordDefinition } from '../types';
-declare const _jsonTypes: readonly ["string", "number", "integer", "boolean", "null", "object", "array"];
-export declare type JSONType = typeof _jsonTypes[number];
-export declare function isJSONType(x: unknown): x is JSONType;
-declare type ValidationTypes = {
-    [K in JSONType]: boolean | RuleGroup | undefined;
-};
-export interface ValidationRules {
-    rules: RuleGroup[];
-    post: RuleGroup;
-    all: {
-        [Key in string]?: boolean | Rule;
-    };
-    keywords: {
-        [Key in string]?: boolean;
-    };
-    types: ValidationTypes;
-}
-export interface RuleGroup {
-    type?: JSONType;
-    rules: Rule[];
-}
-export interface Rule {
-    keyword: string;
-    definition: AddedKeywordDefinition;
-}
-export declare function getRules(): ValidationRules;
-export {};

package/dist/esm-node/compiled/ajv/types/compile/util.d.ts

@@ -1,40 +0,0 @@
-import type { AnySchema, EvaluatedProperties, EvaluatedItems } from '../types';
-import type { SchemaCxt, SchemaObjCxt } from '.';
-import { Code, Name, CodeGen } from './codegen';
-import type { Rule, ValidationRules } from './rules';
-export declare function toHash<T extends string = string>(arr: T[]): {
-    [K in T]?: true;
-};
-export declare function alwaysValidSchema(it: SchemaCxt, schema: AnySchema): boolean | void;
-export declare function checkUnknownRules(it: SchemaCxt, schema?: AnySchema): void;
-export declare function schemaHasRules(schema: AnySchema, rules: {
-    [Key in string]?: boolean | Rule;
-}): boolean;
-export declare function schemaHasRulesButRef(schema: AnySchema, RULES: ValidationRules): boolean;
-export declare function schemaRefOrVal({ topSchemaRef, schemaPath }: SchemaObjCxt, schema: unknown, keyword: string, $data?: string | false): Code | number | boolean;
-export declare function unescapeFragment(str: string): string;
-export declare function escapeFragment(str: string | number): string;
-export declare function escapeJsonPointer(str: string | number): string;
-export declare function unescapeJsonPointer(str: string): string;
-export declare function eachItem<T>(xs: T | T[], f: (x: T) => void): void;
-declare type SomeEvaluated = EvaluatedProperties | EvaluatedItems;
-declare type MergeEvaluatedFunc<T extends SomeEvaluated> = (gen: CodeGen, from: Name | T, to: Name | Exclude<T, true> | undefined, toName?: typeof Name) => Name | T;
-interface MergeEvaluated {
-    props: MergeEvaluatedFunc<EvaluatedProperties>;
-    items: MergeEvaluatedFunc<EvaluatedItems>;
-}
-export declare const mergeEvaluated: MergeEvaluated;
-export declare function evaluatedPropsToName(gen: CodeGen, ps?: EvaluatedProperties): Name;
-export declare function setEvaluated(gen: CodeGen, props: Name, ps: {
-    [K in string]?: true;
-}): void;
-export declare function useFunc(gen: CodeGen, f: {
-    code: string;
-}): Name;
-export declare enum Type {
-    Num = 0,
-    Str = 1
-}
-export declare function getErrorPath(dataProp: Name | string | number, dataPropType?: Type, jsPropertySyntax?: boolean): Code | string;
-export declare function checkStrictMode(it: SchemaCxt, msg: string, mode?: boolean | "log"): void;
-export {};

package/dist/esm-node/compiled/ajv/types/compile/validate/index.d.ts

@@ -1,42 +0,0 @@
-import type { AddedKeywordDefinition, AnySchemaObject, KeywordErrorCxt, KeywordCxtParams } from '../../types';
-import type { SchemaCxt, SchemaObjCxt } from '..';
-import { SubschemaArgs } from './subschema';
-import { Code, Name, CodeGen } from '../codegen';
-import type { JSONType } from '../rules';
-import { ErrorPaths } from '../errors';
-export declare function validateFunctionCode(it: SchemaCxt): void;
-export declare class KeywordCxt implements KeywordErrorCxt {
-    readonly gen: CodeGen;
-    readonly allErrors?: boolean;
-    readonly keyword: string;
-    readonly data: Name;
-    readonly $data?: string | false;
-    schema: any;
-    readonly schemaValue: Code | number | boolean;
-    readonly schemaCode: Code | number | boolean;
-    readonly schemaType: JSONType[];
-    readonly parentSchema: AnySchemaObject;
-    readonly errsCount?: Name;
-    params: KeywordCxtParams;
-    readonly it: SchemaObjCxt;
-    readonly def: AddedKeywordDefinition;
-    constructor(it: SchemaObjCxt, def: AddedKeywordDefinition, keyword: string);
-    result(condition: Code, successAction?: () => void, failAction?: () => void): void;
-    failResult(condition: Code, successAction?: () => void, failAction?: () => void): void;
-    pass(condition: Code, failAction?: () => void): void;
-    fail(condition?: Code): void;
-    fail$data(condition: Code): void;
-    error(append?: boolean, errorParams?: KeywordCxtParams, errorPaths?: ErrorPaths): void;
-    private _error;
-    $dataError(): void;
-    reset(): void;
-    ok(cond: Code | boolean): void;
-    setParams(obj: KeywordCxtParams, assign?: true): void;
-    block$data(valid: Name, codeBlock: () => void, $dataValid?: Code): void;
-    check$data(valid?: Name, $dataValid?: Code): void;
-    invalid$data(): Code;
-    subschema(appl: SubschemaArgs, valid: Name): SchemaCxt;
-    mergeEvaluated(schemaCxt: SchemaCxt, toName?: typeof Name): void;
-    mergeValidEvaluated(schemaCxt: SchemaCxt, valid: Name): boolean | void;
-}
-export declare function getData($data: string, { dataLevel, dataNames, dataPathArr }: SchemaCxt): Code | number;

package/dist/esm-node/compiled/ajv/types/compile/validate/subschema.d.ts

@@ -1,47 +0,0 @@
-import type { AnySchema } from '../../types';
-import type { SchemaObjCxt } from '..';
-import { Code, Name } from '../codegen';
-import { Type } from '../util';
-import type { JSONType } from '../rules';
-export interface SubschemaContext {
-    schema: AnySchema;
-    schemaPath: Code;
-    errSchemaPath: string;
-    topSchemaRef?: Code;
-    errorPath?: Code;
-    dataLevel?: number;
-    dataTypes?: JSONType[];
-    data?: Name;
-    parentData?: Name;
-    parentDataProperty?: Code | number;
-    dataNames?: Name[];
-    dataPathArr?: (Code | number)[];
-    propertyName?: Name;
-    jtdDiscriminator?: string;
-    jtdMetadata?: boolean;
-    compositeRule?: true;
-    createErrors?: boolean;
-    allErrors?: boolean;
-}
-export declare type SubschemaArgs = Partial<{
-    keyword: string;
-    schemaProp: string | number;
-    schema: AnySchema;
-    schemaPath: Code;
-    errSchemaPath: string;
-    topSchemaRef: Code;
-    data: Name | Code;
-    dataProp: Code | string | number;
-    dataTypes: JSONType[];
-    definedProperties: Set<string>;
-    propertyName: Name;
-    dataPropType: Type;
-    jtdDiscriminator: string;
-    jtdMetadata: boolean;
-    compositeRule: true;
-    createErrors: boolean;
-    allErrors: boolean;
-}>;
-export declare function getSubschema(it: SchemaObjCxt, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }: SubschemaArgs): SubschemaContext;
-export declare function extendSubschemaData(subschema: SubschemaContext, it: SchemaObjCxt, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }: SubschemaArgs): void;
-export declare function extendSubschemaMode(subschema: SubschemaContext, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }: SubschemaArgs): void;

package/dist/esm-node/compiled/ajv/types/core.d.ts

@@ -1,173 +0,0 @@
-export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, AnyValidateFunction, ErrorObject, ErrorNoParams, } from "./types";
-export { SchemaCxt, SchemaObjCxt } from "./compile";
-export interface Plugin<Opts> {
-    (ajv: Ajv, options?: Opts): Ajv;
-    [prop: string]: any;
-}
-export { KeywordCxt } from "./compile/validate";
-export { DefinedError } from "./vocabularies/errors";
-export { JSONType } from "./compile/rules";
-export { JSONSchemaType } from "./types/json-schema";
-export { JTDSchemaType, SomeJTDSchemaType, JTDDataType } from "./types/jtd-schema";
-export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "./compile/codegen";
-import type { Schema, AnySchema, AnySchemaObject, SchemaObject, AsyncSchema, Vocabulary, KeywordDefinition, AddedKeywordDefinition, AnyValidateFunction, ValidateFunction, AsyncValidateFunction, ErrorObject, Format, AddedFormat, RegExpEngine, UriResolver } from './types';
-import type { JSONSchemaType } from './types/json-schema';
-import type { JTDSchemaType, SomeJTDSchemaType, JTDDataType } from './types/jtd-schema';
-import ValidationError from './runtime/validation_error';
-import MissingRefError from './compile/ref_error';
-import { ValidationRules } from './compile/rules';
-import { SchemaEnv } from './compile';
-import { Code, ValueScope } from './compile/codegen';
-export declare type Options = CurrentOptions & DeprecatedOptions;
-export interface CurrentOptions {
-    strict?: boolean | "log";
-    strictSchema?: boolean | "log";
-    strictNumbers?: boolean | "log";
-    strictTypes?: boolean | "log";
-    strictTuples?: boolean | "log";
-    strictRequired?: boolean | "log";
-    allowMatchingProperties?: boolean;
-    allowUnionTypes?: boolean;
-    validateFormats?: boolean;
-    $data?: boolean;
-    allErrors?: boolean;
-    verbose?: boolean;
-    discriminator?: boolean;
-    unicodeRegExp?: boolean;
-    timestamp?: "string" | "date";
-    parseDate?: boolean;
-    allowDate?: boolean;
-    $comment?: true | ((comment: string, schemaPath?: string, rootSchema?: AnySchemaObject) => unknown);
-    formats?: {
-        [Name in string]?: Format;
-    };
-    keywords?: Vocabulary;
-    schemas?: AnySchema[] | {
-        [Key in string]?: AnySchema;
-    };
-    logger?: Logger | false;
-    loadSchema?: (uri: string) => Promise<AnySchemaObject>;
-    removeAdditional?: boolean | "all" | "failing";
-    useDefaults?: boolean | "empty";
-    coerceTypes?: boolean | "array";
-    next?: boolean;
-    unevaluated?: boolean;
-    dynamicRef?: boolean;
-    schemaId?: "id" | "$id";
-    jtd?: boolean;
-    meta?: SchemaObject | boolean;
-    defaultMeta?: string | AnySchemaObject;
-    validateSchema?: boolean | "log";
-    addUsedSchema?: boolean;
-    inlineRefs?: boolean | number;
-    passContext?: boolean;
-    loopRequired?: number;
-    loopEnum?: number;
-    ownProperties?: boolean;
-    multipleOfPrecision?: number;
-    int32range?: boolean;
-    messages?: boolean;
-    code?: CodeOptions;
-    uriResolver?: UriResolver;
-}
-export interface CodeOptions {
-    es5?: boolean;
-    esm?: boolean;
-    lines?: boolean;
-    optimize?: boolean | number;
-    formats?: Code;
-    source?: boolean;
-    process?: (code: string, schema?: SchemaEnv) => string;
-    regExp?: RegExpEngine;
-}
-interface InstanceCodeOptions extends CodeOptions {
-    regExp: RegExpEngine;
-    optimize: number;
-}
-interface DeprecatedOptions {
-    /** @deprecated */
-    ignoreKeywordsWithRef?: boolean;
-    /** @deprecated */
-    jsPropertySyntax?: boolean;
-    /** @deprecated */
-    unicode?: boolean;
-}
-declare type RequiredInstanceOptions = {
-    [K in "strictSchema" | "strictNumbers" | "strictTypes" | "strictTuples" | "strictRequired" | "inlineRefs" | "loopRequired" | "loopEnum" | "meta" | "messages" | "schemaId" | "addUsedSchema" | "validateSchema" | "validateFormats" | "int32range" | "unicodeRegExp" | "uriResolver"]: NonNullable<Options[K]>;
-} & {
-    code: InstanceCodeOptions;
-};
-export declare type InstanceOptions = Options & RequiredInstanceOptions;
-export interface Logger {
-    log(...args: unknown[]): unknown;
-    warn(...args: unknown[]): unknown;
-    error(...args: unknown[]): unknown;
-}
-export default class Ajv {
-    opts: InstanceOptions;
-    errors?: ErrorObject[] | null;
-    logger: Logger;
-    readonly scope: ValueScope;
-    readonly schemas: {
-        [Key in string]?: SchemaEnv;
-    };
-    readonly refs: {
-        [Ref in string]?: SchemaEnv | string;
-    };
-    readonly formats: {
-        [Name in string]?: AddedFormat;
-    };
-    readonly RULES: ValidationRules;
-    readonly _compilations: Set<SchemaEnv>;
-    private readonly _loading;
-    private readonly _cache;
-    private readonly _metaOpts;
-    static ValidationError: typeof ValidationError;
-    static MissingRefError: typeof MissingRefError;
-    constructor(opts?: Options);
-    _addVocabularies(): void;
-    _addDefaultMetaSchema(): void;
-    defaultMeta(): string | AnySchemaObject | undefined;
-    validate(schema: Schema | string, data: unknown): boolean;
-    validate(schemaKeyRef: AnySchema | string, data: unknown): boolean | Promise<unknown>;
-    validate<T>(schema: Schema | JSONSchemaType<T> | string, data: unknown): data is T;
-    validate<T>(schema: JTDSchemaType<T>, data: unknown): data is T;
-    validate<N extends never, T extends SomeJTDSchemaType>(schema: T, data: unknown): data is JTDDataType<T>;
-    validate<T>(schema: AsyncSchema, data: unknown | T): Promise<T>;
-    validate<T>(schemaKeyRef: AnySchema | string, data: unknown): data is T | Promise<T>;
-    compile<T = unknown>(schema: Schema | JSONSchemaType<T>, _meta?: boolean): ValidateFunction<T>;
-    compile<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): ValidateFunction<T>;
-    compile<N extends never, T extends SomeJTDSchemaType>(schema: T, _meta?: boolean): ValidateFunction<JTDDataType<T>>;
-    compile<T = unknown>(schema: AsyncSchema, _meta?: boolean): AsyncValidateFunction<T>;
-    compile<T = unknown>(schema: AnySchema, _meta?: boolean): AnyValidateFunction<T>;
-    compileAsync<T = unknown>(schema: SchemaObject | JSONSchemaType<T>, _meta?: boolean): Promise<ValidateFunction<T>>;
-    compileAsync<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): Promise<ValidateFunction<T>>;
-    compileAsync<T = unknown>(schema: AsyncSchema, meta?: boolean): Promise<AsyncValidateFunction<T>>;
-    compileAsync<T = unknown>(schema: AnySchemaObject, meta?: boolean): Promise<AnyValidateFunction<T>>;
-    addSchema(schema: AnySchema | AnySchema[], // If array is passed, `key` will be ignored
-    key?: string, // Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.
-    _meta?: boolean, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.
-    _validateSchema?: boolean | "log"): Ajv;
-    addMetaSchema(schema: AnySchemaObject, key?: string, // schema key
-    _validateSchema?: boolean | "log"): Ajv;
-    validateSchema(schema: AnySchema, throwOrLogError?: boolean): boolean | Promise<unknown>;
-    getSchema<T = unknown>(keyRef: string): AnyValidateFunction<T> | undefined;
-    removeSchema(schemaKeyRef?: AnySchema | string | RegExp): Ajv;
-    addVocabulary(definitions: Vocabulary): Ajv;
-    addKeyword(kwdOrDef: string | KeywordDefinition, def?: KeywordDefinition): Ajv;
-    getKeyword(keyword: string): AddedKeywordDefinition | boolean;
-    removeKeyword(keyword: string): Ajv;
-    addFormat(name: string, format: Format): Ajv;
-    errorsText(errors?: ErrorObject[] | null | undefined, // optional array of validation errors
-    { separator, dataVar }?: ErrorsTextOptions): string;
-    $dataMetaSchema(metaSchema: AnySchemaObject, keywordsJsonPointers: string[]): AnySchemaObject;
-    private _removeAllSchemas;
-    _addSchema(schema: AnySchema, meta?: boolean, baseId?: string, validateSchema?: boolean | "log", addSchema?: boolean): SchemaEnv;
-    private _checkUnique;
-    private _compileSchemaEnv;
-    private _compileMetaSchema;
-}
-export interface ErrorsTextOptions {
-    separator?: string;
-    dataVar?: string;
-}

package/dist/esm-node/compiled/ajv/types/runtime/validation_error.d.ts

@@ -1,7 +0,0 @@
-import type { ErrorObject } from '../types';
-export default class ValidationError extends Error {
-    readonly errors: Partial<ErrorObject>[];
-    readonly ajv: true;
-    readonly validation: true;
-    constructor(errors: Partial<ErrorObject>[]);
-}

package/dist/esm-node/compiled/ajv/types/types/index.d.ts

@@ -1,183 +0,0 @@
-import * as URI from '../../uri-js';
-import type { CodeGen, Code, Name, ScopeValueSets, ValueScopeName } from '../compile/codegen';
-import type { SchemaEnv, SchemaCxt, SchemaObjCxt } from '../compile';
-import type { JSONType } from '../compile/rules';
-import type { KeywordCxt } from '../compile/validate';
-import type Ajv from '../core';
-interface _SchemaObject {
-    id?: string;
-    $id?: string;
-    $schema?: string;
-    [x: string]: any;
-}
-export interface SchemaObject extends _SchemaObject {
-    id?: string;
-    $id?: string;
-    $schema?: string;
-    $async?: false;
-    [x: string]: any;
-}
-export interface AsyncSchema extends _SchemaObject {
-    $async: true;
-}
-export declare type AnySchemaObject = SchemaObject | AsyncSchema;
-export declare type Schema = SchemaObject | boolean;
-export declare type AnySchema = Schema | AsyncSchema;
-export declare type SchemaMap = {
-    [Key in string]?: AnySchema;
-};
-export interface SourceCode {
-    validateName: ValueScopeName;
-    validateCode: string;
-    scopeValues: ScopeValueSets;
-    evaluated?: Code;
-}
-export interface DataValidationCxt<T extends string | number = string | number> {
-    instancePath: string;
-    parentData: {
-        [K in T]: any;
-    };
-    parentDataProperty: T;
-    rootData: Record<string, any> | any[];
-    dynamicAnchors: {
-        [Ref in string]?: ValidateFunction;
-    };
-}
-export interface ValidateFunction<T = unknown> {
-    (this: Ajv | any, data: any, dataCxt?: DataValidationCxt): data is T;
-    errors?: null | ErrorObject[];
-    evaluated?: Evaluated;
-    schema: AnySchema;
-    schemaEnv: SchemaEnv;
-    source?: SourceCode;
-}
-export interface JTDParser<T = unknown> {
-    (json: string): T | undefined;
-    message?: string;
-    position?: number;
-}
-export declare type EvaluatedProperties = {
-    [K in string]?: true;
-} | true;
-export declare type EvaluatedItems = number | true;
-export interface Evaluated {
-    props?: EvaluatedProperties;
-    items?: EvaluatedItems;
-    dynamicProps: boolean;
-    dynamicItems: boolean;
-}
-export interface AsyncValidateFunction<T = unknown> extends ValidateFunction<T> {
-    (...args: Parameters<ValidateFunction<T>>): Promise<T>;
-    $async: true;
-}
-export declare type AnyValidateFunction<T = any> = ValidateFunction<T> | AsyncValidateFunction<T>;
-export interface ErrorObject<K extends string = string, P = Record<string, any>, S = unknown> {
-    keyword: K;
-    instancePath: string;
-    schemaPath: string;
-    params: P;
-    propertyName?: string;
-    message?: string;
-    schema?: S;
-    parentSchema?: AnySchemaObject;
-    data?: unknown;
-}
-export declare type ErrorNoParams<K extends string, S = unknown> = ErrorObject<K, Record<string, never>, S>;
-interface _KeywordDef {
-    keyword: string | string[];
-    type?: JSONType | JSONType[];
-    schemaType?: JSONType | JSONType[];
-    allowUndefined?: boolean;
-    $data?: boolean;
-    implements?: string[];
-    before?: string;
-    post?: boolean;
-    metaSchema?: AnySchemaObject;
-    validateSchema?: AnyValidateFunction;
-    dependencies?: string[];
-    error?: KeywordErrorDefinition;
-    $dataError?: KeywordErrorDefinition;
-}
-export interface CodeKeywordDefinition extends _KeywordDef {
-    code: (cxt: KeywordCxt, ruleType?: string) => void;
-    trackErrors?: boolean;
-}
-export declare type MacroKeywordFunc = (schema: any, parentSchema: AnySchemaObject, it: SchemaCxt) => AnySchema;
-export declare type CompileKeywordFunc = (schema: any, parentSchema: AnySchemaObject, it: SchemaObjCxt) => DataValidateFunction;
-export interface DataValidateFunction {
-    (...args: Parameters<ValidateFunction>): boolean | Promise<any>;
-    errors?: Partial<ErrorObject>[];
-}
-export interface SchemaValidateFunction {
-    (schema: any, data: any, parentSchema?: AnySchemaObject, dataCxt?: DataValidationCxt): boolean | Promise<any>;
-    errors?: Partial<ErrorObject>[];
-}
-export interface FuncKeywordDefinition extends _KeywordDef {
-    validate?: SchemaValidateFunction | DataValidateFunction;
-    compile?: CompileKeywordFunc;
-    schema?: boolean;
-    modifying?: boolean;
-    async?: boolean;
-    valid?: boolean;
-    errors?: boolean | "full";
-}
-export interface MacroKeywordDefinition extends FuncKeywordDefinition {
-    macro: MacroKeywordFunc;
-}
-export declare type KeywordDefinition = CodeKeywordDefinition | FuncKeywordDefinition | MacroKeywordDefinition;
-export declare type AddedKeywordDefinition = KeywordDefinition & {
-    type: JSONType[];
-    schemaType: JSONType[];
-};
-export interface KeywordErrorDefinition {
-    message: string | Code | ((cxt: KeywordErrorCxt) => string | Code);
-    params?: Code | ((cxt: KeywordErrorCxt) => Code);
-}
-export declare type Vocabulary = (KeywordDefinition | string)[];
-export interface KeywordErrorCxt {
-    gen: CodeGen;
-    keyword: string;
-    data: Name;
-    $data?: string | false;
-    schema: any;
-    parentSchema?: AnySchemaObject;
-    schemaCode: Code | number | boolean;
-    schemaValue: Code | number | boolean;
-    schemaType?: JSONType[];
-    errsCount?: Name;
-    params: KeywordCxtParams;
-    it: SchemaCxt;
-}
-export declare type KeywordCxtParams = {
-    [P in string]?: Code | string | number;
-};
-export declare type FormatValidator<T extends string | number> = (data: T) => boolean;
-export declare type FormatCompare<T extends string | number> = (data1: T, data2: T) => number | undefined;
-export declare type AsyncFormatValidator<T extends string | number> = (data: T) => Promise<boolean>;
-export interface FormatDefinition<T extends string | number> {
-    type?: T extends string ? "string" | undefined : "number";
-    validate: FormatValidator<T> | (T extends string ? string | RegExp : never);
-    async?: false | undefined;
-    compare?: FormatCompare<T>;
-}
-export interface AsyncFormatDefinition<T extends string | number> {
-    type?: T extends string ? "string" | undefined : "number";
-    validate: AsyncFormatValidator<T>;
-    async: true;
-    compare?: FormatCompare<T>;
-}
-export declare type AddedFormat = true | RegExp | FormatValidator<string> | FormatDefinition<string> | FormatDefinition<number> | AsyncFormatDefinition<string> | AsyncFormatDefinition<number>;
-export declare type Format = AddedFormat | string;
-export interface RegExpEngine {
-    (pattern: string, u: string): RegExpLike;
-    code: string;
-}
-export interface RegExpLike {
-    test: (s: string) => boolean;
-}
-export interface UriResolver {
-    parse(uri: string): URI.URIComponents;
-    resolve(base: string, path: string): string;
-    serialize(component: URI.URIComponents): string;
-}
-export {};