eslint-plugin-perfectionist 5.2.0 → 5.3.0

package/dist/types/common-groups-options.d.ts

@@ -1,8 +1,31 @@
-import {
-  FallbackSortOption,
-  OrderOption,
-  RegexOption,
-} from './common-options.js'
+import { CommonOptions, RegexOption } from './common-options.js'
+export interface CommonGroupsOptions<
+  CustomTypeOption extends string,
+  AdditionalSortOptions,
+  AdditionalCustomGroupMatchOptions,
+> {
+  /** Specify the exact number of newlines required between elements of groups. */
+  newlinesInside:
+    | NewlinesInsideOption
+    /**
+     * @deprecated The `newlinesBetween` value is deprecated and will be removed
+     *   in V6.
+     */
+    | 'newlinesBetween'
+  /** Custom groups for organizing nodes. */
+  customGroups: CustomGroupsOption<
+    CustomTypeOption,
+    AdditionalSortOptions,
+    AdditionalCustomGroupMatchOptions
+  >
+  /**
+   * Defines the order and grouping of nodes. Nodes are sorted within their
+   * groups and groups are ordered as specified.
+   */
+  groups: GroupsOptions<CustomTypeOption, AdditionalSortOptions>
+  /** Specify the exact number of newlines required between groups. */
+  newlinesBetween: NewlinesBetweenOption
+}
 /**
  * Configuration for custom groups with sorting and newline options.
  *
@@ -26,22 +49,16 @@ import {
  *     },
  *   ]
  *
- * @template SingleCustomGroup - Type defining the structure of a single custom
- *   group.
- * @template AdditionalSortProperties - Additional sort options that extend the
+ * @template AdditionalMatchOptions - Options for matching elements to the
+ *   custom group.
+ * @template AdditionalSortOptions - Additional sort options that extend the
  *   base configuration.
  */
 export type CustomGroupsOption<
-  SingleCustomGroup,
-  AdditionalSortProperties,
   CustomTypeOption extends string,
+  AdditionalSortOptions,
+  AdditionalMatchOptions,
 > = ({
-  /**
-   * Fallback sorting configuration used when primary sort returns equal.
-   * Useful for stable sorting when elements have identical primary sort
-   * values.
-   */
-  fallbackSort?: FallbackSortOption<CustomTypeOption, AdditionalSortProperties>
   /** Specify the exact number of newlines required between elements of groups. */
   newlinesInside?: NewlinesInsideOption
   /**
@@ -49,23 +66,19 @@ export type CustomGroupsOption<
    * this pattern will be included in this custom group.
    */
   elementNamePattern?: RegexOption
-  /**
-   * Sorting algorithm type for this custom group. Overrides the global type
-   * setting for elements in this group.
-   */
-  type?: CustomTypeOption
-  /**
-   * Sort direction for this custom group. Overrides the global order setting
-   * for elements in this group.
-   */
-  order?: OrderOption
   /**
    * Name identifier for the custom group. Used to reference this group in the
    * groups configuration array.
    */
   groupName: string
-} & (AnyOfCustomGroup<SingleCustomGroup> | SingleCustomGroup) &
-  AdditionalSortProperties)[]
+} & Partial<
+  Pick<
+    CommonOptions<CustomTypeOption, AdditionalSortOptions>,
+    'fallbackSort' | 'order' | 'type'
+  >
+> &
+  (AnyOfCustomGroup<AdditionalMatchOptions> | Partial<AdditionalMatchOptions>) &
+  Partial<AdditionalSortOptions>)[]
 /**
  * Configuration for groups with overriding settings.
  *
@@ -78,58 +91,24 @@ export type CustomGroupsOption<
  */
 export type GroupWithOverridesOption<
   CustomTypeOption extends string,
-  AdditionalSortProperties,
+  AdditionalSortOptions,
 > = {
-  /**
-   * Fallback sorting configuration used when primary sort returns equal.
-   * Useful for stable sorting when elements have identical primary sort
-   * values.
-   */
-  fallbackSort?: FallbackSortOption<CustomTypeOption, AdditionalSortProperties>
   /** Specify the exact number of newlines required inside the group. */
   newlinesInside?: NewlinesInsideOption
   /** Name of the group or array of group names for composite groups. */
   group: string[] | string
-  /**
-   * Same as `type` in CommonOptions - Sorting algorithm to use for this
-   * group.
-   */
-  type?: CustomTypeOption
   /**
    * Text of the comment to insert above the group. The comment will be
    * formatted as a line comment (// ...).
    */
   commentAbove?: string
-  /** Same as `order` in CommonOptions - Sort direction for this group. */
-  order?: OrderOption
-} & AdditionalSortProperties
-export interface CommonGroupsOptions<
-  SingleCustomGroup,
-  AdditionalSortProperties,
-  CustomTypeOption extends string,
-> {
-  /** Specify the exact number of newlines required between elements of groups. */
-  newlinesInside:
-    | NewlinesInsideOption
-    /**
-     * @deprecated The `newlinesBetween` value is deprecated and will be removed
-     *   in V6.
-     */
-    | 'newlinesBetween'
-  /** Custom groups for organizing nodes. */
-  customGroups: CustomGroupsOption<
-    SingleCustomGroup,
-    AdditionalSortProperties,
-    CustomTypeOption
+} & Partial<
+  Pick<
+    CommonOptions<CustomTypeOption, AdditionalSortOptions>,
+    'fallbackSort' | 'order' | 'type'
   >
-  /**
-   * Defines the order and grouping of nodes. Nodes are sorted within their
-   * groups and groups are ordered as specified.
-   */
-  groups: GroupsOptions<CustomTypeOption, AdditionalSortProperties>
-  /** Specify the exact number of newlines required between groups. */
-  newlinesBetween: NewlinesBetweenOption
-}
+> &
+  Partial<AdditionalSortOptions>
 /**
  * Configuration for matching multiple patterns in custom groups.
  *
@@ -141,9 +120,9 @@ export interface CommonGroupsOptions<
  *     anyOf: ['react', 'react-*', '@react/*'],
  *   }
  *
- * @template SingleCustomGroup - Type of individual pattern matchers.
+ * @template MatchOptions - Options for matching elements to the custom group.
  */
-export interface AnyOfCustomGroup<SingleCustomGroup> {
+export interface AnyOfCustomGroup<MatchOptions> {
   /**
    * Regular expression pattern to match the element's name. Elements matching
    * this pattern will be included in this custom group.
@@ -153,7 +132,7 @@ export interface AnyOfCustomGroup<SingleCustomGroup> {
    * Array of patterns where matching any single pattern includes the element
    * in the group. Provides OR logic for group membership.
    */
-  anyOf: SingleCustomGroup[]
+  anyOf: Partial<MatchOptions>[]
 }
 /**
  * Configuration for managing newlines between sorted elements.
@@ -180,27 +159,6 @@ export type NewlinesBetweenOption =
    * consistent spacing with the specified line count.
    */
   | number
-/**
- * Configuration for controlling newlines between groups.
- *
- * Placed between group names in the groups array to specify how many blank
- * lines should separate adjacent groups in the sorted output.
- *
- * @example
- *   const groups = [
- *     'imports',
- *     { newlinesBetween: 1 }, // One newline after imports
- *     'types',
- *   ]
- */
-export interface GroupNewlinesBetweenOption {
-  /**
-   * Specifies the newline requirement between adjacent groups. This option is
-   * placed between group names to control their spacing.
-   */
-  newlinesBetween: NewlinesBetweenOption
-  group?: never
-}
 /**
  * Configuration for organizing elements into groups with optional formatting.
  *
@@ -221,13 +179,33 @@ export interface GroupNewlinesBetweenOption {
  */
 export type GroupsOptions<
   CustomTypeOption extends string = string,
-  AdditionalSortProperties = object,
+  AdditionalSortOptions = object,
 > = (
-  | GroupWithOverridesOption<CustomTypeOption, AdditionalSortProperties>
+  | GroupWithOverridesOption<CustomTypeOption, AdditionalSortOptions>
   | GroupNewlinesBetweenOption
   | string[]
   | string
 )[]
+/**
+ * Configuration for controlling newlines between groups.
+ *
+ * Placed between group names in the groups array to specify how many blank
+ * lines should separate adjacent groups in the sorted output.
+ *
+ * @example
+ *   const groups = [
+ *     'imports',
+ *     { newlinesBetween: 1 }, // One newline after imports
+ *     'types',
+ *   ]
+ */
+export interface GroupNewlinesBetweenOption {
+  /**
+   * Specifies the newline requirement between adjacent groups. This option is
+   * placed between group names to control their spacing.
+   */
+  newlinesBetween: NewlinesBetweenOption
+}
 export type NewlinesInsideOption =
   /** Preserve existing newlines without modification. */
   | 'ignore'

package/dist/types/common-options.d.ts

@@ -22,14 +22,14 @@
  */
 export type CommonOptions<
   CustomTypeOption extends string = string,
-  AdditionalSortProperties = object,
+  AdditionalSortOptions = object,
 > = {
   /**
    * Secondary sorting method applied when primary comparison returns equal.
    * Ensures stable and predictable sorting when elements have identical
    * primary values.
    */
-  fallbackSort: FallbackSortOption<CustomTypeOption, AdditionalSortProperties>
+  fallbackSort: FallbackSortOption<CustomTypeOption, AdditionalSortOptions>
   /**
    * Specifies how to handle special characters during sorting.
    *
@@ -67,7 +67,7 @@ export type CommonOptions<
    * alphabet are sorted after those in the alphabet.
    */
   alphabet: string
-} & AdditionalSortProperties
+} & AdditionalSortOptions
 /**
  * Sorting algorithm type that determines how elements are ordered.
  *
@@ -85,6 +85,11 @@ export type CommonOptions<
  *   // Shorter lines appear before longer lines
  */
 export type TypeOption =
+  /**
+   * Sort by the subgroup order defined in `groups` arrays. Useful as a fallback
+   * when elements are equal under the primary comparison.
+   */
+  | 'subgroup-order'
   /**
    * Traditional alphabetical sorting using locale-aware comparison. Best for
    * standard text sorting where consistency is important.
@@ -110,6 +115,33 @@ export type TypeOption =
    * 'alphabet' option to specify character precedence.
    */
   | 'custom'
+/**
+ * Regular expression pattern configuration for matching strings.
+ *
+ * Supports multiple formats for flexibility in pattern definition, from simple
+ * string patterns to complex regular expressions with flags.
+ *
+ * @example
+ *   // Simple string pattern
+ *   const pattern: RegexOption = '^TODO:'
+ *
+ * @example
+ *   // Pattern with flags
+ *   const pattern: RegexOption = {
+ *     pattern: '^(TODO|FIXME):',
+ *     flags: 'i',
+ *   }
+ *
+ * @example
+ *   // Multiple patterns (OR logic)
+ *   const patterns: RegexOption = [
+ *     '^TODO:',
+ *     { pattern: '^FIXME:', flags: 'i' },
+ *   ]
+ */
+export type RegexOption<AdditionalProperties extends object = object> =
+  | SingleRegexOption<AdditionalProperties>[]
+  | SingleRegexOption<AdditionalProperties>
 /**
  * Configuration for handling special characters during string comparison.
  *
@@ -124,7 +156,7 @@ export type TypeOption =
  *   // With 'trim': '_abc' becomes 'abc', but 'a_bc' stays 'a_bc'
  *   const option: SpecialCharactersOption = 'trim'
  */
-export type SpecialCharactersOption =
+type SpecialCharactersOption =
   /**
    * Remove all special characters before comparison. Only alphanumeric characters
    * are considered for sorting.
@@ -140,6 +172,28 @@ export type SpecialCharactersOption =
    * participate in the sort comparison.
    */
   | 'keep'
+/**
+ * Single regular expression pattern configuration.
+ *
+ * Can be either a simple string pattern or an object with pattern and flags for
+ * more complex matching requirements.
+ *
+ * @internal
+ */
+type SingleRegexOption<AdditionalProperties> =
+  | ({
+      /**
+       * The regular expression pattern string. Will be compiled into a RegExp for
+       * matching.
+       */
+      pattern: string
+      /**
+       * Optional RegExp flags to modify pattern matching behavior. Common flags:
+       * 'i' (case-insensitive), 'g' (global), 'm' (multiline).
+       */
+      flags?: string
+    } & AdditionalProperties)
+  | string
 /**
  * Configuration for fallback sorting when primary comparison returns equal.
  *
@@ -154,7 +208,7 @@ export type SpecialCharactersOption =
  *     order: 'asc',
  *   }
  */
-export type FallbackSortOption<
+type FallbackSortOption<
   CustomTypeOption extends string,
   AdditionalProperties,
 > = {
@@ -184,7 +238,7 @@ export type FallbackSortOption<
  *   // Descending: Z → A, 9 → 0
  *   const order: OrderOption = 'desc'
  */
-export type OrderOption =
+type OrderOption =
   /**
    * Descending order - from largest to smallest. Letters: Z to A, Numbers: 9 to
    * 0, Length: longest to shortest.
@@ -195,53 +249,4 @@ export type OrderOption =
    * Length: shortest to longest.
    */
   | 'asc'
-/**
- * Regular expression pattern configuration for matching strings.
- *
- * Supports multiple formats for flexibility in pattern definition, from simple
- * string patterns to complex regular expressions with flags.
- *
- * @example
- *   // Simple string pattern
- *   const pattern: RegexOption = '^TODO:'
- *
- * @example
- *   // Pattern with flags
- *   const pattern: RegexOption = {
- *     pattern: '^(TODO|FIXME):',
- *     flags: 'i',
- *   }
- *
- * @example
- *   // Multiple patterns (OR logic)
- *   const patterns: RegexOption = [
- *     '^TODO:',
- *     { pattern: '^FIXME:', flags: 'i' },
- *   ]
- */
-export type RegexOption<AdditionalProperties extends object = object> =
-  | SingleRegexOption<AdditionalProperties>[]
-  | SingleRegexOption<AdditionalProperties>
-/**
- * Single regular expression pattern configuration.
- *
- * Can be either a simple string pattern or an object with pattern and flags for
- * more complex matching requirements.
- *
- * @internal
- */
-type SingleRegexOption<AdditionalProperties> =
-  | ({
-      /**
-       * The regular expression pattern string. Will be compiled into a RegExp for
-       * matching.
-       */
-      pattern: string
-      /**
-       * Optional RegExp flags to modify pattern matching behavior. Common flags:
-       * 'i' (case-insensitive), 'g' (global), 'm' (multiline).
-       */
-      flags?: string
-    } & AdditionalProperties)
-  | string
 export {}

package/dist/utils/build-default-options-by-group-index-computer.d.ts

@@ -2,7 +2,7 @@ import { OptionsByGroupIndexComputer } from './sort-nodes-by-groups.js'
 import { CommonGroupsOptions } from '../types/common-groups-options.js'
 import { CommonOptions } from '../types/common-options.js'
 type Options = Pick<
-  CommonGroupsOptions<unknown, unknown, string>,
+  CommonGroupsOptions<string, unknown, unknown>,
   'customGroups' | 'groups'
 > &
   CommonOptions

package/dist/utils/compare/build-string-formatter.d.ts

@@ -1,4 +1,4 @@
-import { SpecialCharactersOption } from '../../types/common-options.js'
+import { CommonOptions } from '../../types/common-options.js'
 /**
  * Creates a function that formats strings for comparison.
  *
@@ -23,7 +23,6 @@ import { SpecialCharactersOption } from '../../types/common-options.js'
 export declare function buildStringFormatter({
   specialCharacters,
   ignoreCase,
-}: {
-  specialCharacters: SpecialCharactersOption
-  ignoreCase: boolean
-}): (value: string) => string
+}: Pick<CommonOptions, 'specialCharacters' | 'ignoreCase'>): (
+  value: string,
+) => string

package/dist/utils/compare/build-subgroup-order-comparator.d.ts

@@ -0,0 +1,10 @@
+import { Comparator } from './default-comparator-by-options-computer.js'
+import { AllCommonOptions } from '../../types/all-common-options.js'
+import { SortingNode } from '../../types/sorting-node.js'
+export declare function buildSubgroupOrderComparator({
+  groups,
+  order,
+}: Pick<
+  AllCommonOptions<string, unknown, unknown>,
+  'groups' | 'order'
+>): Comparator<SortingNode>

package/dist/utils/compare/build-subgroup-order-comparator.js

@@ -0,0 +1,49 @@
+import { isGroupWithOverridesOption } from '../is-group-with-overrides-option.js'
+import { isNewlinesBetweenOption } from '../is-newlines-between-option.js'
+import { UnreachableCaseError } from '../unreachable-case-error.js'
+import { computeOrderedValue } from './compute-ordered-value.js'
+function buildSubgroupOrderComparator({ groups, order }) {
+  return (a, b) => {
+    let subgroupContainingA = computeSubgroupContainingNode(a, groups)
+    let subgroupContainingB = computeSubgroupContainingNode(b, groups)
+    if (
+      !subgroupContainingA ||
+      !subgroupContainingB ||
+      subgroupContainingA !== subgroupContainingB
+    ) {
+      return 0
+    }
+    let indexOfAInSubgroup = subgroupContainingA.indexOf(a.group)
+    let indexOfBInSubgroup = subgroupContainingB.indexOf(b.group)
+    let result = indexOfAInSubgroup - indexOfBInSubgroup
+    return computeOrderedValue(result, order)
+  }
+}
+function computeSubgroupContainingNode(sortingNode, groups) {
+  for (let group of groups) {
+    if (isNewlinesBetweenOption(group)) {
+      continue
+    }
+    if (typeof group === 'string' || Array.isArray(group)) {
+      if (doesStringSubgroupContainsNode(sortingNode, group)) {
+        return group
+      }
+      continue
+    }
+    if (isGroupWithOverridesOption(group)) {
+      if (doesStringSubgroupContainsNode(sortingNode, group.group)) {
+        return group.group
+      }
+      continue
+    }
+    throw new UnreachableCaseError(group)
+  }
+  return null
+}
+function doesStringSubgroupContainsNode(sortingNode, subgroup) {
+  if (typeof subgroup === 'string') {
+    return false
+  }
+  return subgroup.includes(sortingNode.group)
+}
+export { buildSubgroupOrderComparator }

package/dist/utils/compare/default-comparator-by-options-computer.d.ts

@@ -1,4 +1,5 @@
 import { CommonOptions, TypeOption } from '../../types/common-options.js'
+import { GroupsOptions } from '../../types/common-groups-options.js'
 import { SortingNode } from '../../types/sorting-node.js'
 export type ComparatorByOptionsComputer<S, T extends SortingNode> = (
   options: S,
@@ -8,7 +9,9 @@ type Options = Pick<
   CommonOptions<TypeOption>,
   'specialCharacters' | 'ignoreCase' | 'alphabet' | 'locales' | 'order' | 'type'
 > &
-  Pick<CommonOptions, 'fallbackSort'>
+  Pick<CommonOptions, 'fallbackSort'> & {
+    groups?: GroupsOptions
+  }
 export declare let defaultComparatorByOptionsComputer: ComparatorByOptionsComputer<
   Options,
   SortingNode

package/dist/utils/compare/default-comparator-by-options-computer.js

@@ -1,3 +1,4 @@
+import { buildSubgroupOrderComparator } from './build-subgroup-order-comparator.js'
 import { buildLineLengthComparator } from './build-line-length-comparator.js'
 import { compareAlphabetically } from './compare-alphabetically.js'
 import { UnreachableCaseError } from '../unreachable-case-error.js'
@@ -6,6 +7,14 @@ import { unsortedComparator } from './unsorted-comparator.js'
 import { compareNaturally } from './compare-naturally.js'
 let defaultComparatorByOptionsComputer = options => {
   switch (options.type) {
+    case 'subgroup-order':
+      if (!options.groups) {
+        return unsortedComparator
+      }
+      return buildSubgroupOrderComparator({
+        ...options,
+        groups: options.groups,
+      })
     case 'alphabetical':
       return (a, b) => compareAlphabetically(a.name, b.name, options)
     case 'line-length':

package/dist/utils/compute-group.d.ts

@@ -5,12 +5,12 @@ import {
 /**
  * Parameters for computing the group of an element.
  *
- * @template SingleCustomGroup - Type of individual custom group configuration.
+ * @template CustomGroupMatchOptions - Type of custom group match options.
  */
-interface GetGroupParameters<SingleCustomGroup> {
+interface ComputeGroupParameters<CustomGroupMatchOptions> {
   /** Configuration options for grouping. */
   options: Pick<
-    CommonGroupsOptions<SingleCustomGroup, unknown, string>,
+    CommonGroupsOptions<string, unknown, CustomGroupMatchOptions>,
     'customGroups' | 'groups'
   >
   /**
@@ -19,15 +19,15 @@ interface GetGroupParameters<SingleCustomGroup> {
    * @param customGroup - Custom group configuration to test against.
    * @returns True if the element matches the custom group.
    */
-  customGroupMatcher: CustomGroupMatcher<SingleCustomGroup>
+  customGroupMatcher: CustomGroupMatcher<CustomGroupMatchOptions>
   /**
    * List of predefined groups that the element belongs to. These are checked
    * after custom groups as a fallback.
    */
   predefinedGroups: string[]
 }
-type CustomGroupMatcher<SingleCustomGroup> = (
-  customGroup: AnyOfCustomGroup<SingleCustomGroup> | SingleCustomGroup,
+type CustomGroupMatcher<MatchOptions> = (
+  customGroup: AnyOfCustomGroup<MatchOptions> | Partial<MatchOptions>,
 ) => boolean
 /**
  * Determines which group an element belongs to based on custom and predefined
@@ -53,7 +53,7 @@ type CustomGroupMatcher<SingleCustomGroup> = (
  *   })
  *   // Returns: 'react'
  *
- * @template SingleCustomGroup - Type of individual custom group configuration.
+ * @template CustomGroupMatchOptions - Type of custom group match options.
  * @param params - Parameters for group computation.
  * @param params.options - Configuration with available groups and custom
  *   groups.
@@ -61,9 +61,9 @@ type CustomGroupMatcher<SingleCustomGroup> = (
  * @param params.predefinedGroups - Fallback predefined groups to check.
  * @returns The matched group name or 'unknown' if no group matches.
  */
-export declare function computeGroup<SingleCustomGroup>({
+export declare function computeGroup<CustomGroupMatchOptions>({
   customGroupMatcher,
   predefinedGroups,
   options,
-}: GetGroupParameters<SingleCustomGroup>): 'unknown' | string
+}: ComputeGroupParameters<CustomGroupMatchOptions>): 'unknown' | string
 export {}

package/dist/utils/compute-overridden-options-by-group-index.d.ts

@@ -1,7 +1,7 @@
 import { CommonGroupsOptions } from '../types/common-groups-options.js'
 import { CommonOptions } from '../types/common-options.js'
 type Options = Pick<
-  CommonGroupsOptions<unknown, unknown, string>,
+  CommonGroupsOptions<string, unknown, unknown>,
   'customGroups' | 'groups'
 > &
   CommonOptions

package/dist/utils/does-custom-group-match.d.ts

@@ -40,7 +40,7 @@ export interface DoesCustomGroupMatchParameters {
  * custom group. All specified criteria must match for the element to be
  * considered part of the group.
  */
-interface BaseSingleCustomGroup {
+interface BaseCustomGroupMatchOptions {
   /**
    * Pattern to match against decorator names. Element must have at least one
    * decorator matching this pattern.
@@ -103,17 +103,19 @@ interface BaseSingleCustomGroup {
  *   })
  *   // Returns: true (matches first subgroup)
  *
- * @template SingleCustomGroup - Type of individual custom group configuration.
+ * @template CustomGroupMatchOptions - Type of custom group match options.
  * @param props - Combined parameters including the custom group and element
  *   properties.
  * @returns True if the element matches the custom group criteria, false
  *   otherwise.
  */
 export declare function doesCustomGroupMatch<
-  SingleCustomGroup extends BaseSingleCustomGroup,
+  CustomGroupMatchOptions extends BaseCustomGroupMatchOptions,
 >(
   props: {
-    customGroup: AnyOfCustomGroup<SingleCustomGroup> | SingleCustomGroup
+    customGroup:
+      | AnyOfCustomGroup<CustomGroupMatchOptions>
+      | CustomGroupMatchOptions
   } & DoesCustomGroupMatchParameters,
 ): boolean
 export {}

package/dist/utils/get-comment-above-that-should-exist.d.ts

@@ -9,7 +9,7 @@ import { SortingNode } from '../types/sorting-node.js'
 interface GetCommentAboveMissingParameters<T extends SortingNode> {
   /** Configuration options for grouping. */
   options: Pick<
-    CommonGroupsOptions<unknown, unknown, string>,
+    CommonGroupsOptions<string, unknown, unknown>,
     'customGroups' | 'groups'
   >
   /** ESLint source code object for accessing comments. */

package/dist/utils/get-newlines-between-errors.d.ts

@@ -33,7 +33,7 @@ interface GetNewlinesBetweenErrorsParameters<
   /** Optional function to customize newlines between specific nodes. */
   newlinesBetweenValueGetter?: NewlinesBetweenValueGetter<T>
   /** Configuration options for newlines and groups. */
-  options: CommonGroupsOptions<unknown, unknown, string>
+  options: CommonGroupsOptions<string, unknown, unknown>
   /** ESLint source code object for accessing lines. */
   sourceCode: TSESLint.SourceCode
   /** Error message ID for missing required newlines. */