basant307/AI_Governance_Project

1declare var ajv: {2  (options?: ajv.Options): ajv.Ajv;3  new(options?: ajv.Options): ajv.Ajv;4  ValidationError: typeof AjvErrors.ValidationError;5  MissingRefError: typeof AjvErrors.MissingRefError;6  $dataMetaSchema: object;7}8 9declare namespace AjvErrors {10  class ValidationError extends Error {11    constructor(errors: Array<ajv.ErrorObject>);12 13    message: string;14    errors: Array<ajv.ErrorObject>;15    ajv: true;16    validation: true;17  }18 19  class MissingRefError extends Error {20    constructor(baseId: string, ref: string, message?: string);21    static message: (baseId: string, ref: string) => string;22 23    message: string;24    missingRef: string;25    missingSchema: string;26  }27}28 29declare namespace ajv {30  type ValidationError = AjvErrors.ValidationError;31 32  type MissingRefError = AjvErrors.MissingRefError;33 34  interface Ajv {35    /**36    * Validate data using schema37    * Schema will be compiled and cached (using serialized JSON as key, [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) is used to serialize by default).38    * @param  {string|object|Boolean} schemaKeyRef key, ref or schema object39    * @param  {Any} data to be validated40    * @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`).41    */42    validate(schemaKeyRef: object | string | boolean, data: any): boolean | PromiseLike<any>;43    /**44    * Create validating function for passed schema.45    * @param  {object|Boolean} schema schema object46    * @return {Function} validating function47    */48    compile(schema: object | boolean): ValidateFunction;49    /**50    * Creates validating function for passed schema with asynchronous loading of missing schemas.51    * `loadSchema` option should be a function that accepts schema uri and node-style callback.52    * @this  Ajv53    * @param {object|Boolean} schema schema object54    * @param {Boolean} meta optional true to compile meta-schema; this parameter can be skipped55    * @param {Function} callback optional node-style callback, it is always called with 2 parameters: error (or null) and validating function.56    * @return {PromiseLike<ValidateFunction>} validating function57    */58    compileAsync(schema: object | boolean, meta?: Boolean, callback?: (err: Error, validate: ValidateFunction) => any): PromiseLike<ValidateFunction>;59    /**60    * Adds schema to the instance.61    * @param {object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored.62    * @param {string} key 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`.63    * @return {Ajv} this for method chaining64    */65    addSchema(schema: Array<object> | object, key?: string): Ajv;66    /**67    * Add schema that will be used to validate other schemas68    * options in META_IGNORE_OPTIONS are alway set to false69    * @param {object} schema schema object70    * @param {string} key optional schema key71    * @return {Ajv} this for method chaining72    */73    addMetaSchema(schema: object, key?: string): Ajv;74    /**75    * Validate schema76    * @param {object|Boolean} schema schema to validate77    * @return {Boolean} true if schema is valid78    */79    validateSchema(schema: object | boolean): boolean;80    /**81    * Get compiled schema from the instance by `key` or `ref`.82    * @param  {string} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id).83    * @return {Function} schema validating function (with property `schema`). Returns undefined if keyRef can't be resolved to an existing schema.84    */85    getSchema(keyRef: string): ValidateFunction | undefined;86    /**87    * Remove cached schema(s).88    * If no parameter is passed all schemas but meta-schemas are removed.89    * If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.90    * Even if schema is referenced by other schemas it still can be removed as other schemas have local references.91    * @param  {string|object|RegExp|Boolean} schemaKeyRef key, ref, pattern to match key/ref or schema object92    * @return {Ajv} this for method chaining93    */94    removeSchema(schemaKeyRef?: object | string | RegExp | boolean): Ajv;95    /**96    * Add custom format97    * @param {string} name format name98    * @param {string|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid)99    * @return {Ajv} this for method chaining100    */101    addFormat(name: string, format: FormatValidator | FormatDefinition): Ajv;102    /**103    * Define custom keyword104    * @this  Ajv105    * @param {string} keyword custom keyword, should be a valid identifier, should be different from all standard, custom and macro keywords.106    * @param {object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`.107    * @return {Ajv} this for method chaining108    */109    addKeyword(keyword: string, definition: KeywordDefinition): Ajv;110    /**111    * Get keyword definition112    * @this  Ajv113    * @param {string} keyword pre-defined or custom keyword.114    * @return {object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise.115    */116    getKeyword(keyword: string): object | boolean;117    /**118    * Remove keyword119    * @this  Ajv120    * @param {string} keyword pre-defined or custom keyword.121    * @return {Ajv} this for method chaining122    */123    removeKeyword(keyword: string): Ajv;124    /**125    * Validate keyword126    * @this  Ajv127    * @param {object} definition keyword definition object128    * @param {boolean} throwError true to throw exception if definition is invalid129    * @return {boolean} validation result130    */131    validateKeyword(definition: KeywordDefinition, throwError: boolean): boolean;132    /**133    * Convert array of error message objects to string134    * @param  {Array<object>} errors optional array of validation errors, if not passed errors from the instance are used.135    * @param  {object} options optional options with properties `separator` and `dataVar`.136    * @return {string} human readable string with all errors descriptions137    */138    errorsText(errors?: Array<ErrorObject> | null, options?: ErrorsTextOptions): string;139    errors?: Array<ErrorObject> | null;140    _opts: Options;141  }142 143  interface CustomLogger {144    log(...args: any[]): any;145    warn(...args: any[]): any;146    error(...args: any[]): any;147  }148 149  interface ValidateFunction {150    (151      data: any,152      dataPath?: string,153      parentData?: object | Array<any>,154      parentDataProperty?: string | number,155      rootData?: object | Array<any>156    ): boolean | PromiseLike<any>;157    schema?: object | boolean;158    errors?: null | Array<ErrorObject>;159    refs?: object;160    refVal?: Array<any>;161    root?: ValidateFunction | object;162    $async?: true;163    source?: object;164  }165 166  interface Options {167    $data?: boolean;168    allErrors?: boolean;169    verbose?: boolean;170    jsonPointers?: boolean;171    uniqueItems?: boolean;172    unicode?: boolean;173    format?: false | string;174    formats?: object;175    keywords?: object;176    unknownFormats?: true | string[] | 'ignore';177    schemas?: Array<object> | object;178    schemaId?: '$id' | 'id' | 'auto';179    missingRefs?: true | 'ignore' | 'fail';180    extendRefs?: true | 'ignore' | 'fail';181    loadSchema?: (uri: string, cb?: (err: Error, schema: object) => void) => PromiseLike<object | boolean>;182    removeAdditional?: boolean | 'all' | 'failing';183    useDefaults?: boolean | 'empty' | 'shared';184    coerceTypes?: boolean | 'array';185    strictDefaults?: boolean | 'log';186    strictKeywords?: boolean | 'log';187    strictNumbers?: boolean;188    async?: boolean | string;189    transpile?: string | ((code: string) => string);190    meta?: boolean | object;191    validateSchema?: boolean | 'log';192    addUsedSchema?: boolean;193    inlineRefs?: boolean | number;194    passContext?: boolean;195    loopRequired?: number;196    ownProperties?: boolean;197    multipleOfPrecision?: boolean | number;198    errorDataPath?: string,199    messages?: boolean;200    sourceCode?: boolean;201    processCode?: (code: string, schema: object) => string;202    cache?: object;203    logger?: CustomLogger | false;204    nullable?: boolean;205    serialize?: ((schema: object | boolean) => any) | false;206  }207 208  type FormatValidator = string | RegExp | ((data: string) => boolean | PromiseLike<any>);209  type NumberFormatValidator = ((data: number) => boolean | PromiseLike<any>);210 211  interface NumberFormatDefinition {212    type: "number",213    validate: NumberFormatValidator;214    compare?: (data1: number, data2: number) => number;215    async?: boolean;216  }217 218  interface StringFormatDefinition {219    type?: "string",220    validate: FormatValidator;221    compare?: (data1: string, data2: string) => number;222    async?: boolean;223  }224 225  type FormatDefinition = NumberFormatDefinition | StringFormatDefinition;226 227  interface KeywordDefinition {228    type?: string | Array<string>;229    async?: boolean;230    $data?: boolean;231    errors?: boolean | string;232    metaSchema?: object;233    // schema: false makes validate not to expect schema (ValidateFunction)234    schema?: boolean;235    statements?: boolean;236    dependencies?: Array<string>;237    modifying?: boolean;238    valid?: boolean;239    // one and only one of the following properties should be present240    validate?: SchemaValidateFunction | ValidateFunction;241    compile?: (schema: any, parentSchema: object, it: CompilationContext) => ValidateFunction;242    macro?: (schema: any, parentSchema: object, it: CompilationContext) => object | boolean;243    inline?: (it: CompilationContext, keyword: string, schema: any, parentSchema: object) => string;244  }245 246  interface CompilationContext {247    level: number;248    dataLevel: number;249    dataPathArr: string[];250    schema: any;251    schemaPath: string;252    baseId: string;253    async: boolean;254    opts: Options;255    formats: {256      [index: string]: FormatDefinition | undefined;257    };258    keywords: {259      [index: string]: KeywordDefinition | undefined;260    };261    compositeRule: boolean;262    validate: (schema: object) => boolean;263    util: {264      copy(obj: any, target?: any): any;265      toHash(source: string[]): { [index: string]: true | undefined };266      equal(obj: any, target: any): boolean;267      getProperty(str: string): string;268      schemaHasRules(schema: object, rules: any): string;269      escapeQuotes(str: string): string;270      toQuotedString(str: string): string;271      getData(jsonPointer: string, dataLevel: number, paths: string[]): string;272      escapeJsonPointer(str: string): string;273      unescapeJsonPointer(str: string): string;274      escapeFragment(str: string): string;275      unescapeFragment(str: string): string;276    };277    self: Ajv;278  }279 280  interface SchemaValidateFunction {281    (282      schema: any,283      data: any,284      parentSchema?: object,285      dataPath?: string,286      parentData?: object | Array<any>,287      parentDataProperty?: string | number,288      rootData?: object | Array<any>289    ): boolean | PromiseLike<any>;290    errors?: Array<ErrorObject>;291  }292 293  interface ErrorsTextOptions {294    separator?: string;295    dataVar?: string;296  }297 298  interface ErrorObject {299    keyword: string;300    dataPath: string;301    schemaPath: string;302    params: ErrorParameters;303    // Added to validation errors of propertyNames keyword schema304    propertyName?: string;305    // Excluded if messages set to false.306    message?: string;307    // These are added with the `verbose` option.308    schema?: any;309    parentSchema?: object;310    data?: any;311  }312 313  type ErrorParameters = RefParams | LimitParams | AdditionalPropertiesParams |314    DependenciesParams | FormatParams | ComparisonParams |315    MultipleOfParams | PatternParams | RequiredParams |316    TypeParams | UniqueItemsParams | CustomParams |317    PatternRequiredParams | PropertyNamesParams |318    IfParams | SwitchParams | NoParams | EnumParams;319 320  interface RefParams {321    ref: string;322  }323 324  interface LimitParams {325    limit: number;326  }327 328  interface AdditionalPropertiesParams {329    additionalProperty: string;330  }331 332  interface DependenciesParams {333    property: string;334    missingProperty: string;335    depsCount: number;336    deps: string;337  }338 339  interface FormatParams {340    format: string341  }342 343  interface ComparisonParams {344    comparison: string;345    limit: number | string;346    exclusive: boolean;347  }348 349  interface MultipleOfParams {350    multipleOf: number;351  }352 353  interface PatternParams {354    pattern: string;355  }356 357  interface RequiredParams {358    missingProperty: string;359  }360 361  interface TypeParams {362    type: string;363  }364 365  interface UniqueItemsParams {366    i: number;367    j: number;368  }369 370  interface CustomParams {371    keyword: string;372  }373 374  interface PatternRequiredParams {375    missingPattern: string;376  }377 378  interface PropertyNamesParams {379    propertyName: string;380  }381 382  interface IfParams {383    failingKeyword: string;384  }385 386  interface SwitchParams {387    caseIndex: number;388  }389 390  interface NoParams { }391 392  interface EnumParams {393    allowedValues: Array<any>;394  }395}396 397export = ajv;398