@eslint-react/core 2.0.0-next.6 → 2.0.0-next.61

package/dist/index.d.ts

@@ -1,12 +1,15 @@
-import { RuleContext } from '@eslint-react/kit';
-import { TSESTree } from '@typescript-eslint/types';
-import { ESLintUtils, TSESTree as TSESTree$1 } from '@typescript-eslint/utils';
-import * as AST from '@eslint-react/ast';
-import { _ } from '@eslint-react/eff';
-import * as birecord from 'birecord';
-import { Scope } from '@typescript-eslint/scope-manager';
-import * as VAR from '@eslint-react/var';
-
+import { TSESTree } from "@typescript-eslint/types";
+import * as AST from "@eslint-react/ast";
+import { unit } from "@eslint-react/eff";
+import { RuleContext } from "@eslint-react/kit";
+import * as VAR from "@eslint-react/var";
+import * as birecord0 from "birecord";
+import { isFalseLiteralType, isTrueLiteralType } from "ts-api-utils";
+import ts from "typescript";
+import { ESLintUtils, TSESTree as TSESTree$1 } from "@typescript-eslint/utils";
+import { Scope } from "@typescript-eslint/scope-manager";
+
+//#region src/component/component-children.d.ts
 /**
  * Determines whether inside `createElement`'s children.
  * @param context The rule context
@@ -14,132 +17,139 @@ import * as VAR from '@eslint-react/var';
  * @returns `true` if the node is inside createElement's children
  */
 declare function isChildrenOfCreateElement(context: RuleContext, node: TSESTree.Node): boolean;
-
+//#endregion
+//#region src/component/component-detection-hint.d.ts
 type ComponentDetectionHint = bigint;
 /**
  * Hints for component collector
  */
 declare const ComponentDetectionHint: {
-    /**
-     * Skip function component created by React.memo
-     */
-    readonly SkipMemo: bigint;
-    /**
-     * Skip function component created by React.forwardRef
-     */
-    readonly SkipForwardRef: bigint;
-    /**
-     * Skip function component defined as array map argument
-     */
-    readonly SkipArrayMapArgument: bigint;
-    /**
-     * Skip function component defined on object method
-     */
-    readonly SkipObjectMethod: bigint;
-    /**
-     * Skip function component defined on class method
-     */
-    readonly SkipClassMethod: bigint;
-    /**
-     * Skip function component defined on class property
-     */
-    readonly SkipClassProperty: bigint;
-    readonly None: 0n;
-    readonly SkipUndefined: bigint;
-    readonly SkipNullLiteral: bigint;
-    readonly SkipBooleanLiteral: bigint;
-    readonly SkipStringLiteral: bigint;
-    readonly SkipNumberLiteral: bigint;
-    readonly SkipBigIntLiteral: bigint;
-    readonly SkipEmptyArray: bigint;
-    readonly SkipCreateElement: bigint;
-    readonly StrictArray: bigint;
-    readonly StrictLogical: bigint;
-    readonly StrictConditional: bigint;
+  /**
+   * Skip function component created by React.memo
+   */
+  readonly SkipMemo: bigint;
+  /**
+   * Skip function component created by React.forwardRef
+   */
+  readonly SkipForwardRef: bigint;
+  /**
+   * Skip function component defined as array map argument
+   */
+  readonly SkipArrayMapArgument: bigint;
+  /**
+   * Skip function component defined on object method
+   */
+  readonly SkipObjectMethod: bigint;
+  /**
+   * Skip function component defined on class method
+   */
+  readonly SkipClassMethod: bigint;
+  /**
+   * Skip function component defined on class property
+   */
+  readonly SkipClassProperty: bigint;
+  readonly None: 0n;
+  readonly SkipUndefined: bigint;
+  readonly SkipNullLiteral: bigint;
+  readonly SkipBooleanLiteral: bigint;
+  readonly SkipStringLiteral: bigint;
+  readonly SkipNumberLiteral: bigint;
+  readonly SkipBigIntLiteral: bigint;
+  readonly SkipEmptyArray: bigint;
+  readonly SkipCreateElement: bigint;
+  readonly StrictArray: bigint;
+  readonly StrictLogical: bigint;
+  readonly StrictConditional: bigint;
 };
 /**
  * Default component detection hint
  */
 declare const DEFAULT_COMPONENT_DETECTION_HINT: bigint;
-
+//#endregion
+//#region src/component/component-phase.d.ts
 type ComponentEffectPhaseKind = "cleanup" | "setup";
 type ComponentLifecyclePhaseKind = "mount" | "unmount";
 type ComponentPhaseKind = ComponentEffectPhaseKind | ComponentLifecyclePhaseKind;
-declare const ComponentPhaseRelevance: birecord.BiRecord<{
-    readonly mount: "unmount";
-    readonly setup: "cleanup";
+declare const ComponentPhaseRelevance: birecord0.BiRecord<{
+  readonly mount: "unmount";
+  readonly setup: "cleanup";
 }>;
 declare const isInversePhase: {
-    (a: ComponentPhaseKind): (b: ComponentPhaseKind) => boolean;
-    (a: ComponentPhaseKind, b: ComponentPhaseKind): boolean;
+  (a: ComponentPhaseKind): (b: ComponentPhaseKind) => boolean;
+  (a: ComponentPhaseKind, b: ComponentPhaseKind): boolean;
 };
-
+//#endregion
+//#region src/semantic/semantic-entry.d.ts
 interface SemanticEntry {
-    node: TSESTree.Node;
-    phase: ComponentPhaseKind;
+  node: TSESTree.Node;
+  phase: ComponentPhaseKind;
 }
-
+//#endregion
+//#region src/semantic/semantic-node.d.ts
 interface SemanticNode {
-    id: _ | TSESTree.Identifier | TSESTree.Identifier[];
-    key: string;
-    kind: string;
-    name: _ | string;
-    node: TSESTree.Node;
-    flag: bigint;
-    hint: bigint;
+  id: unit | TSESTree.Identifier | TSESTree.Identifier[];
+  key: string;
+  kind: string;
+  name: unit | string;
+  node: TSESTree.Node;
+  flag: bigint;
+  hint: bigint;
 }
-
+//#endregion
+//#region src/component/component-flag.d.ts
 type ComponentFlag = bigint;
 declare const ComponentFlag: {
-    None: bigint;
-    PureComponent: bigint;
-    CreateElement: bigint;
-    Memo: bigint;
-    ForwardRef: bigint;
-    Async: bigint;
+  None: bigint;
+  PureComponent: bigint;
+  CreateElement: bigint;
+  Memo: bigint;
+  ForwardRef: bigint;
+  Async: bigint;
 };
-
+//#endregion
+//#region src/component/component-semantic-node.d.ts
 interface FunctionComponent extends SemanticNode {
-    id: _ | TSESTree.Identifier | TSESTree.Identifier[];
-    kind: "function";
-    node: AST.TSESTreeFunction;
-    flag: ComponentFlag;
-    hint: ComponentDetectionHint;
-    initPath: _ | AST.FunctionInitPath;
-    hookCalls: TSESTree.CallExpression[];
-    displayName: _ | TSESTree.Expression;
+  id: unit | TSESTree.Identifier | TSESTree.Identifier[];
+  kind: "function";
+  node: AST.TSESTreeFunction;
+  flag: ComponentFlag;
+  hint: ComponentDetectionHint;
+  initPath: unit | AST.FunctionInitPath;
+  hookCalls: TSESTree.CallExpression[];
+  displayName: unit | TSESTree.Expression;
 }
 interface ClassComponent extends SemanticNode {
-    id: _ | TSESTree.Identifier;
-    kind: "class";
-    node: AST.TSESTreeClass;
-    flag: ComponentFlag;
-    hint: ComponentDetectionHint;
-    methods: AST.TSESTreeMethodOrProperty[];
-    displayName: _ | TSESTree.Expression;
+  id: unit | TSESTree.Identifier;
+  kind: "class";
+  node: AST.TSESTreeClass;
+  flag: ComponentFlag;
+  hint: ComponentDetectionHint;
+  methods: AST.TSESTreeMethodOrProperty[];
+  displayName: unit | TSESTree.Expression;
 }
 type Component = ClassComponent | FunctionComponent;
-
+//#endregion
+//#region src/component/component-collector.d.ts
 type FunctionEntry = {
-    key: string;
-    node: AST.TSESTreeFunction;
-    hookCalls: TSESTree.CallExpression[];
-    isComponent: boolean;
+  key: string;
+  node: AST.TSESTreeFunction;
+  hookCalls: TSESTree.CallExpression[];
+  isComponent: boolean;
 };
 declare namespace useComponentCollector {
-    type Options = {
-        collectDisplayName?: boolean;
-        collectHookCalls?: boolean;
-        hint?: ComponentDetectionHint;
-    };
-    type ReturnType = {
-        ctx: {
-            getAllComponents: (node: TSESTree.Program) => Map<string, FunctionComponent>;
-            getCurrentEntries: () => FunctionEntry[];
-            getCurrentEntry: () => FunctionEntry | _;
-        };
-        listeners: ESLintUtils.RuleListener;
+  type Options = {
+    collectDisplayName?: boolean;
+    collectHookCalls?: boolean;
+    hint?: ComponentDetectionHint;
+  };
+  type ReturnType = {
+    ctx: {
+      getAllComponents: (node: TSESTree.Program) => Map<string, FunctionComponent>;
+      getCurrentEntries: () => FunctionEntry[];
+      getCurrentEntry: () => FunctionEntry | unit;
     };
+    listeners: ESLintUtils.RuleListener;
+  };
 }
 /**
  * Get a ctx and listeners for the rule to collect function components
@@ -148,21 +158,23 @@ declare namespace useComponentCollector {
  * @returns The component collector
  */
 declare function useComponentCollector(context: RuleContext, options?: useComponentCollector.Options): useComponentCollector.ReturnType;
-
+//#endregion
+//#region src/component/component-collector-legacy.d.ts
 declare namespace useComponentCollectorLegacy {
-    type ReturnType = {
-        ctx: {
-            getAllComponents: (node: TSESTree$1.Program) => Map<string, ClassComponent>;
-        };
-        listeners: ESLintUtils.RuleListener;
+  type ReturnType = {
+    ctx: {
+      getAllComponents: (node: TSESTree$1.Program) => Map<string, ClassComponent>;
     };
+    listeners: ESLintUtils.RuleListener;
+  };
 }
 /**
  * Get a ctx and listeners object for the rule to collect class components
  * @returns The context and listeners for the rule
  */
 declare function useComponentCollectorLegacy(): useComponentCollectorLegacy.ReturnType;
-
+//#endregion
+//#region src/component/component-definition.d.ts
 /**
  * Check whether given node is a function of a render method of a class component
  * @example
@@ -176,12 +188,22 @@ declare function useComponentCollectorLegacy(): useComponentCollectorLegacy.Retu
  * @returns `true` if node is a render function, `false` if not
  */
 declare function isFunctionOfRenderMethod(node: AST.TSESTreeFunction): boolean;
-declare function isValidComponentDefinition(context: RuleContext, node: AST.TSESTreeFunction, hint: bigint): boolean;
-
-declare function getFunctionComponentId(context: RuleContext, node: AST.TSESTreeFunction): TSESTree.Identifier | TSESTree.Identifier[] | _;
-
+/**
+ * Determines if a function node represents a valid React component definition
+ * @param context The rule context
+ * @param node The function node to check
+ * @param hint Component detection hints as bit flags
+ * @returns `true` if the node is a valid component definition, `false` otherwise
+ */
+declare function isComponentDefinition(context: RuleContext, node: AST.TSESTreeFunction, hint: bigint): boolean;
+//#endregion
+//#region src/component/component-id.d.ts
+declare function getFunctionComponentId(context: RuleContext, node: AST.TSESTreeFunction): TSESTree.Identifier | TSESTree.Identifier[] | unit;
+//#endregion
+//#region src/component/component-init-path.d.ts
 declare function getComponentFlagFromInitPath(initPath: FunctionComponent["initPath"]): bigint;
-
+//#endregion
+//#region src/component/component-is.d.ts
 /**
  * Check if a node is a React class component
  * @param node The AST node to check
@@ -194,58 +216,37 @@ declare function isClassComponent(node: TSESTree.Node): node is AST.TSESTreeClas
  * @returns `true` if the node is a pure component, `false` otherwise
  */
 declare function isPureComponent(node: TSESTree.Node): boolean;
-
+//#endregion
+//#region src/component/component-kind.d.ts
 type ComponentKind = "classComponent" | "functionComponent";
-
-declare function isComponentDidCatch(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentDidMount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentDidUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentWillMount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentWillReceiveProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentWillUnmount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentWillUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetChildContext(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetDefaultProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetInitialState(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetSnapshotBeforeUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isShouldComponentUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isUnsafeComponentWillMount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isUnsafeComponentWillReceiveProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isUnsafeComponentWillUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetDerivedStateFromProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetDerivedStateFromError(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-
+//#endregion
+//#region src/component/component-method.d.ts
+declare const isRender: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isComponentDidCatch: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isComponentDidMount: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isComponentDidUpdate: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isComponentWillMount: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isComponentWillReceiveProps: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isComponentWillUnmount: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isComponentWillUpdate: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isGetChildContext: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isGetInitialState: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isGetSnapshotBeforeUpdate: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isShouldComponentUpdate: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isUnsafeComponentWillMount: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isUnsafeComponentWillReceiveProps: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isUnsafeComponentWillUpdate: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isGetDefaultProps: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isGetDerivedStateFromProps: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+declare const isGetDerivedStateFromError: (node: TSESTree.Node) => node is AST.TSESTreeMethodOrProperty;
+//#endregion
+//#region src/component/component-name.d.ts
 declare function isComponentName(name: string): boolean;
 declare function isComponentNameLoose(name: string): boolean;
-declare function getComponentNameFromId(id: TSESTree.Identifier | TSESTree.Identifier[] | _): string | undefined;
+declare function getComponentNameFromId(id: TSESTree.Identifier | TSESTree.Identifier[] | unit): string | undefined;
 declare function hasNoneOrLooseComponentName(context: RuleContext, fn: AST.TSESTreeFunction): boolean;
-
-/**
- * Check whether given node is a render function of a class component
- * @example
- * ```tsx
- * class Component extends React.Component {
- *   render() {
- *    return <div />;
- *  }
- * }
- * ```
- * @param node The AST node to check
- * @returns `true` if node is a render function, `false` if not
- */
-declare function isRenderLike(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-/**
- * Check whether given node is a function of a render function of a class component
- * @example
- * ```tsx
- * class Component extends React.Component {
- *   render = () => <div />;
- * ```
- * @param node The AST node to check
- * @returns `true` if node is a render function, `false` if not
- */
-declare function isFunctionOfRender(node: AST.TSESTreeFunction): boolean;
-
+//#endregion
+//#region src/component/component-render-method.d.ts
 /**
  * Check whether given node is a render method of a class component
  * @example
@@ -259,7 +260,8 @@ declare function isFunctionOfRender(node: AST.TSESTreeFunction): boolean;
  * @returns `true` if node is a render function, `false` if not
  */
 declare function isRenderMethodLike(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-
+//#endregion
+//#region src/component/component-render-prop.d.ts
 /**
  * Unsafe check whether given node is a render function
  * ```tsx
@@ -309,11 +311,13 @@ declare function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node): boolea
  * @returns `true` if component is declared inside a render prop, `false` if not
  */
 declare function isDeclaredInRenderPropLoose(node: TSESTree.Node): boolean;
-
+//#endregion
+//#region src/component/component-state.d.ts
 type ComponentStateKind = "actionState" | "state";
 declare function isThisSetState(node: TSESTree.CallExpression): boolean;
 declare function isAssignmentToThisState(node: TSESTree.AssignmentExpression): boolean;
-
+//#endregion
+//#region src/component/component-wrapper.d.ts
 /**
  * Check if the node is a call expression for a component wrapper
  * @param context The ESLint rule context
@@ -328,39 +332,73 @@ declare function isComponentWrapperCall(context: RuleContext, node: TSESTree.Nod
  * @returns `true` if the node is a call expression for a component wrapper loosely
  */
 declare function isComponentWrapperCallLoose(context: RuleContext, node: TSESTree.Node): boolean;
-
+//#endregion
+//#region src/effect/effect-kind.d.ts
 type EffectKind = "useEffect" | "useLayoutEffect" | "useInsertionEffect";
-
+//#endregion
+//#region src/hook/hook-semantic-node.d.ts
 interface Hook extends SemanticNode {
-    id: TSESTree.Identifier | _;
-    node: AST.TSESTreeFunction;
-    name: string;
-    hookCalls: TSESTree.CallExpression[];
+  id: TSESTree.Identifier | unit;
+  node: AST.TSESTreeFunction;
+  name: string;
+  hookCalls: TSESTree.CallExpression[];
 }
-
+//#endregion
+//#region src/hook/hook-collector.d.ts
 declare namespace useHookCollector {
-    type ReturnType = {
-        ctx: {
-            getAllHooks(node: TSESTree$1.Program): Map<string, Hook>;
-        };
-        listeners: ESLintUtils.RuleListener;
+  type ReturnType = {
+    ctx: {
+      getAllHooks(node: TSESTree$1.Program): Map<string, Hook>;
     };
+    listeners: ESLintUtils.RuleListener;
+  };
 }
 declare function useHookCollector(): useHookCollector.ReturnType;
-
+//#endregion
+//#region src/hook/hook-id.d.ts
 declare function isReactHookId(id: TSESTree.Identifier | TSESTree.MemberExpression): boolean;
-
-declare function isReactHook(node: AST.TSESTreeFunction | _): boolean;
+//#endregion
+//#region src/hook/hook-is.d.ts
+/**
+ * Determines if a function node is a React Hook based on its name.
+ * @param node The function node to check
+ * @returns True if the function is a React Hook, false otherwise
+ */
+declare function isReactHook(node: AST.TSESTreeFunction | unit): boolean;
 /**
  * Check if the given node is a React Hook call by its name.
  * @param node The node to check.
  * @returns `true` if the node is a React Hook call, `false` otherwise.
  */
-declare function isReactHookCall(node: TSESTree.Node | _): boolean;
-declare function isReactHookCallWithName(context: RuleContext, node: TSESTree.Node | _): (name: string) => boolean;
-declare function isReactHookCallWithNameLoose(node: TSESTree.Node | _): (name: string) => boolean;
-declare function isReactHookCallWithNameAlias(context: RuleContext, name: string, alias?: _ | string[]): (node: TSESTree.CallExpression) => boolean;
-declare function isUseEffectCallLoose(node: TSESTree.Node | _): boolean;
+declare function isReactHookCall(node: TSESTree.Node | unit): boolean;
+/**
+ * Checks if a node is a call to a specific React hook, with React import validation.
+ * Returns a function that accepts a hook name to check against.
+ * @param context The rule context
+ * @param node The AST node to check
+ * @returns A function that takes a hook name and returns boolean
+ */
+declare function isReactHookCallWithName(context: RuleContext, node: TSESTree.Node | unit): (name: string) => boolean;
+/**
+ * Lightweight version of isReactHookCallWithName that doesn't check imports.
+ * @param node The AST node to check
+ * @returns A function that takes a hook name and returns boolean
+ */
+declare function isReactHookCallWithNameLoose(node: TSESTree.Node | unit): (name: string) => boolean;
+/**
+ * Checks if a node is a call to a specific React hook or one of its aliases.
+ * @param context The rule context
+ * @param name The primary hook name to check
+ * @param alias Optional array of alias names to also accept
+ * @returns Function that checks if a node matches the hook name or aliases
+ */
+declare function isReactHookCallWithNameAlias(context: RuleContext, name: string, alias?: unit | string[]): (node: TSESTree.CallExpression) => boolean;
+/**
+ * Detects useEffect calls and variations (useLayoutEffect, etc.) using regex pattern.
+ * @param node The AST node to check
+ * @returns True if the node is a useEffect-like call
+ */
+declare function isUseEffectCallLoose(node: TSESTree.Node | unit): boolean;
 declare const isUseCall: (context: RuleContext, node: TSESTree.Node | undefined) => boolean;
 declare const isUseActionStateCall: (context: RuleContext, node: TSESTree.Node | undefined) => boolean;
 declare const isUseCallbackCall: (context: RuleContext, node: TSESTree.Node | undefined) => boolean;
@@ -380,9 +418,9 @@ declare const isUseRefCall: (context: RuleContext, node: TSESTree.Node | undefin
 declare const isUseStateCall: (context: RuleContext, node: TSESTree.Node | undefined) => boolean;
 declare const isUseSyncExternalStoreCall: (context: RuleContext, node: TSESTree.Node | undefined) => boolean;
 declare const isUseTransitionCall: (context: RuleContext, node: TSESTree.Node | undefined) => boolean;
-
-type HookKind = "custom" | "useActionState" | "useCallback" | "useContext" | "useDebugValue" | "useDeferredValue" | "useEffect" | "useId" | "useImperativeHandle" | "useInsertionEffect" | "useLayoutEffect" | "useMemo" | "useOptimistic" | "useReducer" | "useRef" | "useState" | "useSyncExternalStore" | "useTransition";
-
+//#endregion
+//#region src/hook/hook-name.d.ts
+declare const REACT_BUILTIN_HOOK_NAMES: readonly ["use", "useActionState", "useCallback", "useContext", "useDebugValue", "useDeferredValue", "useEffect", "useFormStatus", "useId", "useImperativeHandle", "useInsertionEffect", "useLayoutEffect", "useMemo", "useOptimistic", "useReducer", "useRef", "useState", "useSyncExternalStore", "useTransition"];
 /**
  * Catch all identifiers that begin with "use" followed by an uppercase Latin
  * character to exclude identifiers like "user".
@@ -390,17 +428,21 @@ type HookKind = "custom" | "useActionState" | "useCallback" | "useContext" | "us
  * @see https://github.com/facebook/react/blob/1d6c8168db1d82713202e842df3167787ffa00ed/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts#L16
  */
 declare function isReactHookName(name: string): boolean;
-
+//#endregion
+//#region src/jsx/jsx-attribute.d.ts
 /**
- * Get the JSX attribute node with the given name
- * @param context The ESLint rule context
- * @param name The name of the attribute
- * @param attributes The attributes to search
- * @param initialScope The initial scope to use for variable resolution
- * @returns The JSX attribute node or undefined
+ * Searches for a specific JSX attribute by name in a list of attributes
+ * Returns the last matching attribute (rightmost in JSX)
+ *
+ * @param context - ESLint rule context
+ * @param name - The name of the attribute to find
+ * @param attributes - Array of JSX attributes to search through
+ * @param initialScope - Optional scope for resolving variables
+ * @returns The found attribute or undefined
  */
-declare function getAttribute(context: RuleContext, name: string, attributes: (TSESTree$1.JSXAttribute | TSESTree$1.JSXSpreadAttribute)[], initialScope?: Scope): TSESTree$1.JSXAttribute | TSESTree$1.JSXSpreadAttribute | _;
-
+declare function getAttribute(context: RuleContext, name: string, attributes: (TSESTree$1.JSXAttribute | TSESTree$1.JSXSpreadAttribute)[], initialScope?: Scope): TSESTree$1.JSXAttribute | TSESTree$1.JSXSpreadAttribute | unit;
+//#endregion
+//#region src/jsx/jsx-attribute-name.d.ts
 /**
  * Get the stringified name of a JSX attribute
  * @param context The ESLint rule context
@@ -408,112 +450,306 @@ declare function getAttribute(context: RuleContext, name: string, attributes: (T
  * @returns The name of the attribute
  */
 declare function getAttributeName(context: RuleContext, node: TSESTree$1.JSXAttribute): string;
-
+//#endregion
+//#region src/jsx/jsx-attribute-value.d.ts
 /**
- * Get a StaticValue of the attribute value
- * @param context The rule context
- * @param node The JSX attribute node
- * @param name The name of the attribute
- * @returns The StaticValue of the attribute value
+ * Extracts the value of a JSX attribute by name
+ * @param context - ESLint rule context
+ * @param node - JSX attribute or spread attribute node
+ * @param name - Name of the attribute to extract
+ * @returns The extracted attribute value in a structured format
  */
 declare function getAttributeValue(context: RuleContext, node: TSESTree$1.JSXAttribute | TSESTree$1.JSXSpreadAttribute, name: string): Exclude<VAR.LazyValue, {
-    kind: "lazy";
+  kind: "lazy";
 }>;
-
+//#endregion
+//#region src/jsx/jsx-detection-hint.d.ts
+/**
+ * BitFlags for configuring JSX detection behavior
+ * Uses BigInt for bit operations to support many flags
+ */
 type JSXDetectionHint = bigint;
+/**
+ * Flags to control JSX detection behavior:
+ * - Skip* flags: Ignore specific node types when detecting JSX
+ * - Strict* flags: Enforce stricter rules for container types
+ */
 declare const JSXDetectionHint: {
-    readonly None: 0n;
-    readonly SkipUndefined: bigint;
-    readonly SkipNullLiteral: bigint;
-    readonly SkipBooleanLiteral: bigint;
-    readonly SkipStringLiteral: bigint;
-    readonly SkipNumberLiteral: bigint;
-    readonly SkipBigIntLiteral: bigint;
-    readonly SkipEmptyArray: bigint;
-    readonly SkipCreateElement: bigint;
-    readonly StrictArray: bigint;
-    readonly StrictLogical: bigint;
-    readonly StrictConditional: bigint;
+  readonly None: 0n;
+  readonly SkipUndefined: bigint;
+  readonly SkipNullLiteral: bigint;
+  readonly SkipBooleanLiteral: bigint;
+  readonly SkipStringLiteral: bigint;
+  readonly SkipNumberLiteral: bigint;
+  readonly SkipBigIntLiteral: bigint;
+  readonly SkipEmptyArray: bigint;
+  readonly SkipCreateElement: bigint;
+  readonly StrictArray: bigint;
+  readonly StrictLogical: bigint;
+  readonly StrictConditional: bigint;
 };
+/**
+ * Default JSX detection configuration
+ * Skips undefined and boolean literals (common in React)
+ */
 declare const DEFAULT_JSX_DETECTION_HINT: bigint;
-
+//#endregion
+//#region src/jsx/jsx-detection.d.ts
 /**
- * Check if a node is a `JSXText` or a `Literal` node
+ * Checks if a node is a `JSXText` or a `Literal` node
  * @param node The AST node to check
  * @returns `true` if the node is a `JSXText` or a `Literal` node
  */
-declare function isJsxText(node: TSESTree$1.Node | null | _): node is TSESTree$1.JSXText | TSESTree$1.Literal;
+declare function isJsxText(node: TSESTree$1.Node | null | unit): node is TSESTree$1.JSXText | TSESTree$1.Literal;
 /**
- * Heuristic decision to determine if a node is a JSX-like node.
- * @param code The sourceCode object
+ * Determines if a node represents JSX-like content based on heuristics
+ * Supports configuration through hint flags to customize detection behavior
+ *
+ * @param code The source code with scope lookup capability
  * @param code.getScope The function to get the scope of a node
- * @param node The AST node to check
- * @param hint The `JSXDetectionHint` to use
- * @returns boolean
+ * @param node The AST node to analyze
+ * @param hint The configuration flags to adjust detection behavior
+ * @returns boolean Whether the node is considered JSX-like
  */
 declare function isJsxLike(code: {
-    getScope: (node: TSESTree$1.Node) => Scope;
-}, node: TSESTree$1.Node | _ | null, hint?: JSXDetectionHint): boolean;
-
+  getScope: (node: TSESTree$1.Node) => Scope;
+}, node: TSESTree$1.Node | unit | null, hint?: JSXDetectionHint): boolean;
+//#endregion
+//#region src/jsx/jsx-element-is.d.ts
 /**
- * Get the stringified type of a JSX element
- * @param context The ESLint rule context
- * @param node The JSX element node
- * @returns The type of the element
+ * Determines if a JSX element is a host element
+ * Host elements in React start with lowercase letters (e.g., div, span)
+ *
+ * @param context - ESLint rule context
+ * @param node - AST node to check
+ * @returns boolean indicating if the element is a host element
+ */
+declare function isHostElement(context: RuleContext, node: TSESTree.Node): boolean;
+/**
+ * Determines if a JSX element is a React Fragment
+ * Fragments can be imported from React and used like <Fragment> or <React.Fragment>
+ *
+ * @param context - ESLint rule context
+ * @param node - AST node to check
+ * @returns boolean indicating if the element is a Fragment with type narrowing
+ */
+declare function isFragmentElement(context: RuleContext, node: TSESTree.Node): node is TSESTree.JSXElement;
+//#endregion
+//#region src/jsx/jsx-element-type.d.ts
+/**
+ * Extracts the element type name from a JSX element or fragment
+ * For JSX elements, returns the stringified name (e.g., "div", "Button", "React.Fragment")
+ * For JSX fragments, returns an empty string
+ *
+ * @param context - ESLint rule context
+ * @param node - JSX element or fragment node
+ * @returns String representation of the element type
  */
 declare function getElementType(context: RuleContext, node: TSESTree.JSXElement | TSESTree.JSXFragment): string;
-
+//#endregion
+//#region src/jsx/jsx-has.d.ts
+/**
+ * Checks if a JSX element has a specific attribute
+ *
+ * @param context - ESLint rule context
+ * @param name - Name of the attribute to check for
+ * @param attributes - List of JSX attributes from opening element
+ * @param initialScope - Optional scope for resolving variables in spread attributes
+ * @returns boolean indicating whether the attribute exists
+ */
 declare function hasAttribute(context: RuleContext, name: string, attributes: TSESTree.JSXOpeningElement["attributes"], initialScope?: Scope): boolean;
+/**
+ * Checks if a JSX element has at least one of the specified attributes
+ *
+ * @param context - ESLint rule context
+ * @param names - Array of attribute names to check for
+ * @param attributes - List of JSX attributes from opening element
+ * @param initialScope - Optional scope for resolving variables in spread attributes
+ * @returns boolean indicating whether any of the attributes exist
+ */
 declare function hasAnyAttribute(context: RuleContext, names: string[], attributes: TSESTree.JSXOpeningElement["attributes"], initialScope?: Scope): boolean;
+/**
+ * Checks if a JSX element has all of the specified attributes
+ *
+ * @param context - ESLint rule context
+ * @param names - Array of attribute names to check for
+ * @param attributes - List of JSX attributes from opening element
+ * @param initialScope - Optional scope for resolving variables in spread attributes
+ * @returns boolean indicating whether all of the attributes exist
+ */
 declare function hasEveryAttribute(context: RuleContext, names: string[], attributes: TSESTree.JSXOpeningElement["attributes"], initialScope?: Scope): boolean;
-
+//#endregion
+//#region src/jsx/jsx-hierarchy.d.ts
 /**
- * Find the parent JSX attribute node of a node
- * @param node The node to find the parent attribute of
- * @param test The test to apply to the parent attribute
- * @returns The parent attribute node or undefined
+ * Traverses up the AST to find a parent JSX attribute node that matches a given test
+ *
+ * @param node - The starting AST node
+ * @param test - Optional predicate function to test if the attribute meets criteria
+ *               Defaults to always returning true (matches any attribute)
+ * @returns The first matching JSX attribute node found when traversing upwards, or undefined
  */
-declare function findParentAttribute(node: TSESTree.Node, test?: (node: TSESTree.JSXAttribute) => boolean): TSESTree.JSXAttribute | _;
-
-declare function isHostElement(context: RuleContext, node: TSESTree.Node): boolean;
-declare function isKeyedElement(context: RuleContext, node: TSESTree.Node, initialScope?: Scope): boolean;
-declare function isFragmentElement(context: RuleContext, node: TSESTree.Node | null | _, allowJSXFragment?: false): node is TSESTree.JSXElement;
-declare function isFragmentElement(context: RuleContext, node: TSESTree.Node | null | _, allowJSXFragment?: true): node is TSESTree.JSXElement | TSESTree.JSXFragment;
-
+declare function findParentAttribute(node: TSESTree.Node, test?: (node: TSESTree.JSXAttribute) => boolean): TSESTree.JSXAttribute | unit;
+//#endregion
+//#region src/jsx/jsx-stringify.d.ts
 /**
- * Get the stringified representation of a JSX node
- * @param node The JSX node
- * @returns The stringified representation
+ * Converts a JSX AST node to its string representation
+ * Handles different JSX node types and returns their textual form
+ *
+ * @param node - JSX node from TypeScript ESTree
+ * @returns String representation of the JSX node
  */
 declare function stringifyJsx(node: TSESTree$1.JSXIdentifier | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXNamespacedName | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXClosingElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXText): string;
-
+//#endregion
+//#region src/type/type-is.d.ts
+/** @internal */
+declare const isAnyType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isBigIntType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isBooleanType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isEnumType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isFalsyBigIntType: (type: ts.Type) => type is ts.LiteralType & {
+  freshType: ts.FreshableType;
+  regularType: ts.FreshableType;
+  flags: ts.TypeFlags;
+  symbol: ts.Symbol;
+  pattern?: ts.DestructuringPattern;
+  aliasSymbol?: ts.Symbol;
+  aliasTypeArguments?: readonly ts.Type[];
+  getFlags: () => ts.TypeFlags;
+  getSymbol: () => ts.Symbol | undefined;
+  getProperties: () => ts.Symbol[];
+  getProperty: (propertyName: string) => ts.Symbol | undefined;
+  getApparentProperties: () => ts.Symbol[];
+  getCallSignatures: () => readonly ts.Signature[];
+  getConstructSignatures: () => readonly ts.Signature[];
+  getStringIndexType: () => ts.Type | undefined;
+  getNumberIndexType: () => ts.Type | undefined;
+  getBaseTypes: () => ts.BaseType[] | undefined;
+  getNonNullableType: () => ts.Type;
+  getConstraint: () => ts.Type | undefined;
+  getDefault: () => ts.Type | undefined;
+  isUnion: () => this is ts.UnionType;
+  isIntersection: () => this is ts.IntersectionType;
+  isUnionOrIntersection: () => this is ts.UnionOrIntersectionType;
+  isLiteral: () => this is ts.LiteralType;
+  isStringLiteral: () => this is ts.StringLiteralType;
+  isNumberLiteral: () => this is ts.NumberLiteralType;
+  isTypeParameter: () => this is ts.TypeParameter;
+  isClassOrInterface: () => this is ts.InterfaceType;
+  isClass: () => this is ts.InterfaceType;
+  isIndexType: () => this is ts.IndexType;
+  value: {
+    negative: boolean;
+    base10Value: "0";
+  };
+};
+/** @internal */
+declare const isFalsyNumberType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isFalsyStringType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isNeverType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isNullishType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isNumberType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isObjectType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isStringType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isTruthyBigIntType: (type: ts.Type) => type is ts.LiteralType & {
+  freshType: ts.FreshableType;
+  regularType: ts.FreshableType;
+  flags: ts.TypeFlags;
+  symbol: ts.Symbol;
+  pattern?: ts.DestructuringPattern;
+  aliasSymbol?: ts.Symbol;
+  aliasTypeArguments?: readonly ts.Type[];
+  getFlags: () => ts.TypeFlags;
+  getSymbol: () => ts.Symbol | undefined;
+  getProperties: () => ts.Symbol[];
+  getProperty: (propertyName: string) => ts.Symbol | undefined;
+  getApparentProperties: () => ts.Symbol[];
+  getCallSignatures: () => readonly ts.Signature[];
+  getConstructSignatures: () => readonly ts.Signature[];
+  getStringIndexType: () => ts.Type | undefined;
+  getNumberIndexType: () => ts.Type | undefined;
+  getBaseTypes: () => ts.BaseType[] | undefined;
+  getNonNullableType: () => ts.Type;
+  getConstraint: () => ts.Type | undefined;
+  getDefault: () => ts.Type | undefined;
+  isUnion: () => this is ts.UnionType;
+  isIntersection: () => this is ts.IntersectionType;
+  isUnionOrIntersection: () => this is ts.UnionOrIntersectionType;
+  isLiteral: () => this is ts.LiteralType;
+  isStringLiteral: () => this is ts.StringLiteralType;
+  isNumberLiteral: () => this is ts.NumberLiteralType;
+  isTypeParameter: () => this is ts.TypeParameter;
+  isClassOrInterface: () => this is ts.InterfaceType;
+  isClass: () => this is ts.InterfaceType;
+  isIndexType: () => this is ts.IndexType;
+  value: ts.PseudoBigInt;
+};
+/** @internal */
+declare const isTruthyNumberType: (type: ts.Type) => boolean;
 /** @internal */
+declare const isTruthyStringType: (type: ts.Type) => boolean;
+/** @internal */
+declare const isUnknownType: (type: ts.Type) => boolean;
+//#endregion
+//#region src/type/type-variant.d.ts
+type TypeVariant = "any" | "bigint" | "boolean" | "enum" | "never" | "nullish" | "number" | "object" | "string" | "unknown" | "falsy bigint" | "falsy boolean" | "falsy number" | "falsy string" | "truthy bigint" | "truthy boolean" | "truthy number" | "truthy string";
+/**
+ * Ported from https://github.com/typescript-eslint/typescript-eslint/blob/eb736bbfc22554694400e6a4f97051d845d32e0b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts#L826 with some enhancements
+ * Get the variants of an array of types.
+ * @param types The types to get the variants of
+ * @returns The variants of the types
+ * @internal
+ */
+declare function getTypeVariants(types: ts.Type[]): Set<TypeVariant>;
+//#endregion
+//#region src/utils/get-instance-id.d.ts
+/**
+ * Gets the identifier node of an instance based on AST node relationships.
+ * Used for tracking where hooks or components are being assigned in the code.
+ * @param node The current AST node to evaluate
+ * @param prev The previous AST node in the traversal (used for context)
+ * @internal
+ */
 declare function getInstanceId(node: TSESTree.Node, prev?: TSESTree.Node): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.BinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpression | TSESTree.UpdateExpression | TSESTree.YieldExpression | undefined;
-
+//#endregion
+//#region src/utils/is-from-react.d.ts
 /**
- * Check if an identifier is initialized from react
+ * Check if an identifier name is initialized from react
  * @param name The top-level identifier's name
  * @param importSource The import source to check against
  * @param initialScope Initial scope to search for the identifier
- * @returns Whether the identifier is initialized from react
+ * @returns Whether the identifier name is initialized from react
+ * @internal
  */
 declare function isInitializedFromReact(name: string, importSource: string, initialScope: Scope): boolean;
-
+//#endregion
+//#region src/utils/is-instance-id-equal.d.ts
 /** @internal */
 declare function isInstanceIdEqual(context: RuleContext, a: TSESTree.Node, b: TSESTree.Node): boolean;
-
+//#endregion
+//#region src/utils/is-react-api.d.ts
 declare namespace isReactAPI {
-    type ReturnType = {
-        (context: RuleContext, node: _ | null | TSESTree.Node): node is TSESTree.Identifier | TSESTree.MemberExpression;
-        (context: RuleContext): (node: _ | null | TSESTree.Node) => node is TSESTree.MemberExpression | TSESTree.Identifier;
-    };
+  type ReturnType = {
+    (context: RuleContext, node: unit | null | TSESTree.Node): node is TSESTree.Identifier | TSESTree.MemberExpression;
+    (context: RuleContext): (node: unit | null | TSESTree.Node) => node is TSESTree.MemberExpression | TSESTree.Identifier;
+  };
 }
 declare function isReactAPI(api: string): isReactAPI.ReturnType;
 declare namespace isReactAPICall {
-    type ReturnType = {
-        (context: RuleContext, node: _ | null | TSESTree.Node): node is TSESTree.CallExpression;
-        (context: RuleContext): (node: _ | null | TSESTree.Node) => node is TSESTree.CallExpression;
-    };
+  type ReturnType = {
+    (context: RuleContext, node: unit | null | TSESTree.Node): node is TSESTree.CallExpression;
+    (context: RuleContext): (node: unit | null | TSESTree.Node) => node is TSESTree.CallExpression;
+  };
 }
 declare function isReactAPICall(api: string): isReactAPICall.ReturnType;
 declare const isCaptureOwnerStack: isReactAPI.ReturnType;
@@ -542,5 +778,5 @@ declare const isCreateRefCall: isReactAPICall.ReturnType;
 declare const isForwardRefCall: isReactAPICall.ReturnType;
 declare const isMemoCall: isReactAPICall.ReturnType;
 declare const isLazyCall: isReactAPICall.ReturnType;
-
-export { type ClassComponent, type Component, ComponentDetectionHint, type ComponentEffectPhaseKind, ComponentFlag, type ComponentKind, type ComponentLifecyclePhaseKind, type ComponentPhaseKind, ComponentPhaseRelevance, type ComponentStateKind, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, type EffectKind, type FunctionComponent, type Hook, type HookKind, JSXDetectionHint, type SemanticEntry, type SemanticNode, findParentAttribute, getAttribute, getAttributeName, getAttributeValue, getComponentFlagFromInitPath, getComponentNameFromId, getElementType, getFunctionComponentId, getInstanceId, hasAnyAttribute, hasAttribute, hasEveryAttribute, hasNoneOrLooseComponentName, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFragmentElement, isFunctionOfRender, isFunctionOfRenderMethod, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHostElement, isInitializedFromReact, isInstanceIdEqual, isInversePhase, isJsxLike, isJsxText, isKeyedElement, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookId, isReactHookName, isRenderFunctionLoose, isRenderLike, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, isValidComponentDefinition, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+//#endregion
+export { ClassComponent, Component, ComponentDetectionHint, ComponentEffectPhaseKind, ComponentFlag, ComponentKind, ComponentLifecyclePhaseKind, ComponentPhaseKind, ComponentPhaseRelevance, ComponentStateKind, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, EffectKind, FunctionComponent, Hook, JSXDetectionHint, REACT_BUILTIN_HOOK_NAMES, SemanticEntry, SemanticNode, TypeVariant, findParentAttribute, getAttribute, getAttributeName, getAttributeValue, getComponentFlagFromInitPath, getComponentNameFromId, getElementType, getFunctionComponentId, getInstanceId, getTypeVariants, hasAnyAttribute, hasAttribute, hasEveryAttribute, hasNoneOrLooseComponentName, isAnyType, isAssignmentToThisState, isBigIntType, isBooleanType, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isEnumType, isFalseLiteralType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isForwardRef, isForwardRefCall, isFragmentElement, isFunctionOfRenderMethod, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHostElement, isInitializedFromReact, isInstanceIdEqual, isInversePhase, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isNeverType, isNullishType, isNumberType, isObjectType, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookId, isReactHookName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isStringType, isThisSetState, isTrueLiteralType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };