@nx/eslint 0.0.0-pr-22179-271588f

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2023 Narwhal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+<div style="text-align: center;">
+
+[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![NPM Version](https://badge.fury.io/js/%40nrwl%2Fworkspace.svg)](https://www.npmjs.com/@nx/workspace)
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+
+</div>
+
+
+<hr>
+
+# Nx: Smart Monorepos · Fast CI
+
+Nx is a build system with built-in tooling and advanced CI capabilities. It helps you maintain and scale monorepos, both locally and on CI.
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://blog.nrwl.io/nx/home)
+
+<p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
+width="100%" alt="Nx - Smart Monorepos · Fast CI"></a></p>
+

package/executors.json

@@ -0,0 +1,10 @@
+{
+  "executors": {
+    "lint": {
+      "implementation": "./src/executors/lint/lint.impl",
+      "schema": "./src/executors/lint/schema.json",
+      "hasher": "./src/executors/lint/hasher",
+      "description": "Run ESLint on a project."
+    }
+  }
+}

package/generators.json

@@ -0,0 +1,28 @@
+{
+  "name": "nx/eslint",
+  "version": "0.1",
+  "generators": {
+    "init": {
+      "factory": "./src/generators/init/init#initEsLint",
+      "schema": "./src/generators/init/schema.json",
+      "description": "Set up the ESLint plugin.",
+      "hidden": true
+    },
+    "workspace-rules-project": {
+      "factory": "./src/generators/workspace-rules-project/workspace-rules-project#lintWorkspaceRulesProjectGenerator",
+      "schema": "./src/generators/workspace-rules-project/schema.json",
+      "description": "Create the Workspace Lint Rules Project.",
+      "hidden": true
+    },
+    "workspace-rule": {
+      "factory": "./src/generators/workspace-rule/workspace-rule#lintWorkspaceRuleGenerator",
+      "schema": "./src/generators/workspace-rule/schema.json",
+      "description": "Create a new Workspace ESLint rule."
+    },
+    "convert-to-flat-config": {
+      "factory": "./src/generators/convert-to-flat-config/generator",
+      "schema": "./src/generators/convert-to-flat-config/schema.json",
+      "description": "Convert an Nx workspace's ESLint configs to use Flat Config."
+    }
+  }
+}

package/index.d.ts

@@ -0,0 +1,4 @@
+export { lintProjectGenerator } from './src/generators/lint-project/lint-project';
+export { lintInitGenerator } from './src/generators/init/init';
+export { Linter } from './src/generators/utils/linter';
+export { hasRulesRequiringTypeChecking } from './src/utils/rules-requiring-type-checking';

package/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRulesRequiringTypeChecking = exports.Linter = exports.lintInitGenerator = exports.lintProjectGenerator = void 0;
+var lint_project_1 = require("./src/generators/lint-project/lint-project");
+Object.defineProperty(exports, "lintProjectGenerator", { enumerable: true, get: function () { return lint_project_1.lintProjectGenerator; } });
+var init_1 = require("./src/generators/init/init");
+Object.defineProperty(exports, "lintInitGenerator", { enumerable: true, get: function () { return init_1.lintInitGenerator; } });
+var linter_1 = require("./src/generators/utils/linter");
+Object.defineProperty(exports, "Linter", { enumerable: true, get: function () { return linter_1.Linter; } });
+// @nx/angular needs it for the Angular CLI workspace migration to Nx to
+// infer whether a config is using type aware rules and set the
+// `hasTypeAwareRules` option of the `@nx/eslint:lint` executor.
+var rules_requiring_type_checking_1 = require("./src/utils/rules-requiring-type-checking");
+Object.defineProperty(exports, "hasRulesRequiringTypeChecking", { enumerable: true, get: function () { return rules_requiring_type_checking_1.hasRulesRequiringTypeChecking; } });

package/migrations.json

@@ -0,0 +1,138 @@
+{
+  "generators": {
+    "add-eslint-inputs": {
+      "cli": "nx",
+      "version": "15.0.0-beta.0",
+      "description": "Stop hashing eslint config files for build targets and dependent tasks",
+      "factory": "./src/migrations/update-15-0-0/add-eslint-inputs"
+    },
+    "add-eslint-ignore": {
+      "cli": "nx",
+      "version": "15.7.1-beta.0",
+      "description": "Add node_modules to root eslint ignore",
+      "factory": "./src/migrations/update-15-7-1/add-eslint-ignore"
+    },
+    "update-16-0-0-add-nx-packages": {
+      "cli": "nx",
+      "version": "16.0.0-beta.1",
+      "description": "Replace @nrwl/linter with @nx/linter",
+      "implementation": "./src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages"
+    },
+    "update-16-8-0-add-ignored-files": {
+      "version": "16.8.0",
+      "description": "update-16-8-0-add-ignored-files",
+      "implementation": "./src/migrations/update-16-8-0-add-ignored-files/update-16-8-0-add-ignored-files"
+    },
+    "update-17-0-0-rename-to-eslint": {
+      "version": "17.0.0-beta.7",
+      "description": "update-17-0-0-rename-to-eslint",
+      "implementation": "./src/migrations/update-17-0-0-rename-to-eslint/update-17-0-0-rename-to-eslint"
+    },
+    "update-typescript-eslint": {
+      "version": "17.1.0-beta.1",
+      "description": "Updates for @typescript-utils/utils v6.9.1+",
+      "implementation": "./src/migrations/update-17-1-0/update-typescript-eslint"
+    },
+    "simplify-eslint-patterns": {
+      "version": "17.2.0-beta.0",
+      "description": "Simplify eslintFilePatterns",
+      "implementation": "./src/migrations/update-17-2-0/simplify-eslint-patterns"
+    },
+    "move-options-to-target-defaults": {
+      "version": "17.2.9",
+      "description": "Move executor options to target defaults",
+      "implementation": "./src/migrations/update-17-2-9/move-options-to-target-defaults"
+    }
+  },
+  "packageJsonUpdates": {
+    "16.0.0": {
+      "version": "16.0.0-beta.0",
+      "packages": {
+        "@typescript-eslint/parser": {
+          "version": "^5.58.0"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^5.58.0"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^5.58.0"
+        }
+      }
+    },
+    "16.5.0": {
+      "version": "16.5.0-beta.2",
+      "packages": {
+        "@typescript-eslint/parser": {
+          "version": "^5.60.1"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^5.60.1"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^5.60.1"
+        }
+      }
+    },
+    "16.7.0": {
+      "version": "16.7.0-beta.2",
+      "packages": {
+        "eslint": {
+          "version": "~8.46.0"
+        },
+        "@typescript-eslint/parser": {
+          "version": "^5.60.1"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^5.60.1"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^5.60.1"
+        }
+      }
+    },
+    "17.0.0": {
+      "version": "17.0.0-rc.2",
+      "packages": {
+        "eslint-config-prettier": {
+          "version": "^9.0.0"
+        }
+      }
+    },
+    "17.1.0": {
+      "version": "17.1.0-beta.1",
+      "packages": {
+        "@typescript-eslint/parser": {
+          "version": "^6.9.1"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^6.9.1"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^6.9.1"
+        }
+      }
+    },
+    "17.2.0": {
+      "version": "17.2.0-beta.2",
+      "packages": {
+        "eslint": {
+          "version": "~8.48.0"
+        }
+      }
+    },
+    "17.3.0": {
+      "version": "17.3.0-beta.0",
+      "packages": {
+        "@typescript-eslint/parser": {
+          "version": "^6.13.2"
+        },
+        "@typescript-eslint/eslint-plugin": {
+          "version": "^6.13.2"
+        },
+        "@typescript-eslint/utils": {
+          "version": "^6.13.2"
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@nx/eslint",
+  "version": "0.0.0-pr-22179-271588f",
+  "private": false,
+  "description": "The ESLint plugin for Nx contains executors, generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nrwl/nx.git",
+    "directory": "packages/eslint"
+  },
+  "keywords": [
+    "Monorepo",
+    "Web",
+    "Lint",
+    "ESLint",
+    "CLI"
+  ],
+  "main": "./index.js",
+  "typings": "./index.d.ts",
+  "author": "Victor Savkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nrwl/nx/issues"
+  },
+  "homepage": "https://nx.dev",
+  "ng-update": {
+    "requirements": {},
+    "migrations": "./migrations.json"
+  },
+  "generators": "./generators.json",
+  "executors": "./executors.json",
+  "peerDependencies": {
+    "js-yaml": "4.1.0"
+  },
+  "dependencies": {
+    "@nx/devkit": "0.0.0-pr-22179-271588f",
+    "@nx/js": "0.0.0-pr-22179-271588f",
+    "eslint": "^8.0.0",
+    "tslib": "^2.3.0",
+    "typescript": "~5.3.2",
+    "@nx/linter": "0.0.0-pr-22179-271588f"
+  },
+  "peerDependenciesMeta": {
+    "js-yaml": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs"
+}

package/plugin.d.ts

@@ -0,0 +1 @@
+export { createNodes, EslintPluginOptions } from './src/plugins/plugin';

package/plugin.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = void 0;
+var plugin_1 = require("./src/plugins/plugin");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });

package/src/executors/lint/hasher.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Hash, ProjectGraph, ProjectsConfigurations, Task, TaskGraph, TaskHasher } from '@nx/devkit';
+export default function run(task: Task, context: {
+    hasher: TaskHasher;
+    projectGraph: ProjectGraph;
+    taskGraph: TaskGraph;
+    projectsConfigurations: ProjectsConfigurations;
+    env: NodeJS.ProcessEnv;
+}): Promise<Hash>;

package/src/executors/lint/hasher.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+async function run(task, context) {
+    const res = await context.hasher.hashTask(task, context.taskGraph, context.env);
+    if (task.overrides['hasTypeAwareRules'] === true) {
+        return res;
+    }
+    const deps = allDeps(task.id, context.taskGraph, context.projectGraph);
+    const tags = (0, devkit_1.hashArray)(deps.map((d) => (context.projectsConfigurations.projects[d].tags || []).join('|')));
+    const command = res.details['command'];
+    let selfSource = '';
+    for (let n of Object.keys(res.details)) {
+        if (n.startsWith(`${task.target.project}:`)) {
+            selfSource = res.details.nodes[n];
+        }
+    }
+    const nodes = {};
+    const hashes = [];
+    for (const d of Object.keys(res.details.nodes).sort()) {
+        if (d.indexOf('$fileset') === -1) {
+            nodes[d] = res.details.nodes[d];
+            hashes.push(res.details.nodes[d]);
+        }
+    }
+    return {
+        value: (0, devkit_1.hashArray)([command, selfSource, ...hashes, tags]),
+        details: {
+            command,
+            nodes: { [task.target.project]: selfSource, tags, ...nodes },
+        },
+    };
+}
+exports.default = run;
+function allDeps(taskId, taskGraph, projectGraph) {
+    if (!taskGraph.tasks) {
+        return [];
+    }
+    const project = taskGraph.tasks[taskId].target.project;
+    return projectGraph.dependencies[project]
+        .filter((d) => !!projectGraph.nodes[d.target])
+        .map((d) => d.target);
+}

package/src/executors/lint/lint.impl.d.ts

@@ -0,0 +1,5 @@
+import { ExecutorContext } from '@nx/devkit';
+import type { Schema } from './schema';
+export default function run(options: Schema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/src/executors/lint/lint.impl.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const eslint_utils_1 = require("./utility/eslint-utils");
+const utils_1 = require("nx/src/tasks-runner/utils");
+async function run(options, context) {
+    // this is only used for the hasher
+    delete options.hasTypeAwareRules;
+    const systemRoot = context.root;
+    // eslint resolves files relative to the current working directory.
+    // We want these paths to always be resolved relative to the workspace
+    // root to be able to run the lint executor from any subfolder.
+    process.chdir(systemRoot);
+    const projectName = context.projectName || '<???>';
+    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
+    const printInfo = options.format && !options.silent;
+    if (printInfo) {
+        console.info(`\nLinting ${JSON.stringify(projectName)}...`);
+    }
+    options.cacheLocation = options.cacheLocation
+        ? (0, devkit_1.joinPathFragments)(options.cacheLocation, projectName)
+        : undefined;
+    const { printConfig, errorOnUnmatchedPattern, ...normalizedOptions } = options;
+    /**
+     * Until ESLint v9 is released and the new so called flat config is the default
+     * we only want to support it if the user has explicitly opted into it by converting
+     * their root ESLint config to use eslint.config.js
+     */
+    const hasFlatConfig = (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, 'eslint.config.js'));
+    // while standard eslint uses by default closest config to the file, if otherwise not specified,
+    // the flat config would always use the root config, so we need to explicitly set it to the local one
+    if (hasFlatConfig && !normalizedOptions.eslintConfig) {
+        const eslintConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, 'eslint.config.js');
+        if ((0, fs_1.existsSync)(eslintConfigPath)) {
+            normalizedOptions.eslintConfig = eslintConfigPath;
+        }
+    }
+    /**
+     * We want users to have the option of not specifying the config path, and let
+     * eslint automatically resolve the `.eslintrc.json` files in each folder.
+     */
+    let eslintConfigPath = normalizedOptions.eslintConfig
+        ? (0, path_1.resolve)(systemRoot, normalizedOptions.eslintConfig)
+        : undefined;
+    const { eslint, ESLint } = await (0, eslint_utils_1.resolveAndInstantiateESLint)(eslintConfigPath, normalizedOptions, hasFlatConfig);
+    const version = ESLint.version?.split('.');
+    if (!version ||
+        version.length < 2 ||
+        Number(version[0]) < 7 ||
+        (Number(version[0]) === 7 && Number(version[1]) < 6)) {
+        throw new Error('ESLint must be version 7.6 or higher.');
+    }
+    if (printConfig) {
+        try {
+            const fileConfig = await eslint.calculateConfigForFile(printConfig);
+            console.log(JSON.stringify(fileConfig, null, ' '));
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            console.error(err);
+            return {
+                success: false,
+            };
+        }
+    }
+    let lintResults = [];
+    const normalizedLintFilePatterns = normalizedOptions.lintFilePatterns.map((pattern) => {
+        return (0, utils_1.interpolate)(pattern, {
+            workspaceRoot: '',
+            projectRoot,
+            projectName: context.projectName,
+        });
+    });
+    try {
+        lintResults = await eslint.lintFiles(normalizedLintFilePatterns);
+    }
+    catch (err) {
+        if (err.message.includes('You must therefore provide a value for the "parserOptions.project" property for @typescript-eslint/parser')) {
+            const ruleName = err.message.match(/rule '([^']+)':/)?.[1];
+            let eslintConfigPathForError = `for ${projectName}`;
+            if (context.projectsConfigurations?.projects?.[projectName]?.root) {
+                const { root } = context.projectsConfigurations.projects[projectName];
+                eslintConfigPathForError = `\`${root}/.eslintrc.json\``;
+            }
+            console.error(`
+Error: You have attempted to use ${ruleName ? `the lint rule ${ruleName}` : 'a lint rule'} which requires the full TypeScript type-checker to be available, but you do not have \`parserOptions.project\` configured to point at your project tsconfig.json files in the relevant TypeScript file "overrides" block of your project ESLint config ${eslintConfigPath || eslintConfigPathForError}
+
+Please see https://nx.dev/guides/eslint for full guidance on how to resolve this issue.
+`);
+            return {
+                success: false,
+            };
+        }
+        // If some unexpected error, rethrow
+        throw err;
+    }
+    if (lintResults.length === 0 && errorOnUnmatchedPattern) {
+        const ignoredPatterns = (await Promise.all(normalizedLintFilePatterns.map(async (pattern) => (await eslint.isPathIgnored(pattern)) ? pattern : null)))
+            .filter((pattern) => !!pattern)
+            .map((pattern) => `- '${pattern}'`);
+        if (ignoredPatterns.length) {
+            const ignoreSection = hasFlatConfig
+                ? `'ignores' configuration`
+                : `'.eslintignore' file`;
+            throw new Error(`All files matching the following patterns are ignored:\n${ignoredPatterns.join('\n')}\n\nPlease check your ${ignoreSection}.`);
+        }
+        throw new Error('Invalid lint configuration. Nothing to lint. Please check your lint target pattern(s).');
+    }
+    // output fixes to disk, if applicable based on the options
+    await ESLint.outputFixes(lintResults);
+    // if quiet, only show errors
+    if (normalizedOptions.quiet) {
+        console.debug('Quiet mode enabled - filtering out warnings\n');
+        lintResults = ESLint.getErrorResults(lintResults);
+    }
+    const formatter = await eslint.loadFormatter(normalizedOptions.format);
+    const formattedResults = await formatter.format(lintResults);
+    if (normalizedOptions.outputFile) {
+        const pathToOutputFile = (0, devkit_1.joinPathFragments)(context.root, normalizedOptions.outputFile);
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(pathToOutputFile), { recursive: true });
+        (0, fs_1.writeFileSync)(pathToOutputFile, formattedResults);
+    }
+    else {
+        console.info(formattedResults);
+    }
+    const totals = getTotals(lintResults);
+    if (printInfo) {
+        outputPrintInfo(totals);
+    }
+    return {
+        success: normalizedOptions.force ||
+            (totals.errors === 0 &&
+                (normalizedOptions.maxWarnings === -1 ||
+                    totals.warnings <= normalizedOptions.maxWarnings)),
+    };
+}
+exports.default = run;
+function getTotals(lintResults) {
+    let errors = 0;
+    let warnings = 0;
+    let fixableErrors = 0;
+    let fixableWarnings = 0;
+    for (const result of lintResults) {
+        errors += result.errorCount || 0;
+        warnings += result.warningCount || 0;
+        fixableErrors += result.fixableErrorCount || 0;
+        fixableWarnings += result.fixableWarningCount || 0;
+    }
+    return {
+        errors,
+        warnings,
+        fixableErrors,
+        fixableWarnings,
+    };
+}
+function pluralizedOutput(word, count) {
+    return `${count} ${word}${count === 1 ? '' : 's'}`;
+}
+function outputPrintInfo({ errors, warnings, fixableErrors, fixableWarnings, }) {
+    const total = warnings + errors;
+    const totalFixable = fixableErrors + fixableWarnings;
+    if (total <= 0) {
+        console.info('\u2714 All files pass linting\n');
+        return;
+    }
+    console.info(`\u2716 ${pluralizedOutput('problem', total)} (${pluralizedOutput('error', errors)}, ${pluralizedOutput('warning', warnings)})\n`);
+    if (totalFixable <= 0)
+        return;
+    console.info(`  ${pluralizedOutput('error', fixableErrors)} and ${pluralizedOutput('warning', fixableWarnings)} are potentially fixable with the \`--fix\` option.\n`);
+}

package/src/executors/lint/schema.d.ts

@@ -0,0 +1,40 @@
+import type { JsonObject } from '@angular-devkit/core';
+import type { Linter } from 'eslint';
+
+export interface Schema extends JsonObject {
+  eslintConfig: string | null;
+  lintFilePatterns: string[];
+  format: Formatter;
+  force: boolean;
+  silent: boolean;
+  fix: boolean;
+  cache: boolean;
+  noEslintrc: boolean;
+  outputFile: string | null;
+  cacheLocation: string | null;
+  maxWarnings: number;
+  quiet: boolean;
+  ignorePath: string | null;
+  hasTypeAwareRules: boolean;
+  cacheStrategy: 'content' | 'metadata' | null;
+  rulesdir: string[];
+  resolvePluginsRelativeTo: string | null;
+  reportUnusedDisableDirectives: Linter.StringSeverity | null;
+  printConfig?: string | null;
+  errorOnUnmatchedPattern?: boolean;
+}
+
+type Formatter =
+  | 'stylish'
+  | 'compact'
+  | 'codeframe'
+  | 'unix'
+  | 'visualstudio'
+  | 'table'
+  | 'checkstyle'
+  | 'html'
+  | 'jslint-xml'
+  | 'json'
+  | 'json-with-metadata'
+  | 'junit'
+  | 'tap';