@modern-js/utils 2.65.5 → 2.67.0

package/dist/compiled/ajv/types/ajv.d.ts

@@ -1,16 +0,0 @@
-import type { AnySchemaObject } from './types';
-import AjvCore from './core';
-declare class Ajv extends AjvCore {
-    _addVocabularies(): void;
-    _addDefaultMetaSchema(): void;
-    defaultMeta(): string | AnySchemaObject | undefined;
-}
-export default Ajv;
-export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, SchemaValidateFunction, ErrorObject, ErrorNoParams, } from "./types";
-export { Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions } from "./core";
-export { SchemaCxt, SchemaObjCxt } from "./compile";
-export { KeywordCxt } from "./compile/validate";
-export { DefinedError } from "./vocabularies/errors";
-export { JSONType } from "./compile/rules";
-export { JSONSchemaType } from "./types/json-schema";
-export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "./compile/codegen";

package/dist/compiled/ajv/types/compile/codegen/code.d.ts

@@ -1,40 +0,0 @@
-export declare abstract class _CodeOrName {
-    abstract readonly str: string;
-    abstract readonly names: UsedNames;
-    abstract toString(): string;
-    abstract emptyStr(): boolean;
-}
-export declare const IDENTIFIER: RegExp;
-export declare class Name extends _CodeOrName {
-    readonly str: string;
-    constructor(s: string);
-    toString(): string;
-    emptyStr(): boolean;
-    get names(): UsedNames;
-}
-export declare class _Code extends _CodeOrName {
-    readonly _items: readonly CodeItem[];
-    private _str?;
-    private _names?;
-    constructor(code: string | readonly CodeItem[]);
-    toString(): string;
-    emptyStr(): boolean;
-    get str(): string;
-    get names(): UsedNames;
-}
-export declare type CodeItem = Name | string | number | boolean | null;
-export declare type UsedNames = Record<string, number | undefined>;
-export declare type Code = _Code | Name;
-export declare type SafeExpr = Code | number | boolean | null;
-export declare const nil: _Code;
-declare type CodeArg = SafeExpr | string | undefined;
-export declare function _(strs: TemplateStringsArray, ...args: CodeArg[]): _Code;
-export declare function str(strs: TemplateStringsArray, ...args: (CodeArg | string[])[]): _Code;
-export declare function addCodeArg(code: CodeItem[], arg: CodeArg | string[]): void;
-export declare function strConcat(c1: Code, c2: Code): Code;
-export declare function stringify(x: unknown): Code;
-export declare function safeStringify(x: unknown): string;
-export declare function getProperty(key: Code | string | number): Code;
-export declare function getEsmExportName(key: Code | string | number): Code;
-export declare function regexpCode(rx: RegExp): Code;
-export {};

package/dist/compiled/ajv/types/compile/codegen/index.d.ts

@@ -1,79 +0,0 @@
-import type { ScopeValueSets, NameValue, ValueScope, ValueScopeName } from './scope';
-import { _Code, Code, Name } from './code';
-import { Scope } from './scope';
-export { _, str, strConcat, nil, getProperty, stringify, regexpCode, Name, Code } from "./code";
-export { Scope, ScopeStore, ValueScope, ValueScopeName, ScopeValueSets, varKinds } from "./scope";
-export declare type SafeExpr = Code | number | boolean | null;
-export declare type Block = Code | (() => void);
-export declare const operators: {
-    GT: _Code;
-    GTE: _Code;
-    LT: _Code;
-    LTE: _Code;
-    EQ: _Code;
-    NEQ: _Code;
-    NOT: _Code;
-    OR: _Code;
-    AND: _Code;
-    ADD: _Code;
-};
-export interface CodeGenOptions {
-    es5?: boolean;
-    lines?: boolean;
-    ownProperties?: boolean;
-}
-export declare class CodeGen {
-    readonly _scope: Scope;
-    readonly _extScope: ValueScope;
-    readonly _values: ScopeValueSets;
-    private readonly _nodes;
-    private readonly _blockStarts;
-    private readonly _constants;
-    private readonly opts;
-    constructor(extScope: ValueScope, opts?: CodeGenOptions);
-    toString(): string;
-    name(prefix: string): Name;
-    scopeName(prefix: string): ValueScopeName;
-    scopeValue(prefixOrName: ValueScopeName | string, value: NameValue): Name;
-    getScopeValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined;
-    scopeRefs(scopeName: Name): Code;
-    scopeCode(): Code;
-    private _def;
-    const(nameOrPrefix: Name | string, rhs: SafeExpr, _constant?: boolean): Name;
-    let(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name;
-    var(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name;
-    assign(lhs: Code, rhs: SafeExpr, sideEffects?: boolean): CodeGen;
-    add(lhs: Code, rhs: SafeExpr): CodeGen;
-    code(c: Block | SafeExpr): CodeGen;
-    object(...keyValues: [Name | string, SafeExpr | string][]): _Code;
-    if(condition: Code | boolean, thenBody?: Block, elseBody?: Block): CodeGen;
-    elseIf(condition: Code | boolean): CodeGen;
-    else(): CodeGen;
-    endIf(): CodeGen;
-    private _for;
-    for(iteration: Code, forBody?: Block): CodeGen;
-    forRange(nameOrPrefix: Name | string, from: SafeExpr, to: SafeExpr, forBody: (index: Name) => void, varKind?: Code): CodeGen;
-    forOf(nameOrPrefix: Name | string, iterable: Code, forBody: (item: Name) => void, varKind?: Code): CodeGen;
-    forIn(nameOrPrefix: Name | string, obj: Code, forBody: (item: Name) => void, varKind?: Code): CodeGen;
-    endFor(): CodeGen;
-    label(label: Name): CodeGen;
-    break(label?: Code): CodeGen;
-    return(value: Block | SafeExpr): CodeGen;
-    try(tryBody: Block, catchCode?: (e: Name) => void, finallyCode?: Block): CodeGen;
-    throw(error: Code): CodeGen;
-    block(body?: Block, nodeCount?: number): CodeGen;
-    endBlock(nodeCount?: number): CodeGen;
-    func(name: Name, args?: Code, async?: boolean, funcBody?: Block): CodeGen;
-    endFunc(): CodeGen;
-    optimize(n?: number): void;
-    private _leafNode;
-    private _blockNode;
-    private _endBlockNode;
-    private _elseNode;
-    private get _root();
-    private get _currNode();
-    private set _currNode(value);
-}
-export declare function not<T extends Code | SafeExpr>(x: T): T;
-export declare function and(...args: Code[]): Code;
-export declare function or(...args: Code[]): Code;

package/dist/compiled/ajv/types/compile/codegen/scope.d.ts

@@ -1,79 +0,0 @@
-import { Code, Name } from './code';
-interface NameGroup {
-    prefix: string;
-    index: number;
-}
-export interface NameValue {
-    ref: ValueReference;
-    key?: unknown;
-    code?: Code;
-}
-export declare type ValueReference = unknown;
-interface ScopeOptions {
-    prefixes?: Set<string>;
-    parent?: Scope;
-}
-interface ValueScopeOptions extends ScopeOptions {
-    scope: ScopeStore;
-    es5?: boolean;
-    lines?: boolean;
-}
-export declare type ScopeStore = Record<string, ValueReference[] | undefined>;
-declare type ScopeValues = {
-    [Prefix in string]?: Map<unknown, ValueScopeName>;
-};
-export declare type ScopeValueSets = {
-    [Prefix in string]?: Set<ValueScopeName>;
-};
-export declare enum UsedValueState {
-    Started = 0,
-    Completed = 1
-}
-export declare type UsedScopeValues = {
-    [Prefix in string]?: Map<ValueScopeName, UsedValueState | undefined>;
-};
-export declare const varKinds: {
-    const: Name;
-    let: Name;
-    var: Name;
-};
-export declare class Scope {
-    protected readonly _names: {
-        [Prefix in string]?: NameGroup;
-    };
-    protected readonly _prefixes?: Set<string>;
-    protected readonly _parent?: Scope;
-    constructor({ prefixes, parent }?: ScopeOptions);
-    toName(nameOrPrefix: Name | string): Name;
-    name(prefix: string): Name;
-    protected _newName(prefix: string): string;
-    private _nameGroup;
-}
-interface ScopePath {
-    property: string;
-    itemIndex: number;
-}
-export declare class ValueScopeName extends Name {
-    readonly prefix: string;
-    value?: NameValue;
-    scopePath?: Code;
-    constructor(prefix: string, nameStr: string);
-    setValue(value: NameValue, { property, itemIndex }: ScopePath): void;
-}
-interface VSOptions extends ValueScopeOptions {
-    _n: Code;
-}
-export declare class ValueScope extends Scope {
-    protected readonly _values: ScopeValues;
-    protected readonly _scope: ScopeStore;
-    readonly opts: VSOptions;
-    constructor(opts: ValueScopeOptions);
-    get(): ScopeStore;
-    name(prefix: string): ValueScopeName;
-    value(nameOrPrefix: ValueScopeName | string, value: NameValue): ValueScopeName;
-    getValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined;
-    scopeRefs(scopeName: Name, values?: ScopeValues | ScopeValueSets): Code;
-    scopeCode(values?: ScopeValues | ScopeValueSets, usedValues?: UsedScopeValues, getCode?: (n: ValueScopeName) => Code | undefined): Code;
-    private _reduceValues;
-}
-export {};

package/dist/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/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/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/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/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/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/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/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/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;
-}