ajv

  • Version 8.6.2
  • Published
  • 998 kB
  • 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 formats

                                                                                                                                                                                                    formats?: Code;

                                                                                                                                                                                                      property lines

                                                                                                                                                                                                      lines?: boolean;

                                                                                                                                                                                                        property optimize

                                                                                                                                                                                                        optimize?: boolean | number;

                                                                                                                                                                                                          property process

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

                                                                                                                                                                                                            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 (39)

                                                                                                                                                                                                                                                                                                                                                                                                                      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>