@eslint-react/core 3.0.0-next.9 → 3.0.0-rc.0

package/dist/index.d.ts

@@ -1,17 +1,25 @@
 import * as ast from "@eslint-react/ast";
-import { unit } from "@eslint-react/eff";
 import { TSESTree } from "@typescript-eslint/types";
 import { RegExpLike, RuleContext } from "@eslint-react/shared";
 import { ESLintUtils, TSESTree as TSESTree$1 } from "@typescript-eslint/utils";
 import { Scope } from "@typescript-eslint/scope-manager";
 import * as typescript from "typescript";
 
+//#region src/api/find-import-source.d.ts
+/**
+ * Find the import source of a variable
+ * @param name The variable name
+ * @param initialScope The initial scope to search
+ * @returns The import source or null if not found
+ */
+declare function findImportSource(name: string, initialScope: Scope): string | null;
+//#endregion
 //#region src/api/is-from-react.d.ts
 /**
  * Check if a variable is initialized from React import
  * @param name The variable name
  * @param initialScope The initial scope
- * @param importSource Alternative import source of React (e.g., "preact/compat")
+ * @param importSource Alternative import source of React (ex: "preact/compat")
  * @returns True if the variable is initialized or derived from React import
  */
 declare function isInitializedFromReact(name: string, initialScope: Scope, importSource?: string): boolean;
@@ -21,7 +29,7 @@ declare function isInitializedFromReact(name: string, initialScope: Scope, impor
  * if a variable is initialized from React Native import
  * @param name The variable name
  * @param initialScope The initial scope
- * @param importSource Alternative import source of React Native (e.g., "react-native-web")
+ * @param importSource Alternative import source of React Native (ex: "react-native-web")
  * @returns True if the variable is initialized from React Native import
  */
 declare function isInitializedFromReactNative(name: string, initialScope: Scope, importSource?: string): boolean;
@@ -29,20 +37,20 @@ declare function isInitializedFromReactNative(name: string, initialScope: Scope,
 //#region src/api/is-react-api.d.ts
 declare namespace isReactAPI {
   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;
+    (context: RuleContext, node: null | TSESTree.Node): node is TSESTree.Identifier | TSESTree.MemberExpression;
+    (context: RuleContext): (node: null | TSESTree.Node) => node is TSESTree.MemberExpression | TSESTree.Identifier;
   };
 }
 /**
  * Check if the node is a React API identifier or member expression
- * @param api The React API name to check against (e.g., "useState", "React.memo")
+ * @param api The React API name to check against (ex: "useState", "React.memo")
  * @returns A predicate function to check if a node matches the API
  */
 declare function isReactAPI(api: string): isReactAPI.ReturnType;
 declare namespace isReactAPICall {
   type ReturnType = {
-    (context: RuleContext, node: unit | null | TSESTree.Node): node is TSESTree.CallExpression;
-    (context: RuleContext): (node: unit | null | TSESTree.Node) => node is TSESTree.CallExpression;
+    (context: RuleContext, node: null | TSESTree.Node): node is TSESTree.CallExpression;
+    (context: RuleContext): (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
   };
 }
 /**
@@ -78,19 +86,20 @@ declare const isForwardRefCall: isReactAPICall.ReturnType;
 declare const isMemoCall: isReactAPICall.ReturnType;
 declare const isLazyCall: isReactAPICall.ReturnType;
 //#endregion
-//#region src/component/component-detection-hint.d.ts
+//#region src/component/component-detection.d.ts
 type ComponentDetectionHint = bigint;
 /**
  * Hints for component collector
  */
 declare const ComponentDetectionHint: {
-  readonly DoNotIncludeFunctionDefinedOnObjectMethod: bigint;
+  readonly DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback: bigint;
+  readonly DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: bigint;
+  readonly DoNotIncludeFunctionDefinedAsArrayMapCallback: bigint;
+  readonly DoNotIncludeFunctionDefinedInArrayExpression: bigint;
+  readonly DoNotIncludeFunctionDefinedInArrayPattern: bigint;
   readonly DoNotIncludeFunctionDefinedOnClassMethod: bigint;
   readonly DoNotIncludeFunctionDefinedOnClassProperty: bigint;
-  readonly DoNotIncludeFunctionDefinedInArrayPattern: bigint;
-  readonly DoNotIncludeFunctionDefinedInArrayExpression: bigint;
-  readonly DoNotIncludeFunctionDefinedAsArrayMapCallback: bigint;
-  readonly DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: bigint;
+  readonly DoNotIncludeFunctionDefinedOnObjectMethod: bigint;
   readonly None: 0n;
   readonly DoNotIncludeJsxWithNullValue: bigint;
   readonly DoNotIncludeJsxWithNumberValue: bigint;
@@ -108,6 +117,15 @@ declare const ComponentDetectionHint: {
  * Default component detection hint
  */
 declare const DEFAULT_COMPONENT_DETECTION_HINT: bigint;
+/**
+ * Determine if a function node represents a valid React component definition
+ *
+ * @param context The rule context
+ * @param node The function node to analyze
+ * @param hint Component detection hints (bit flags) to customize detection logic
+ * @returns `true` if the node is considered a component definition
+ */
+declare function isComponentDefinition(context: RuleContext, node: ast.TSESTreeFunction, hint: bigint): boolean;
 //#endregion
 //#region src/semantic/semantic-node.d.ts
 /**
@@ -116,19 +134,19 @@ declare const DEFAULT_COMPONENT_DETECTION_HINT: bigint;
  */
 interface SemanticNode {
   /** The identifier of the node */
-  id: unit | TSESTree.Node;
+  id: null | TSESTree.Node;
   /** The unique key of the node */
   key: string;
   /** The kind of the node */
   kind: string;
   /** The name of the node */
-  name: unit | string;
-  /** The AST node */
-  node: TSESTree.Node;
+  name: null | string;
   /** The flag of the node */
   flag: bigint;
   /** The hint of the node */
   hint: bigint;
+  /** The AST node */
+  node: TSESTree.Node;
 }
 //#endregion
 //#region src/semantic/semantic-func.d.ts
@@ -138,36 +156,23 @@ interface SemanticNode {
  */
 interface SemanticFunc extends SemanticNode {
   /** The identifier of the function */
-  id: ast.FunctionID | unit;
+  id: ast.FunctionID;
   /** The AST node of the function */
   node: ast.TSESTreeFunction;
   /** The name of the function */
-  name: string | unit;
+  name: string | null;
   /** The return type annotation of the function */
-  type: TSESTree.TSTypeAnnotation | unit;
+  type: TSESTree.TSTypeAnnotation | null;
   /** The body of the function */
   body: TSESTree.BlockStatement | TSESTree.Expression;
-  /** The directives of the function (e.g., "use strict", "use client", "use server", etc.) */
+  /** The directives of the function (ex: "use strict", "use client", "use server", etc.) */
   directives: ast.TSESTreeDirective[];
   /** The parameters of the function */
   parameters: TSESTree.Parameter[];
   /** The type parameters of the function */
-  typeParameters: TSESTree.TSTypeParameterDeclaration | unit;
+  typeParameters: TSESTree.TSTypeParameterDeclaration | null;
 }
 //#endregion
-//#region src/component/component-flag.d.ts
-type ComponentFlag = bigint;
-/**
- * Component flag constants
- */
-declare const ComponentFlag: {
-  /** No flags set */None: bigint; /** Indicates the component is a pure component (e.g., extends PureComponent) */
-  PureComponent: bigint; /** Indicates the component creates elements using `createElement` instead of JSX */
-  CreateElement: bigint; /** Indicates the component is memoized (e.g., React.memo) */
-  Memo: bigint; /** Indicates the component forwards a ref (e.g., React.forwardRef) */
-  ForwardRef: bigint;
-};
-//#endregion
 //#region src/component/component-semantic-node.d.ts
 /**
  * Represents a React Function Component
@@ -176,7 +181,7 @@ interface FunctionComponentSemanticNode extends SemanticNode {
   /**
    * The identifier or identifier sequence of the component
    */
-  id: unit | ast.FunctionID;
+  id: ast.FunctionID;
   /**
    * The kind of component
    */
@@ -188,11 +193,11 @@ interface FunctionComponentSemanticNode extends SemanticNode {
   /**
    * Flags describing the component's characteristics
    */
-  flag: ComponentFlag;
+  flag: bigint;
   /**
    * Hint for how the component was detected
    */
-  hint: ComponentDetectionHint;
+  hint: bigint;
   /**
    * List of expressions returned by the component
    */
@@ -200,7 +205,7 @@ interface FunctionComponentSemanticNode extends SemanticNode {
   /**
    * The initialization path of the function
    */
-  initPath: unit | ast.FunctionInitPath;
+  initPath: null | ast.FunctionInitPath;
   /**
    * Indicates if the component is inside an export default declaration
    */
@@ -216,9 +221,9 @@ interface FunctionComponentSemanticNode extends SemanticNode {
   /**
    * The display name of the component
    */
-  displayName: unit | TSESTree.Expression;
+  displayName: null | TSESTree.Expression;
   /**
-   * The directives used in the function (e.g., "use strict", "use client", etc.)
+   * The directives used in the function (ex: "use strict", "use client", etc.)
    */
   directives: ast.TSESTreeDirective[];
 }
@@ -229,7 +234,7 @@ interface ClassComponentSemanticNode extends SemanticNode {
   /**
    * The identifier of the component
    */
-  id: unit | TSESTree.BindingName;
+  id: null | TSESTree.BindingName;
   /**
    * The kind of component
    */
@@ -241,11 +246,11 @@ interface ClassComponentSemanticNode extends SemanticNode {
   /**
    * Flags describing the component's characteristics
    */
-  flag: ComponentFlag;
+  flag: bigint;
   /**
    * Hint for how the component was detected
    */
-  hint: ComponentDetectionHint;
+  hint: bigint;
   /**
    * List of methods and properties in the class
    */
@@ -253,7 +258,7 @@ interface ClassComponentSemanticNode extends SemanticNode {
   /**
    * The display name of the component
    */
-  displayName: unit | TSESTree.Expression;
+  displayName: null | TSESTree.Expression;
 }
 /**
  * Represents a React Component
@@ -273,7 +278,7 @@ declare namespace useComponentCollector {
     ctx: {
       getAllComponents: (node: TSESTree.Program) => FunctionComponentSemanticNode[];
       getCurrentEntries: () => FunctionEntry$1[];
-      getCurrentEntry: () => FunctionEntry$1 | unit;
+      getCurrentEntry: () => FunctionEntry$1 | null;
     };
     visitor: ESLintUtils.RuleListener;
   };
@@ -301,48 +306,8 @@ declare namespace useComponentCollectorLegacy {
  * @returns The ctx and visitor of the collector
  */
 declare function useComponentCollectorLegacy(context: RuleContext): useComponentCollectorLegacy.ReturnType;
-/**
- * Check whether the given node is a this.setState() call
- * @param node The node to check
- * @internal
- */
-declare function isThisSetState(node: TSESTree$1.CallExpression): boolean;
-/**
- * Check whether the given node is an assignment to this.state
- * @param node The node to check
- * @internal
- */
-declare function isAssignmentToThisState(node: TSESTree$1.AssignmentExpression): boolean;
 //#endregion
-//#region src/component/component-definition.d.ts
-/**
- * Determine if a function node represents a valid React component definition
- *
- * @param context The rule context
- * @param node The function node to analyze
- * @param hint Component detection hints (bit flags) to customize detection logic
- * @returns `true` if the node is considered a component definition
- */
-declare function isComponentDefinition(context: RuleContext, node: ast.TSESTreeFunction, hint: bigint): boolean;
-//#endregion
-//#region src/component/component-id.d.ts
-/**
- * Get function component identifier from `const Component = memo(() => {});`
- * @param context The rule context
- * @param node The function node to analyze
- * @returns The function identifier or `unit` if not found
- */
-declare function getFunctionComponentId(context: RuleContext, node: ast.TSESTreeFunction): ast.FunctionID | unit;
-//#endregion
-//#region src/component/component-init-path.d.ts
-/**
- * Get component flag from init path
- * @param initPath The init path of the function component
- * @returns The component flag
- */
-declare function getComponentFlagFromInitPath(initPath: FunctionComponentSemanticNode["initPath"]): bigint;
-//#endregion
-//#region src/component/component-is.d.ts
+//#region src/component/component-detection-legacy.d.ts
 /**
  * Check if a node is a React class component
  * @param node The AST node to check
@@ -355,22 +320,6 @@ declare function isClassComponent(node: TSESTree.Node): node is ast.TSESTreeClas
  * @returns `true` if the node is a PureComponent, `false` otherwise
  */
 declare function isPureComponent(node: TSESTree.Node): boolean;
-//#endregion
-//#region src/component/component-method-callback.d.ts
-/**
- * Check if the given node is a componentDidMount callback
- * @param node The node to check
- * @returns True if the node is a componentDidMount callback, false otherwise
- */
-declare function isComponentDidMountCallback(node: TSESTree.Node): boolean;
-/**
- * Check if the given node is a componentWillUnmount callback
- * @param node The node to check
- * @returns True if the node is a componentWillUnmount callback, false otherwise
- */
-declare function isComponentWillUnmountCallback(node: TSESTree.Node): boolean;
-//#endregion
-//#region src/component/component-method-is.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;
@@ -389,28 +338,18 @@ declare const isUnsafeComponentWillUpdate: (node: TSESTree.Node) => node is ast.
 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
-/**
- * Check if a string matches the strict component name pattern
- * @param name The name to check
- */
-declare function isComponentName(name: string): boolean;
 /**
- * Check if a string matches the loose component name pattern
- * @param name The name to check
+ * Check if the given node is a componentDidMount callback
+ * @param node The node to check
+ * @returns True if the node is a componentDidMount callback, false otherwise
  */
-declare function isComponentNameLoose(name: string): boolean;
+declare function isComponentDidMountCallback(node: TSESTree.Node): boolean;
 /**
- * Check if a function has a loose component name
- * @param context The rule context
- * @param fn The function to check
- * @param allowNone Whether to allow no name
- * @returns Whether the function has a loose component name
+ * Check if the given node is a componentWillUnmount callback
+ * @param node The node to check
+ * @returns True if the node is a componentWillUnmount callback, false otherwise
  */
-declare function isFunctionWithLooseComponentName(context: RuleContext, fn: ast.TSESTreeFunction, allowNone?: boolean): boolean;
-//#endregion
-//#region src/component/component-render-method.d.ts
+declare function isComponentWillUnmountCallback(node: TSESTree.Node): boolean;
 /**
  * Check whether given node is a render method of a class component
  * @example
@@ -424,57 +363,79 @@ declare function isFunctionWithLooseComponentName(context: RuleContext, fn: ast.
  * @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
+ * Check if the given node is a function within a render method of a class component
+ *
+ * @param node The AST node to check
+ * @returns `true` if the node is a render function inside a class component
+ *
+ * @example
  * ```tsx
- * const renderRow = () => <div />
- * `                 ^^^^^^^^^^^^`
- * _ = <Component renderRow={() => <div />} />
- * `                         ^^^^^^^^^^^^^   `
+ * class Component extends React.Component {
+ *   renderHeader = () => <div />; // Returns true
+ * }
  * ```
- * @param context The rule context
- * @param node The AST node to check
- * @returns `true` if node is a render function, `false` if not
  */
-declare function isRenderFunctionLoose(context: RuleContext, node: TSESTree.Node): node is ast.TSESTreeFunction;
+declare function isRenderMethodCallback(node: ast.TSESTreeFunction): boolean;
 /**
- * Unsafe check whether given JSXAttribute is a render prop
- * ```tsx
- * _ = <Component renderRow={() => <div />} />
- * `              ^^^^^^^^^^^^^^^^^^^^^^^^^  `
- * ```
- * @param context The rule context
- * @param node The AST node to check
- * @returns `true` if node is a render prop, `false` if not
+ * Check whether the given node is a this.setState() call
+ * @param node The node to check
+ * @internal
  */
-declare function isRenderPropLoose(context: RuleContext, node: TSESTree.JSXAttribute): boolean;
+declare function isThisSetState(node: TSESTree.CallExpression): boolean;
 /**
- * Unsafe check whether given node is declared directly inside a render property
- * ```tsx
- * const rows = { render: () => <div /> }
- * `                      ^^^^^^^^^^^^^ `
- * _ = <Component rows={ [{ render: () => <div /> }] } />
- * `                                ^^^^^^^^^^^^^       `
- *  ```
+ * Check whether the given node is an assignment to this.state
+ * @param node The node to check
  * @internal
- * @param node The AST node to check
- * @returns `true` if component is declared inside a render property, `false` if not
  */
-declare function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node): boolean;
+declare function isAssignmentToThisState(node: TSESTree.AssignmentExpression): boolean;
+//#endregion
+//#region src/component/component-flag.d.ts
 /**
- * Unsafe check whether given node is declared inside a render prop
- * ```tsx
- * _ = <Component renderRow={"node"} />
- * `                         ^^^^^^   `
- * _ = <Component rows={ [{ render: "node" }] } />
- * `                                ^^^^^^       `
- * ```
- * @param node The AST node to check
- * @returns `true` if component is declared inside a render prop, `false` if not
+ * Component flag constants
+ */
+declare const ComponentFlag: {
+  /** Indicates the component creates elements using `createElement` instead of JSX */CreateElement: bigint; /** Indicates the component forwards a ref (ex: React.forwardRef) */
+  ForwardRef: bigint; /** Indicates the component is memoized (ex: React.memo) */
+  Memo: bigint; /** No flags set */
+  None: bigint; /** Indicates the component is a pure component (ex: extends PureComponent) */
+  PureComponent: bigint;
+};
+/**
+ * Get component flag from init path
+ * @param initPath The init path of the function component
+ * @returns The component flag
+ */
+declare function getComponentFlagFromInitPath(initPath: FunctionComponentSemanticNode["initPath"]): bigint;
+//#endregion
+//#region src/component/component-id.d.ts
+/**
+ * Get function component identifier from `const Component = memo(() => {});`
+ * @param context The rule context
+ * @param node The function node to analyze
+ * @returns The function identifier or `null` if not found
+ */
+declare function getFunctionComponentId(context: RuleContext, node: ast.TSESTreeFunction): ast.FunctionID;
+//#endregion
+//#region src/component/component-name.d.ts
+/**
+ * Check if a string matches the strict component name pattern
+ * @param name The name to check
+ */
+declare function isComponentName(name: string): boolean;
+/**
+ * Check if a string matches the loose component name pattern
+ * @param name The name to check
  */
-declare function isDeclaredInRenderPropLoose(node: TSESTree.Node): boolean;
+declare function isComponentNameLoose(name: string): boolean;
+/**
+ * Check if a function has a loose component name
+ * @param context The rule context
+ * @param fn The function to check
+ * @param allowNone Whether to allow no name
+ * @returns Whether the function has a loose component name
+ */
+declare function isFunctionWithLooseComponentName(context: RuleContext, fn: ast.TSESTreeFunction, allowNone?: boolean): boolean;
 //#endregion
 //#region src/component/component-wrapper.d.ts
 /**
@@ -510,7 +471,7 @@ declare function isComponentWrapperCallbackLoose(context: RuleContext, node: TSE
 /**
  * Represents the kind of a React function
  */
-type ComponentKind = "client-function" | "server-function";
+type FunctionKind = "client-function" | "server-function";
 //#endregion
 //#region src/function/function-semantic-node.d.ts
 /**
@@ -536,35 +497,17 @@ interface ServerFunctionSemanticNode extends SemanticFunc {
  */
 type FunctionSemanticNode = ClientFunctionSemanticNode | ServerFunctionSemanticNode;
 //#endregion
-//#region src/hierarchy/find-enclosing-component-or-hook.d.ts
-type FindEnclosingComponentOrHookFilter = (n: TSESTree.Node, name: string | null) => boolean;
-/**
- * Find the enclosing React component or hook for a given AST node
- * @param node The AST node to start the search from
- * @param test Optional test function to customize component or hook identification
- * @returns The enclosing component or hook node, or `null` if none is ASAST.
- */
-declare function findEnclosingComponentOrHook(node: TSESTree.Node | unit, test?: FindEnclosingComponentOrHookFilter): TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | undefined;
-//#endregion
-//#region src/hierarchy/is-inside-component-or-hook.d.ts
-/**
- * Check if a given AST node is inside a React component or hook
- * @param node The AST node to check
- * @returns True if the node is inside a component or hook, false otherwise
- */
-declare function isInsideComponentOrHook(node: TSESTree.Node | unit): boolean;
-//#endregion
 //#region src/hook/hook-callback.d.ts
 /**
  * Determine if a node is the setup function passed to a useEffect-like hook
  * @param node The AST node to check
  */
-declare function isUseEffectSetupCallback(node: TSESTree.Node | unit): boolean;
+declare function isUseEffectSetupCallback(node: TSESTree.Node | null): boolean;
 /**
  * Determine if a node is the cleanup function returned by a useEffect-like hook's setup function
  * @param node The AST node to check
  */
-declare function isUseEffectCleanupCallback(node: TSESTree.Node | unit): boolean;
+declare function isUseEffectCleanupCallback(node: TSESTree.Node | null): boolean;
 //#endregion
 //#region src/hook/hook-semantic-node.d.ts
 /**
@@ -573,14 +516,14 @@ declare function isUseEffectCleanupCallback(node: TSESTree.Node | unit): boolean
  */
 interface HookSemanticNode extends SemanticNode {
   /** The identifier of the hook */
-  id: ast.FunctionID | unit;
+  id: ast.FunctionID;
   /** The AST node of the hook */
   node: ast.TSESTreeFunction;
   /** The name of the hook */
   name: string;
   /** The other hooks called by the hook */
   hookCalls: TSESTree.CallExpression[];
-  /** The directives used in the function (e.g., "use strict", "use client", etc.) */
+  /** The directives used in the function (ex: "use strict", "use client", etc.) */
   directives: TSESTree.StringLiteral[];
 }
 //#endregion
@@ -594,7 +537,7 @@ declare namespace useHookCollector {
     ctx: {
       getAllHooks(node: TSESTree$1.Program): HookSemanticNode[];
       getCurrentEntries(): FunctionEntry[];
-      getCurrentEntry(): FunctionEntry | unit;
+      getCurrentEntry(): FunctionEntry | null;
     };
     visitor: ESLintUtils.RuleListener;
   };
@@ -620,53 +563,53 @@ declare function isHookId(id: TSESTree.Node): id is TSESTree.Identifier | TSESTr
  * @param node The function node to check
  * @returns True if the function is a React Hook, false otherwise
  */
-declare function isHook(node: ast.TSESTreeFunction | unit): boolean;
+declare function isHook(node: ast.TSESTreeFunction | null): 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 isHookCall(node: TSESTree.Node | unit): node is TSESTree.CallExpression;
+declare function isHookCall(node: TSESTree.Node | null): node is TSESTree.CallExpression;
 /**
  * Check if a node is a call to a specific React hook.
  * Returns a function that accepts a hook name to check against.
  * @param node The AST node to check
  * @returns A function that takes a hook name and returns boolean
  */
-declare function isHookCallWithName(node: TSESTree.Node | unit): (name: string) => boolean;
+declare function isHookCallWithName(node: TSESTree.Node | null): (name: string) => boolean;
 /**
  * Detect useEffect calls and variations (useLayoutEffect, etc.) using a regex pattern
  * @param node The AST node to check
  * @param additionalEffectHooks Regex pattern matching custom hooks that should be treated as effect hooks
  * @returns True if the node is a useEffect-like call
  */
-declare function isUseEffectLikeCall(node: TSESTree.Node | unit, additionalEffectHooks?: RegExpLike): node is TSESTree.CallExpression;
+declare function isUseEffectLikeCall(node: TSESTree.Node | null, additionalEffectHooks?: RegExpLike): node is TSESTree.CallExpression;
 /**
  * Detect useState calls and variations (useCustomState, etc.) using a regex pattern
  * @param node The AST node to check
  * @param additionalStateHooks Regex pattern matching custom hooks that should be treated as state hooks
  * @returns True if the node is a useState-like call
  */
-declare function isUseStateLikeCall(node: TSESTree.Node | unit, additionalStateHooks?: RegExpLike): node is TSESTree.CallExpression;
-declare const isUseCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseActionStateCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseCallbackCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseContextCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseDebugValueCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseDeferredValueCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseEffectCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseFormStatusCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseIdCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseImperativeHandleCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseInsertionEffectCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseLayoutEffectCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseMemoCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseOptimisticCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseReducerCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseRefCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseStateCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseSyncExternalStoreCall: (node: TSESTree.Node | undefined) => boolean;
-declare const isUseTransitionCall: (node: TSESTree.Node | undefined) => boolean;
+declare function isUseStateLikeCall(node: TSESTree.Node | null, additionalStateHooks?: RegExpLike): node is TSESTree.CallExpression;
+declare const isUseCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseActionStateCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseCallbackCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseContextCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseDebugValueCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseDeferredValueCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseEffectCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseFormStatusCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseIdCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseImperativeHandleCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseInsertionEffectCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseLayoutEffectCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseMemoCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseOptimisticCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseReducerCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseRefCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseStateCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseSyncExternalStoreCall: (node: TSESTree.Node | null) => boolean;
+declare const isUseTransitionCall: (node: TSESTree.Node | null) => boolean;
 //#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"];
@@ -678,36 +621,21 @@ declare const REACT_BUILTIN_HOOK_NAMES: readonly ["use", "useActionState", "useC
  */
 declare function isHookName(name: string): boolean;
 //#endregion
-//#region src/jsx/jsx-attribute.d.ts
-/**
- * Creates a helper function to find a specific JSX attribute by name
- * Handles direct attributes and spread attributes (variables or object literals)
- * @param context The ESLint rule context
- * @param node The JSX element node
- * @param initialScope (Optional) The initial scope to use for variable resolution
- */
-declare function getJsxAttribute(context: RuleContext, node: TSESTree.JSXElement, initialScope?: Scope): (name: string) => TSESTree.JSXAttribute | TSESTree.JSXSpreadAttribute | undefined;
-//#endregion
-//#region src/jsx/jsx-attribute-name.d.ts
-/**
- * Get the stringified name of a JSX attribute
- * @param context The ESLint rule context
- * @param node The JSX attribute node
- * @returns The name of the attribute
- */
-declare function getJsxAttributeName(context: RuleContext, node: TSESTree$1.JSXAttribute): string;
-//#endregion
 //#region src/jsx/jsx-attribute-value.d.ts
 /**
  * Represents possible JSX attribute value types that can be resolved
  */
 type JsxAttributeValue = {
+  kind: "missing";
+  node: TSESTree.JSXEmptyExpression;
+  toStatic(): null;
+} | {
   kind: "boolean";
   toStatic(): true;
 } | {
   kind: "element";
   node: TSESTree.JSXElement;
-  toStatic(): unknown;
+  toStatic(): null;
 } | {
   kind: "literal";
   node: TSESTree.Literal;
@@ -718,44 +646,14 @@ type JsxAttributeValue = {
   toStatic(): unknown;
 } | {
   kind: "spreadProps";
+  getProperty(name: string): unknown;
   node: TSESTree.JSXSpreadAttribute["argument"];
-  toStatic(name?: string): unknown;
+  toStatic(): null;
 } | {
   kind: "spreadChild";
+  getChildren(at: number): unknown;
   node: TSESTree.JSXSpreadChild["expression"];
-  toStatic(): unknown;
-};
-/**
- * Resolve the static value of a JSX attribute or spread attribute
- *
- * @param context - The ESLint rule context
- * @param attribute - The JSX attribute node to resolve
- * @returns An object containing the value kind, the node (if applicable), and a `toStatic` helper
- */
-declare function resolveJsxAttributeValue(context: RuleContext, attribute: ast.TSESTreeJSXAttributeLike): {
-  readonly kind: "boolean";
-  readonly toStatic: () => true;
-  readonly node?: never;
-} | {
-  readonly kind: "literal";
-  readonly node: TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral;
-  readonly toStatic: () => string | number | bigint | boolean | RegExp | null;
-} | {
-  readonly kind: "expression";
-  readonly node: TSESTree.JSXEmptyExpression | TSESTree.Expression;
-  readonly toStatic: () => unknown;
-} | {
-  readonly kind: "element";
-  readonly node: TSESTree.JSXElement;
-  readonly toStatic: () => undefined;
-} | {
-  readonly kind: "spreadChild";
-  readonly node: TSESTree.JSXEmptyExpression | TSESTree.Expression;
-  readonly toStatic: () => undefined;
-} | {
-  readonly kind: "spreadProps";
-  readonly node: TSESTree.Expression;
-  readonly toStatic: (name?: string) => unknown;
+  toStatic(): null;
 };
 //#endregion
 //#region src/jsx/jsx-config.d.ts
@@ -815,81 +713,206 @@ declare const JsxDetectionHint: {
  * Skips undefined and boolean literals (common in React)
  */
 declare const DEFAULT_JSX_DETECTION_HINT: bigint;
-/**
- * Check 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 | unit): node is TSESTree$1.JSXText | TSESTree$1.Literal;
 /**
  * Determine 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 context The rule context with scope lookup capability
  * @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 | unit | null, hint?: JsxDetectionHint): boolean;
+declare function isJsxLike(context: RuleContext, node: TSESTree$1.Node | null, hint?: JsxDetectionHint): boolean;
 //#endregion
-//#region src/jsx/jsx-element-is.d.ts
+//#region src/jsx/jsx-inspector.d.ts
 /**
- * Determine if a JSX element is a host element
- * Host elements in React start with lowercase letters (e.g., div, span)
+ * A stateful helper that binds an ESLint `RuleContext` once and exposes
+ * ergonomic methods for the most common JSX inspection tasks that rules need.
  *
- * @param context ESLint rule context
- * @param node AST node to check
- * @returns boolean indicating if the element is a host element
- */
-declare function isJsxHostElement(context: RuleContext, node: TSESTree.Node): boolean;
-/**
- * Determine if a JSX element is a React Fragment
- * Fragments can be imported from React and used like <Fragment> or <React.Fragment>
+ * ### Typical usage inside a rule's `create` function
  *
- * @param context ESLint rule context
- * @param node AST node to check
- * @param jsxConfig Optional JSX configuration
- * @param jsxConfig.jsxFragmentFactory Name of the fragment factory (e.g., React.Fragment)
- * @returns boolean indicating if the element is a Fragment
- */
-declare function isJsxFragmentElement(context: RuleContext, node: TSESTree.Node, jsxConfig?: Pick<JsxConfig, "jsxFragmentFactory">): boolean;
-//#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
+ * ```ts
+ * export function create(context: RuleContext) {
+ *   const jsx = JsxInspector.from(context);
  *
- * @param context ESLint rule context
- * @param node JSX element or fragment node
- * @returns String representation of the element type
- */
-declare function getJsxElementType(context: RuleContext, node: TSESTree.JSXElement | TSESTree.JSXFragment): string;
-//#endregion
-//#region src/jsx/jsx-hierarchy.d.ts
-/**
- * Traverses up the AST to find a parent JSX attribute node that matches a given test
+ *   return defineRuleListener({
+ *     JSXElement(node) {
+ *       // element type
+ *       const type = jsx.getElementType(node);           // "div" | "React.Fragment" | …
  *
- * @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 findParentJsxAttribute(node: TSESTree.Node, test?: (node: TSESTree.JSXAttribute) => boolean): TSESTree.JSXAttribute | unit;
-//#endregion
-//#region src/jsx/jsx-stringify.d.ts
-/**
- * Incomplete but sufficient stringification of JSX nodes for common use cases
+ *       // attribute lookup + value resolution in one step
+ *       const val  = jsx.getAttributeValue(node, "sandbox");
+ *       if (typeof val?.getStatic() === "string") { … }
  *
- * @param node JSX node from TypeScript ESTree
- * @returns String representation of the JSX node
+ *       // simple boolean checks
+ *       if (jsx.isHostElement(node)) { … }
+ *       if (jsx.isFragmentElement(node)) { … }
+ *       if (jsx.hasAttribute(node, "key")) { … }
+ *     },
+ *   });
+ * }
+ * ```
  */
-declare function stringifyJsx(node: TSESTree$1.JSXIdentifier | TSESTree$1.JSXNamespacedName | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXClosingElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXText): string;
+declare class JsxInspector {
+  #private;
+  readonly context: RuleContext;
+  /**
+   * Merged JSX configuration (tsconfig compiler options + pragma annotations).
+   * The result is lazily computed and cached for the lifetime of this inspector.
+   */
+  get jsxConfig(): Required<JsxConfig>;
+  private constructor();
+  /**
+   * Walk **up** the AST from `node` to find the nearest ancestor that is a
+   * `JSXAttribute` and passes the optional `test` predicate.
+   * @param node The starting node for the search.
+   * @param test A predicate function to test each ancestor node.
+   */
+  static findParentAttribute(node: TSESTree.Node, test?: (node: TSESTree.JSXAttribute) => boolean): TSESTree.JSXAttribute | null;
+  /**
+   * Create a new `JsxInspector` bound to the given rule context.
+   * @param context The ESLint rule context to bind to this inspector instance.
+   */
+  static from(context: RuleContext): JsxInspector;
+  /**
+   * Whether the node is a `JSXText` or a `Literal` node.
+   * @param node The node to check.
+   */
+  static isJsxText(node: TSESTree.Node | null): node is TSESTree.JSXText | TSESTree.Literal;
+  /**
+   * Find a JSX attribute (or spread attribute containing the property) by name
+   * on a given element.
+   *
+   * Returns the **last** matching attribute (to mirror React's behaviour where
+   * later props win), or `undefined` if not found.
+   * @param node The JSX element to search for the attribute.
+   * @param name The name of the attribute to find (ex: `"className"`).
+   */
+  findAttribute(node: TSESTree.JSXElement, name: string): ast.TSESTreeJSXAttributeLike | undefined;
+  /**
+   * Get the stringified name of a `JSXAttribute` node
+   * (ex: `"className"`, `"aria-label"`, `"xml:space"`).
+   * @param node The `JSXAttribute` node to extract the name from.
+   * @returns The stringified name of the attribute.
+   */
+  getAttributeName(node: TSESTree.JSXAttribute): string;
+  /**
+   * Resolve the static value of an attribute, automatically handling the
+   * `spreadProps` case by extracting the named property.
+   *
+   * This eliminates the repetitive pattern:
+   * ```ts
+   * const v = core.resolveJsxAttributeValue(ctx, attr);
+   * const s = v.kind === "spreadProps" ? v.getProperty(name) : v.toStatic();
+   * ```
+   *
+   * Returns `undefined` when the attribute is not present or its value
+   * cannot be statically determined.
+   * @param node The JSX element to search for the attribute.
+   * @param name The name of the attribute to resolve (ex: `"className"`).
+   * @returns The static value of the attribute, or `undefined` if not found or not statically resolvable.
+   */
+  getAttributeStaticValue(node: TSESTree.JSXElement, name: string): unknown;
+  /**
+   * **All-in-one helper** – find an attribute by name on an element *and*
+   * resolve its value in a single call.
+   *
+   * Returns `undefined` when the attribute is not present.
+   * @param node The JSX element to search for the attribute.
+   * @param name The name of the attribute to find and resolve (ex: `"className"`).
+   * @returns A descriptor of the attribute's value that can be further inspected, or `undefined` if the attribute is not found.
+   */
+  getAttributeValue(node: TSESTree.JSXElement, name: string): JsxAttributeValue | undefined;
+  /**
+   * Get the **self name** (last segment) of a JSX element type.
+   *
+   * - `<Foo.Bar.Baz>` → `"Baz"`
+   * - `<div>` → `"div"`
+   * - `<></>` → `""`
+   * @param node The JSX element or fragment to extract the self name from.
+   */
+  getElementSelfName(node: TSESTree.JSXElement | TSESTree.JSXFragment): string;
+  /**
+   * Get the string representation of a JSX element's type.
+   *
+   * - `<div>` → `"div"`
+   * - `<Foo.Bar>` → `"Foo.Bar"`
+   * - `<React.Fragment>` → `"React.Fragment"`
+   * - `<></>` (JSXFragment) → `""`
+   * @param node The JSX element or fragment to extract the type from.
+   */
+  getElementType(node: TSESTree.JSXElement | TSESTree.JSXFragment): string;
+  /**
+   * Shorthand: check whether an attribute exists on the element.
+   * @param node The JSX element to check for the attribute.
+   * @param name The name of the attribute to check for (ex: `"className"`).
+   * @returns `true` if the attribute exists on the element, `false` otherwise.
+   */
+  hasAttribute(node: TSESTree.JSXElement, name: string): boolean;
+  /**
+   * Whether the node is a React **Fragment** element (either `<Fragment>` /
+   * `<React.Fragment>` or the shorthand `<>` syntax).
+   *
+   * The check honours the configured `jsxFragmentFactory`.
+   * @param node The node to check.
+   */
+  isFragmentElement(node: TSESTree.Node): node is TSESTree.JSXElement | TSESTree.JSXFragment;
+  /**
+   * Whether the node is a **host** (intrinsic / DOM) element – i.e. its tag
+   * name starts with a lowercase letter.
+   * @param node The node to check.
+   */
+  isHostElement(node: TSESTree.Node): node is TSESTree.JSXElement;
+  /**
+   * Resolve the *value* of a JSX attribute (or spread attribute) into a
+   * descriptor that can be inspected further.
+   *
+   * See {@link JsxAttributeValue} for the full set of `kind` discriminants.
+   * @param attribute The attribute node to resolve the value of.
+   * @returns A descriptor of the attribute's value that can be further inspected.
+   */
+  resolveAttributeValue(attribute: ast.TSESTreeJSXAttributeLike): {
+    readonly kind: "boolean";
+    readonly toStatic: () => true;
+    readonly node?: never;
+    readonly getChildren?: never;
+  } | {
+    readonly kind: "literal";
+    readonly node: TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral;
+    readonly toStatic: () => string | number | bigint | boolean | RegExp | null;
+    readonly getChildren?: never;
+  } | {
+    readonly kind: "missing";
+    readonly node: TSESTree.JSXEmptyExpression;
+    readonly toStatic: () => null;
+    readonly getChildren?: never;
+  } | {
+    readonly kind: "expression";
+    readonly node: TSESTree.Expression;
+    readonly toStatic: () => unknown;
+    readonly getChildren?: never;
+  } | {
+    readonly kind: "element";
+    readonly node: TSESTree.JSXElement;
+    readonly toStatic: () => null;
+    readonly getChildren?: never;
+  } | {
+    readonly kind: "spreadChild";
+    readonly node: TSESTree.JSXEmptyExpression | TSESTree.Expression;
+    readonly toStatic: () => null;
+    readonly getChildren: (_at: number) => null;
+  } | {
+    readonly kind: "spreadProps";
+    readonly node: TSESTree.Expression;
+    readonly toStatic: () => null;
+    readonly getProperty: (name: string) => unknown;
+  };
+}
+//#endregion
+//#region src/ref/ref-id.d.ts
+declare function isRefId(node: TSESTree.Expression | TSESTree.PrivateIdentifier): boolean;
 //#endregion
-//#region src/ref/is-from-ref.d.ts
+//#region src/ref/ref-init.d.ts
 /**
  * Check if the variable with the given name is initialized or derived from a ref
  * @param name The variable name
@@ -901,9 +924,9 @@ declare function isInitializedFromRef(name: string, initialScope: Scope): boolea
  * Get the init expression of a ref variable
  * @param name The variable name
  * @param initialScope The initial scope
- * @returns The init expression node if the variable is derived from a ref, or undefined otherwise
+ * @returns The init expression node if the variable is derived from a ref, or null otherwise
  */
-declare function getRefInit(name: string, initialScope: Scope): TSESTree$1.Expression | unit;
+declare function getRefInit(name: string, initialScope: Scope): TSESTree$1.Expression | null;
 //#endregion
 //#region src/ref/ref-name.d.ts
 /**
@@ -911,6 +934,6 @@ declare function getRefInit(name: string, initialScope: Scope): TSESTree$1.Expre
  * @param name The name to check
  * @returns True if the name is "ref" or ends with "Ref"
  */
-declare function isRefName(name: string): boolean;
+declare function isRefLikeName(name: string): boolean;
 //#endregion
-export { ClassComponentSemanticNode, ClientFunctionSemanticNode, ComponentDetectionHint, ComponentFlag, ComponentKind, ComponentSemanticNode, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FindEnclosingComponentOrHookFilter, FunctionComponentSemanticNode, FunctionSemanticNode, HookSemanticNode, JsxAttributeValue, JsxConfig, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, SemanticFunc, SemanticNode, ServerFunctionSemanticNode, findEnclosingComponentOrHook, findParentJsxAttribute, getComponentFlagFromInitPath, getFunctionComponentId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getRefInit, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidMountCallback, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUnmountCallback, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isComponentWrapperCallback, isComponentWrapperCallbackLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHook, isHookCall, isHookCallWithName, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isInitializedFromRef, isInsideComponentOrHook, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRefName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ClassComponentSemanticNode, ClientFunctionSemanticNode, ComponentDetectionHint, ComponentFlag, ComponentSemanticNode, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FunctionComponentSemanticNode, FunctionKind, FunctionSemanticNode, HookSemanticNode, JsxAttributeValue, JsxConfig, JsxDetectionHint, JsxEmit, JsxInspector, REACT_BUILTIN_HOOK_NAMES, SemanticFunc, SemanticNode, ServerFunctionSemanticNode, findImportSource, getComponentFlagFromInitPath, getFunctionComponentId, getJsxConfigFromAnnotation, getJsxConfigFromContext, getRefInit, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidMountCallback, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUnmountCallback, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isComponentWrapperCallback, isComponentWrapperCallbackLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isForwardRef, isForwardRefCall, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHook, isHookCall, isHookCallWithName, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isInitializedFromRef, isJsxLike, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRefId, isRefLikeName, isRender, isRenderMethodCallback, isRenderMethodLike, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStoreCall, isUseTransitionCall, useComponentCollector, useComponentCollectorLegacy, useHookCollector };