1  export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, AnyValidateFunction, ErrorObject, ErrorNoParams, } from "./types";
  2  export { SchemaCxt, SchemaObjCxt } from "./compile";
  3  export interface Plugin<Opts> {
  4      (ajv: Ajv, options?: Opts): Ajv;
  5      [prop: string]: any;
  6  }
  7  export { KeywordCxt } from "./compile/validate";
  8  export { DefinedError } from "./vocabularies/errors";
  9  export { JSONType } from "./compile/rules";
 10  export { JSONSchemaType } from "./types/json-schema";
 11  export { JTDSchemaType, SomeJTDSchemaType, JTDDataType } from "./types/jtd-schema";
 12  export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "./compile/codegen";
 13  import type { Schema, AnySchema, AnySchemaObject, SchemaObject, AsyncSchema, Vocabulary, KeywordDefinition, AddedKeywordDefinition, AnyValidateFunction, ValidateFunction, AsyncValidateFunction, ErrorObject, Format, AddedFormat, RegExpEngine } from "./types";
 14  import type { JSONSchemaType } from "./types/json-schema";
 15  import type { JTDSchemaType, SomeJTDSchemaType, JTDDataType } from "./types/jtd-schema";
 16  import ValidationError from "./runtime/validation_error";
 17  import MissingRefError from "./compile/ref_error";
 18  import { ValidationRules } from "./compile/rules";
 19  import { SchemaEnv } from "./compile";
 20  import { Code, ValueScope } from "./compile/codegen";
 21  export declare type Options = CurrentOptions & DeprecatedOptions;
 22  export interface CurrentOptions {
 23      strict?: boolean | "log";
 24      strictSchema?: boolean | "log";
 25      strictNumbers?: boolean | "log";
 26      strictTypes?: boolean | "log";
 27      strictTuples?: boolean | "log";
 28      strictRequired?: boolean | "log";
 29      allowMatchingProperties?: boolean;
 30      allowUnionTypes?: boolean;
 31      validateFormats?: boolean;
 32      $data?: boolean;
 33      allErrors?: boolean;
 34      verbose?: boolean;
 35      discriminator?: boolean;
 36      unicodeRegExp?: boolean;
 37      timestamp?: "string" | "date";
 38      parseDate?: boolean;
 39      allowDate?: boolean;
 40      $comment?: true | ((comment: string, schemaPath?: string, rootSchema?: AnySchemaObject) => unknown);
 41      formats?: {
 42          [Name in string]?: Format;
 43      };
 44      keywords?: Vocabulary;
 45      schemas?: AnySchema[] | {
 46          [Key in string]?: AnySchema;
 47      };
 48      logger?: Logger | false;
 49      loadSchema?: (uri: string) => Promise<AnySchemaObject>;
 50      removeAdditional?: boolean | "all" | "failing";
 51      useDefaults?: boolean | "empty";
 52      coerceTypes?: boolean | "array";
 53      next?: boolean;
 54      unevaluated?: boolean;
 55      dynamicRef?: boolean;
 56      schemaId?: "id" | "$id";
 57      jtd?: boolean;
 58      meta?: SchemaObject | boolean;
 59      defaultMeta?: string | AnySchemaObject;
 60      validateSchema?: boolean | "log";
 61      addUsedSchema?: boolean;
 62      inlineRefs?: boolean | number;
 63      passContext?: boolean;
 64      loopRequired?: number;
 65      loopEnum?: number;
 66      ownProperties?: boolean;
 67      multipleOfPrecision?: number;
 68      int32range?: boolean;
 69      messages?: boolean;
 70      code?: CodeOptions;
 71  }
 72  export interface CodeOptions {
 73      es5?: boolean;
 74      lines?: boolean;
 75      optimize?: boolean | number;
 76      formats?: Code;
 77      source?: boolean;
 78      process?: (code: string, schema?: SchemaEnv) => string;
 79      regExp?: RegExpEngine;
 80  }
 81  interface InstanceCodeOptions extends CodeOptions {
 82      regExp: RegExpEngine;
 83      optimize: number;
 84  }
 85  interface DeprecatedOptions {
 86      /** @deprecated */
 87      ignoreKeywordsWithRef?: boolean;
 88      /** @deprecated */
 89      jsPropertySyntax?: boolean;
 90      /** @deprecated */
 91      unicode?: boolean;
 92  }
 93  declare type RequiredInstanceOptions = {
 94      [K in "strictSchema" | "strictNumbers" | "strictTypes" | "strictTuples" | "strictRequired" | "inlineRefs" | "loopRequired" | "loopEnum" | "meta" | "messages" | "schemaId" | "addUsedSchema" | "validateSchema" | "validateFormats" | "int32range" | "unicodeRegExp"]: NonNullable<Options[K]>;
 95  } & {
 96      code: InstanceCodeOptions;
 97  };
 98  export declare type InstanceOptions = Options & RequiredInstanceOptions;
 99  export interface Logger {
100      log(...args: unknown[]): unknown;
101      warn(...args: unknown[]): unknown;
102      error(...args: unknown[]): unknown;
103  }
104  export default class Ajv {
105      opts: InstanceOptions;
106      errors?: ErrorObject[] | null;
107      logger: Logger;
108      readonly scope: ValueScope;
109      readonly schemas: {
110          [Key in string]?: SchemaEnv;
111      };
112      readonly refs: {
113          [Ref in string]?: SchemaEnv | string;
114      };
115      readonly formats: {
116          [Name in string]?: AddedFormat;
117      };
118      readonly RULES: ValidationRules;
119      readonly _compilations: Set<SchemaEnv>;
120      private readonly _loading;
121      private readonly _cache;
122      private readonly _metaOpts;
123      static ValidationError: typeof ValidationError;
124      static MissingRefError: typeof MissingRefError;
125      constructor(opts?: Options);
126      _addVocabularies(): void;
127      _addDefaultMetaSchema(): void;
128      defaultMeta(): string | AnySchemaObject | undefined;
129      validate(schema: Schema | string, data: unknown): boolean;
130      validate(schemaKeyRef: AnySchema | string, data: unknown): boolean | Promise<unknown>;
131      validate<T>(schema: Schema | JSONSchemaType<T> | string, data: unknown): data is T;
132      validate<T>(schema: JTDSchemaType<T>, data: unknown): data is T;
133      validate<N extends never, T extends SomeJTDSchemaType>(schema: T, data: unknown): data is JTDDataType<T>;
134      validate<T>(schema: AsyncSchema, data: unknown | T): Promise<T>;
135      validate<T>(schemaKeyRef: AnySchema | string, data: unknown): data is T | Promise<T>;
136      compile<T = unknown>(schema: Schema | JSONSchemaType<T>, _meta?: boolean): ValidateFunction<T>;
137      compile<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): ValidateFunction<T>;
138      compile<N extends never, T extends SomeJTDSchemaType>(schema: T, _meta?: boolean): ValidateFunction<JTDDataType<T>>;
139      compile<T = unknown>(schema: AsyncSchema, _meta?: boolean): AsyncValidateFunction<T>;
140      compile<T = unknown>(schema: AnySchema, _meta?: boolean): AnyValidateFunction<T>;
141      compileAsync<T = unknown>(schema: SchemaObject | JSONSchemaType<T>, _meta?: boolean): Promise<ValidateFunction<T>>;
142      compileAsync<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): Promise<ValidateFunction<T>>;
143      compileAsync<T = unknown>(schema: AsyncSchema, meta?: boolean): Promise<AsyncValidateFunction<T>>;
144      compileAsync<T = unknown>(schema: AnySchemaObject, meta?: boolean): Promise<AnyValidateFunction<T>>;
145      addSchema(schema: AnySchema | AnySchema[], // If array is passed, `key` will be ignored
146      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`.
147      _meta?: boolean, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.
148      _validateSchema?: boolean | "log"): Ajv;
149      addMetaSchema(schema: AnySchemaObject, key?: string, // schema key
150      _validateSchema?: boolean | "log"): Ajv;
151      validateSchema(schema: AnySchema, throwOrLogError?: boolean): boolean | Promise<unknown>;
152      getSchema<T = unknown>(keyRef: string): AnyValidateFunction<T> | undefined;
153      removeSchema(schemaKeyRef?: AnySchema | string | RegExp): Ajv;
154      addVocabulary(definitions: Vocabulary): Ajv;
155      addKeyword(kwdOrDef: string | KeywordDefinition, def?: KeywordDefinition): Ajv;
156      getKeyword(keyword: string): AddedKeywordDefinition | boolean;
157      removeKeyword(keyword: string): Ajv;
158      addFormat(name: string, format: Format): Ajv;
159      errorsText(errors?: ErrorObject[] | null | undefined, // optional array of validation errors
160      { separator, dataVar }?: ErrorsTextOptions): string;
161      $dataMetaSchema(metaSchema: AnySchemaObject, keywordsJsonPointers: string[]): AnySchemaObject;
162      private _removeAllSchemas;
163      _addSchema(schema: AnySchema, meta?: boolean, baseId?: string, validateSchema?: boolean | "log", addSchema?: boolean): SchemaEnv;
164      private _checkUnique;
165      private _compileSchemaEnv;
166      private _compileMetaSchema;
167  }
168  export interface ErrorsTextOptions {
169      separator?: string;
170      dataVar?: string;
171  }