Code Quality Rules

/**
 * Enforce consistent type imports
 */
"consistent-type-imports": RuleModule;

/**
 * Enforce consistent type exports
 */
"consistent-type-exports": RuleModule;

/**
 * Disallow import type side effects
 */
"no-import-type-side-effects": RuleModule;

/**
 * Disallow require statements except in import statements
 */
"no-require-imports": RuleModule;

/**
 * Disallow var requires in favor of import
 */
"no-var-requires": RuleModule;

/**
 * Disallow specified modules when loaded by import
 */
"no-restricted-imports": RuleModule;

// ❌ Bad - consistent-type-imports
import { User, createUser } from './user';
const user: User = createUser();

// ✅ Good
import type { User } from './user';
import { createUser } from './user';
const user: User = createUser();

// ❌ Bad - no-var-requires
const fs = require('fs'); // Error in TypeScript

// ✅ Good
import * as fs from 'fs';

/**
 * Enforce type definitions to be consistently defined as interface or type
 */
"consistent-type-definitions": RuleModule;

/**
 * Enforce consistent indexed object style
 */
"consistent-indexed-object-style": RuleModule;

/**
 * Enforce consistent generic constructors
 */
"consistent-generic-constructors": RuleModule;

/**
 * Disallow type aliases in favor of interfaces where possible
 */
"no-type-alias": RuleModule;

/**
 * Require consistent use of type assertions
 */
"consistent-type-assertions": RuleModule;

/**
 * Disallow inferrable types in variable declarations
 */
"no-inferrable-types": RuleModule;

/**
 * Disallow specified types from being used
 */
"no-restricted-types": RuleModule;

/**
 * Disallow this keywords outside of classes or class-like objects
 */
"no-invalid-this": RuleModule;

/**
 * Disallow unnecessary namespace qualifiers
 */
"no-unnecessary-qualifier": RuleModule;

// ❌ Bad - consistent-type-definitions (with interface preference)
type User = {
  name: string;
  email: string;
};

// ✅ Good
interface User {
  name: string;
  email: string;
}

// ❌ Bad - no-inferrable-types
const count: number = 0; // Type is inferrable

// ✅ Good
const count = 0; // Type inferred as number

/**
 * Require explicit return types on functions and class methods
 */
"explicit-function-return-type": RuleModule;

/**
 * Require explicit return and argument types on exported functions
 */
"explicit-module-boundary-types": RuleModule;

/**
 * Enforce consistent return statements in functions
 */
"consistent-return": RuleModule;

/**
 * Enforce default parameters to be last
 */
"default-param-last": RuleModule;

/**
 * Enforce a maximum number of parameters in function definitions
 */
"max-params": RuleModule;

/**
 * Disallow functions without return type annotation
 */
"typedef": RuleModule;

/**
 * Require function overload signatures to be consecutive
 */
"adjacent-overload-signatures": RuleModule;

/**
 * Prefer function signatures to be unified when possible
 */
"unified-signatures": RuleModule;

// ❌ Bad - explicit-function-return-type
function calculateTotal(items) { // Missing return type
  return items.length * 10;
}

// ✅ Good
function calculateTotal(items: Item[]): number {
  return items.length * 10;
}

// ❌ Bad - default-param-last
function greet(name = 'World', greeting: string) { // Default param not last
  return `${greeting}, ${name}!`;
}

// ✅ Good
function greet(greeting: string, name = 'World'): string {
  return `${greeting}, ${name}!`;
}

/**
 * Require explicit accessibility modifiers on class properties and methods
 */
"explicit-member-accessibility": RuleModule;

/**
 * Enforce consistent member declaration order
 */
"member-ordering": RuleModule;

/**
 * Enforce consistent method signature style
 */
"method-signature-style": RuleModule;

/**
 * Enforce consistent property style for classes
 */
"class-literal-property-style": RuleModule;

/**
 * Enforce that class methods use this when appropriate
 */
"class-methods-use-this": RuleModule;

/**
 * Disallow duplicate class members
 */
"no-dupe-class-members": RuleModule;

/**
 * Disallow empty class constructors
 */
"no-useless-constructor": RuleModule;

/**
 * Disallow classes that serve no purpose
 */
"no-extraneous-class": RuleModule;

/**
 * Enforce or disallow parameter properties
 */
"parameter-properties": RuleModule;

// ❌ Bad - explicit-member-accessibility
class User {
  name: string; // Missing accessibility modifier
  constructor(name: string) {
    this.name = name;
  }
}

// ✅ Good
class User {
  public name: string;
  public constructor(name: string) {
    this.name = name;
  }
}

// ❌ Bad - method-signature-style (with method preference)
interface Calculator {
  add: (a: number, b: number) => number; // Property signature
}

// ✅ Good
interface Calculator {
  add(a: number, b: number): number; // Method signature
}

/**
 * Require or disallow initialization in variable declarations
 */
"init-declarations": RuleModule;

/**
 * Disallow variable redeclaration
 */
"no-redeclare": RuleModule;

/**
 * Disallow shadowing of variables
 */
"no-shadow": RuleModule;

/**
 * Disallow use of variables before they are defined
 */
"no-use-before-define": RuleModule;

/**
 * Disallow unused variables
 */
"no-unused-vars": RuleModule;

/**
 * Disallow unused expressions
 */
"no-unused-expressions": RuleModule;

/**
 * Disallow aliasing this
 */
"no-this-alias": RuleModule;

// ❌ Bad - no-unused-vars
function processData(data: string, unusedParam: number) { // unusedParam not used
  return data.toUpperCase();
}

// ✅ Good
function processData(data: string): string {
  return data.toUpperCase();
}

// ❌ Bad - no-shadow
const name = 'global';
function process() {
  const name = 'local'; // Shadows global name
  return name;
}

// ✅ Good
const globalName = 'global';
function process() {
  const localName = 'local';
  return localName;
}

/**
 * Disallow empty functions
 */
"no-empty-function": RuleModule;

/**
 * Disallow useless empty exports
 */
"no-useless-empty-export": RuleModule;

/**
 * Disallow meaningless void operator
 */
"no-meaningless-void-operator": RuleModule;

/**
 * Disallow confusing void expressions in statement position
 */
"no-confusing-void-expression": RuleModule;

/**
 * Require using Error objects as Promise rejection reasons
 */
"prefer-promise-reject-errors": RuleModule;

/**
 * Require that function overload signatures be consecutive
 */
"adjacent-overload-signatures": RuleModule;

/**
 * Enforce consistent spacing and formatting
 */
"comma-dangle": RuleModule;

/**
 * Enforce dot notation when possible
 */
"dot-notation": RuleModule;

// ❌ Bad - no-empty-function
function processData() {} // Empty function

// ✅ Good
function processData(): void {
  // TODO: Implement data processing
  throw new Error('Not implemented');
}

// ❌ Bad - prefer-promise-reject-errors
return Promise.reject('Error message'); // String rejection

// ✅ Good
return Promise.reject(new Error('Error message')); // Error object

/**
 * Disallow usage of deprecated APIs
 */
"no-deprecated": RuleModule;

/**
 * Disallow // tslint:<rule-flag> comments
 */
"ban-tslint-comment": RuleModule;

/**
 * Disallow @ts-<directive> comments or require descriptions
 */
"ban-ts-comment": RuleModule;

/**
 * Disallow triple slash reference directives
 */
"triple-slash-reference": RuleModule;

/**
 * Disallow the use of require()
 */
"no-require-imports": RuleModule;

/**
 * Disallow TypeScript namespaces
 */
"no-namespace": RuleModule;

/**
 * Require using namespace keyword over module keyword
 */
"prefer-namespace-keyword": RuleModule;

// ❌ Bad - ban-ts-comment
// @ts-ignore // Error: Use @ts-expect-error instead
const result = riskyOperation();

// ✅ Good
// @ts-expect-error - Known issue with third-party library
const result = riskyOperation();

// ❌ Bad - no-namespace
namespace Utils { // Prefer modules
  export function helper() {}
}

// ✅ Good
// utils.ts
export function helper() {}

interface RuleModule {
  meta: {
    type: "problem" | "suggestion" | "layout";
    docs: {
      description: string;
      recommended?: boolean | string;
      requiresTypeChecking?: boolean;
      extendsBaseRule?: boolean | string;
    };
    messages: Record<string, string>;
    schema: JSONSchema;
    fixable?: "code" | "whitespace";
    hasSuggestions?: boolean;
  };
  create(context: RuleContext): RuleListener;
}

interface RuleContext {
  id: string;
  options: unknown[];
  settings: Record<string, unknown>;
  parserOptions: ParserOptions;
  getSourceCode(): SourceCode;
  report(descriptor: ReportDescriptor): void;
  getFilename(): string;
  getCwd(): string;
}

interface ReportDescriptor {
  node: Node;
  message: string;
  messageId?: string;
  data?: Record<string, unknown>;
  fix?: (fixer: RuleFixer) => Fix | null;
  suggest?: SuggestionDescriptor[];
}