@pobammer-ts/small-rules 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1246 @@
+//#region src/index.d.ts
+declare const smallRules: import("oxlint-plugin-utilities").Plugin<{
+  "array-type-generic": import("oxlint-plugin-utilities").CreateRule<readonly [], "useGenericArrayType", readonly []>;
+  "ban-instances": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly bannedInstances?: readonly string[] | {
+      readonly [x: string]: string;
+    };
+    readonly bannedProperties?: {
+      readonly [x: string]: {
+        readonly [x: string]: string;
+      };
+    };
+  }], "bannedInstance" | "bannedInstanceCustom" | "bannedProperty" | "bannedPropertyCustom", 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";
+  }]>;
+  "ban-react-fc": import("oxlint-plugin-utilities").CreateRule<readonly [], "banReactFC", readonly []>;
+  "ban-types": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly bannedTypes?: readonly string[] | {
+      readonly [x: string]: string;
+    };
+  }], "bannedType" | "bannedTypeWithReplacement", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly bannedTypes: {
+        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";
+  }]>;
+  "directive-disable-enable-pair": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allowWholeFile?: boolean;
+  }], "missingPair" | "missingRulePair", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      allowWholeFile: {
+        type: "boolean";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "directive-no-aggregating-enable": import("oxlint-plugin-utilities").CreateRule<readonly [], "aggregatingEnable", readonly []>;
+  "directive-no-duplicate-disable": import("oxlint-plugin-utilities").CreateRule<readonly [], "duplicate" | "duplicateRule", readonly []>;
+  "directive-no-restricted-disable": import("oxlint-plugin-utilities").CreateRule<readonly string[], "disallow", {
+    readonly items: {
+      type: "string";
+    };
+    readonly type: "array";
+    readonly uniqueItems: true;
+  }>;
+  "directive-no-unlimited-disable": import("oxlint-plugin-utilities").CreateRule<readonly [], "unexpected", readonly []>;
+  "directive-no-unused-enable": import("oxlint-plugin-utilities").CreateRule<readonly [], "unused" | "unusedRule", readonly []>;
+  "directive-no-use": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allow?: readonly string[];
+  }], "disallow", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly allow: {
+        readonly items: {
+          type: "string";
+        };
+        readonly type: "array";
+        readonly uniqueItems: true;
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "directive-require-description": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly ignore?: readonly string[];
+  }], "missingDescription", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly ignore: {
+        readonly items: {
+          type: "string";
+        };
+        readonly type: "array";
+        readonly uniqueItems: true;
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "enforce-ianitor-check-type": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly baseThreshold?: number;
+    readonly errorThreshold?: number;
+    readonly interfacePenalty?: number;
+    readonly performanceMode?: boolean;
+    readonly warnThreshold?: number;
+  }], "complexInterfaceNeedsCheck" | "missingIanitorCheckType", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly baseThreshold: {
+        readonly minimum: 1;
+        readonly type: "number";
+      };
+      readonly errorThreshold: {
+        readonly minimum: 1;
+        readonly type: "number";
+      };
+      readonly interfacePenalty: {
+        readonly minimum: 1;
+        readonly type: "number";
+      };
+      readonly performanceMode: {
+        readonly type: "boolean";
+      };
+      readonly warnThreshold: {
+        readonly minimum: 1;
+        readonly type: "number";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "memoized-effect-dependencies": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly environment?: "roblox-ts" | "standard";
+    readonly hooks?: readonly {
+      readonly dependenciesIndex?: number;
+      readonly name: string;
+    }[];
+    readonly mode?: "aggressive" | "definite" | "moderate";
+  }], "unmemoizedDependency", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly environment: {
+        readonly default: "roblox-ts";
+        readonly description: "The React environment: 'roblox-ts' uses @rbxts/react, 'standard' uses react.";
+        readonly enum: readonly ["roblox-ts", "standard"];
+        readonly type: "string";
+      };
+      readonly hooks: {
+        readonly description: "Array of effect hook entries to check for memoized dependencies";
+        readonly items: {
+          readonly additionalProperties: false;
+          readonly properties: {
+            readonly dependenciesIndex: {
+              readonly description: "Index of the dependencies array for validation";
+              readonly type: "number";
+            };
+            readonly name: {
+              readonly description: "The name of the hook";
+              readonly type: "string";
+            };
+          };
+          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: readonly ["aggressive", "definite", "moderate"];
+        readonly type: "string";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-array-constructor-elements": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly environment?: "roblox-ts" | "standard";
+    readonly requireExplicitGenericOnNewArray?: boolean;
+  }], "avoidConstructorEnumeration" | "avoidLengthConstructorInStandard" | "avoidSingleArgumentConstructor" | "collapseArrayPushInitialization" | "requireExplicitGenericOnNewArray" | "suggestArrayFromLength" | "suggestArrayLiteral" | "suggestCollapseArrayPushInitialization", 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";
+  }]>;
+  "no-array-size-assignment": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allowAutofix?: boolean;
+  }], "usePush", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly allowAutofix: {
+        readonly default: false;
+        readonly type: "boolean";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-async-constructor": import("oxlint-plugin-utilities").CreateRule<readonly [], "asyncIifeInConstructor" | "awaitInConstructor" | "orphanedPromise" | "promiseChainInConstructor" | "unhandledAsyncCall", readonly []>;
+  "no-cascading-set-state": import("oxlint-plugin-utilities").CreateRule<readonly [], "cascadingSetState", undefined>;
+  "no-color3-constructor": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly reportUnknownComponents?: boolean;
+  }], "onlyZeroArgs" | "useFromRGB", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly reportUnknownComponents: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-commented-code": import("oxlint-plugin-utilities").CreateRule<readonly [], "commentedCode", readonly []>;
+  "no-constant-condition-with-break": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly loopExitCalls?: readonly string[];
+  }], "unexpected", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly loopExitCalls: {
+        readonly items: {
+          readonly minLength: 1;
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-error": import("oxlint-plugin-utilities").CreateRule<readonly [], "noError", readonly []>;
+  "no-events-in-events-callback": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly eventsImportPaths: readonly string[];
+  }], "preferFunctions", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly eventsImportPaths: {
+        readonly items: {
+          readonly minLength: 1;
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+    };
+    readonly required: readonly ["eventsImportPaths"];
+    readonly type: "object";
+  }]>;
+  "no-giant-component": import("oxlint-plugin-utilities").CreateRule<readonly [], "giantComponent", undefined>;
+  "no-god-components": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly enforceTargetLines?: boolean;
+    readonly ignoreComponents?: readonly string[];
+    readonly maxDestructuredProps?: number;
+    readonly maxLines?: number;
+    readonly maxStateHooks?: number;
+    readonly maxTsxNesting?: number;
+    readonly stateHooks?: readonly string[];
+    readonly targetLines?: number;
+  }], "exceedsMaxLines" | "exceedsTargetLines" | "nullLiteral" | "tooManyProps" | "tooManyStateHooks" | "tsxNestingTooDeep", 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 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";
+  }]>;
+  "no-ianitor-in-function-body": import("oxlint-plugin-utilities").CreateRule<readonly [], "hoistIanitorValidator", readonly []>;
+  "no-ianitor-success-access": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferCreateGuard", readonly []>;
+  "no-identity-map": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly bindingPatterns?: readonly string[];
+  }], "identityArrayMap" | "identityBindingMap", 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";
+  }]>;
+  "no-increment-decrement": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allowAutofix?: boolean;
+  }], "noDecrement" | "noIncrement", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly allowAutofix: {
+        readonly default: false;
+        readonly type: "boolean";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-inline-property-on-memo-component": import("oxlint-plugin-utilities").CreateRule<readonly [], "inlineProperty", undefined>;
+  "no-instance-methods-without-this": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly checkPrivate?: boolean;
+    readonly checkProtected?: boolean;
+    readonly checkPublic?: boolean;
+  }], "noInstanceMethodWithoutThis", 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";
+  }]>;
+  "no-native-properties-spread": import("oxlint-plugin-utilities").CreateRule<readonly [], "noElementSpread" | "noNativePropertiesSpread", readonly []>;
+  "no-new-instance-in-use-memo": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly constructors?: readonly string[];
+    readonly environment?: "roblox-ts" | "standard";
+    readonly maxHelperTraceDepth?: number;
+  }], "noNewInUseMemo", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly constructors: {
+        readonly description: "Constructor identifiers that should be disallowed inside useMemo callbacks.";
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+      readonly environment: {
+        readonly default: "roblox-ts";
+        readonly description: "The React environment: 'roblox-ts' uses @rbxts/react, 'standard' uses react.";
+        readonly enum: readonly ["roblox-ts", "standard"];
+        readonly 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";
+  }]>;
+  "no-print": import("oxlint-plugin-utilities").CreateRule<readonly [], "noPrint", readonly []>;
+  "no-redundant-aspect-ratio-constraint": import("oxlint-plugin-utilities").CreateRule<readonly [], "redundantAspectRatioConstraint", readonly []>;
+  "no-render-helper-functions": import("oxlint-plugin-utilities").CreateRule<readonly [], "noRenderHelper", readonly []>;
+  "no-spec-file-extension": import("oxlint-plugin-utilities").CreateRule<readonly [], "noSpecFileExtension", readonly []>;
+  "no-static-react-create-element": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly environment?: "roblox-ts" | "standard";
+  }], "useJsx", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      environment: {
+        enum: readonly ["roblox-ts", "standard"];
+        type: string;
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-table-create-map": import("oxlint-plugin-utilities").CreateRule<readonly [], "avoidConstructThenMap", readonly []>;
+  "no-task-wait": import("oxlint-plugin-utilities").CreateRule<readonly [], "noPromiseDelayAwait" | "noTaskWait", readonly []>;
+  "no-underscore-react-props": import("oxlint-plugin-utilities").CreateRule<readonly [], "noUnderscoreReactProp", readonly []>;
+  "no-unused-imports": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly checkJSDoc?: boolean;
+  }], "unusedImport", 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";
+  }]>;
+  "no-unused-use-memo": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly environment?: "roblox-ts" | "standard";
+  }], "unusedUseMemo", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly environment: {
+        readonly default: "roblox-ts";
+        readonly enum: readonly ["roblox-ts", "standard"];
+        readonly type: "string";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-use-memo-simple-expression": import("oxlint-plugin-utilities").CreateRule<readonly [], "simpleMemo", undefined>;
+  "no-useless-constants": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly ignoreCallPatterns?: readonly string[];
+  }], "uselessConstant" | "uselessConstantNoFix" | "uselessConstants", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly ignoreCallPatterns: {
+        readonly default: readonly string[];
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-useless-default": import("oxlint-plugin-utilities").CreateRule<readonly [], "uselessDefault", readonly []>;
+  "no-useless-use-effect": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly environment?: "roblox-ts" | "standard";
+    readonly hooks?: readonly string[];
+    readonly propertyCallbackPrefixes?: readonly string[];
+    readonly refHooks?: readonly string[];
+    readonly reportAdjustState?: boolean;
+    readonly reportDerivedState?: boolean;
+    readonly reportDuplicateDeps?: boolean;
+    readonly reportEffectChain?: boolean;
+    readonly reportEmptyEffect?: boolean;
+    readonly reportEventFlag?: boolean;
+    readonly reportEventSpecificLogic?: boolean;
+    readonly reportExternalStore?: boolean;
+    readonly reportInitializeState?: boolean;
+    readonly reportLogOnly?: boolean;
+    readonly reportMixedDerivedState?: boolean;
+    readonly reportNotifyParent?: boolean;
+    readonly reportPassRefToParent?: boolean;
+    readonly reportResetState?: boolean;
+    readonly stateHooks?: readonly string[];
+  }], "adjustState" | "derivedState" | "duplicateDeps" | "effectChain" | "emptyEffect" | "eventFlag" | "eventSpecificLogic" | "externalStore" | "initializeState" | "logOnly" | "mixedDerivedState" | "notifyParent" | "passRefToParent" | "resetState", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly environment: {
+        readonly default: "roblox-ts";
+        readonly description: "The React environment: 'roblox-ts' uses @rbxts/react, 'standard' uses react.";
+        readonly enum: readonly ["roblox-ts", "standard"];
+        readonly type: "string";
+      };
+      readonly hooks: {
+        readonly default: readonly ["useEffect", "useLayoutEffect", "useInsertionEffect"];
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+      readonly propertyCallbackPrefixes: {
+        readonly default: readonly ["on"];
+        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 type: "boolean";
+      };
+      readonly reportDerivedState: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportDuplicateDeps: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportEffectChain: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportEmptyEffect: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportEventFlag: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportEventSpecificLogic: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportExternalStore: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportInitializeState: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportLogOnly: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportMixedDerivedState: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportNotifyParent: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportPassRefToParent: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly reportResetState: {
+        readonly default: true;
+        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";
+  }]>;
+  "no-useless-use-memo": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly dependencyMode?: "aggressive" | "empty-or-omitted" | "non-updating";
+    readonly environment?: "roblox-ts" | "standard";
+    readonly staticGlobalFactories?: readonly string[];
+  }], "uselessUseMemo", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly dependencyMode: {
+        readonly default: "non-updating";
+        readonly enum: readonly ["empty-or-omitted", "non-updating", "aggressive"];
+        readonly type: "string";
+      };
+      readonly environment: {
+        readonly default: "roblox-ts";
+        readonly enum: readonly ["roblox-ts", "standard"];
+        readonly type: "string";
+      };
+      readonly staticGlobalFactories: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "no-useless-use-spring": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly springHooks?: readonly string[];
+    readonly staticGlobalFactories?: readonly string[];
+    readonly treatEmptyDepsAsViolation?: boolean;
+  }], "uselessSpring", readonly [{
+    readonly additionalProperties: false;
+    readonly default: {
+      readonly staticGlobalFactories: readonly string[];
+      readonly treatEmptyDepsAsViolation: true;
+    };
+    readonly properties: {
+      readonly springHooks: {
+        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";
+  }]>;
+  "no-warn": import("oxlint-plugin-utilities").CreateRule<readonly [], "noWarn", readonly []>;
+  "only-type-imports": import("oxlint-plugin-utilities").CreateRule<readonly [], "onlyTypeImports", readonly []>;
+  "prefer-class-properties": import("oxlint-plugin-utilities").CreateRule<readonly ["always" | "never"], "unexpectedAssignment" | "unexpectedClassProperty", readonly [{
+    readonly enum: readonly ["always", "never"];
+    readonly type: "string";
+  }]>;
+  "prefer-constant-dispatch": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferConstantDispatch", readonly []>;
+  "prefer-context-stack": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferContextStack", readonly []>;
+  "prefer-early-return": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly maximumStatements?: number;
+  }], "preferEarlyReturn", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly maximumStatements: {
+        readonly default: 1;
+        readonly minimum: 0;
+        readonly type: "number";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "prefer-expect-assertions": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly additionalExpectCallNames?: readonly string[];
+    readonly onlyFunctionsWithAsyncKeyword?: boolean;
+    readonly onlyFunctionsWithExpectInCallback?: boolean;
+    readonly onlyFunctionsWithExpectInLoop?: boolean;
+  }], "assertionsRequiresNumberArgument" | "assertionsRequiresOneArgument" | "hasAssertionsTakesNoArguments" | "haveExpectAssertions" | "suggestAddingAssertions" | "suggestAddingHasAssertions" | "wrongAssertionCount", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly additionalExpectCallNames: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+      readonly onlyFunctionsWithAsyncKeyword: {
+        readonly type: "boolean";
+      };
+      readonly onlyFunctionsWithExpectInCallback: {
+        readonly type: "boolean";
+      };
+      readonly onlyFunctionsWithExpectInLoop: {
+        readonly type: "boolean";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "prefer-expect-assertions-count": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly additionalAssertionFunctions?: readonly string[];
+  }], "preferAssertionsCount", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly additionalAssertionFunctions: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "prefer-hoisted-jsx-elements": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly additionalHoistableComponents?: readonly string[];
+    readonly additionalStaticFactories?: readonly string[];
+  }], "hoistableJsxElement", 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 type: "object";
+  }]>;
+  "prefer-hoisted-jsx-object-properties": import("oxlint-plugin-utilities").CreateRule<readonly [], "hoistableObjectProp", readonly []>;
+  "prefer-idiv": import("oxlint-plugin-utilities").CreateRule<readonly [], "useIdiv", readonly []>;
+  "prefer-local-portal-component": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferPortalComponent", readonly []>;
+  "prefer-math-min-max": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferMathMethod", readonly []>;
+  "prefer-modding-inspect": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferModdingInspect", readonly []>;
+  "prefer-module-scope-constants": import("oxlint-plugin-utilities").CreateRule<readonly [], "mustBeModuleScope" | "mustUseConst", readonly []>;
+  "prefer-padding-components": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferDirectionalPadding" | "preferEqualPadding", readonly []>;
+  "prefer-pascal-case-enums": import("oxlint-plugin-utilities").CreateRule<readonly [], "notPascalCase", readonly []>;
+  "prefer-sequence-overloads": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferSingleOverload" | "preferTwoPointOverload", readonly []>;
+  "prefer-single-world-query": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferSingleGet" | "preferSingleHas", readonly []>;
+  "prefer-singular-enums": import("oxlint-plugin-utilities").CreateRule<readonly [], "notSingular", readonly []>;
+  "prefer-ternary-conditional-rendering": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferTernaryConditionalRendering", readonly []>;
+  "prefer-udim2-shorthand": import("oxlint-plugin-utilities").CreateRule<readonly [], "preferFromOffset" | "preferFromScale", readonly []>;
+  "prefer-use-reducer": import("oxlint-plugin-utilities").CreateRule<readonly [], "excessiveUseState", undefined>;
+  "prevent-abbreviations": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allowList?: {
+      readonly [x: string]: boolean;
+    };
+    readonly allowPropertyAccess?: readonly string[];
+    readonly checkDefaultAndNamespaceImports?: "internal" | boolean;
+    readonly checkFilenames?: boolean;
+    readonly checkProperties?: boolean;
+    readonly checkShorthandImports?: "internal" | boolean;
+    readonly checkShorthandProperties?: boolean;
+    readonly checkVariables?: boolean;
+    readonly extendDefaultAllowList?: boolean;
+    readonly extendDefaultReplacements?: boolean;
+    readonly ignore?: readonly (string | {})[];
+    readonly ignoreShorthands?: readonly string[];
+    readonly replacements?: {
+      readonly [x: string]: false | {
+        readonly [x: string]: boolean;
+      };
+    };
+    readonly shorthands?: {
+      readonly [x: string]: string;
+    };
+  }], "replace" | "suggestion", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly allowList: {
+        readonly additionalProperties: {
+          readonly type: "boolean";
+        };
+        readonly type: "object";
+      };
+      readonly allowPropertyAccess: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+      readonly checkDefaultAndNamespaceImports: {
+        readonly enum: readonly [false, true, "internal"];
+      };
+      readonly checkFilenames: {
+        readonly type: "boolean";
+      };
+      readonly checkProperties: {
+        readonly type: "boolean";
+      };
+      readonly checkShorthandImports: {
+        readonly enum: readonly [false, true, "internal"];
+      };
+      readonly checkShorthandProperties: {
+        readonly type: "boolean";
+      };
+      readonly checkVariables: {
+        readonly type: "boolean";
+      };
+      readonly extendDefaultAllowList: {
+        readonly type: "boolean";
+      };
+      readonly extendDefaultReplacements: {
+        readonly type: "boolean";
+      };
+      readonly ignore: {
+        readonly items: {
+          readonly oneOf: readonly [{
+            readonly type: "object";
+          }, {
+            readonly type: "string";
+          }];
+        };
+        readonly type: "array";
+      };
+      readonly ignoreShorthands: {
+        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 type: "object";
+      };
+      readonly shorthands: {
+        readonly additionalProperties: {
+          readonly type: "string";
+        };
+        readonly type: "object";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "react-hooks-strict-return": import("oxlint-plugin-utilities").CreateRule<readonly [], "tooManyReturnValues", readonly []>;
+  "require-async-suffix": import("oxlint-plugin-utilities").CreateRule<readonly [], "missingAsyncSuffix", readonly []>;
+  "require-module-level-instantiation": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly classes?: {
+      readonly [x: string]: string;
+    };
+  }], "mustBeModuleLevel", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly classes: {
+        readonly additionalProperties: {
+          readonly type: "string";
+        };
+        readonly type: "object";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "require-named-effect-functions": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly environment?: "roblox-ts" | "standard";
+    readonly hooks?: readonly {
+      readonly allowAsync: boolean;
+      readonly name: string;
+    }[];
+  }], "anonymousFunction" | "arrowFunction" | "asyncAnonymousFunction" | "asyncArrowFunction" | "asyncFunctionDeclaration" | "asyncFunctionExpression" | "functionExpression" | "identifierReferencesArrow" | "identifierReferencesAsyncArrow" | "identifierReferencesAsyncFunction" | "identifierReferencesCallback", 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 description: "Array of hook configuration objects with name and allowAsync settings";
+        readonly items: {
+          readonly additionalProperties: false;
+          readonly properties: {
+            readonly allowAsync: {
+              readonly description: "Whether async functions are allowed for this hook";
+              readonly type: "boolean";
+            };
+            readonly name: {
+              readonly description: "Hook name to check";
+              readonly type: "string";
+            };
+          };
+          readonly required: readonly ["name", "allowAsync"];
+          readonly type: "object";
+        };
+        readonly type: "array";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "require-paired-calls": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allowConditionalClosers?: boolean;
+    readonly allowMultipleOpeners?: boolean;
+    readonly maxNestingDepth?: number;
+    readonly pairs: readonly {
+      readonly alternatives?: readonly string[];
+      readonly closer: string | readonly string[];
+      readonly opener: string;
+      readonly openerAlternatives?: readonly string[];
+      readonly platform?: "roblox";
+      readonly requireSync?: boolean;
+      readonly yieldingFunctions?: readonly string[];
+    }[];
+  }], "asyncViolation" | "conditionalOpener" | "maxNestingExceeded" | "multipleOpeners" | "robloxYieldViolation" | "unexpectedCloser" | "unpairedCloser" | "unpairedOpener" | "wrongOrder", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly allowConditionalClosers: {
+        readonly default: false;
+        readonly type: "boolean";
+      };
+      readonly allowMultipleOpeners: {
+        readonly default: true;
+        readonly type: "boolean";
+      };
+      readonly maxNestingDepth: {
+        readonly default: 0;
+        readonly minimum: 0;
+        readonly type: "number";
+      };
+      readonly pairs: {
+        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 required: readonly ["pairs"];
+    readonly type: "object";
+  }]>;
+  "require-react-component-keys": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allowRootKeys?: boolean;
+    readonly ignoreCallExpressions?: readonly string[];
+    readonly iterationMethods?: readonly string[];
+    readonly memoizationHooks?: readonly string[];
+  }], "missingKey" | "rootComponentWithKey", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly allowRootKeys: {
+        readonly default: false;
+        readonly description: "Allow key props on root component returns";
+        readonly type: "boolean";
+      };
+      readonly ignoreCallExpressions: {
+        readonly default: readonly ["ReactTree.mount"];
+        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 ["useCallback", "useMemo"];
+        readonly description: "Hook names that indicate memoization contexts where keys are required";
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "require-react-display-names": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly environment?: "roblox-ts" | "standard";
+  }], "directContextExport" | "directMemoExport" | "missingContextDisplayName" | "missingMemoDisplayName", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      environment: {
+        enum: readonly ["roblox-ts", "standard"];
+        type: string;
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "require-switch-case-braces": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly metric?: "lines" | "statements";
+  }], "wrapCaseBody", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly metric: {
+        readonly default: "lines";
+        readonly enum: readonly ["lines", "statements"];
+        readonly type: "string";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "require-throw-error-capture": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allow?: readonly (string | {
+      readonly from?: "file" | "lib" | "package";
+      readonly name: string | readonly string[];
+      readonly package?: string;
+    })[];
+  }], "missingCaptureStackTrace", 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 from: {
+                readonly description: "Where the error class is declared";
+                readonly enum: readonly ["file", "lib", "package"];
+                readonly type: "string";
+              };
+              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 package: {
+                readonly description: "Package the error class is imported from (required when from is 'package')";
+                readonly type: "string";
+              };
+            };
+            readonly required: readonly ["name"];
+            readonly type: "object";
+          }];
+        };
+        readonly type: "array";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "require-unicode-regex": import("oxlint-plugin-utilities").CreateRule<readonly [], "requireUnicodeFlag", readonly []>;
+  "rerender-memo-with-default-value": import("oxlint-plugin-utilities").CreateRule<readonly [], "emptyArrayDefault" | "emptyObjectDefault", undefined>;
+  "strict-component-boundaries": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly allow?: readonly string[];
+    readonly maxDepth?: number;
+  }], "noReachingIntoComponent", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly allow: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+      readonly maxDepth: {
+        readonly type: "integer";
+      };
+    };
+    readonly type: "object";
+  }]>;
+  "use-exhaustive-dependencies": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly hooks?: readonly {
+      readonly closureIndex?: number;
+      readonly dependenciesIndex?: number;
+      readonly name: string;
+      readonly stableResult?: number | boolean | readonly string[] | readonly number[];
+    }[];
+    readonly reportMissingDependenciesArray?: boolean;
+    readonly reportUnnecessaryDependencies?: boolean;
+    readonly reportUnnecessaryStableDependencies?: boolean;
+    readonly resolveExpressionDependencies?: boolean;
+  }], "addDependenciesArraySuggestion" | "addDependencySuggestion" | "addMissingDependenciesSuggestion" | "missingDependencies" | "missingDependenciesArray" | "missingDependency" | "removeDependencySuggestion" | "unnecessaryDependency" | "unstableDependency", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly hooks: {
+        readonly description: "Array of custom hook entries to check for exhaustive dependencies";
+        readonly items: {
+          readonly additionalProperties: false;
+          readonly properties: {
+            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 name: {
+              readonly description: "The name of the hook";
+              readonly type: "string";
+            };
+            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";
+  }]>;
+  "use-hook-at-top-level": import("oxlint-plugin-utilities").CreateRule<readonly [{
+    readonly ignoreHooks?: readonly string[];
+    readonly importSources?: {
+      readonly [x: string]: boolean;
+    };
+    readonly onlyHooks?: readonly string[];
+  }], "afterEarlyReturn" | "conditionalHook" | "loopHook" | "nestedFunction" | "recursiveHookCall" | "tryBlockHook", readonly [{
+    readonly additionalProperties: false;
+    readonly properties: {
+      readonly ignoreHooks: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+      readonly importSources: {
+        readonly additionalProperties: {
+          readonly type: "boolean";
+        };
+        readonly type: "object";
+      };
+      readonly onlyHooks: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
+    };
+    readonly type: "object";
+  }]>;
+}>;
+//#endregion
+export { smallRules as default };