.config/coc/extensions/node_modules/coc-prettier/node_modules/table/node_modules/ajv/dist/core.d.ts

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