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 { (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 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; specialNumbers?: "fast" | "null"; $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; 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; } type RequiredInstanceOptions = { [K in "strictSchema" | "strictNumbers" | "strictTypes" | "strictTuples" | "strictRequired" | "inlineRefs" | "loopRequired" | "loopEnum" | "meta" | "messages" | "schemaId" | "addUsedSchema" | "validateSchema" | "validateFormats" | "int32range" | "unicodeRegExp" | "uriResolver"]: NonNullable; } & { code: InstanceCodeOptions; }; export 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; 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; validate(schema: Schema | JSONSchemaType | string, data: unknown): data is T; validate(schema: JTDSchemaType, data: unknown): data is T; validate(schema: T, data: unknown): data is JTDDataType; validate(schema: AsyncSchema, data: unknown | T): Promise; validate(schemaKeyRef: AnySchema | string, data: unknown): data is T | Promise; compile(schema: Schema | JSONSchemaType, _meta?: boolean): ValidateFunction; compile(schema: JTDSchemaType, _meta?: boolean): ValidateFunction; compile(schema: T, _meta?: boolean): ValidateFunction>; compile(schema: AsyncSchema, _meta?: boolean): AsyncValidateFunction; compile(schema: AnySchema, _meta?: boolean): AnyValidateFunction; compileAsync(schema: SchemaObject | JSONSchemaType, _meta?: boolean): Promise>; compileAsync(schema: JTDSchemaType, _meta?: boolean): Promise>; compileAsync(schema: AsyncSchema, meta?: boolean): Promise>; compileAsync(schema: AnySchemaObject, meta?: boolean): Promise>; 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; getSchema(keyRef: string): AnyValidateFunction | 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; }