@atlaskit/eslint-plugin-platform 2.7.2 → 2.9.0

package/dist/types/rules/import/shared/jest-utils.d.ts

@@ -0,0 +1,55 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Shared utilities for jest.mock-related lint rules.
+ *
+ * These helpers are used by both `no-barrel-entry-jest-mock` (cross-package)
+ * and `no-jest-mock-barrel-files` (relative imports).
+ */
+/**
+ * Check if a CallExpression node is a jest.mock() call
+ */
+export declare function isJestMockCall(node: TSESTree.CallExpression): boolean;
+/**
+ * Check if a node is a jest.requireActual() call
+ */
+export declare function isJestRequireActual(node: TSESTree.Node): boolean;
+/**
+ * Check if a node is a jest.requireMock() call
+ */
+export declare function isJestRequireMock(node: TSESTree.Node): boolean;
+/**
+ * Extract the import path string from a jest.mock/jest.requireMock/jest.requireActual call's arguments.
+ * Returns null if the path cannot be statically determined.
+ */
+export declare function extractImportPath(node: TSESTree.CallExpression): string | null;
+/**
+ * Find all jest.requireMock() calls in the AST whose import path matches a given target.
+ *
+ * The `matchPath` callback allows callers to provide their own path-matching strategy:
+ * - Cross-package rules can use simple string equality
+ * - Relative import rules can use normalized/resolved path comparison
+ */
+export declare function findJestRequireMockCalls({ ast, matchPath, }: {
+    ast: TSESTree.Program;
+    matchPath: (candidatePath: string) => boolean;
+}): TSESTree.CallExpression[];
+/**
+ * Find all jest.requireActual() calls in the AST whose import path matches a given target.
+ * Works identically to findJestRequireMockCalls but for requireActual.
+ */
+export declare function findJestRequireActualCalls({ ast, matchPath, }: {
+    ast: TSESTree.Program;
+    matchPath: (candidatePath: string) => boolean;
+}): TSESTree.CallExpression[];
+/**
+ * Determine the best new import path for a jest.requireMock() call by inspecting
+ * the destructured symbols or property access at the call site.
+ *
+ * @param requireMockNode - The jest.requireMock() CallExpression node
+ * @param symbolToNewPath - Map from symbol name to the new mock path that provides it
+ * @returns The resolved new path, or null if it cannot be determined
+ */
+export declare function resolveNewPathForRequireMock({ requireMockNode, symbolToNewPath, }: {
+    requireMockNode: TSESTree.CallExpression;
+    symbolToNewPath: Map<string, string>;
+}): string | null;

package/dist/types/rules/import/shared/package-registry.d.ts

@@ -0,0 +1,26 @@
+import type { FileSystem } from './types';
+/**
+ * Find the package directory for a given package name.
+ * Returns the absolute path to the package directory or null if not found.
+ *
+ * This function uses lazy scanning - it will scan platform/packages on first lookup
+ * and cache results in fs.cache for subsequent lookups.
+ *
+ * Note: Package resolution is NOT constrained by applyToImportsFrom. Any package under
+ * platform/packages can be resolved. Use isPackageInApplyToImportsFrom to check if a
+ * package should be processed by the lint rule.
+ */
+export declare function findPackageInRegistry({ packageName, workspaceRoot, fs, }: {
+    packageName: string;
+    workspaceRoot: string;
+    fs: FileSystem;
+}): string | null;
+/**
+ * Check if a package is within one of the applyToImportsFrom folders.
+ * This can be used to quickly filter out packages that shouldn't be checked.
+ */
+export declare function isPackageInApplyToImportsFrom({ packageDir, workspaceRoot, applyToImportsFrom, }: {
+    packageDir: string;
+    workspaceRoot: string;
+    applyToImportsFrom?: string[];
+}): boolean;

package/dist/types/rules/import/shared/package-resolution.d.ts

@@ -0,0 +1,58 @@
+import type { FileSystem } from './types';
+/**
+ * Parse the package.json exports field and return a map of export paths to resolved file paths.
+ */
+export declare function parsePackageExports({ packageDir, fs, }: {
+    packageDir: string;
+    fs: FileSystem;
+}): Map<string, string>;
+export interface ExportMatchResult {
+    exportPath: string;
+    /**
+     * When resolved through an entry-point wrapper, the name under which
+     * the symbol is exported from the entry-point file.
+     * Callers use this to override the barrel's `originalName` so the
+     * generated import matches the entry-point's export shape.
+     */
+    entryPointExportName?: string;
+}
+/**
+ * Find a matching export entry for a given source file path.
+ * Returns the export path (e.g., "./controllers/analytics") or null if not found.
+ *
+ * When `fs` is provided, also checks entry-point wrapper files. If an export resolves
+ * to a file inside a recognized entry-points folder (entry-points, entrypoints, etc.),
+ * the wrapper is parsed to see if it re-exports from `sourceFilePath`.
+ *
+ * `sourceExportName` is the name under which the symbol is exported from the source file
+ * (e.g. `'default'`). Used to look up the corresponding entry-point export name so the
+ * caller can generate the correct import style.
+ */
+export declare function findExportForSourceFile({ sourceFilePath, exportsMap, fs, sourceExportName, }: {
+    sourceFilePath: string;
+    exportsMap: Map<string, string>;
+    fs?: FileSystem;
+    sourceExportName?: string;
+}): ExportMatchResult | null;
+/**
+ * Extract the package name and subpath from an import specifier.
+ * Returns null if the import is not a scoped package import.
+ */
+export declare function extractPackageNameFromImport(moduleSpecifier: string): {
+    packageName: string;
+    subPath: string;
+} | null;
+/**
+ * Resolve a cross-package import to its package directory and export info.
+ * Returns null if the package is not in the target folder or cannot be resolved.
+ */
+export declare function resolveCrossPackageImport({ moduleSpecifier, workspaceRoot, fs, }: {
+    moduleSpecifier: string;
+    workspaceRoot: string;
+    fs: FileSystem;
+}): {
+    packageName: string;
+    packageDir: string;
+    exportPath: string;
+    entryFilePath: string;
+} | null;

package/dist/types/rules/import/shared/perf.d.ts

@@ -0,0 +1,13 @@
+import type { FileSystem } from './types';
+export declare const PERF_ENV_VAR = "INTERNAL_ESLINT_BARREL_PERF";
+export declare function isPerfEnabled(): boolean;
+export declare function perfInc({ fs, key, by }: {
+    fs: FileSystem;
+    key: string;
+    by?: number;
+}): void;
+export declare function perfTime<T>({ fs, key, fn }: {
+    fs: FileSystem;
+    key: string;
+    fn: () => T;
+}): T;

package/dist/types/rules/import/shared/types.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Directory entry returned by readdirSync with withFileTypes option.
+ */
+export interface DirectoryEntry {
+    name: string;
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+/**
+ * State for the package registry cache.
+ * This is used to cache package name to directory mappings for efficient lookups.
+ */
+export interface PackageRegistryCache {
+    /** Map of package name to absolute directory path */
+    packageNameToDir: Map<string, string>;
+    /** Set of directories that have been scanned (including those without packages) */
+    scannedDirectories: Set<string>;
+    /** yarn.lock mtime when cache was built (for invalidation) */
+    yarnLockMtime: number;
+    /** The workspace root this cache was built for (from package registry perspective) */
+    workspaceRoot: string | null;
+}
+/**
+ * Cache structure for file system operations.
+ * Contains both package registry cache and workspace root cache.
+ */
+export interface FileSystemCache extends Partial<PackageRegistryCache> {
+    /** Cached git repository root (from git rev-parse --show-toplevel) */
+    gitRepoRoot?: string;
+    /**
+     * Cache of parsed package.json exports maps keyed by absolute package directory.
+     * This avoids repeated reads/parses during IDE lint runs.
+     */
+    packageExportsByDir?: Map<string, {
+        /** mtimeMs of package.json when this entry was computed. null means unknown (forces re-read). */
+        packageJsonMtimeMs: number | null;
+        exportsMap: Map<string, string>;
+    }>;
+    /**
+     * Cache of read file contents keyed by absolute file path.
+     * Used by barrel parsing to avoid repeated reads in IDE lint runs.
+     */
+    fileContentByPath?: Map<string, {
+        /** mtimeMs when this entry was cached. null means unknown (forces re-read). */
+        mtimeMs: number | null;
+        content: string;
+    }>;
+    /**
+     * Cache of parsed barrel exports keyed by barrel file path.
+     * Stores the barrel file mtime at time of parsing to support invalidation.
+     */
+    barrelExportsByPath?: Map<string, {
+        mtimeMs: number;
+        exports: Map<string, ExportInfo>;
+    }>;
+    /**
+     * Cache for resolveImportPath results keyed by basedir + importPath.
+     */
+    resolvedImportPathByKey?: Map<string, string | null>;
+    /**
+     * Optional perf counters and timers for debugging and optimization.
+     * Enabled by setting INTERNAL_ESLINT_BARREL_PERF.
+     */
+    perf?: {
+        installedExitHook: boolean;
+        counters: Record<string, number>;
+        timers: Record<string, number>;
+    };
+}
+/**
+ * File system abstraction for testability.
+ * This interface allows the core logic to be tested with mock file systems.
+ * The cache property holds package resolution state and can be passed as an empty
+ * object for tests to ensure fresh state for each test case.
+ */
+export interface FileSystem {
+    existsSync(path: string): boolean;
+    readFileSync(path: string, encoding: 'utf-8'): string;
+    realpathSync(path: string): string;
+    statSync(path: string): {
+        isFile(): boolean;
+        mtimeMs?: number;
+    };
+    readdirSync(path: string, options: {
+        withFileTypes: true;
+    }): DirectoryEntry[];
+    /** Execute a command synchronously and return stdout. Returns null on error. */
+    execSync(command: string, options?: {
+        cwd?: string;
+    }): string | null;
+    /** Cache for package resolution and workspace root - will be populated lazily */
+    cache: FileSystemCache;
+}
+/**
+ * Real file system implementation using Node.js fs module.
+ */
+export declare const realFileSystem: FileSystem;
+/**
+ * Information about cross-package re-export origin.
+ */
+export interface CrossPackageSource {
+    /** The package name (e.g., '@atlassian/package-b') */
+    packageName: string;
+    /** The export path within the package (e.g., '.' or './utils') */
+    exportPath: string;
+}
+/**
+ * Information about where an export originates.
+ */
+export interface ExportInfo {
+    /** The absolute path to the file where this export originates */
+    path: string;
+    /** Whether this is a type-only export */
+    isTypeOnly: boolean;
+    /** Whether this is a re-export of a default export */
+    isDefaultExport?: boolean;
+    /** The original name of the symbol in the source file (for aliased exports) */
+    originalName?: string;
+    /** Information about cross-package re-export origin, if applicable */
+    crossPackageSource?: CrossPackageSource;
+}
+/**
+ * Context for package resolution operations.
+ */
+export interface PackageResolutionContext {
+    packageName: string;
+    packageDir: string;
+    exportPath: string;
+    entryFilePath: string;
+    exportsMap: Map<string, string>;
+}

package/dist/types/rules/visit-example-type-import-required/index.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+export declare const RULE_NAME = "visit-example-type-import-required";
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types-ts4.5/index.d.ts

@@ -15,7 +15,6 @@ declare const rules: {
     'no-pre-post-install-scripts': import("eslint").Rule.RuleModule;
     'no-invalid-storybook-decorator-usage': import("eslint").Rule.RuleModule;
     'ensure-publish-valid': import("eslint").Rule.RuleModule;
-    'ensure-native-and-af-exports-synced': import("eslint").Rule.RuleModule;
     'no-module-level-eval': import("eslint").Rule.RuleModule;
     'no-module-level-eval-nav4': import("eslint").Rule.RuleModule;
     'static-feature-flags': import("eslint").Rule.RuleModule;
@@ -25,10 +24,18 @@ declare const rules: {
     'no-alias': import("eslint").Rule.RuleModule;
     'use-entrypoints-in-examples': import("eslint").Rule.RuleModule;
     'use-recommended-utils': import("eslint").Rule.RuleModule;
+    'valid-gate-name': import("eslint").Rule.RuleModule;
     'no-sparse-checkout': import("eslint").Rule.RuleModule;
     'no-direct-document-usage': import("eslint").Rule.RuleModule;
     'no-set-immediate': import("eslint").Rule.RuleModule;
     'prefer-crypto-random-uuid': import("eslint").Rule.RuleModule;
+    'no-barrel-entry-imports': import("eslint").Rule.RuleModule;
+    'no-barrel-entry-jest-mock': import("eslint").Rule.RuleModule;
+    'no-jest-mock-barrel-files': import("eslint").Rule.RuleModule;
+    'no-relative-barrel-file-imports': import("eslint").Rule.RuleModule;
+    'no-conversation-assistant-barrel-imports': import("eslint").Rule.RuleModule;
+    'visit-example-type-import-required': import("eslint").Rule.RuleModule;
+    'ensure-use-sync-external-store-server-snapshot': import("eslint").Rule.RuleModule;
 };
 declare const plugin: {
     meta: {
@@ -51,7 +58,6 @@ declare const plugin: {
         'no-pre-post-install-scripts': import("eslint").Rule.RuleModule;
         'no-invalid-storybook-decorator-usage': import("eslint").Rule.RuleModule;
         'ensure-publish-valid': import("eslint").Rule.RuleModule;
-        'ensure-native-and-af-exports-synced': import("eslint").Rule.RuleModule;
         'no-module-level-eval': import("eslint").Rule.RuleModule;
         'no-module-level-eval-nav4': import("eslint").Rule.RuleModule;
         'static-feature-flags': import("eslint").Rule.RuleModule;
@@ -61,10 +67,18 @@ declare const plugin: {
         'no-alias': import("eslint").Rule.RuleModule;
         'use-entrypoints-in-examples': import("eslint").Rule.RuleModule;
         'use-recommended-utils': import("eslint").Rule.RuleModule;
+        'valid-gate-name': import("eslint").Rule.RuleModule;
         'no-sparse-checkout': import("eslint").Rule.RuleModule;
         'no-direct-document-usage': import("eslint").Rule.RuleModule;
         'no-set-immediate': import("eslint").Rule.RuleModule;
         'prefer-crypto-random-uuid': import("eslint").Rule.RuleModule;
+        'no-barrel-entry-imports': import("eslint").Rule.RuleModule;
+        'no-barrel-entry-jest-mock': import("eslint").Rule.RuleModule;
+        'no-jest-mock-barrel-files': import("eslint").Rule.RuleModule;
+        'no-relative-barrel-file-imports': import("eslint").Rule.RuleModule;
+        'no-conversation-assistant-barrel-imports': import("eslint").Rule.RuleModule;
+        'visit-example-type-import-required': import("eslint").Rule.RuleModule;
+        'ensure-use-sync-external-store-server-snapshot': import("eslint").Rule.RuleModule;
     };
     configs: {
         recommended: {
@@ -76,9 +90,11 @@ declare const plugin: {
                 '@atlaskit/platform/inline-usage': "error";
                 '@atlaskit/platform/prefer-fg': "error";
                 '@atlaskit/platform/no-alias': "error";
+                '@atlaskit/platform/valid-gate-name': "error";
                 '@atlaskit/platform/ensure-feature-flag-registration': "error";
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+                '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
                 '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
                 '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -110,9 +126,11 @@ declare const plugin: {
                 '@atlaskit/platform/inline-usage': "error";
                 '@atlaskit/platform/prefer-fg': "error";
                 '@atlaskit/platform/no-alias': "error";
+                '@atlaskit/platform/valid-gate-name': "error";
                 '@atlaskit/platform/ensure-feature-flag-registration': "error";
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+                '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
                 '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
                 '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -137,6 +155,7 @@ declare const plugin: {
             rules: {
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+                '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
                 '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
                 '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -164,6 +183,7 @@ declare const plugin: {
             rules: {
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+                '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
                 '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
                 '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -199,9 +219,11 @@ declare const configs: {
             '@atlaskit/platform/inline-usage': "error";
             '@atlaskit/platform/prefer-fg': "error";
             '@atlaskit/platform/no-alias': "error";
+            '@atlaskit/platform/valid-gate-name': "error";
             '@atlaskit/platform/ensure-feature-flag-registration': "error";
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+            '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
             '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -233,9 +255,11 @@ declare const configs: {
             '@atlaskit/platform/inline-usage': "error";
             '@atlaskit/platform/prefer-fg': "error";
             '@atlaskit/platform/no-alias': "error";
+            '@atlaskit/platform/valid-gate-name': "error";
             '@atlaskit/platform/ensure-feature-flag-registration': "error";
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+            '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
             '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -260,6 +284,7 @@ declare const configs: {
         rules: {
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+            '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
             '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -287,6 +312,7 @@ declare const configs: {
         rules: {
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+            '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
             '@atlaskit/platform/ensure-atlassian-team': "error";

package/dist/types-ts4.5/rules/import/no-barrel-entry-imports/index.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from 'eslint';
+import { type FileSystem } from '../shared/types';
+/**
+ * Factory function to create the ESLint rule with a given file system.
+ * This enables testing with mock file systems.
+ */
+export declare function createRule(fs: FileSystem): Rule.RuleModule;
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types-ts4.5/rules/import/no-barrel-entry-jest-mock/index.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from 'eslint';
+import { type FileSystem } from '../shared/types';
+/**
+ * Factory function to create the ESLint rule with a given file system.
+ * This enables testing with mock file systems.
+ */
+export declare function createRule(fs: FileSystem): Rule.RuleModule;
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types-ts4.5/rules/import/no-conversation-assistant-barrel-imports/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types-ts4.5/rules/import/no-jest-mock-barrel-files/index.d.ts

@@ -0,0 +1,22 @@
+import type { Rule } from 'eslint';
+import { type ExportInfo, type FileSystem } from '../shared/types';
+/**
+ * Validate and resolve a barrel file from an import path
+ * Returns null if not a valid relative barrel import
+ */
+export declare function validateAndResolveBarrelFile({ importPath, basedir, workspaceRoot, fs, }: {
+    importPath: string;
+    basedir: string;
+    workspaceRoot: string;
+    fs: FileSystem;
+}): {
+    resolvedPath: string;
+    exportMap: Map<string, ExportInfo>;
+} | null;
+/**
+ * Factory function to create the ESLint rule with a given file system.
+ * This enables testing with mock file systems.
+ */
+export declare function createRule(fs: FileSystem): Rule.RuleModule;
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types-ts4.5/rules/import/no-relative-barrel-file-imports/index.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from 'eslint';
+import { type FileSystem } from '../shared/types';
+export declare function createRule(fs: FileSystem): Rule.RuleModule;
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types-ts4.5/rules/import/shared/barrel-parsing.d.ts

@@ -0,0 +1,30 @@
+import type { ExportInfo, FileSystem } from './types';
+/**
+ * Get all named exports from a file.
+ * This extracts what names are exported from a file for star exports.
+ */
+export declare function getNamedExportsFromFile({ filePath, fs, }: {
+    filePath: string;
+    fs: FileSystem;
+}): Set<string>;
+/**
+ * Check if an export map represents a barrel file (has re-exports from other files)
+ */
+export declare function hasReExportsFromOtherFiles({ exportMap, sourceFilePath, }: {
+    exportMap: Map<string, ExportInfo>;
+    sourceFilePath: string;
+}): boolean;
+/**
+ * Parse export statements from a file to find where each export comes from.
+ * Returns a map of export name -> ExportInfo.
+ *
+ * This function recursively traces through nested barrels and cross-package re-exports
+ * to find the ultimate source file for each export.
+ */
+export declare function parseBarrelExports({ barrelFilePath, depth, fs, workspaceRoot, visitedPackages, }: {
+    barrelFilePath: string;
+    depth?: number;
+    fs: FileSystem;
+    workspaceRoot?: string;
+    visitedPackages?: Set<string>;
+}): Map<string, ExportInfo>;

package/dist/types-ts4.5/rules/import/shared/file-system.d.ts

@@ -0,0 +1,38 @@
+import type { FileSystem } from './types';
+/**
+ * The default folder paths that barrel import rules apply to.
+ * Only imports from packages within these folders will be checked.
+ * This can be overridden via lint rule options.
+ */
+export declare const DEFAULT_TARGET_FOLDERS: string[];
+/**
+ * Try to read file contents with error handling.
+ * Returns null if file cannot be read.
+ */
+export declare function readFileContent({ filePath, fs, }: {
+    filePath: string;
+    fs: FileSystem;
+}): string | null;
+/**
+ * Check if a path is a relative import (starts with ./ or ../)
+ */
+export declare function isRelativeImport(importPath: string): boolean;
+/**
+ * Resolve the actual file path from an import path.
+ * Handles extension inference and index file resolution.
+ */
+export declare function resolveImportPath({ basedir, importPath, fs, }: {
+    basedir: string;
+    importPath: string;
+    fs: FileSystem;
+}): string | null;
+/**
+ * Find the workspace root using git rev-parse --show-toplevel.
+ * The result is cached on fs.cache.gitRepoRoot to avoid repeated shell calls.
+ * Falls back to directory traversal if git command fails.
+ */
+export declare function findWorkspaceRoot({ startPath, fs, applyToImportsFrom, }: {
+    startPath: string;
+    fs: FileSystem;
+    applyToImportsFrom?: string[];
+}): string;

package/dist/types-ts4.5/rules/import/shared/jest-utils.d.ts

@@ -0,0 +1,55 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Shared utilities for jest.mock-related lint rules.
+ *
+ * These helpers are used by both `no-barrel-entry-jest-mock` (cross-package)
+ * and `no-jest-mock-barrel-files` (relative imports).
+ */
+/**
+ * Check if a CallExpression node is a jest.mock() call
+ */
+export declare function isJestMockCall(node: TSESTree.CallExpression): boolean;
+/**
+ * Check if a node is a jest.requireActual() call
+ */
+export declare function isJestRequireActual(node: TSESTree.Node): boolean;
+/**
+ * Check if a node is a jest.requireMock() call
+ */
+export declare function isJestRequireMock(node: TSESTree.Node): boolean;
+/**
+ * Extract the import path string from a jest.mock/jest.requireMock/jest.requireActual call's arguments.
+ * Returns null if the path cannot be statically determined.
+ */
+export declare function extractImportPath(node: TSESTree.CallExpression): string | null;
+/**
+ * Find all jest.requireMock() calls in the AST whose import path matches a given target.
+ *
+ * The `matchPath` callback allows callers to provide their own path-matching strategy:
+ * - Cross-package rules can use simple string equality
+ * - Relative import rules can use normalized/resolved path comparison
+ */
+export declare function findJestRequireMockCalls({ ast, matchPath, }: {
+    ast: TSESTree.Program;
+    matchPath: (candidatePath: string) => boolean;
+}): TSESTree.CallExpression[];
+/**
+ * Find all jest.requireActual() calls in the AST whose import path matches a given target.
+ * Works identically to findJestRequireMockCalls but for requireActual.
+ */
+export declare function findJestRequireActualCalls({ ast, matchPath, }: {
+    ast: TSESTree.Program;
+    matchPath: (candidatePath: string) => boolean;
+}): TSESTree.CallExpression[];
+/**
+ * Determine the best new import path for a jest.requireMock() call by inspecting
+ * the destructured symbols or property access at the call site.
+ *
+ * @param requireMockNode - The jest.requireMock() CallExpression node
+ * @param symbolToNewPath - Map from symbol name to the new mock path that provides it
+ * @returns The resolved new path, or null if it cannot be determined
+ */
+export declare function resolveNewPathForRequireMock({ requireMockNode, symbolToNewPath, }: {
+    requireMockNode: TSESTree.CallExpression;
+    symbolToNewPath: Map<string, string>;
+}): string | null;

package/dist/types-ts4.5/rules/import/shared/package-registry.d.ts

@@ -0,0 +1,26 @@
+import type { FileSystem } from './types';
+/**
+ * Find the package directory for a given package name.
+ * Returns the absolute path to the package directory or null if not found.
+ *
+ * This function uses lazy scanning - it will scan platform/packages on first lookup
+ * and cache results in fs.cache for subsequent lookups.
+ *
+ * Note: Package resolution is NOT constrained by applyToImportsFrom. Any package under
+ * platform/packages can be resolved. Use isPackageInApplyToImportsFrom to check if a
+ * package should be processed by the lint rule.
+ */
+export declare function findPackageInRegistry({ packageName, workspaceRoot, fs, }: {
+    packageName: string;
+    workspaceRoot: string;
+    fs: FileSystem;
+}): string | null;
+/**
+ * Check if a package is within one of the applyToImportsFrom folders.
+ * This can be used to quickly filter out packages that shouldn't be checked.
+ */
+export declare function isPackageInApplyToImportsFrom({ packageDir, workspaceRoot, applyToImportsFrom, }: {
+    packageDir: string;
+    workspaceRoot: string;
+    applyToImportsFrom?: string[];
+}): boolean;