Class Module Rules

/**
 * Rule for sorting class members with advanced grouping options
 */
const sortClasses: Rule.RuleModule;

/**
 * Configuration options for sort-classes rule
 */
interface SortClassesOptions {
  /** Sorting strategy */
  type?: "alphabetical" | "line-length" | "natural" | "custom";
  /** Sort direction */
  order?: "asc" | "desc";
  /** Case sensitivity for sorting */
  ignoreCase?: boolean;
  /** Locale for sorting */
  locales?: NonNullable<Intl.LocalesArgument>;
  /** Custom alphabet for sorting */
  alphabet?: string;
  /** How to handle special characters */
  specialCharacters?: "remove" | "trim" | "keep";
  /** Newlines between different groups */
  newlinesBetween?: "ignore" | "always" | "never" | number;
  /** Custom class member groups */
  groups?: GroupsOptions<ClassGroup>;
  /** Custom groups for fine-tuned control */
  customGroups?: CustomGroupsOption<ClassSingleCustomGroup>;
  /** Partition class members by comments */
  partitionByComment?: PartitionByCommentOption;
  /** Partition class members by newlines */
  partitionByNewLine?: boolean;
}

type ClassGroup = 
  | "index-signature" | "static-property" | "private-property" | "property"
  | "constructor" | "static-method" | "private-method" | "method"
  | "accessor-property" | "get-method" | "set-method"
  | "static-accessor-property" | "static-get-method" | "static-set-method"
  | "private-accessor-property" | "private-get-method" | "private-set-method"
  | "unknown" | string;

interface ClassSingleCustomGroup {
  selector?: ClassSelector;
  modifiers?: ClassModifier[];
  elementNamePattern?: RegexOption;
}

type ClassSelector = 
  | "index-signature" | "property" | "accessor-property" | "constructor"
  | "method" | "get-method" | "set-method";

type ClassModifier = 
  | "abstract" | "static" | "private" | "protected" | "public"
  | "readonly" | "optional" | "override" | "declare" | "decorated";

// Basic class member sorting
{
  "perfectionist/sort-classes": ["error", {
    "type": "alphabetical",
    "order": "asc"
  }]
}

// Advanced grouping by member type and visibility
{
  "perfectionist/sort-classes": ["error", {
    "groups": [
      "index-signature",
      ["static-property", "private-property", "property"],
      "constructor",
      ["static-method", "private-method", "method"],
      ["get-method", "set-method"]
    ],
    "customGroups": [
      {
        "groupName": "lifecycle",
        "selector": "method",
        "elementNamePattern": "^(componentDidMount|componentWillUnmount)$"
      }
    ]
  }]
}

/**
 * Rule for sorting module exports and statements
 */
const sortModules: Rule.RuleModule;

/**
 * Configuration options for sort-modules rule
 */
interface SortModulesOptions {
  type?: "alphabetical" | "line-length" | "natural" | "custom";
  order?: "asc" | "desc";
  ignoreCase?: boolean;
  locales?: NonNullable<Intl.LocalesArgument>;
  alphabet?: string;
  specialCharacters?: "remove" | "trim" | "keep";
  newlinesBetween?: "ignore" | "always" | "never" | number;
  groups?: GroupsOptions<ModuleGroup>;
  customGroups?: CustomGroupsOption<ModuleSingleCustomGroup>;
  partitionByComment?: PartitionByCommentOption;
  partitionByNewLine?: boolean;
}

type ModuleGroup = 
  | "declare-namespace" | "declare-module" | "declare-global"
  | "export-namespace" | "export-interface" | "export-type" | "export-default"
  | "export-named" | "export-all" | "import-namespace" | "import-default"
  | "import-named" | "import-all" | "require" | "unknown" | string;

interface ModuleSingleCustomGroup {
  selector?: ModuleSelector;
  modifiers?: ModuleModifier[];
  elementNamePattern?: RegexOption;
}

type ModuleSelector = 
  | "import" | "export" | "require" | "declare"
  | "namespace" | "interface" | "type" | "function" | "class";

type ModuleModifier = 
  | "default" | "named" | "namespace" | "type" | "value"
  | "declare" | "export" | "async" | "inline";

// Sort module statements by type
{
  "perfectionist/sort-modules": ["error", {
    "groups": [
      ["import-namespace", "import-default", "import-named"],
      "require",
      ["export-namespace", "export-default", "export-named"],
      ["declare-namespace", "declare-module"]
    ]
  }]
}

/**
 * Rule for sorting decorators
 */
const sortDecorators: Rule.RuleModule;

/**
 * Configuration options for sort-decorators rule
 */
interface SortDecoratorsOptions {
  type?: "alphabetical" | "line-length" | "natural" | "custom";
  order?: "asc" | "desc";
  ignoreCase?: boolean;
  locales?: NonNullable<Intl.LocalesArgument>;
  alphabet?: string;
  specialCharacters?: "remove" | "trim" | "keep";
  groups?: GroupsOptions<DecoratorGroup>;
  customGroups?: CustomGroupsOption<DecoratorSingleCustomGroup>;
}

type DecoratorGroup = "unknown" | string;

interface DecoratorSingleCustomGroup {
  elementNamePattern?: RegexOption;
}

// Sort decorators alphabetically
{
  "perfectionist/sort-decorators": ["error", {
    "type": "alphabetical"
  }]
}

// Custom decorator grouping
{
  "perfectionist/sort-decorators": ["error", {
    "customGroups": [
      {
        "groupName": "validation",
        "elementNamePattern": "^(IsString|IsNumber|IsEmail)$"
      },
      {
        "groupName": "framework",
        "elementNamePattern": "^(Component|Injectable|Controller)$"
      }
    ],
    "groups": ["framework", "validation", "unknown"]
  }]
}

/**
 * Base class/module sorting configuration
 */
interface ClassModuleSortingOptions {
  type?: "alphabetical" | "line-length" | "natural" | "custom";
  order?: "asc" | "desc";
  ignoreCase?: boolean;
  locales?: NonNullable<Intl.LocalesArgument>;
  alphabet?: string;
  specialCharacters?: "remove" | "trim" | "keep";
}

/**
 * Group configuration for class/module elements
 */
type GroupsOptions<T> = (
  | (GroupNewlinesBetweenOption & GroupCommentAboveOption)
  | GroupNewlinesBetweenOption
  | GroupCommentAboveOption
  | T[]
  | T
)[];

interface GroupNewlinesBetweenOption {
  newlinesBetween: "ignore" | "always" | "never" | number;
}

interface GroupCommentAboveOption {
  commentAbove: string;
}

/**
 * Custom group configuration for class/module elements
 */
type CustomGroupsOption<SingleCustomGroup = object> = ({
  newlinesInside?: "always" | "never" | number;
  fallbackSort?: FallbackSortOption;
  order?: "asc" | "desc";
  groupName: string;
  type?: "alphabetical" | "line-length" | "natural" | "custom";
} & (AnyOfCustomGroup<SingleCustomGroup> | SingleCustomGroup))[];

interface AnyOfCustomGroup<SingleCustomGroup> {
  anyOf: SingleCustomGroup[];
}

interface FallbackSortOption {
  order?: "asc" | "desc";
  type: "alphabetical" | "line-length" | "natural" | "custom";
}

/**
 * Regex pattern for matching class/module elements
 */
type RegexOption = SingleRegexOption[] | SingleRegexOption;

type SingleRegexOption = 
  | {
      pattern: string;
      flags?: string;
    }
  | string;

/**
 * Partition by comment configuration
 */
type PartitionByCommentOption =
  | {
      block?: RegexOption | boolean;
      line?: RegexOption | boolean;
    }
  | RegexOption
  | boolean;