/*!
 * This bundle includes code from the following third-party projects.
 * Full notices: https://github.com/howmanysmall/small-rules/blob/main/THIRD-PARTY-NOTICES.md
 *
 * anti-slop <https://github.com/dmmulroy/anti-slop>
 * Copyright (c) 2026 Dillon Mulroy
 * SPDX-License-Identifier: MIT
 *
 * MIT License
 *
 * Copyright (c) 2026 Dillon Mulroy
 *
 * 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.
 *
 * anti-slop shared helpers <https://github.com/dmmulroy/anti-slop>
 * Copyright (c) 2026 Dillon Mulroy
 * SPDX-License-Identifier: MIT
 *
 * MIT License
 *
 * Copyright (c) 2026 Dillon Mulroy
 *
 * 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.
 *
 * ESLint Stylistic <https://github.com/eslint-stylistic/eslint-stylistic>
 * Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
 * Copyright (c) 2023-PRESENT ESLint Stylistic contributors
 * SPDX-License-Identifier: MIT
 *
 * MIT License
 *
 * Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
 * Copyright (c) 2023-PRESENT ESLint Stylistic contributors
 *
 * 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.
 *
 * eslint-plugin-roblox-ts <https://github.com/roblox-ts/eslint-plugin-roblox-ts>
 * Copyright (c) 2025-PRESENT roblox-ts
 * SPDX-License-Identifier: MIT
 *
 * MIT License
 *
 * Copyright (c) 2025-PRESENT roblox-ts
 *
 * 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.
 */
//#region src/utilities/directive-comments.d.ts
interface DirectiveKindsSchema {
  readonly description: string;
  readonly items: {
    readonly type: "string";
  };
  readonly type: "array";
  readonly uniqueItems: true;
}
//#endregion
//#region src/rules/react/no-useless-use-memo.d.ts
export declare const enum DependencyMode {
  Aggressive = "aggressive",
  EmptyOrOmitted = "empty-or-omitted",
  NonUpdating = "non-updating"
}
//#endregion
//#region src/index.d.ts
declare const smallRules: import("oxlint-plugin-utilities").Plugin<{
  "array-type-generic": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "useGenericArrayType", undefined>;
  "ban-instances": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly bannedInstances: {
        readonly description: "Map of banned class names to custom messages, or an array of class names.";
        readonly oneOf: readonly [{
          readonly items: {
            readonly type: "string";
          };
          readonly type: "array";
        }, {
          readonly additionalProperties: {
            readonly type: "string";
          };
          readonly type: "object";
        }];
      };
      readonly bannedProperties: {
        readonly additionalProperties: {
          readonly additionalProperties: {
            readonly type: "string";
          };
          readonly type: "object";
        };
        readonly description: "Map of banned class names to maps of banned property names and custom messages.";
        readonly type: "object";
      };
    };
    readonly type: "object";
  }], "bannedInstance" | "bannedInstanceCustom" | "bannedProperty" | "bannedPropertyCustom", undefined>;
  "ban-react-fc": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "banReactFC", undefined>;
  "ban-types": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly bannedTypes: {
        readonly default: {
          readonly Omit: "Except";
        };
        readonly description: "Array of banned type names or an object mapping banned type names to preferred replacement names.";
        readonly oneOf: readonly [{
          readonly items: {
            readonly type: "string";
          };
          readonly type: "array";
        }, {
          readonly additionalProperties: {
            readonly type: "string";
          };
          readonly type: "object";
        }];
      };
    };
    readonly type: "object";
  }], "bannedType" | "bannedTypeWithReplacement", undefined>;
  "consistent-compound-words": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowList: {
        readonly additionalProperties: {
          readonly enum: readonly [true];
        };
        readonly type: "object";
      };
      readonly checkProperties: {
        readonly type: "boolean";
      };
      readonly checkShorthandProperties: {
        readonly type: "boolean";
      };
      readonly checkVariables: {
        readonly type: "boolean";
      };
      readonly extendDefaultReplacements: {
        readonly type: "boolean";
      };
      readonly replacements: {
        readonly additionalProperties: {
          readonly anyOf: readonly [{
            readonly enum: readonly [false];
          }, {
            readonly minLength: 1;
            readonly type: "string";
          }];
        };
        readonly type: "object";
      };
    };
    readonly type: "object";
  }], "error" | "rename", undefined>;
  curly: import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly default: {
      readonly allowLiteralReturns: false;
      readonly oneLineBodies: readonly ["break", "continue", "return"];
      readonly printWidth: 120;
      readonly tabWidth: 4;
    };
    readonly properties: {
      readonly allowLiteralReturns: {
        readonly default: false;
        readonly description: "Let a `return` of an object or array literal sit on one line after a lone `if`";
        readonly type: "boolean";
      };
      readonly oneLineBodies: {
        readonly anyOf: readonly [{
          readonly enum: readonly ["*", "binding", "block-like", "break", "class", "continue", "control-flow", "declaration", "enum", "export", "expression", "function", "if", "import", "interface", "loop", "multiline", "multiline-binding", "overload", "return", "single-line", "single-line-binding", "single-line-if", "switch", "throw", "top-level", "try", "type"];
          readonly type: "string";
        }, {
          readonly items: {
            readonly enum: readonly ["*", "binding", "block-like", "break", "class", "continue", "control-flow", "declaration", "enum", "export", "expression", "function", "if", "import", "interface", "loop", "multiline", "multiline-binding", "overload", "return", "single-line", "single-line-binding", "single-line-if", "switch", "throw", "top-level", "try", "type"];
            readonly type: "string";
          };
          readonly minItems: 1;
          readonly type: "array";
        }];
        readonly default: readonly ["break", "continue", "return"];
        readonly description: "The statement kind or kinds that sit on one line, without braces, after a lone `if`. Declarations always keep their braces";
      };
      readonly printWidth: {
        readonly default: 120;
        readonly description: "The longest line, in columns, that a one-line `if` may make; match the formatter";
        readonly minimum: 1;
        readonly type: "integer";
      };
      readonly tabWidth: {
        readonly default: 4;
        readonly description: "The columns a tab counts as when measuring a line; match the formatter";
        readonly minimum: 1;
        readonly type: "integer";
      };
    };
    readonly type: "object";
  }], "complexBody" | "elseChain" | "loopBody" | "simpleBody", undefined>;
  "directive-disable-enable-pair": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowWholeFile: {
        readonly description: "Allow a disable directive that covers the entire file.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "missingPair" | "missingRulePair", undefined>;
  "directive-no-aggregating-enable": import("oxlint-plugin-utilities").CreateRule<readonly [], "aggregatingEnable", undefined>;
  "directive-no-duplicate-disable": import("oxlint-plugin-utilities").CreateRule<readonly [], "duplicate" | "duplicateRule", undefined>;
  "directive-no-restricted-disable": import("oxlint-plugin-utilities").CreateRule<{
    readonly items: {
      type: "string";
    };
    readonly type: "array";
    readonly uniqueItems: true;
  }, "disallow", undefined>;
  "directive-no-unlimited-disable": import("oxlint-plugin-utilities").CreateRule<readonly [], "unexpected", undefined>;
  "directive-no-unused-enable": import("oxlint-plugin-utilities").CreateRule<readonly [], "unused" | "unusedRule", undefined>;
  "directive-no-use": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      allow: DirectiveKindsSchema;
    };
    readonly type: "object";
  }], "disallow", undefined>;
  "directive-require-description": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      ignore: DirectiveKindsSchema;
    };
    readonly type: "object";
  }], "missingDescription", undefined>;
  "enforce-ianitor-check-type": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly baseThreshold: {
        readonly default: number;
        readonly description: "Minimum complexity score before missing Ianitor.Check<T> annotations are reported.";
        readonly minimum: 1;
        readonly type: "number";
      };
      readonly errorThreshold: {
        readonly default: number;
        readonly description: "Complexity score used to cap recursive analysis before reporting is determined.";
        readonly minimum: 1;
        readonly type: "number";
      };
      readonly interfacePenalty: {
        readonly default: number;
        readonly description: "Complexity penalty applied when an Ianitor validator builds an interface-like shape.";
        readonly minimum: 1;
        readonly type: "number";
      };
      readonly performanceMode: {
        readonly default: boolean;
        readonly description: "Whether repeated type nodes are cached during complexity analysis.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "complexInterfaceNeedsCheck" | "missingIanitorCheckType", undefined>;
  "isolated-functions": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly comments: {
        readonly description: "Comment patterns that mark a function as isolated.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
        readonly uniqueItems: true;
      };
      readonly functions: {
        readonly description: "Function names that mark argument callbacks as isolated.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
        readonly uniqueItems: true;
      };
      readonly overrideGlobals: {
        readonly additionalProperties: {
          readonly anyOf: readonly [{
            readonly type: "boolean";
          }, {
            readonly enum: readonly ["off", "readonly", "writable", "writeable"];
            readonly type: "string";
          }];
        };
        readonly description: "Override which global variables are allowed inside isolated scopes.";
        readonly type: "object";
      };
      readonly selectors: {
        readonly description: "AST selectors that mark matched function nodes as isolated.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
        readonly uniqueItems: true;
      };
    };
    readonly type: "object";
  }], "externallyScopedVariable" | "super" | "thisExpression", undefined>;
  "memoized-effect-dependencies": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
      readonly hooks: {
        readonly default: {
          name: string;
          dependenciesIndex: number;
        }[];
        readonly description: "Effect hooks checked by default; configured entries are added to this set.";
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly name: {
              readonly description: "The name of the hook";
              readonly type: "string";
            };
            readonly dependenciesIndex: {
              readonly description: "Index of the dependencies array for validation";
              readonly type: "number";
            };
          };
          readonly required: readonly ["name"];
          readonly type: "object";
        };
        readonly type: "array";
      };
      readonly mode: {
        readonly default: "definite";
        readonly description: "Strictness for memoization detection: definite (only obvious), moderate (unknown calls and non-const), aggressive (any non-module).";
        readonly enum: ("aggressive" | "definite" | "moderate")[];
        readonly type: "string";
      };
    };
    readonly type: "object";
  }], "unmemoizedDependency", undefined>;
  "no-adjust-state-on-prop-change": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidAdjustingStateWhenAPropChanges", undefined>;
  "no-array-constructor-elements": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        readonly default: "roblox-ts";
        readonly description: "Array constructor environment mode: 'roblox-ts' allows new Array(length); 'standard' reports it.";
        readonly enum: readonly ["roblox-ts", "standard"];
        readonly type: "string";
      };
      readonly requireExplicitGenericOnNewArray: {
        readonly default: true;
        readonly description: "When true, zero-argument new Array() requires explicit generic type arguments or contextual array typing.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "avoidConstructorEnumeration" | "avoidLengthConstructorInStandard" | "avoidSingleArgumentConstructor" | "collapseArrayPushInitialization" | "requireExplicitGenericOnNewArray" | "suggestArrayFromLength" | "suggestArrayLiteral" | "suggestCollapseArrayPushInitialization", undefined>;
  "no-array-constructor-index-assignment": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferArrayLiteral", undefined>;
  "no-array-size-assignment": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowAutofix: {
        readonly default: false;
        readonly description: "Allow the fixer to replace safe append assignments with array.push(value).";
        readonly type: "boolean";
      };
      readonly environment: {
        readonly enum: readonly ["roblox-ts", "standard"];
        readonly type: string;
        readonly default: "roblox-ts";
        readonly description: "Array environment mode: 'roblox-ts' checks array[array.size()]; 'standard' checks array[array.length].";
      };
    };
    readonly type: "object";
  }], "usePush", undefined>;
  "no-async-constructor": import("oxlint-plugin-utilities").CreateRule<readonly [], "asyncIifeInConstructor" | "awaitInConstructor" | "orphanedPromise" | "promiseChainInConstructor" | "unhandledAsyncCall", undefined>;
  "no-async-in-system": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly additionalSystemTypeNames: {
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
        readonly uniqueItems: true;
      };
      readonly callbackParameterTypes: {
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly callbackArgumentIndex: {
              readonly minimum: 0;
              readonly type: "integer";
            };
            readonly className: {
              readonly type: "string";
            };
            readonly imported: {
              readonly type: "string";
            };
            readonly memberPath: {
              readonly items: {
                readonly type: "string";
              };
              readonly type: "array";
            };
            readonly parameterIndex: {
              readonly minimum: 0;
              readonly type: "integer";
            };
            readonly source: {
              readonly type: "string";
            };
          };
          readonly required: readonly ["callbackArgumentIndex", "className", "imported", "memberPath", "parameterIndex", "source"];
          readonly type: "object";
        };
        readonly type: "array";
      };
      readonly synchronousCallbacks: {
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly callbackArgumentIndexes: {
              readonly items: {
                readonly minimum: 0;
                readonly type: "integer";
              };
              readonly minItems: 1;
              readonly type: "array";
              readonly uniqueItems: true;
            };
            readonly calleePath: {
              readonly items: {
                readonly type: "string";
              };
              readonly minItems: 1;
              readonly type: "array";
            };
          };
          readonly required: readonly ["callbackArgumentIndexes", "calleePath"];
          readonly type: "object";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "noAsyncInSystem", undefined>;
  "no-cascading-set-state": import("oxlint-plugin-utilities").CreateRule<undefined, "cascadingSetState", undefined>;
  "no-chain-state-updates": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidChainingStateUpdates", undefined>;
  "no-chained-type-assertions": import("oxlint-plugin-utilities").CreateOnceRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowedTargets: {
        readonly default: readonly [];
        readonly description: "Identifier names allowed as the final target of a single `as unknown/any/never as T` bridge, e.g. `vector` or `Vector3`.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
        readonly uniqueItems: true;
      };
    };
    readonly type: "object";
  }], "chained", undefined>;
  "no-color3-constructor": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly reportUnknownComponents: {
        readonly default: true;
        readonly description: "Report new Color3(...) calls when one or more components are not numeric literals.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "onlyZeroArgs" | "useFromRGB", undefined>;
  "no-commented-code": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly maxLines: {
        readonly default: 0;
        readonly description: "Maximum number of lines of commented code allowed without reporting. Default 0 means any commented code triggers an error.";
        readonly type: "number";
      };
    };
    readonly type: "object";
  }], "commentedCode", undefined>;
  "no-conditional-empty-object-spread": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "avoid", undefined>;
  "no-constant-condition-with-break": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly loopExitCalls: {
        readonly description: "Call expressions that count as intentional loop exits inside constant loops.";
        readonly items: {
          readonly minLength: 1;
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "unexpected", undefined>;
  "no-dead-store": import("oxlint-plugin-utilities").CreateRule<readonly [], "deadStore", undefined>;
  "no-derived-state": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidDerivedState", undefined>;
  "no-discarded-rejection": import("oxlint-plugin-utilities").CreateRule<readonly [], "noDiscardedRejection", undefined>;
  "no-error": import("oxlint-plugin-utilities").CreateRule<readonly [], "noError", readonly []>;
  "no-event-handler": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidEventHandler" | "avoidPropHandler", undefined>;
  "no-events-in-events-callback": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly eventsImportPaths: {
        readonly description: "Import paths that identify Events objects whose callbacks should be checked.";
        readonly items: {
          readonly minLength: 1;
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly required: readonly ["eventsImportPaths"];
    readonly type: "object";
  }], "preferFunctions", undefined>;
  "no-external-store-subscription": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidExternalStoreSubscription", undefined>;
  "no-filter-map-chain": import("oxlint-plugin-utilities").CreateRule<readonly [], "avoidFilterMapChain", undefined>;
  "no-floating-point-equality": import("oxlint-plugin-utilities").CreateRule<readonly [], "exactFloatComparison", undefined>;
  "no-giant-component": import("oxlint-plugin-utilities").CreateRule<undefined, "giantComponent", undefined>;
  "no-god-components": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly enforceTargetLines: {
        readonly default: true;
        readonly description: "Whether to report when exceeding targetLines (soft limit).";
        readonly type: "boolean";
      };
      readonly ignoreComponents: {
        readonly default: readonly [];
        readonly description: "Component names to ignore.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly maxDestructuredProps: {
        readonly default: 5;
        readonly description: "Maximum number of destructured props in a component parameter.";
        readonly type: "number";
      };
      readonly maxLines: {
        readonly default: 200;
        readonly description: "Hard maximum lines for a component.";
        readonly type: "number";
      };
      readonly maxStateHooks: {
        readonly default: 5;
        readonly description: "Maximum number of stateful hook calls in a component.";
        readonly type: "number";
      };
      readonly maxTsxNesting: {
        readonly default: 3;
        readonly description: "Maximum JSX/TSX nesting depth in a component.";
        readonly type: "number";
      };
      readonly stateHooks: {
        readonly default: readonly ["useState", "useReducer", "useBinding"];
        readonly description: "Hook names to count toward state complexity.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly targetLines: {
        readonly default: 120;
        readonly description: "Soft target lines for a component.";
        readonly type: "number";
      };
    };
    readonly type: "object";
  }], "exceedsMaxLines" | "exceedsTargetLines" | "nullLiteral" | "tooManyProps" | "tooManyStateHooks" | "tsxNestingTooDeep", undefined>;
  "no-has-before-remove-in-jecs": import("oxlint-plugin-utilities").CreateRule<readonly [], "removeWithoutHas", undefined>;
  "no-ianitor-in-function-body": import("oxlint-plugin-utilities").CreateRule<readonly [], "hoistIanitorValidator", undefined>;
  "no-ianitor-success-access": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferCreateGuard", undefined>;
  "no-identity-map": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly bindingPatterns: {
        readonly default: readonly string[];
        readonly description: "Variable name patterns to recognize as Bindings (case insensitive)";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "identityArrayMap" | "identityBindingMap", undefined>;
  "no-increment-decrement": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowAutofix: {
        readonly default: false;
        readonly description: "Allow the fixer to replace standalone ++ and -- statements and for-loop updates.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "noDecrement" | "noIncrement", undefined>;
  "no-initialize-state": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidInitializingState", undefined>;
  "no-inline-property-on-memo-component": import("oxlint-plugin-utilities").CreateRule<undefined, "inlineProperty", undefined>;
  "no-instance-methods-without-this": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly checkPrivate: {
        readonly default: true;
        readonly description: "Check private methods (default: true)";
        readonly type: "boolean";
      };
      readonly checkProtected: {
        readonly default: true;
        readonly description: "Check protected methods (default: true)";
        readonly type: "boolean";
      };
      readonly checkPublic: {
        readonly default: true;
        readonly description: "Check public methods (default: true)";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "noInstanceMethodWithoutThis", undefined>;
  "no-jsx-spread-child": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "noJsxSpreadChild", undefined>;
  "no-known-value-widening": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "widening", undefined>;
  "no-loop-iterable-mutation": import("oxlint-plugin-utilities").CreateRule<readonly [], "noLoopIterableMutation", undefined>;
  "no-module-mocking": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "moduleMock", undefined>;
  "no-native-properties-spread": import("oxlint-plugin-utilities").CreateRule<readonly [], "noElementSpread" | "noNativePropertiesSpread", undefined>;
  "no-nested-hook-calls": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "nestedHookCall", undefined>;
  "no-new-instance-in-use-memo": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly constructors: {
        readonly default: readonly string[];
        readonly description: "Constructor identifiers that should be disallowed inside useMemo callbacks.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
      readonly maxHelperTraceDepth: {
        readonly default: 4;
        readonly description: "Maximum depth for tracing local helper function calls from useMemo callbacks. 0 disables helper traversal.";
        readonly minimum: 0;
        readonly type: "integer";
      };
    };
    readonly type: "object";
  }], "noNewInUseMemo", undefined>;
  "no-object-parameters": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "objectParameter", undefined>;
  "no-pass-data-to-parent": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidPassingDataToParentInComponent" | "avoidPassingDataToParentInHook", undefined>;
  "no-pass-live-state-to-parent": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidPassingLiveStateToParentInComponent" | "avoidPassingLiveStateToParentInHook", undefined>;
  "no-print": import("oxlint-plugin-utilities").CreateRule<readonly [], "noPrint", readonly []>;
  "no-real-temporary-directory": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly default: {
      readonly additionalFunctions: readonly [];
    };
    readonly properties: {
      readonly additionalFunctions: {
        readonly default: readonly [];
        readonly description: "More functions that create or locate a real temp directory, grouped by the module that exports them";
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly functions: {
              readonly description: "The exported functions, as dotted paths for namespaces, such as `dirSync` or `promises.dir`";
              readonly items: {
                readonly type: "string";
              };
              readonly minItems: 1;
              readonly type: "array";
            };
            readonly source: {
              readonly description: "The module specifier, such as `tmp`; a `node:` prefix is optional";
              readonly type: "string";
            };
          };
          readonly required: readonly ["functions", "source"];
          readonly type: "object";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "noRealTemporaryDirectory", undefined>;
  "no-recursive": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {};
    readonly type: "object";
  }], "noRecursive", undefined>;
  "no-reduce-accumulator-copy": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "accumulatorCopy", undefined>;
  "no-redundant-aspect-ratio-constraint": import("oxlint-plugin-utilities").CreateRule<readonly [], "redundantAspectRatioConstraint", undefined>;
  "no-reflect-apply": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "reflectApply", undefined>;
  "no-reflect-get": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "reflectGet", undefined>;
  "no-render-helper-functions": import("oxlint-plugin-utilities").CreateRule<readonly [], "noRenderHelper", undefined>;
  "no-reset-all-state-on-prop-change": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "avoidResettingAllStateWhenAPropChanges", undefined>;
  "no-restricted-property-assignment": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowFiles: {
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly checkComputed: {
        readonly default: true;
        readonly type: "boolean";
      };
      readonly restrictions: {
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly message: {
              readonly type: "string";
            };
            readonly object: {
              readonly type: "string";
            };
            readonly properties: {
              readonly items: {
                readonly type: "string";
              };
              readonly minItems: 1;
              readonly type: "array";
            };
          };
          readonly required: readonly ["object", "properties"];
          readonly type: "object";
        };
        readonly type: "array";
      };
    };
    readonly required: readonly ["restrictions"];
    readonly type: "object";
  }], "restricted" | "restrictedCustom", undefined>;
  "no-runtime-in-type-files": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly default: {
      files: readonly ["**/packages/*/src/lib/**/*-types.ts"];
    };
    readonly properties: {
      readonly files: {
        readonly default: readonly ["**/packages/*/src/lib/**/*-types.ts"];
        readonly description: "Glob patterns for the files that may hold only declarations that erase, matched against the full path";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "noRuntimeInTypeFile", undefined>;
  "no-runtime-typeof": import("oxlint-plugin-utilities").CreateOnceRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowInTypeGuards: {
        readonly default: false;
        readonly description: "Allow `typeof` inside functions whose return type is a type predicate (`value is T`) or an assertion predicate (`asserts value is T`).";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "runtimeTypeof", readonly [{
    readonly allowInTypeGuards: false;
  }]>;
  "no-shape-in-symbol-names": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "forbiddenSymbolName", undefined>;
  "no-spec-file-extension": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "noSpecFileExtension", undefined>;
  "no-static-react-create-element": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "useJsx", undefined>;
  "no-table-create-map": import("oxlint-plugin-utilities").CreateRule<readonly [], "avoidConstructThenMap", undefined>;
  "no-task-wait": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "noPromiseDelayAwait" | "noTaskWait", undefined>;
  "no-test-timeout": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly default: {
      readonly additionalTestFunctions: readonly [];
    };
    readonly properties: {
      readonly additionalTestFunctions: {
        readonly default: readonly [];
        readonly description: "Names of test or suite functions to check besides `describe`, `fit`, `it`, `test`, `xit`, and `xtest`";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "noTestTimeout", undefined>;
  "no-trivial-assertions": import("oxlint-plugin-utilities").CreateRule<readonly [], "freshIdentity" | "freshPredicate" | "issue", undefined>;
  "no-underscore-react-props": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "noUnderscoreReactProperty", undefined>;
  "no-unknown-parameters": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "unknownParameter", undefined>;
  "no-unknown-returns": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "unknownReturn", undefined>;
  "no-unknown-type-aliases": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "unknownAlias", undefined>;
  "no-unsafe-dictionary-type": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "unsafeDictionary", undefined>;
  "no-unsupported-syntax": import("oxlint-plugin-utilities").CreateOnceRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly globalThis: {
        readonly default: true;
        readonly description: "Disallow the globalThis identifier.";
        readonly type: "boolean";
      };
      readonly labels: {
        readonly default: true;
        readonly description: "Disallow labeled statements.";
        readonly type: "boolean";
      };
      readonly prototype: {
        readonly default: true;
        readonly description: "Disallow `.prototype` member access.";
        readonly type: "boolean";
      };
      readonly regexLiterals: {
        readonly default: true;
        readonly description: "Disallow regular expression literals.";
        readonly type: "boolean";
      };
      readonly spreadDestructuring: {
        readonly default: true;
        readonly description: "Disallow rest elements in destructuring patterns.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "globalThis" | "label" | "prototype" | "regexLiteral" | "spreadDestructuring", undefined>;
  "no-unused-imports": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly checkJSDoc: {
        readonly default: true;
        readonly description: "Check if imports are referenced in JSDoc comments";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "unusedImport", undefined>;
  "no-unused-use-memo": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "unusedUseMemo", undefined>;
  "no-use-memo-simple-expression": import("oxlint-plugin-utilities").CreateRule<undefined, "simpleMemo", undefined>;
  "no-use-of-empty-return-value": import("oxlint-plugin-utilities").CreateRule<readonly [], "removeUseOfOutput", undefined>;
  "no-useless-constants": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly ignoreCallPatterns: {
        readonly default: readonly string[];
        readonly description: "Regular expression patterns for call expressions that should be ignored.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "uselessConstant" | "uselessConstantNoFix" | "uselessConstants", undefined>;
  "no-useless-default": import("oxlint-plugin-utilities").CreateRule<readonly [], "uselessDefault", undefined>;
  "no-useless-empty-string-comparison": import("oxlint-plugin-utilities").CreateOnceRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowAutofix: {
        readonly default: false;
        readonly description: "Rewrite strict comparisons to `.length` automatically. Off by default because the rule cannot see types, and `.length` throws on a nullish operand.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "looseEmptyStringComparison" | "suggestLengthComparison" | "useLengthComparison", undefined>;
  "no-useless-use-effect": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
      readonly hooks: {
        readonly default: readonly ["useEffect", "useLayoutEffect", "useInsertionEffect"];
        readonly description: "Effect hook names checked for avoidable effect patterns.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly propertyCallbackPrefixes: {
        readonly default: readonly ["on"];
        readonly description: "Property name prefixes treated as event callback props.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly refHooks: {
        readonly default: readonly ["useRef"];
        readonly description: "Ref hook names that return mutable ref objects.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly reportAdjustState: {
        readonly default: true;
        readonly description: "Report effects that only adjust state after render.";
        readonly type: "boolean";
      };
      readonly reportDerivedState: {
        readonly default: true;
        readonly description: "Report effects that copy derived values into state.";
        readonly type: "boolean";
      };
      readonly reportDuplicateDeps: {
        readonly default: true;
        readonly description: "Report duplicate entries in effect dependency arrays.";
        readonly type: "boolean";
      };
      readonly reportEffectChain: {
        readonly default: true;
        readonly description: "Report effects that only trigger another effect through state.";
        readonly type: "boolean";
      };
      readonly reportEmptyEffect: {
        readonly default: true;
        readonly description: "Report effects whose callback body is empty.";
        readonly type: "boolean";
      };
      readonly reportEventFlag: {
        readonly default: true;
        readonly description: "Report effects that react to event flags stored in state.";
        readonly type: "boolean";
      };
      readonly reportEventSpecificLogic: {
        readonly default: true;
        readonly description: "Report effects that move event-specific logic out of the event callback.";
        readonly type: "boolean";
      };
      readonly reportExternalStore: {
        readonly default: true;
        readonly description: "Report effects that mirror external store values into local state.";
        readonly type: "boolean";
      };
      readonly reportInitializeState: {
        readonly default: true;
        readonly description: "Report effects that only initialize state after mount.";
        readonly type: "boolean";
      };
      readonly reportLogOnly: {
        readonly default: true;
        readonly description: "Report effects that only log values.";
        readonly type: "boolean";
      };
      readonly reportMixedDerivedState: {
        readonly default: true;
        readonly description: "Report effects that mix derived-state updates with other work.";
        readonly type: "boolean";
      };
      readonly reportNotifyParent: {
        readonly default: true;
        readonly description: "Report effects that only notify a parent through a callback prop.";
        readonly type: "boolean";
      };
      readonly reportPassRefToParent: {
        readonly default: true;
        readonly description: "Report effects that only pass a ref value to a parent callback.";
        readonly type: "boolean";
      };
      readonly reportResetState: {
        readonly default: true;
        readonly description: "Report effects that reset local state when inputs change.";
        readonly type: "boolean";
      };
      readonly stateHooks: {
        readonly default: readonly ["useState", "useReducer"];
        readonly description: "State hook names that return [value, setter] pairs.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "adjustState" | "derivedState" | "duplicateDeps" | "effectChain" | "emptyEffect" | "eventFlag" | "eventSpecificLogic" | "externalStore" | "initializeState" | "logOnly" | "mixedDerivedState" | "notifyParent" | "passRefToParent" | "resetState", undefined>;
  "no-useless-use-memo": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly dependencyMode: {
        readonly default: DependencyMode.NonUpdating;
        readonly description: "Dependency-array mode used to decide whether a memoized value is static.";
        readonly enum: readonly [DependencyMode.EmptyOrOmitted, DependencyMode.Aggressive, DependencyMode.NonUpdating];
        readonly type: "string";
      };
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
      readonly staticGlobalFactories: {
        readonly default: readonly string[];
        readonly description: "Global constructors and factories whose calls are treated as static values.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "uselessUseMemo", undefined>;
  "no-useless-use-spring": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly default: {
      readonly springHooks: readonly string[];
      readonly staticGlobalFactories: readonly string[];
      readonly treatEmptyDepsAsViolation: true;
    };
    readonly properties: {
      readonly springHooks: {
        readonly default: readonly string[];
        readonly description: "Hook identifiers that should be treated as spring hooks";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly staticGlobalFactories: {
        readonly default: readonly string[];
        readonly description: "Global factory identifiers that are treated as static constructors";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly treatEmptyDepsAsViolation: {
        readonly default: true;
        readonly description: "Treat static config with an empty dependency array as a violation";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "uselessSpring", undefined>;
  "no-variadic-spread": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "noVariadicSpread", undefined>;
  "no-warn": import("oxlint-plugin-utilities").CreateRule<readonly [], "noWarn", readonly []>;
  "no-widen-then-assert": import("oxlint-plugin-utilities").CreateOnceRule<undefined, "widenThenAssert", undefined>;
  "only-type-imports": import("oxlint-plugin-utilities").CreateRule<readonly [], "onlyTypeImports", undefined>;
  "prefer-class-properties": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly enum: readonly ["always", "never"];
    readonly type: "string";
  }], "unexpectedAssignment" | "unexpectedClassProperty", undefined>;
  "prefer-constant-dispatch": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferConstantDispatch", undefined>;
  "prefer-context-stack": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferContextStack", undefined>;
  "prefer-direct-hook-imports": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowedHooks: {
        readonly description: "Hook names that are allowed to be called via React namespace.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "preferDirectHookImport", undefined>;
  "prefer-early-return": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly maximumStatements: {
        readonly default: 1;
        readonly description: "Maximum allowed statement count inside the guarded branch before reporting.";
        readonly minimum: 0;
        readonly type: "number";
      };
    };
    readonly type: "object";
  }], "preferEarlyReturn", undefined>;
  "prefer-expect-assertions": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly additionalAssertionFunctions: {
        readonly default: readonly [];
        readonly description: "Additional assertion function names counted as test assertions.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly additionalExpectCallNames: {
        readonly default: readonly [];
        readonly description: "Additional expect-like call names counted when checking assertion counts.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly onlyFunctionsWithAsyncKeyword: {
        readonly default: false;
        readonly description: "Only require assertion guards for test callbacks marked async.";
        readonly type: "boolean";
      };
      readonly onlyFunctionsWithExpectInCallback: {
        readonly default: false;
        readonly description: "Only require assertion guards when expect is called inside a nested callback.";
        readonly type: "boolean";
      };
      readonly onlyFunctionsWithExpectInLoop: {
        readonly default: false;
        readonly description: "Only require assertion guards when expect is called inside a loop.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "assertionsRequiresNumberArgument" | "assertionsRequiresOneArgument" | "hasAssertionsTakesNoArguments" | "haveExpectAssertions" | "preferAssertionsCount" | "suggestAddingAssertions" | "suggestAddingHasAssertions" | "wrongAssertionCount", undefined>;
  "prefer-hoisted-jsx-elements": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly additionalHoistableComponents: {
        readonly description: "Additional component names that can be hoisted to module-level constants.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly additionalStaticFactories: {
        readonly description: "Additional factory functions whose return values are considered static.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "hoistableJsxElement", undefined>;
  "prefer-hoisted-jsx-object-properties": import("oxlint-plugin-utilities").CreateRule<readonly [], "hoistableObjectProp", undefined>;
  "prefer-idiv": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "useIdiv", undefined>;
  "prefer-local-portal-component": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferPortalComponent", undefined>;
  "prefer-math-min-max": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferMathMethod", undefined>;
  "prefer-membership-filter-in-jecs": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferMembershipFilter", undefined>;
  "prefer-modding-inspect": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferModdingInspect", undefined>;
  "prefer-module-scope-constants": import("oxlint-plugin-utilities").CreateRule<readonly [], "mustBeModuleScope" | "mustUseConst", undefined>;
  "prefer-native-collection-copy": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferNativeCollectionCopy", undefined>;
  "prefer-optional-parameter": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "preferOptionalParameter", undefined>;
  "prefer-padding-components": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferDirectionalPadding" | "preferEqualPadding", undefined>;
  "prefer-pascal-case-enums": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "notPascalCase", undefined>;
  "prefer-sequence-overloads": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "preferSingleOverload" | "preferTwoPointOverload", undefined>;
  "prefer-single-world-query-in-jecs": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferSingleGet" | "preferSingleHas", undefined>;
  "prefer-singular-enums": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "notSingular", undefined>;
  "prefer-ternary-conditional-rendering": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferTernaryConditionalRendering", undefined>;
  "prefer-udim2-shorthand": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferFromOffset" | "preferFromScale", undefined>;
  "prefer-use-reducer": import("oxlint-plugin-utilities").CreateRule<undefined, "excessiveUseState", undefined>;
  "prevent-abbreviations": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowList: {
        readonly additionalProperties: {
          readonly type: "boolean";
        };
        readonly default: Record<string, boolean>;
        readonly defaultLabel: "default allow list";
        readonly description: "Names that should be allowed even when they match a discouraged abbreviation.";
        readonly type: "object";
      };
      readonly allowPropertyAccess: {
        readonly default: string[];
        readonly description: "Property names that may keep abbreviated member access.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly checkDefaultAndNamespaceImports: {
        readonly default: "internal";
        readonly description: "Whether default and namespace import local names should be checked.";
        readonly enum: readonly [false, true, "internal"];
      };
      readonly checkFilenames: {
        readonly default: true;
        readonly description: "Whether file names should be checked for abbreviations.";
        readonly type: "boolean";
      };
      readonly checkProperties: {
        readonly default: false;
        readonly description: "Whether object, member, and JSX property names should be checked.";
        readonly type: "boolean";
      };
      readonly checkShorthandImports: {
        readonly default: "internal";
        readonly description: "Whether renamed shorthand imports should be checked.";
        readonly enum: readonly [false, true, "internal"];
      };
      readonly checkShorthandProperties: {
        readonly default: true;
        readonly description: "Whether shorthand object property names should be checked.";
        readonly type: "boolean";
      };
      readonly checkVariables: {
        readonly default: true;
        readonly description: "Whether variable, function, class, and component names should be checked.";
        readonly type: "boolean";
      };
      readonly extendDefaultAllowList: {
        readonly default: true;
        readonly description: "Merge configured allowList entries with the default allow list.";
        readonly type: "boolean";
      };
      readonly extendDefaultReplacements: {
        readonly default: true;
        readonly description: "Merge configured replacements with the default replacement map.";
        readonly type: "boolean";
      };
      readonly ignore: {
        readonly default: string[];
        readonly description: "Names or regular expression patterns that should be ignored.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly ignoreShorthands: {
        readonly default: readonly [];
        readonly description: "Shorthand names that should not be reported.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly replacements: {
        readonly additionalProperties: {
          readonly oneOf: readonly [{
            readonly enum: readonly [false];
          }, {
            readonly additionalProperties: {
              readonly type: "boolean";
            };
            readonly type: "object";
          }];
        };
        readonly default: Record<string, Record<string, boolean>>;
        readonly defaultLabel: "default replacement map";
        readonly description: "Replacement suggestions for discouraged names.";
        readonly type: "object";
      };
      readonly shorthands: {
        readonly additionalProperties: {
          readonly type: "string";
        };
        readonly default: {
          args: string;
          char: string;
          dt: string;
          plr: string;
        };
        readonly defaultLabel: "default shorthands";
        readonly description: "Shorthand names and the full names they should expand to.";
        readonly type: "object";
      };
    };
    readonly type: "object";
  }], "replace" | "suggestion", undefined>;
  "react-hooks-strict-return": import("oxlint-plugin-utilities").CreateRule<readonly [], "tooManyReturnValues", undefined>;
  "require-async-suffix": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly except: {
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "missingAsyncSuffix", undefined>;
  "require-module-level-instantiation": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly classes: {
        readonly additionalProperties: {
          readonly type: "string";
        };
        readonly description: "Class names mapped to the import source that must be instantiated at module scope.";
        readonly type: "object";
      };
    };
    readonly type: "object";
  }], "mustBeModuleLevel", undefined>;
  "require-named-effect-functions": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly environment: {
        readonly default: "roblox-ts";
        readonly description: "Environment mode: 'roblox-ts' only allows identifiers, 'standard' allows both identifiers and named function expressions";
        readonly enum: readonly ["roblox-ts", "standard"];
        readonly type: "string";
      };
      readonly hooks: {
        readonly default: readonly [{
          readonly name: "useEffect";
          readonly allowAsync: false;
        }, {
          readonly name: "useLayoutEffect";
          readonly allowAsync: false;
        }, {
          readonly name: "useInsertionEffect";
          readonly allowAsync: false;
        }];
        readonly description: "Hook configuration objects with name and allowAsync settings.";
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly name: {
              readonly description: "Hook name to check";
              readonly type: "string";
            };
            readonly allowAsync: {
              readonly description: "Whether async functions are allowed for this hook";
              readonly type: "boolean";
            };
          };
          readonly required: readonly ["name", "allowAsync"];
          readonly type: "object";
        };
        readonly type: "array";
      };
      readonly inlineFunctionDeclarations: {
        readonly default: false;
        readonly description: "Convert effect callbacks that reference a named function declaration into inline named function expressions (standard and sloptor modes only), keeping the effect body visible to dependency analysis. When the declaration is only referenced by the effect and is not exported or commented, the fix also removes the now-unused declaration.";
        readonly type: "boolean";
      };
      readonly sloptor: {
        readonly default: false;
        readonly description: "Compile with sloptor (a Go-based roblox-ts compiler). Sloptor targets @rbxts/react like roblox-ts but supports standard TypeScript features, so the rule applies standard-mode behavior. Use with environment: 'roblox-ts'.";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "anonymousFunction" | "arrowFunction" | "asyncAnonymousFunction" | "asyncArrowFunction" | "asyncFunctionDeclaration" | "asyncFunctionExpression" | "functionExpression" | "identifierReferencesArrow" | "identifierReferencesAsyncArrow" | "identifierReferencesAsyncFunction" | "identifierReferencesCallback" | "identifierReferencesFunctionDeclaration", undefined>;
  "require-paired-calls": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowConditionalClosers: {
        readonly default: false;
        readonly description: "Allow closer calls that appear only on some conditional paths.";
        readonly type: "boolean";
      };
      readonly allowMultipleOpeners: {
        readonly default: true;
        readonly description: "Allow repeated opener calls before matching closer calls.";
        readonly type: "boolean";
      };
      readonly maxNestingDepth: {
        readonly default: 0;
        readonly description: "Maximum opener nesting depth before reporting; 0 disables the limit.";
        readonly minimum: 0;
        readonly type: "number";
      };
      readonly pairs: {
        readonly default: readonly [{
          readonly closer: "debug.profileend";
          readonly opener: "debug.profilebegin";
          readonly platform: "roblox";
          readonly requireSync: true;
          readonly yieldingFunctions: readonly ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
        }];
        readonly description: "Opener and closer call pairs that must stay balanced.";
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly alternatives: {
              readonly items: {
                readonly minLength: 1;
                readonly type: "string";
              };
              readonly type: "array";
            };
            readonly closer: {
              readonly oneOf: readonly [{
                readonly minLength: 1;
                readonly type: "string";
              }, {
                readonly items: {
                  readonly minLength: 1;
                  readonly type: "string";
                };
                readonly minItems: 1;
                readonly type: "array";
              }];
            };
            readonly opener: {
              readonly minLength: 1;
              readonly type: "string";
            };
            readonly openerAlternatives: {
              readonly items: {
                readonly minLength: 1;
                readonly type: "string";
              };
              readonly type: "array";
            };
            readonly platform: {
              readonly enum: readonly ["roblox"];
              readonly type: "string";
            };
            readonly requireSync: {
              readonly default: false;
              readonly type: "boolean";
            };
            readonly yieldingFunctions: {
              readonly items: {
                readonly minLength: 1;
                readonly type: "string";
              };
              readonly type: "array";
            };
          };
          readonly required: readonly ["opener", "closer"];
          readonly type: "object";
        };
        readonly minItems: 1;
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "asyncViolation" | "conditionalOpener" | "maxNestingExceeded" | "multipleOpeners" | "robloxYieldViolation" | "unexpectedCloser" | "unpairedCloser" | "unpairedOpener" | "wrongOrder", undefined>;
  "require-react-component-keys": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowRootKeys: {
        readonly default: boolean;
        readonly description: "Allow key props on root component returns";
        readonly type: "boolean";
      };
      readonly ignoreCallExpressions: {
        readonly default: readonly string[];
        readonly description: "Function calls where JSX arguments don't need keys";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly iterationMethods: {
        readonly default: readonly string[];
        readonly description: "Array method names that indicate iteration contexts where keys are required";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly memoizationHooks: {
        readonly default: readonly string[];
        readonly description: "Hook names that indicate memoization contexts where keys are required";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "missingKey" | "rootComponentWithKey", undefined>;
  "require-react-display-names": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      environment: {
        default: "roblox-ts";
        description: string;
        enum: readonly ["roblox-ts", "standard"];
        type: string;
      };
    };
    readonly type: "object";
  }], "directContextExport" | "directMemoExport" | "missingContextDisplayName" | "missingMemoDisplayName", undefined>;
  "require-readable-spacing": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly default: {
      readonly afterBlocks: boolean;
      readonly afterImports: boolean;
      readonly allowAttachedUses: boolean;
      readonly allowGuardClauseRuns: boolean;
      readonly allowMultilineBindingRuns: boolean;
      readonly aroundDeclarations: boolean;
      readonly aroundMultilineBindings: boolean;
      readonly beforeControlFlow: boolean;
      readonly betweenTopLevelStatements: boolean;
      readonly overrides: readonly [];
    };
    readonly properties: {
      readonly afterBlocks: {
        readonly default: true;
        readonly description: "Require a blank line after a statement that ends in a block";
        readonly type: "boolean";
      };
      readonly afterImports: {
        readonly default: true;
        readonly description: "Require a blank line after the import group";
        readonly type: "boolean";
      };
      readonly allowAttachedUses: {
        readonly default: false;
        readonly description: "Let a statement stay attached to the one-line statement above it when it reads a name that statement declares or assigns";
        readonly type: "boolean";
      };
      readonly allowGuardClauseRuns: {
        readonly default: false;
        readonly description: "Let one-line `if` statements, and a one-line `return` or `throw` after one, stay grouped";
        readonly type: "boolean";
      };
      readonly allowMultilineBindingRuns: {
        readonly default: false;
        readonly description: "Let consecutive bindings stay grouped when one of them spans lines";
        readonly type: "boolean";
      };
      readonly aroundDeclarations: {
        readonly default: true;
        readonly description: "Require blank lines around functions, classes, interfaces, and types";
        readonly type: "boolean";
      };
      readonly aroundMultilineBindings: {
        readonly default: true;
        readonly description: "Require blank lines around bindings that span lines";
        readonly type: "boolean";
      };
      readonly beforeControlFlow: {
        readonly default: true;
        readonly description: "Require a blank line before control flow statements";
        readonly type: "boolean";
      };
      readonly betweenTopLevelStatements: {
        readonly default: true;
        readonly description: "Require blank lines between top-level statements";
        readonly type: "boolean";
      };
      readonly overrides: {
        readonly default: readonly [];
        readonly description: "Padding entries checked before the built-in ones, highest priority first. The first entry that matches a pair of statements decides it";
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly blankLine: {
              readonly description: "`always` requires a blank line between the statements; `any` accepts either spacing";
              readonly enum: readonly ["always", "any"];
              readonly type: "string";
            };
            readonly next: {
              readonly anyOf: readonly [{
                readonly enum: readonly ["*", "binding", "block-like", "break", "class", "continue", "control-flow", "declaration", "enum", "export", "expression", "function", "if", "import", "interface", "loop", "multiline", "multiline-binding", "overload", "return", "single-line", "single-line-binding", "single-line-if", "switch", "throw", "top-level", "try", "type"];
                readonly type: "string";
              }, {
                readonly items: {
                  readonly enum: readonly ["*", "binding", "block-like", "break", "class", "continue", "control-flow", "declaration", "enum", "export", "expression", "function", "if", "import", "interface", "loop", "multiline", "multiline-binding", "overload", "return", "single-line", "single-line-binding", "single-line-if", "switch", "throw", "top-level", "try", "type"];
                  readonly type: "string";
                };
                readonly minItems: 1;
                readonly type: "array";
              }];
              readonly description: "The kind or kinds of the second statement";
            };
            readonly previous: {
              readonly anyOf: readonly [{
                readonly enum: readonly ["*", "binding", "block-like", "break", "class", "continue", "control-flow", "declaration", "enum", "export", "expression", "function", "if", "import", "interface", "loop", "multiline", "multiline-binding", "overload", "return", "single-line", "single-line-binding", "single-line-if", "switch", "throw", "top-level", "try", "type"];
                readonly type: "string";
              }, {
                readonly items: {
                  readonly enum: readonly ["*", "binding", "block-like", "break", "class", "continue", "control-flow", "declaration", "enum", "export", "expression", "function", "if", "import", "interface", "loop", "multiline", "multiline-binding", "overload", "return", "single-line", "single-line-binding", "single-line-if", "switch", "throw", "top-level", "try", "type"];
                  readonly type: "string";
                };
                readonly minItems: 1;
                readonly type: "array";
              }];
              readonly description: "The kind or kinds of the first statement";
            };
            readonly usesPrevious: {
              readonly default: false;
              readonly description: "Match only when the second statement reads a name that the first one declares or assigns";
              readonly type: "boolean";
            };
          };
          readonly required: readonly ["blankLine", "next", "previous"];
          readonly type: "object";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "expectedBlankLine", undefined>;
  "require-safety-comment-for-type-assertion": import("oxlint-plugin-utilities").CreateOnceRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly markers: {
        readonly default: readonly ["SAFETY"];
        readonly description: "Comment markers that introduce a justification, written as `MARKER:` followed by non-whitespace text.";
        readonly items: {
          readonly minLength: 1;
          readonly type: "string";
        };
        readonly minItems: 1;
        readonly type: "array";
        readonly uniqueItems: true;
      };
    };
    readonly type: "object";
  }], "missingSafetyComment", readonly [{
    readonly markers: readonly ["SAFETY"];
  }]>;
  "require-switch-case-braces": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly metric: {
        readonly default: "lines";
        readonly description: "Whether to report cases by line span or by statement count.";
        readonly enum: readonly ["lines", "statements"];
        readonly type: "string";
      };
    };
    readonly type: "object";
  }], "wrapCaseBody", undefined>;
  "require-throw-error-capture": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allow: {
        readonly description: "Error classes that do not need Error.captureStackTrace";
        readonly items: {
          readonly anyOf: readonly [{
            readonly type: "string";
          }, {
            readonly additionalProperties: false;
            readonly properties: {
              readonly name: {
                readonly anyOf: readonly [{
                  readonly type: "string";
                }, {
                  readonly items: {
                    readonly type: "string";
                  };
                  readonly type: "array";
                }];
                readonly description: "Name(s) of the error class";
              };
              readonly from: {
                readonly description: "Where the error class is declared";
                readonly enum: readonly ["file", "library", "package"];
                readonly type: "string";
              };
              readonly package: {
                readonly description: "Package the error class is imported from (required when from is 'package')";
                readonly type: "string";
              };
              readonly path: {
                readonly description: "Optional file path filter for file specifiers (matched against the end of the file path)";
                readonly type: "string";
              };
            };
            readonly required: readonly ["name"];
            readonly type: "object";
          }];
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "missingCaptureStackTrace", undefined>;
  "require-tsx-for-hooks": import("oxlint-plugin-utilities").CreateRule<readonly [], "requireTsxForHooks", undefined>;
  "require-unicode-regex": import("oxlint-plugin-utilities").CreateOnceRule<readonly [], "requireUnicodeFlag", undefined>;
  "rerender-memo-with-default-value": import("oxlint-plugin-utilities").CreateRule<undefined, "emptyArrayDefault" | "emptyObjectDefault", undefined>;
  "starts-with-verb": import("oxlint-plugin-utilities").CreateOnceRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allowList: {
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly denyList: {
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "notVerb", undefined>;
  "strict-component-boundaries": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly allow: {
        readonly default: readonly [];
        readonly description: "Regular expression patterns for imports allowed to cross component boundaries.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly maxDepth: {
        readonly default: 1;
        readonly description: "Maximum path depth allowed inside another component before reporting.";
        readonly type: "integer";
      };
    };
    readonly type: "object";
  }], "noReachingIntoComponent", undefined>;
  "use-exhaustive-dependencies": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly hooks: {
        readonly default: readonly [];
        readonly description: "Array of custom hook entries to check for exhaustive dependencies";
        readonly items: {
          readonly additionalProperties: false;
          readonly properties: {
            readonly name: {
              readonly description: "The name of the hook";
              readonly type: "string";
            };
            readonly closureIndex: {
              readonly description: "Index of the closure argument for dependency validation";
              readonly type: "number";
            };
            readonly dependenciesIndex: {
              readonly description: "Index of the dependencies array for validation";
              readonly type: "number";
            };
            readonly stableResult: {
              readonly description: "Specify stable results: true (whole result), number (array index), number[] (multiple indices), or string[] (object properties)";
              readonly oneOf: readonly [{
                readonly type: "boolean";
              }, {
                readonly type: "number";
              }, {
                readonly items: {
                  readonly type: "number";
                };
                readonly type: "array";
              }, {
                readonly items: {
                  readonly type: "string";
                };
                readonly type: "array";
              }];
            };
          };
          readonly required: readonly ["name"];
          readonly type: "object";
        };
        readonly type: "array";
      };
      readonly reportMissingDependenciesArray: {
        readonly default: true;
        readonly description: "Report when the dependencies array is completely missing";
        readonly type: "boolean";
      };
      readonly reportUnnecessaryDependencies: {
        readonly default: true;
        readonly description: "Report when unnecessary dependencies are specified";
        readonly type: "boolean";
      };
      readonly reportUnnecessaryStableDependencies: {
        readonly default: false;
        readonly description: "Report when stable values (useRef, useState setter, etc.) are included as dependencies";
        readonly type: "boolean";
      };
      readonly resolveExpressionDependencies: {
        readonly default: true;
        readonly description: "Recognize expression dependencies like `value !== undefined` as covering a capture";
        readonly type: "boolean";
      };
    };
    readonly type: "object";
  }], "addDependenciesArraySuggestion" | "addDependencySuggestion" | "addMissingDependenciesSuggestion" | "missingDependencies" | "missingDependenciesArray" | "missingDependency" | "removeDependencySuggestion" | "unnecessaryDependency" | "unstableDependency", undefined>;
  "use-hook-at-top-level": import("oxlint-plugin-utilities").CreateRule<readonly [{
    readonly additionalProperties: false;
    readonly properties: {
      readonly ignoreHooks: {
        readonly description: "Hook names that should be ignored even when they match the hook naming pattern.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
      readonly importSources: {
        readonly additionalProperties: {
          readonly type: "boolean";
        };
        readonly description: "Import sources or namespace names mapped to whether their hooks should be checked.";
        readonly type: "object";
      };
      readonly onlyHooks: {
        readonly description: "If set, only these hook names are checked.";
        readonly items: {
          readonly type: "string";
        };
        readonly type: "array";
      };
    };
    readonly type: "object";
  }], "afterEarlyReturn" | "conditionalHook" | "loopHook" | "nestedFunction" | "recursiveHookCall" | "tryBlockHook", undefined>;
}>;
//#endregion
export { smallRules as default };