markuplint 2.0.0-rc.6 → 2.1.1

package/README.md

@@ -1,27 +1,66 @@
 # ![markuplint](https://cdn.rawgit.com/YusukeHirao/markuplint/HEAD/media/logo-v.svg)
 
 [![npm version](https://badge.fury.io/js/markuplint.svg)](https://badge.fury.io/js/markuplint)
-[![Build Status](https://travis-ci.org/markuplint/markuplint.svg?branch=main)](https://travis-ci.org/markuplint/markuplint) [![Coverage Status](https://coveralls.io/repos/github/markuplint/markuplint/badge.svg?branch=main)](https://coveralls.io/github/markuplint/markuplint?branch=main)
+[![Test](https://github.com/markuplint/markuplint/workflows/Test/badge.svg?branch=main)](https://github.com/markuplint/markuplint/actions?query=workflow%3ATest)
+[![Coverage Status](https://coveralls.io/repos/github/markuplint/markuplint/badge.svg?branch=main)](https://coveralls.io/github/markuplint/markuplint?branch=main)
 
-A Linter for All Markup Languages (for legacy/modern HTML, Web Components, SVG, MathML, AMP HTML and more).
+Peace of mind in your markup - A Linter for All Markup Languages.
 
-## Install
+## Features
+
+- Conformance checking that according to HTML Living Standard, WAI-ARIA, and ARIA in HTML.
+- Supports SVG and CSS Values.
+- Supports React, Vue, Svelte, Pug, PHP, and more.
+- Possible to specify the rule to each element if you use the selector.
+- Possible to create a custom rule.
+
+![Screenshot: Violation Report CLI output](https://raw.githubusercontent.com/markuplint/markuplint/main/packages/markuplint/media/screenshot01.png)
+
+## Instant using
 
 ```
-$ npm install -D markuplint
-$ yarn add -D markuplint
+$ npx markuplint target.html
 ```
 
 Supported for _Node.js_ `v12.4.0` or later.
 
 ## Usage
 
-### CLI
+### Initialization
+
+Create a [configuration](https://markuplint.dev/configuration) file and install dependencies.
 
 ```
-$ npx markuplint verifyee.html
+$ npx markuplint --init
+# or
+$ yarn run markuplint --init
 ```
 
+Answer questions interactively.
+By doing this, needed modules are installed includes `markuplint`.
+
+Add a command to the `scripts` option on `package.json`:
+
+```json
+{
+  "scripts": {
+    "html:lint": "markuplint **/*.html"
+  }
+}
+```
+
+If you want to change the target path, you can change it for your project.
+
+Execute the script:
+
+```
+$ npm run html:lint
+# or
+$ yarn html:lint
+```
+
+### Command line options
+
 ```
 $ npx markuplint --help
 
@@ -52,27 +91,38 @@ Examples
 	$ cat verifyee.html | markuplint
 ```
 
-![Screen shot](media/screenshot01.png)
+## Guideline
+
+- [Getting Started](https://markuplint.dev/getting-started)
+- [Rules](https://markuplint.dev/rules)
+- [Configuration](https://markuplint.dev/configuration)
+- [API](https://markuplint.dev/api-docs)
+- [Playground](https://playground.markuplint.dev/)
+
+## Editor Extensions
+
+| Editor                                                                                                                                                                                                                                                          | Installation Page                                                                                       | Author                                         |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| <a href="https://marketplace.visualstudio.com/items?itemName=yusukehirao.vscode-markuplint"><img src="https://raw.githubusercontent.com/markuplint/markuplint/main/media/vscode.png" width="75" height="82" alt="Visual Studio Code: markuplint extension"></a> | [Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=yusukehirao.vscode-markuplint) | [@YusukeHirao](https://github.com/YusukeHirao) |
 
-### API
+## License
 
--   [Functions](https://markuplint.dev/api-docs#Functions)
--   [Interface Document](https://api.markuplint.dev) (genereated by [TypeDoc](https://typedoc.org/))
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fmarkuplint%2Fmarkuplint.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fmarkuplint%2Fmarkuplint?ref=badge_large)
 
-## Configuration
+## Sponsors
 
--   [Configuration](https://markuplint.dev/configuration)
+[:heart: Sponsor](https://github.com/sponsors/markuplint)
 
-## Rules
+### Personal Supporters
 
--   [Rules](https://markuplint.dev/rules)
--   Customizing your rule **🚧 WIP**
+[<img width="36" src="https://avatars.githubusercontent.com/u/6581173?v=4" alt="mikimhk"/>](https://github.com/mikimhk)
+[<img width="36" src="https://avatars.githubusercontent.com/u/91733847?v=4" alt="Tokitake" />](https://github.com/Tokitake)
 
 ## Thanks
 
 This linter is inspired by:
 
--   [HTMLHint](http://htmlhint.com/)
--   [ESLint](https://eslint.org/)
--   [stylelint](https://stylelint.io/)
--   [textlint](https://textlint.github.io/)
+- [HTMLHint](http://htmlhint.com/)
+- [ESLint](https://eslint.org/)
+- [stylelint](https://stylelint.io/)
+- [textlint](https://textlint.github.io/)

package/lib/api/index.d.mts

@@ -0,0 +1,2 @@
+export { default as MLEngine } from './ml-engine.mjs';
+export { lint } from './lint.mjs';

package/lib/api/index.mjs

@@ -0,0 +1,2 @@
+export { default as MLEngine } from './ml-engine.mjs';
+export { lint } from './lint.mjs';

package/lib/api/lint.d.mts

@@ -0,0 +1,4 @@
+import type { MLResultInfo } from '../types.mjs';
+import type { APIOptions } from './types.mjs';
+import type { Target } from '@markuplint/file-resolver';
+export declare function lint(targetList: Target[], options?: APIOptions): Promise<MLResultInfo[]>;

package/lib/api/lint.mjs

@@ -0,0 +1,15 @@
+import { resolveFiles } from '@markuplint/file-resolver';
+import MLEngine from './ml-engine.mjs';
+export async function lint(targetList, options) {
+    const res = [];
+    const files = await resolveFiles(targetList);
+    for (const file of files) {
+        const engine = new MLEngine(file, options);
+        const result = await engine.exec();
+        if (!result) {
+            continue;
+        }
+        res.push(result);
+    }
+    return res;
+}

package/lib/api/ml-engine.d.mts

@@ -0,0 +1,27 @@
+import type { MLResultInfo } from '../types.mjs';
+import type { APIOptions, MLEngineEventMap } from './types.mjs';
+import type { MLFile, Target } from '@markuplint/file-resolver';
+import { StrictEventEmitter } from 'strict-event-emitter';
+declare type MLEngineOptions = {
+    debug?: boolean;
+    watch?: boolean;
+};
+export default class MLEngine extends StrictEventEmitter<MLEngineEventMap> {
+    #private;
+    static toMLFile(target: Target): Promise<MLFile>;
+    constructor(file: MLFile, options?: APIOptions & MLEngineOptions);
+    exec(): Promise<MLResultInfo | null>;
+    setCode(code: string): Promise<void>;
+    close(): Promise<void>;
+    private setup;
+    private provide;
+    private cretateCore;
+    private resolveConfig;
+    private resolveParser;
+    private resolveRuleset;
+    private resolveSchemas;
+    private resolveRules;
+    private i18n;
+    private watch;
+}
+export {};

package/lib/api/ml-engine.mjs

@@ -0,0 +1,232 @@
+var _MLEngine_file, _MLEngine_options, _MLEngine_core, _MLEngine_watcher;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { configProvider, resolveFiles, resolveParser, resolveRules, resolveSpecs } from '@markuplint/file-resolver';
+import { MLCore, convertRuleset } from '@markuplint/ml-core';
+import { FSWatcher } from 'chokidar';
+import { StrictEventEmitter } from 'strict-event-emitter';
+import { log as coreLog, verbosely } from '../debug.mjs';
+import { i18n } from '../i18n.mjs';
+const log = coreLog.extend('ml-engine');
+const fileLog = log.extend('file');
+export default class MLEngine extends StrictEventEmitter {
+    constructor(file, options) {
+        super();
+        _MLEngine_file.set(this, void 0);
+        _MLEngine_options.set(this, void 0);
+        _MLEngine_core.set(this, null);
+        _MLEngine_watcher.set(this, new FSWatcher());
+        __classPrivateFieldSet(this, _MLEngine_file, file, "f");
+        __classPrivateFieldSet(this, _MLEngine_options, options, "f");
+        if (__classPrivateFieldGet(this, _MLEngine_options, "f")?.debug) {
+            verbosely();
+        }
+        if (options?.watch) {
+            __classPrivateFieldGet(this, _MLEngine_watcher, "f").on('all', this.watch.bind(this));
+        }
+        else {
+            __classPrivateFieldGet(this, _MLEngine_watcher, "f").close();
+        }
+    }
+    static async toMLFile(target) {
+        const files = await resolveFiles([target]);
+        return files[0];
+    }
+    async exec() {
+        log('exec: start');
+        const core = await this.setup();
+        if (!core) {
+            log('exec: cancel (unsetuped yet)');
+            return null;
+        }
+        const violations = await core.verify(__classPrivateFieldGet(this, _MLEngine_options, "f")?.fix).catch(e => {
+            if (e instanceof Error) {
+                return e;
+            }
+            throw e;
+        });
+        const sourceCode = await __classPrivateFieldGet(this, _MLEngine_file, "f").getCode();
+        const fixedCode = core.document.toString();
+        if (violations instanceof Error) {
+            this.emit('lint-error', __classPrivateFieldGet(this, _MLEngine_file, "f").path, sourceCode, violations);
+            const errMessage = violations.stack ?? violations.message;
+            log('exec: error %O', errMessage);
+            return {
+                violations: [
+                    {
+                        severity: 'error',
+                        message: errMessage,
+                        ruleId: '@markuplint/ml-core',
+                        line: 0,
+                        col: 0,
+                        raw: '',
+                    },
+                ],
+                filePath: __classPrivateFieldGet(this, _MLEngine_file, "f").path,
+                sourceCode,
+                fixedCode,
+            };
+        }
+        const debugMap = ('debugMap' in core.document && core.document.debugMap()) || null;
+        this.emit('lint', __classPrivateFieldGet(this, _MLEngine_file, "f").path, sourceCode, violations, fixedCode, debugMap);
+        log('exec: end');
+        return {
+            violations,
+            filePath: __classPrivateFieldGet(this, _MLEngine_file, "f").path,
+            sourceCode,
+            fixedCode,
+        };
+    }
+    async setCode(code) {
+        const core = await this.setup();
+        if (!core) {
+            return;
+        }
+        __classPrivateFieldGet(this, _MLEngine_file, "f").setCode(code);
+        core.setCode(code);
+    }
+    async close() {
+        this.removeAllListeners();
+        await __classPrivateFieldGet(this, _MLEngine_watcher, "f").close();
+    }
+    async setup() {
+        if (__classPrivateFieldGet(this, _MLEngine_core, "f")) {
+            return __classPrivateFieldGet(this, _MLEngine_core, "f");
+        }
+        const fabric = await this.provide(false);
+        if (!fabric) {
+            return null;
+        }
+        if (fabric.configErrors) {
+            this.emit('config-errors', __classPrivateFieldGet(this, _MLEngine_file, "f").path, fabric.configErrors);
+        }
+        const core = this.cretateCore(fabric);
+        return core;
+    }
+    async provide(remerge) {
+        const configSet = await this.resolveConfig(remerge);
+        fileLog('Fetched Config files: %O', configSet.files);
+        fileLog('Resolved Config: %O', configSet.config);
+        fileLog('Resolved Plugins: %O', configSet.plugins);
+        fileLog('Resolve Errors: %O', configSet.errs);
+        if (!(await __classPrivateFieldGet(this, _MLEngine_file, "f").isFile())) {
+            this.emit('log', 'file-no-exists', `The file doesn't exist or it is not a file: ${__classPrivateFieldGet(this, _MLEngine_file, "f").path}`);
+            return null;
+        }
+        // Exclude
+        const excludeFiles = configSet.config.excludeFiles || [];
+        for (const excludeFile of excludeFiles) {
+            if (__classPrivateFieldGet(this, _MLEngine_file, "f").matches(excludeFile)) {
+                this.emit('exclude', __classPrivateFieldGet(this, _MLEngine_file, "f").path, excludeFile);
+                return null;
+            }
+        }
+        const { parser, parserOptions, matched } = await this.resolveParser(configSet);
+        const checkingExt = !__classPrivateFieldGet(this, _MLEngine_options, "f")?.ignoreExt;
+        if (checkingExt && !matched) {
+            this.emit('log', 'ext-unmatched', `Avoided linting because a file is unmatched by the extension: ${__classPrivateFieldGet(this, _MLEngine_file, "f").path}`);
+            return null;
+        }
+        const ruleset = this.resolveRuleset(configSet);
+        fileLog('Resolved ruleset: %O', ruleset);
+        const schemas = await this.resolveSchemas(configSet);
+        if (fileLog.enabled) {
+            if (schemas[0].cites.length) {
+                const [, ...additionalSpecs] = schemas;
+                fileLog('Resolved schemas: HTML Standard');
+                for (const additionalSpec of additionalSpecs) {
+                    fileLog('Resolved schemas: %O', additionalSpec);
+                }
+            }
+            else {
+                fileLog('Resolved schemas: %O', schemas);
+            }
+        }
+        const rules = await this.resolveRules(configSet.plugins, ruleset);
+        fileLog('Resolved rules: %O', rules);
+        const locale = await i18n(__classPrivateFieldGet(this, _MLEngine_options, "f")?.locale);
+        if (fileLog.enabled) {
+            fileLog('Loaded %d rules: %O', rules.length, rules.map(r => r.name));
+        }
+        return {
+            parser,
+            parserOptions,
+            ruleset,
+            schemas,
+            rules,
+            locale,
+            configErrors: configSet.errs,
+        };
+    }
+    async cretateCore(fabric) {
+        fileLog('Get source code');
+        const sourceCode = await __classPrivateFieldGet(this, _MLEngine_file, "f").getCode();
+        fileLog('Source code path: %s', __classPrivateFieldGet(this, _MLEngine_file, "f").path);
+        fileLog('Source code size: %dbyte', sourceCode.length);
+        this.emit('code', __classPrivateFieldGet(this, _MLEngine_file, "f").path, sourceCode);
+        const core = new MLCore({
+            sourceCode,
+            filename: __classPrivateFieldGet(this, _MLEngine_file, "f").path,
+            debug: __classPrivateFieldGet(this, _MLEngine_options, "f")?.debug,
+            ...fabric,
+        });
+        __classPrivateFieldSet(this, _MLEngine_core, core, "f");
+        return core;
+    }
+    async resolveConfig(remerge) {
+        const configFilePathsFromTarget = __classPrivateFieldGet(this, _MLEngine_options, "f")?.noSearchConfig
+            ? null
+            : await configProvider.search(__classPrivateFieldGet(this, _MLEngine_file, "f"));
+        this.emit('log', 'configFilePathsFromTarget', configFilePathsFromTarget || 'null');
+        const configKey = __classPrivateFieldGet(this, _MLEngine_options, "f")?.config && configProvider.set(__classPrivateFieldGet(this, _MLEngine_options, "f").config);
+        this.emit('log', 'configKey', configKey || 'null');
+        const configSet = await configProvider.resolve([configFilePathsFromTarget, __classPrivateFieldGet(this, _MLEngine_options, "f")?.configFile, configKey], remerge);
+        this.emit('config', __classPrivateFieldGet(this, _MLEngine_file, "f").path, configSet);
+        if (__classPrivateFieldGet(this, _MLEngine_options, "f")?.watch) {
+            __classPrivateFieldGet(this, _MLEngine_watcher, "f").add(Array.from(configSet.files));
+        }
+        return configSet;
+    }
+    async resolveParser(configSet) {
+        const parser = await resolveParser(__classPrivateFieldGet(this, _MLEngine_file, "f"), configSet.config.parser, configSet.config.parserOptions);
+        this.emit('parser', __classPrivateFieldGet(this, _MLEngine_file, "f").path, parser.parserModName);
+        fileLog('Fetched Parser module: %s', parser.parserModName);
+        return parser;
+    }
+    resolveRuleset(configSet) {
+        const ruleset = convertRuleset(configSet.config);
+        this.emit('ruleset', __classPrivateFieldGet(this, _MLEngine_file, "f").path, ruleset);
+        return ruleset;
+    }
+    async resolveSchemas(configSet) {
+        const { schemas } = await resolveSpecs(__classPrivateFieldGet(this, _MLEngine_file, "f").path, configSet.config.specs);
+        this.emit('schemas', __classPrivateFieldGet(this, _MLEngine_file, "f").path, schemas);
+        return schemas;
+    }
+    async resolveRules(plugins, ruleset) {
+        const rules = await resolveRules(plugins, ruleset, __classPrivateFieldGet(this, _MLEngine_options, "f")?.importPresetRules ?? true, __classPrivateFieldGet(this, _MLEngine_options, "f")?.autoLoad ?? true);
+        if (__classPrivateFieldGet(this, _MLEngine_options, "f")?.rules) {
+            rules.push(...__classPrivateFieldGet(this, _MLEngine_options, "f").rules);
+        }
+        this.emit('rules', __classPrivateFieldGet(this, _MLEngine_file, "f").path, rules);
+        return rules;
+    }
+    async i18n() {
+        const i18nSettings = await i18n(__classPrivateFieldGet(this, _MLEngine_options, "f")?.locale);
+        this.emit('i18n', __classPrivateFieldGet(this, _MLEngine_file, "f").path, i18nSettings);
+        return i18nSettings;
+    }
+    async watch(type, filePath) {
+        this.emit('log', `watch:${type}`, filePath);
+        const fabric = await this.provide(true);
+        if (!fabric) {
+            return;
+        }
+        if (fabric.configErrors) {
+            this.emit('config-errors', __classPrivateFieldGet(this, _MLEngine_file, "f").path, fabric.configErrors);
+        }
+        this.emit('log', 'update:core', __classPrivateFieldGet(this, _MLEngine_file, "f").path);
+        __classPrivateFieldGet(this, _MLEngine_core, "f")?.update(fabric);
+        this.exec();
+    }
+}
+_MLEngine_file = new WeakMap(), _MLEngine_options = new WeakMap(), _MLEngine_core = new WeakMap(), _MLEngine_watcher = new WeakMap();

package/lib/api/types.d.mts

@@ -0,0 +1,43 @@
+import type { ConfigSet } from '@markuplint/file-resolver';
+import type { LocaleSet } from '@markuplint/i18n';
+import type { MLMarkupLanguageParser } from '@markuplint/ml-ast';
+import type { Config, Violation, ParserOptions } from '@markuplint/ml-config';
+import type { AnyMLRule, MLSchema, Ruleset } from '@markuplint/ml-core';
+export declare type APIOptions = {
+    configFile?: string;
+    config?: Config;
+    defaultConfig?: Config;
+    noSearchConfig?: boolean;
+    locale?: string;
+    fix?: boolean;
+    ignoreExt?: boolean;
+    rules?: AnyMLRule[];
+    importPresetRules?: boolean;
+    /**
+     * @deprecated
+     */
+    autoLoad?: boolean;
+};
+export declare type MLFabric = {
+    ruleset: Ruleset;
+    rules: AnyMLRule[];
+    schemas: MLSchema;
+    parser: MLMarkupLanguageParser;
+    parserOptions: ParserOptions;
+    locale: LocaleSet;
+    configErrors?: Error[];
+};
+export declare type MLEngineEventMap = {
+    log: (phase: string, message: string) => void;
+    config: (filePath: string, config: ConfigSet, message?: string) => void;
+    exclude: (filePath: string, setting: string, message?: string) => void;
+    parser: (filePath: string, parser: string, message?: string) => void;
+    ruleset: (filePath: string, ruleset: Ruleset, message?: string) => void;
+    schemas: (filePath: string, schemas: MLSchema, message?: string) => void;
+    rules: (filePath: string, rules: AnyMLRule[], message?: string) => void;
+    i18n: (filePath: string, locale: LocaleSet, message?: string) => void;
+    code: (filePath: string, sourceCode: string, message?: string) => void;
+    lint: (filePath: string, sourceCode: string, violations: Violation[], fixedCode: string, debug: string[] | null, message?: string) => void;
+    'lint-error': (filePath: string, sourceCode: string, error: Error) => void;
+    'config-errors': (filePath: string, errors: Error[]) => void;
+};

package/lib/api/types.mjs

@@ -0,0 +1 @@
+export {};

package/lib/api/v1.d.mts

@@ -0,0 +1,51 @@
+import type { Config, RuleConfigValue } from '@markuplint/ml-config';
+import type { MLRule } from '@markuplint/ml-core';
+/**
+ * @deprecated
+ * @param options
+ * @returns
+ */
+export declare function lint_v1(options: {
+    /**
+     * Glob pattern
+     */
+    files?: string | string[];
+    /**
+     * Target source code of evaluation
+     */
+    sourceCodes?: string | string[];
+    /**
+     * File names when `sourceCodes`
+     */
+    names?: string | string[];
+    /**
+     * Workspace path when `sourceCodes`
+     */
+    workspace?: string;
+    /**
+     * Configure file or object
+     */
+    config?: string | Config;
+    /**
+     * The config applied when not resolved from files or set it explicitly.
+     */
+    defaultConfig?: Config;
+    /**
+     * Rules (default: `@markuplint/rules`)
+     */
+    rules?: MLRule<RuleConfigValue, unknown>[];
+    /**
+     * Auto resolve rules
+     *
+     * Auto importing form *node_modules* when set `@markuplint/rule-{RULE_NAME}` or `markuplint-rule-{RULE_NAME}` in config rules
+     */
+    rulesAutoResolve?: boolean;
+    /**
+     * Auto fix
+     */
+    fix?: boolean;
+    /**
+     * Locale
+     */
+    locale?: string;
+}): Promise<import("../types.mjs").MLResultInfo[]>;

package/lib/api/v1.mjs

@@ -0,0 +1,39 @@
+import { lint } from './lint.mjs';
+/**
+ * @deprecated
+ * @param options
+ * @returns
+ */
+export async function lint_v1(options) {
+    const filePathList = options.files ? (Array.isArray(options.files) ? options.files : [options.files]) : [];
+    const codes = options.sourceCodes
+        ? Array.isArray(options.sourceCodes)
+            ? options.sourceCodes
+            : [options.sourceCodes]
+        : [];
+    const files = [
+        ...filePathList,
+        ...codes.map((code, i) => ({
+            sourceCode: code,
+            name: Array.isArray(options.names) ? options.names?.[i] : options.names,
+            workspace: options.workspace?.[i],
+        })),
+    ];
+    let config;
+    let configFile;
+    if (typeof options.config === 'string') {
+        configFile = options.config;
+    }
+    else if (options.config) {
+        config = options.config;
+    }
+    const result = await lint(files, {
+        config,
+        configFile,
+        noSearchConfig: !options.files,
+        rules: options.rules,
+        autoLoad: options.rulesAutoResolve ?? true,
+        locale: options.locale,
+    });
+    return result;
+}

package/lib/cli/bootstrap.d.mts

@@ -0,0 +1,52 @@
+export declare const help = "\nUsage\n\t$ markuplint <HTML file pathes (glob format)>\n\t$ <stdout> | markuplint\n\nOptions\n\t--config,                -c FILE_PATH  A configuration file path.\n\t--fix,                                 Fix HTML.\n\t--format,                -f FORMAT     Output format. Support \"JSON\", \"Simple\" and \"Standard\". Default: \"Standard\".\n\t--no-search-config                     No search a configure file automatically.\n\t--ignore-ext                           Evaluate files that are received even though the type of extension.\n\t--no-import-preset-rules               No import preset rules.\n\t--locale                               Locale of the message of violation. Default is an OS setting.\n\t--no-color,                            Output no color.\n\t--problem-only,          -p            Output only problems, without passeds.\n\t--verbose                              Output with detailed information.\n\n\t--init                                 Initialize settings interactively.\n\t--create-rule                          Add the scaffold of a custom rule.\n\n\t--help,                  -h            Show help.\n\t--version,               -v            Show version.\n\nExamples\n\t$ markuplint verifyee.html --config path/to/.markuplintrc\n\t$ cat verifyee.html | markuplint\n";
+export declare const cli: import("meow").Result<{
+    config: {
+        type: "string";
+        alias: string;
+    };
+    fix: {
+        type: "boolean";
+        default: false;
+    };
+    format: {
+        type: "string";
+        alias: string;
+    };
+    searchConfig: {
+        type: "boolean";
+        default: true;
+    };
+    ignoreExt: {
+        type: "boolean";
+        default: false;
+    };
+    importPresetRules: {
+        type: "boolean";
+        default: true;
+    };
+    locale: {
+        type: "string";
+    };
+    color: {
+        type: "boolean";
+        default: true;
+    };
+    problemOnly: {
+        type: "boolean";
+        alias: string;
+        default: false;
+    };
+    verbose: {
+        type: "boolean";
+        default: false;
+    };
+    init: {
+        type: "boolean";
+        default: false;
+    };
+    createRule: {
+        type: "boolean";
+        default: false;
+    };
+}>;
+export declare type CLIOptions = typeof cli.flags;