| 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 } 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; |
| } |
| 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"]: 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; |
| } |