ajv

  • Version 8.9.0
  • Published
  • 1.01 MB
  • 4 dependencies
  • MIT license

Install

npm i ajv
yarn add ajv
pnpm add ajv

Overview

Another JSON Schema Validator

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable nil

const nil: _Code;

    Functions

    function str

    str: (strs: TemplateStringsArray, ...args: (CodeArg | string[])[]) => _Code;

      function stringify

      stringify: (x: unknown) => Code;

        Classes

        class Ajv

        class Ajv extends AjvCore {}

          method defaultMeta

          defaultMeta: () => string | AnySchemaObject | undefined;

            class CodeGen

            class CodeGen {}

              constructor

              constructor(extScope: ValueScope, opts?: CodeGenOptions);

                method add

                add: (lhs: Code, rhs: SafeExpr) => CodeGen;

                  method assign

                  assign: (lhs: Code, rhs: SafeExpr, sideEffects?: boolean) => CodeGen;

                    method block

                    block: (body?: Block, nodeCount?: number) => CodeGen;

                      method break

                      break: (label?: Code) => CodeGen;

                        method code

                        code: (c: Block | SafeExpr) => CodeGen;

                          method const

                          const: (nameOrPrefix: Name | string, rhs: SafeExpr, _constant?: boolean) => Name;

                            method else

                            else: () => CodeGen;

                              method elseIf

                              elseIf: (condition: Code | boolean) => CodeGen;

                                method endBlock

                                endBlock: (nodeCount?: number) => CodeGen;

                                  method endFor

                                  endFor: () => CodeGen;

                                    method endFunc

                                    endFunc: () => CodeGen;

                                      method endIf

                                      endIf: () => CodeGen;

                                        method for

                                        for: (iteration: Code, forBody?: Block) => CodeGen;

                                          method forIn

                                          forIn: (
                                          nameOrPrefix: Name | string,
                                          obj: Code,
                                          forBody: (item: Name) => void,
                                          varKind?: Code
                                          ) => CodeGen;

                                            method forOf

                                            forOf: (
                                            nameOrPrefix: Name | string,
                                            iterable: Code,
                                            forBody: (item: Name) => void,
                                            varKind?: Code
                                            ) => CodeGen;

                                              method forRange

                                              forRange: (
                                              nameOrPrefix: Name | string,
                                              from: SafeExpr,
                                              to: SafeExpr,
                                              forBody: (index: Name) => void,
                                              varKind?: Code
                                              ) => CodeGen;

                                                method func

                                                func: (name: Name, args?: Code, async?: boolean, funcBody?: Block) => CodeGen;

                                                  method getScopeValue

                                                  getScopeValue: (prefix: string, keyOrRef: unknown) => ValueScopeName | undefined;

                                                    method if

                                                    if: (condition: Code | boolean, thenBody?: Block, elseBody?: Block) => CodeGen;

                                                      method label

                                                      label: (label: Name) => CodeGen;

                                                        method let

                                                        let: (nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean) => Name;

                                                          method name

                                                          name: (prefix: string) => Name;

                                                            method object

                                                            object: (...keyValues: [Name | string, SafeExpr | string][]) => _Code;

                                                              method optimize

                                                              optimize: (n?: number) => void;

                                                                method return

                                                                return: (value: Block | SafeExpr) => CodeGen;

                                                                  method scopeCode

                                                                  scopeCode: () => Code;

                                                                    method scopeName

                                                                    scopeName: (prefix: string) => ValueScopeName;

                                                                      method scopeRefs

                                                                      scopeRefs: (scopeName: Name) => Code;

                                                                        method scopeValue

                                                                        scopeValue: (prefixOrName: ValueScopeName | string, value: NameValue) => Name;

                                                                          method throw

                                                                          throw: (error: Code) => CodeGen;

                                                                            method toString

                                                                            toString: () => string;

                                                                              method try

                                                                              try: (
                                                                              tryBody: Block,
                                                                              catchCode?: (e: Name) => void,
                                                                              finallyCode?: Block
                                                                              ) => CodeGen;

                                                                                method var

                                                                                var: (nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean) => Name;

                                                                                  class KeywordCxt

                                                                                  class KeywordCxt implements KeywordErrorCxt {}

                                                                                    constructor

                                                                                    constructor(it: SchemaObjCxt, def: AddedKeywordDefinition, keyword: string);

                                                                                      property $data

                                                                                      readonly $data?: string | false;

                                                                                        property allErrors

                                                                                        readonly allErrors?: boolean;

                                                                                          property data

                                                                                          readonly data: Name;

                                                                                            property def

                                                                                            readonly def: AddedKeywordDefinition;

                                                                                              property errsCount

                                                                                              readonly errsCount?: Name;

                                                                                                property gen

                                                                                                readonly gen: CodeGen;

                                                                                                  property it

                                                                                                  readonly it: SchemaObjCxt;

                                                                                                    property keyword

                                                                                                    readonly keyword: string;

                                                                                                      property params

                                                                                                      params: KeywordCxtParams;

                                                                                                        property parentSchema

                                                                                                        readonly parentSchema: AnySchemaObject;

                                                                                                          property schema

                                                                                                          schema: any;

                                                                                                            property schemaCode

                                                                                                            readonly schemaCode: number | boolean | Code;

                                                                                                              property schemaType

                                                                                                              readonly schemaType: (
                                                                                                              | 'string'
                                                                                                              | 'number'
                                                                                                              | 'boolean'
                                                                                                              | 'object'
                                                                                                              | 'integer'
                                                                                                              | 'null'
                                                                                                              | 'array'
                                                                                                              )[];

                                                                                                                property schemaValue

                                                                                                                readonly schemaValue: number | boolean | Code;

                                                                                                                  method $dataError

                                                                                                                  $dataError: () => void;

                                                                                                                    method block$data

                                                                                                                    block$data: (valid: Name, codeBlock: () => void, $dataValid?: Code) => void;

                                                                                                                      method check$data

                                                                                                                      check$data: (valid?: Name, $dataValid?: Code) => void;

                                                                                                                        method error

                                                                                                                        error: (
                                                                                                                        append?: boolean,
                                                                                                                        errorParams?: KeywordCxtParams,
                                                                                                                        errorPaths?: ErrorPaths
                                                                                                                        ) => void;

                                                                                                                          method fail

                                                                                                                          fail: (condition?: Code) => void;

                                                                                                                            method fail$data

                                                                                                                            fail$data: (condition: Code) => void;

                                                                                                                              method failResult

                                                                                                                              failResult: (
                                                                                                                              condition: Code,
                                                                                                                              successAction?: () => void,
                                                                                                                              failAction?: () => void
                                                                                                                              ) => void;

                                                                                                                                method invalid$data

                                                                                                                                invalid$data: () => Code;

                                                                                                                                  method mergeEvaluated

                                                                                                                                  mergeEvaluated: (schemaCxt: SchemaCxt, toName?: typeof Name) => void;

                                                                                                                                    method mergeValidEvaluated

                                                                                                                                    mergeValidEvaluated: (schemaCxt: SchemaCxt, valid: Name) => boolean | void;

                                                                                                                                      method ok

                                                                                                                                      ok: (cond: Code | boolean) => void;

                                                                                                                                        method pass

                                                                                                                                        pass: (condition: Code, failAction?: () => void) => void;

                                                                                                                                          method reset

                                                                                                                                          reset: () => void;

                                                                                                                                            method result

                                                                                                                                            result: (
                                                                                                                                            condition: Code,
                                                                                                                                            successAction?: () => void,
                                                                                                                                            failAction?: () => void
                                                                                                                                            ) => void;

                                                                                                                                              method setParams

                                                                                                                                              setParams: (obj: KeywordCxtParams, assign?: true) => void;

                                                                                                                                                method subschema

                                                                                                                                                subschema: (appl: SubschemaArgs, valid: Name) => SchemaCxt;

                                                                                                                                                  class Name

                                                                                                                                                  class Name extends _CodeOrName {}

                                                                                                                                                    constructor

                                                                                                                                                    constructor(s: string);

                                                                                                                                                      property names

                                                                                                                                                      readonly names: UsedNames;

                                                                                                                                                        property str

                                                                                                                                                        readonly str: string;

                                                                                                                                                          method emptyStr

                                                                                                                                                          emptyStr: () => boolean;

                                                                                                                                                            method toString

                                                                                                                                                            toString: () => string;

                                                                                                                                                              Interfaces

                                                                                                                                                              interface AsyncFormatDefinition

                                                                                                                                                              interface AsyncFormatDefinition<T extends string | number> {}

                                                                                                                                                                property async

                                                                                                                                                                async: true;

                                                                                                                                                                  property compare

                                                                                                                                                                  compare?: FormatCompare<T>;

                                                                                                                                                                    property type

                                                                                                                                                                    type?: T extends string ? 'string' | undefined : 'number';

                                                                                                                                                                      property validate

                                                                                                                                                                      validate: AsyncFormatValidator<T>;

                                                                                                                                                                        interface AsyncSchema

                                                                                                                                                                        interface AsyncSchema extends _SchemaObject {}

                                                                                                                                                                          property $async

                                                                                                                                                                          $async: true;

                                                                                                                                                                            interface AsyncValidateFunction

                                                                                                                                                                            interface AsyncValidateFunction<T = unknown> extends ValidateFunction<T> {}

                                                                                                                                                                              property $async

                                                                                                                                                                              $async: true;

                                                                                                                                                                                call signature

                                                                                                                                                                                (...args: Parameters<ValidateFunction<T>>): Promise<T>;

                                                                                                                                                                                  interface CodeGenOptions

                                                                                                                                                                                  interface CodeGenOptions {}

                                                                                                                                                                                    property es5

                                                                                                                                                                                    es5?: boolean;

                                                                                                                                                                                      property lines

                                                                                                                                                                                      lines?: boolean;

                                                                                                                                                                                        property ownProperties

                                                                                                                                                                                        ownProperties?: boolean;

                                                                                                                                                                                          interface CodeKeywordDefinition

                                                                                                                                                                                          interface CodeKeywordDefinition extends _KeywordDef {}

                                                                                                                                                                                            property code

                                                                                                                                                                                            code: (cxt: KeywordCxt, ruleType?: string) => void;

                                                                                                                                                                                              property trackErrors

                                                                                                                                                                                              trackErrors?: boolean;

                                                                                                                                                                                                interface CodeOptions

                                                                                                                                                                                                interface CodeOptions {}

                                                                                                                                                                                                  property es5

                                                                                                                                                                                                  es5?: boolean;

                                                                                                                                                                                                    property esm

                                                                                                                                                                                                    esm?: boolean;

                                                                                                                                                                                                      property formats

                                                                                                                                                                                                      formats?: Code;

                                                                                                                                                                                                        property lines

                                                                                                                                                                                                        lines?: boolean;

                                                                                                                                                                                                          property optimize

                                                                                                                                                                                                          optimize?: boolean | number;

                                                                                                                                                                                                            property process

                                                                                                                                                                                                            process?: (code: string, schema?: SchemaEnv) => string;

                                                                                                                                                                                                              property regExp

                                                                                                                                                                                                              regExp?: RegExpEngine;

                                                                                                                                                                                                                property source

                                                                                                                                                                                                                source?: boolean;

                                                                                                                                                                                                                  interface ErrorObject

                                                                                                                                                                                                                  interface ErrorObject<
                                                                                                                                                                                                                  K extends string = string,
                                                                                                                                                                                                                  P = Record<string, any>,
                                                                                                                                                                                                                  S = unknown
                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                    data?: unknown;

                                                                                                                                                                                                                      property instancePath

                                                                                                                                                                                                                      instancePath: string;

                                                                                                                                                                                                                        property keyword

                                                                                                                                                                                                                        keyword: K;

                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                          message?: string;

                                                                                                                                                                                                                            property params

                                                                                                                                                                                                                            params: P;

                                                                                                                                                                                                                              property parentSchema

                                                                                                                                                                                                                              parentSchema?: AnySchemaObject;

                                                                                                                                                                                                                                property propertyName

                                                                                                                                                                                                                                propertyName?: string;

                                                                                                                                                                                                                                  property schema

                                                                                                                                                                                                                                  schema?: S;

                                                                                                                                                                                                                                    property schemaPath

                                                                                                                                                                                                                                    schemaPath: string;

                                                                                                                                                                                                                                      interface ErrorsTextOptions

                                                                                                                                                                                                                                      interface ErrorsTextOptions {}

                                                                                                                                                                                                                                        property dataVar

                                                                                                                                                                                                                                        dataVar?: string;

                                                                                                                                                                                                                                          property separator

                                                                                                                                                                                                                                          separator?: string;

                                                                                                                                                                                                                                            interface FormatDefinition

                                                                                                                                                                                                                                            interface FormatDefinition<T extends string | number> {}

                                                                                                                                                                                                                                              property async

                                                                                                                                                                                                                                              async?: false | undefined;

                                                                                                                                                                                                                                                property compare

                                                                                                                                                                                                                                                compare?: FormatCompare<T>;

                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                  type?: T extends string ? 'string' | undefined : 'number';

                                                                                                                                                                                                                                                    property validate

                                                                                                                                                                                                                                                    validate: FormatValidator<T> | (T extends string ? string | RegExp : never);

                                                                                                                                                                                                                                                      interface FuncKeywordDefinition

                                                                                                                                                                                                                                                      interface FuncKeywordDefinition extends _KeywordDef {}

                                                                                                                                                                                                                                                        property async

                                                                                                                                                                                                                                                        async?: boolean;

                                                                                                                                                                                                                                                          property compile

                                                                                                                                                                                                                                                          compile?: CompileKeywordFunc;

                                                                                                                                                                                                                                                            property errors

                                                                                                                                                                                                                                                            errors?: boolean | 'full';

                                                                                                                                                                                                                                                              property modifying

                                                                                                                                                                                                                                                              modifying?: boolean;

                                                                                                                                                                                                                                                                property schema

                                                                                                                                                                                                                                                                schema?: boolean;

                                                                                                                                                                                                                                                                  property valid

                                                                                                                                                                                                                                                                  valid?: boolean;

                                                                                                                                                                                                                                                                    property validate

                                                                                                                                                                                                                                                                    validate?: SchemaValidateFunction | DataValidateFunction;

                                                                                                                                                                                                                                                                      interface KeywordErrorDefinition

                                                                                                                                                                                                                                                                      interface KeywordErrorDefinition {}

                                                                                                                                                                                                                                                                        property message

                                                                                                                                                                                                                                                                        message: string | Code | ((cxt: KeywordErrorCxt) => string | Code);

                                                                                                                                                                                                                                                                          property params

                                                                                                                                                                                                                                                                          params?: Code | ((cxt: KeywordErrorCxt) => Code);

                                                                                                                                                                                                                                                                            interface Logger

                                                                                                                                                                                                                                                                            interface Logger {}

                                                                                                                                                                                                                                                                              method error

                                                                                                                                                                                                                                                                              error: (...args: unknown[]) => unknown;

                                                                                                                                                                                                                                                                                method log

                                                                                                                                                                                                                                                                                log: (...args: unknown[]) => unknown;

                                                                                                                                                                                                                                                                                  method warn

                                                                                                                                                                                                                                                                                  warn: (...args: unknown[]) => unknown;

                                                                                                                                                                                                                                                                                    interface MacroKeywordDefinition

                                                                                                                                                                                                                                                                                    interface MacroKeywordDefinition extends FuncKeywordDefinition {}

                                                                                                                                                                                                                                                                                      property macro

                                                                                                                                                                                                                                                                                      macro: MacroKeywordFunc;

                                                                                                                                                                                                                                                                                        interface Plugin

                                                                                                                                                                                                                                                                                        interface Plugin<Opts> {}

                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                          (ajv: Ajv, options?: Opts): Ajv;

                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                            [prop: string]: any;

                                                                                                                                                                                                                                                                                              interface SchemaCxt

                                                                                                                                                                                                                                                                                              interface SchemaCxt {}

                                                                                                                                                                                                                                                                                                property allErrors

                                                                                                                                                                                                                                                                                                readonly allErrors?: boolean;

                                                                                                                                                                                                                                                                                                  property baseId

                                                                                                                                                                                                                                                                                                  baseId: string;

                                                                                                                                                                                                                                                                                                    property compositeRule

                                                                                                                                                                                                                                                                                                    readonly compositeRule?: boolean;

                                                                                                                                                                                                                                                                                                      property createErrors

                                                                                                                                                                                                                                                                                                      readonly createErrors?: boolean;

                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                        readonly data: Name;

                                                                                                                                                                                                                                                                                                          property dataLevel

                                                                                                                                                                                                                                                                                                          readonly dataLevel: number;

                                                                                                                                                                                                                                                                                                            property dataNames

                                                                                                                                                                                                                                                                                                            readonly dataNames: Name[];

                                                                                                                                                                                                                                                                                                              property dataPathArr

                                                                                                                                                                                                                                                                                                              readonly dataPathArr: (Code | number)[];

                                                                                                                                                                                                                                                                                                                property dataTypes

                                                                                                                                                                                                                                                                                                                dataTypes: JSONType[];

                                                                                                                                                                                                                                                                                                                  property definedProperties

                                                                                                                                                                                                                                                                                                                  definedProperties: Set<string>;

                                                                                                                                                                                                                                                                                                                    property errorPath

                                                                                                                                                                                                                                                                                                                    readonly errorPath: Code;

                                                                                                                                                                                                                                                                                                                      property errSchemaPath

                                                                                                                                                                                                                                                                                                                      readonly errSchemaPath: string;

                                                                                                                                                                                                                                                                                                                        property evaluated

                                                                                                                                                                                                                                                                                                                        evaluated?: Name;

                                                                                                                                                                                                                                                                                                                          property gen

                                                                                                                                                                                                                                                                                                                          readonly gen: CodeGen;

                                                                                                                                                                                                                                                                                                                            property items

                                                                                                                                                                                                                                                                                                                            items?: EvaluatedItems | Name;

                                                                                                                                                                                                                                                                                                                              property jtdDiscriminator

                                                                                                                                                                                                                                                                                                                              jtdDiscriminator?: string;

                                                                                                                                                                                                                                                                                                                                property jtdMetadata

                                                                                                                                                                                                                                                                                                                                jtdMetadata?: boolean;

                                                                                                                                                                                                                                                                                                                                  property opts

                                                                                                                                                                                                                                                                                                                                  readonly opts: InstanceOptions;

                                                                                                                                                                                                                                                                                                                                    property parentData

                                                                                                                                                                                                                                                                                                                                    readonly parentData: Name;

                                                                                                                                                                                                                                                                                                                                      property parentDataProperty

                                                                                                                                                                                                                                                                                                                                      readonly parentDataProperty: Code | number;

                                                                                                                                                                                                                                                                                                                                        property propertyName

                                                                                                                                                                                                                                                                                                                                        readonly propertyName?: Name;

                                                                                                                                                                                                                                                                                                                                          property props

                                                                                                                                                                                                                                                                                                                                          props?: EvaluatedProperties | Name;

                                                                                                                                                                                                                                                                                                                                            property rootId

                                                                                                                                                                                                                                                                                                                                            readonly rootId: string;

                                                                                                                                                                                                                                                                                                                                              property schema

                                                                                                                                                                                                                                                                                                                                              readonly schema: AnySchema;

                                                                                                                                                                                                                                                                                                                                                property schemaEnv

                                                                                                                                                                                                                                                                                                                                                readonly schemaEnv: SchemaEnv;

                                                                                                                                                                                                                                                                                                                                                  property schemaPath

                                                                                                                                                                                                                                                                                                                                                  readonly schemaPath: Code;

                                                                                                                                                                                                                                                                                                                                                    property self

                                                                                                                                                                                                                                                                                                                                                    readonly self: Ajv;

                                                                                                                                                                                                                                                                                                                                                      property topSchemaRef

                                                                                                                                                                                                                                                                                                                                                      readonly topSchemaRef: Code;

                                                                                                                                                                                                                                                                                                                                                        property validateName

                                                                                                                                                                                                                                                                                                                                                        readonly validateName: Name;

                                                                                                                                                                                                                                                                                                                                                          property ValidationError

                                                                                                                                                                                                                                                                                                                                                          readonly ValidationError?: Name;

                                                                                                                                                                                                                                                                                                                                                            interface SchemaObjCxt

                                                                                                                                                                                                                                                                                                                                                            interface SchemaObjCxt extends SchemaCxt {}

                                                                                                                                                                                                                                                                                                                                                              property schema

                                                                                                                                                                                                                                                                                                                                                              readonly schema: AnySchemaObject;

                                                                                                                                                                                                                                                                                                                                                                interface SchemaObject

                                                                                                                                                                                                                                                                                                                                                                interface SchemaObject extends _SchemaObject {}

                                                                                                                                                                                                                                                                                                                                                                  property $async

                                                                                                                                                                                                                                                                                                                                                                  $async?: false;

                                                                                                                                                                                                                                                                                                                                                                    property $id

                                                                                                                                                                                                                                                                                                                                                                    $id?: string;

                                                                                                                                                                                                                                                                                                                                                                      property $schema

                                                                                                                                                                                                                                                                                                                                                                      $schema?: string;

                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                        id?: string;

                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                          [x: string]: any;

                                                                                                                                                                                                                                                                                                                                                                            interface SchemaValidateFunction

                                                                                                                                                                                                                                                                                                                                                                            interface SchemaValidateFunction {}

                                                                                                                                                                                                                                                                                                                                                                              property errors

                                                                                                                                                                                                                                                                                                                                                                              errors?: Partial<ErrorObject>[];

                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                schema: any,
                                                                                                                                                                                                                                                                                                                                                                                data: any,
                                                                                                                                                                                                                                                                                                                                                                                parentSchema?: AnySchemaObject,
                                                                                                                                                                                                                                                                                                                                                                                dataCxt?: DataValidationCxt
                                                                                                                                                                                                                                                                                                                                                                                ): boolean | Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                  interface ValidateFunction

                                                                                                                                                                                                                                                                                                                                                                                  interface ValidateFunction<T = unknown> {}

                                                                                                                                                                                                                                                                                                                                                                                    property errors

                                                                                                                                                                                                                                                                                                                                                                                    errors?: null | ErrorObject[];

                                                                                                                                                                                                                                                                                                                                                                                      property evaluated

                                                                                                                                                                                                                                                                                                                                                                                      evaluated?: Evaluated;

                                                                                                                                                                                                                                                                                                                                                                                        property schema

                                                                                                                                                                                                                                                                                                                                                                                        schema: AnySchema;

                                                                                                                                                                                                                                                                                                                                                                                          property schemaEnv

                                                                                                                                                                                                                                                                                                                                                                                          schemaEnv: SchemaEnv;

                                                                                                                                                                                                                                                                                                                                                                                            property source

                                                                                                                                                                                                                                                                                                                                                                                            source?: SourceCode;

                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                              (this: Ajv | any, data: any, dataCxt?: DataValidationCxt): data is T;

                                                                                                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                type AnySchema

                                                                                                                                                                                                                                                                                                                                                                                                type AnySchema = Schema | AsyncSchema;

                                                                                                                                                                                                                                                                                                                                                                                                  type AnySchemaObject

                                                                                                                                                                                                                                                                                                                                                                                                  type AnySchemaObject = SchemaObject | AsyncSchema;

                                                                                                                                                                                                                                                                                                                                                                                                    type Code

                                                                                                                                                                                                                                                                                                                                                                                                    type Code = _Code | Name;

                                                                                                                                                                                                                                                                                                                                                                                                      type DefinedError

                                                                                                                                                                                                                                                                                                                                                                                                      type DefinedError =
                                                                                                                                                                                                                                                                                                                                                                                                      | TypeError
                                                                                                                                                                                                                                                                                                                                                                                                      | ApplicatorKeywordError
                                                                                                                                                                                                                                                                                                                                                                                                      | ValidationKeywordError
                                                                                                                                                                                                                                                                                                                                                                                                      | FormatError
                                                                                                                                                                                                                                                                                                                                                                                                      | UnevaluatedPropertiesError
                                                                                                                                                                                                                                                                                                                                                                                                      | UnevaluatedItemsError
                                                                                                                                                                                                                                                                                                                                                                                                      | DependentRequiredError
                                                                                                                                                                                                                                                                                                                                                                                                      | DiscriminatorError;

                                                                                                                                                                                                                                                                                                                                                                                                        type ErrorNoParams

                                                                                                                                                                                                                                                                                                                                                                                                        type ErrorNoParams<K extends string, S = unknown> = ErrorObject<
                                                                                                                                                                                                                                                                                                                                                                                                        K,
                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, never>,
                                                                                                                                                                                                                                                                                                                                                                                                        S
                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                          type Format

                                                                                                                                                                                                                                                                                                                                                                                                          type Format = AddedFormat | string;

                                                                                                                                                                                                                                                                                                                                                                                                            type InstanceOptions

                                                                                                                                                                                                                                                                                                                                                                                                            type InstanceOptions = Options & RequiredInstanceOptions;

                                                                                                                                                                                                                                                                                                                                                                                                              type JSONSchemaType

                                                                                                                                                                                                                                                                                                                                                                                                              type JSONSchemaType<T> = StrictNullChecksWrapper<
                                                                                                                                                                                                                                                                                                                                                                                                              'JSONSchemaType',
                                                                                                                                                                                                                                                                                                                                                                                                              UncheckedJSONSchemaType<T, false>
                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                type JSONType

                                                                                                                                                                                                                                                                                                                                                                                                                type JSONType = typeof _jsonTypes[number];

                                                                                                                                                                                                                                                                                                                                                                                                                  type KeywordDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                  type KeywordDefinition =
                                                                                                                                                                                                                                                                                                                                                                                                                  | CodeKeywordDefinition
                                                                                                                                                                                                                                                                                                                                                                                                                  | FuncKeywordDefinition
                                                                                                                                                                                                                                                                                                                                                                                                                  | MacroKeywordDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                    type Options

                                                                                                                                                                                                                                                                                                                                                                                                                    type Options = CurrentOptions & DeprecatedOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                      type Schema

                                                                                                                                                                                                                                                                                                                                                                                                                      type Schema = SchemaObject | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        type Vocabulary

                                                                                                                                                                                                                                                                                                                                                                                                                        type Vocabulary = (KeywordDefinition | string)[];

                                                                                                                                                                                                                                                                                                                                                                                                                          Package Files (10)

                                                                                                                                                                                                                                                                                                                                                                                                                          Dependencies (4)

                                                                                                                                                                                                                                                                                                                                                                                                                          Dev Dependencies (40)

                                                                                                                                                                                                                                                                                                                                                                                                                          Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                          No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                          Badge

                                                                                                                                                                                                                                                                                                                                                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ajv.

                                                                                                                                                                                                                                                                                                                                                                                                                          • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ajv)
                                                                                                                                                                                                                                                                                                                                                                                                                          • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                            <a href="https://www.jsdocs.io/package/ajv"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>