eslint-plugin-json-schema-validator/lib/types.d.ts

ESLint plugin that validates data using JSON Schema Validator.

import type { JSONSchema4 } from "json-schema";
import type { Rule } from "eslint";
import type { AST as JSON } from "jsonc-eslint-parser";
import type { AST as YAML } from "yaml-eslint-parser";
import type { AST as TOML } from "toml-eslint-parser";
import type { AST as ES } from "eslint";
import type { Comment as ESTreeComment } from "estree";
import type { ESLintNode, VElement } from "vue-eslint-parser/ast";
export interface RuleListener {
    [key: string]: ((node: never) => void) | undefined;
}
export interface RuleModule {
    meta: RuleMetaData;
    create(context: Rule.RuleContext): RuleListener;
}
export interface RuleMetaData {
    docs: {
        description: string;
        categories: "recommended"[] | null;
        url: string;
        ruleId: string;
        ruleName: string;
        replacedBy?: string[];
        default?: "error" | "warn";
    };
    messages: {
        [messageId: string]: string;
    };
    fixable?: "code" | "whitespace";
    schema: JSONSchema4 | JSONSchema4[];
    deprecated?: boolean;
    type: "problem" | "suggestion" | "layout";
}
export interface PartialRuleModule {
    meta: PartialRuleMetaData;
    create(context: RuleContext, params: {
        customBlock: boolean;
        filename: string;
    }): RuleListener;
}
export interface PartialRuleMetaData {
    docs: {
        description: string;
        categories: "recommended"[] | null;
        replacedBy?: string[];
        default?: "error" | "warn";
    };
    messages: {
        [messageId: string]: string;
    };
    fixable?: "code" | "whitespace";
    schema: JSONSchema4 | JSONSchema4[];
    deprecated?: boolean;
    type: "problem" | "suggestion" | "layout";
}
export declare type JsonSchemaValidatorSettings = {
    http?: {
        requestOptions?: any;
        getModulePath?: string;
    };
};
export interface RuleContext {
    id: string;
    options: any[];
    settings: {
        "json-schema-validator"?: JsonSchemaValidatorSettings;
    };
    parserPath: string;
    parserServices: {
        isJSON?: true;
        isYAML?: true;
        isTOML?: true;
        customBlock?: VElement;
    };
    getAncestors(): Node[];
    getFilename(): string;
    getSourceCode(): SourceCode;
    report(descriptor: ReportDescriptor): void;
    getCwd?: () => string;
}
export declare namespace SourceCode {
    function splitLines(text: string): string[];
}
export declare type Node = ESLintNode | JSON.JSONNode | YAML.YAMLNode | TOML.TOMLNode;
export declare type Token = ES.Token | YAML.Token | TOML.Token | Comment;
export declare type Comment = ESTreeComment | YAML.Comment | TOML.Comment;
export declare type NodeOrToken = Node | Token;
export interface SourceCode {
    text: string;
    ast: JSON.JSONProgram | YAML.YAMLProgram | TOML.TOMLProgram;
    lines: string[];
    hasBOM: boolean;
    parserServices: {
        isJSON?: true;
        isYAML?: true;
        isTOML?: true;
    };
    visitorKeys: {
        [nodeType: string]: string[];
    };
    getText(node?: NodeOrToken, beforeCount?: number, afterCount?: number): string;
    getLines(): string[];
    getAllComments(): Comment[];
    getComments(node: NodeOrToken): {
        leading: Comment[];
        trailing: Comment[];
    };
    getNodeByRangeIndex(index: number): Node | null;
    isSpaceBetweenTokens(first: Token, second: Token): boolean;
    getLocFromIndex(index: number): JSON.Position;
    getIndexFromLoc(loc: JSON.Position): number;
    getTokenByRangeStart(offset: number, options?: {
        includeComments?: boolean;
    }): Token | null;
    getFirstToken(node: Node): Token;
    getFirstToken(node: Node, options?: CursorWithSkipOptions): Token | null;
    getFirstTokens(node: Node, options?: CursorWithCountOptions): Token[];
    getLastToken(node: Node): Token;
    getLastToken(node: Node, options?: CursorWithSkipOptions): Token | null;
    getLastTokens(node: Node, options?: CursorWithCountOptions): Token[];
    getTokenBefore(node: NodeOrToken, options?: CursorWithSkipOptions): Token | null;
    getTokensBefore(node: NodeOrToken, options?: CursorWithCountOptions): Token[];
    getTokenAfter(node: NodeOrToken, options?: CursorWithSkipOptions): Token | null;
    getTokensAfter(node: NodeOrToken, options?: CursorWithCountOptions): Token[];
    getFirstTokenBetween(left: NodeOrToken, right: NodeOrToken, options?: CursorWithSkipOptions): Token | null;
    getFirstTokensBetween(left: NodeOrToken, right: NodeOrToken, options?: CursorWithCountOptions): Token[];
    getLastTokenBetween(left: NodeOrToken, right: NodeOrToken, options?: CursorWithSkipOptions): Token | null;
    getLastTokensBetween(left: NodeOrToken, right: NodeOrToken, options?: CursorWithCountOptions): Token[];
    getTokensBetween(left: NodeOrToken, right: NodeOrToken, padding?: number | FilterPredicate | CursorWithCountOptions): Token[];
    getTokens(node: Node, beforeCount?: number, afterCount?: number): Token[];
    getTokens(node: Node, options: FilterPredicate | CursorWithCountOptions): Token[];
    commentsExistBetween(left: NodeOrToken, right: NodeOrToken): boolean;
    getCommentsBefore(nodeOrToken: NodeOrToken): Comment[];
    getCommentsAfter(nodeOrToken: NodeOrToken): Comment[];
    getCommentsInside(node: Node): Comment[];
}
declare type FilterPredicate = (tokenOrComment: Token) => boolean;
declare type CursorWithSkipOptions = number | FilterPredicate | {
    includeComments?: boolean;
    filter?: FilterPredicate;
    skip?: number;
};
declare type CursorWithCountOptions = number | FilterPredicate | {
    includeComments?: boolean;
    filter?: FilterPredicate;
    count?: number;
};
interface ReportDescriptorOptionsBase {
    data?: {
        [key: string]: string;
    };
    fix?: null | ((fixer: RuleFixer) => null | Fix | IterableIterator<Fix> | Fix[]);
}
declare type SuggestionDescriptorMessage = {
    desc: string;
} | {
    messageId: string;
};
declare type SuggestionReportDescriptor = SuggestionDescriptorMessage & ReportDescriptorOptionsBase;
interface ReportDescriptorOptions extends ReportDescriptorOptionsBase {
    suggest?: SuggestionReportDescriptor[] | null;
}
declare type ReportDescriptor = ReportDescriptorMessage & ReportDescriptorLocation & ReportDescriptorOptions;
declare type ReportDescriptorMessage = {
    message: string;
} | {
    messageId: string;
};
declare type ReportDescriptorLocation = {
    node: NodeOrToken;
} | {
    loc: SourceLocation | {
        line: number;
        column: number;
    };
};
export interface RuleFixer {
    insertTextAfter(nodeOrToken: NodeOrToken, text: string): Fix;
    insertTextAfterRange(range: [number, number], text: string): Fix;
    insertTextBefore(nodeOrToken: NodeOrToken, text: string): Fix;
    insertTextBeforeRange(range: [number, number], text: string): Fix;
    remove(nodeOrToken: NodeOrToken): Fix;
    removeRange(range: [number, number]): Fix;
    replaceText(nodeOrToken: NodeOrToken, text: string): Fix;
    replaceTextRange(range: [number, number], text: string): Fix;
}
export interface Fix {
    range: [number, number];
    text: string;
}
interface SourceLocation {
    start: JSON.Position;
    end: JSON.Position;
}
export {};