knip 5.23.0 → 5.23.1

package/dist/compilers/mdx.d.ts

@@ -1,6 +1,6 @@
 import type { HasDependency } from './types.js';
 declare const _default: {
     condition: (hasDependency: HasDependency) => boolean;
-    compiler: (text: string) => string;
+    compiler: (text: string) => any;
 };
 export default _default;

package/dist/constants.d.ts

@@ -5,10 +5,10 @@ export declare const ANONYMOUS = "__anonymous";
 export declare const KNIP_CONFIG_LOCATIONS: string[];
 export declare const DEFAULT_EXTENSIONS: string[];
 export declare const GLOBAL_IGNORE_PATTERNS: string[];
-export declare const IGNORED_GLOBAL_BINARIES: Set<string>;
-export declare const IGNORED_DEPENDENCIES: Set<string>;
-export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
-export declare const FOREIGN_FILE_EXTENSIONS: Set<string>;
+export declare const IGNORED_GLOBAL_BINARIES: any;
+export declare const IGNORED_DEPENDENCIES: any;
+export declare const IGNORED_RUNTIME_DEPENDENCIES: any;
+export declare const FOREIGN_FILE_EXTENSIONS: any;
 export declare const IGNORE_DEFINITELY_TYPED: string[];
 export declare const ISSUE_TYPES: IssueType[];
 export declare const ISSUE_TYPE_TITLE: Record<IssueType, string>;

package/dist/index.d.ts

@@ -1,11 +1,4 @@
 import type { CommandLineOptions } from './types/cli.js';
 export type { RawConfiguration as KnipConfig } from './types/config.js';
 export type { Preprocessor, Reporter, ReporterOptions } from './types/issues.js';
-export declare const main: (unresolvedConfiguration: CommandLineOptions) => Promise<{
-    report: import("./types/issues.js").Report;
-    issues: import("./types/issues.js").Issues;
-    counters: import("./types/issues.js").Counters;
-    rules: import("./types/issues.js").Rules;
-    tagHints: Set<import("./types/issues.js").TagHint>;
-    configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
-}>;
+export declare const main: (unresolvedConfiguration: CommandLineOptions) => unknown;

package/dist/index.js

@@ -317,8 +317,17 @@ export const main = async (unresolvedConfiguration) => {
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
-                        if (!isIgnored && importsForExport) {
+                        if (importsForExport) {
                             const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
+                            if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
+                                for (const tagName of exportedItem.jsDocTags) {
+                                    if (tags[1].includes(tagName.replace(/^\@/, ''))) {
+                                        collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
+                                    }
+                                }
+                            }
+                            if (isIgnored)
+                                continue;
                             if (reExportingEntryFile) {
                                 if (!isIncludeEntryExports) {
                                     createAndPrintTrace(filePath, { identifier, isEntry, hasRef: isReferenced });
@@ -339,7 +348,7 @@ export const main = async (unresolvedConfiguration) => {
                                             continue;
                                         if (member.refs[0] === 0) {
                                             const id = `${identifier}.${member.identifier}`;
-                                            const { isReferenced } = isIdentifierReferenced(filePath, id);
+                                            const { isReferenced } = isIdentifierReferenced(filePath, id, true);
                                             const isIgnored = shouldIgnoreTags(member.jsDocTags);
                                             if (!isReferenced) {
                                                 if (isIgnored)
@@ -413,20 +422,13 @@ export const main = async (unresolvedConfiguration) => {
                                 line: exportedItem.line,
                                 col: exportedItem.col,
                             });
-                            if (isIssueAdded) {
+                            if (isFix && isIssueAdded) {
                                 if (isType)
                                     fixer.addUnusedTypeNode(filePath, exportedItem.fixes);
                                 else
                                     fixer.addUnusedExportNode(filePath, exportedItem.fixes);
                             }
                         }
-                        else if (isIgnored) {
-                            for (const tagName of exportedItem.jsDocTags) {
-                                if (tags[1].includes(tagName.replace(/^\@/, ''))) {
-                                    collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
-                                }
-                            }
-                        }
                     }
                 }
             }

package/dist/manifest/helpers.d.ts

@@ -9,5 +9,5 @@ type GetFilteredScriptsOptions = {
     isProduction: boolean;
     scripts?: Scripts;
 };
-export declare const getFilteredScripts: ({ isProduction, scripts }: GetFilteredScriptsOptions) => Scripts;
+export declare const getFilteredScripts: ({ isProduction, scripts }: GetFilteredScriptsOptions) => any;
 export {};

package/dist/manifest/index.d.ts

@@ -1,12 +1,14 @@
-import type { HostDependencies, InstalledBinaries } from '../types/workspace.js';
 type Options = {
     packageNames: string[];
     dir: string;
     cwd: string;
 };
 export declare const getDependencyMetaData: ({ cwd, dir, packageNames }: Options) => {
-    hostDependencies: HostDependencies;
-    installedBinaries: InstalledBinaries;
-    hasTypesIncluded: Set<string>;
+    hostDependencies: Map<string, {
+        name: string;
+        isPeerOptional: boolean;
+    }[]>;
+    installedBinaries: Map<string, Set<string>>;
+    hasTypesIncluded: any;
 };
 export {};

package/dist/plugins/babel/helpers.d.ts

@@ -1,4 +1,4 @@
-export declare const resolveName: (identifier: string, namespace: "preset" | "plugin") => string;
+export declare const resolveName: (identifier: string, namespace: "preset" | "plugin") => any;
 export declare const api: {
     assertVersion: () => boolean;
     cache: {

package/dist/plugins/babel/index.d.ts

@@ -3,7 +3,7 @@ import type { BabelConfig, BabelConfigObj } from './types.js';
 export declare const getDependenciesFromConfig: (config: BabelConfigObj) => string[];
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     resolveConfig: ResolveConfig<BabelConfig>;

package/dist/plugins/capacitor/index.d.ts

@@ -2,7 +2,7 @@ import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { CapacitorConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     resolveConfig: ResolveConfig<CapacitorConfig>;

package/dist/plugins/cypress/index.d.ts

@@ -4,7 +4,7 @@ declare const _default: {
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    entry: string[];
+    entry: any[];
     resolveEntryPaths: ResolveEntryPaths;
 };
 export default _default;

package/dist/plugins/eleventy/helpers.d.ts

@@ -109,22 +109,22 @@ export declare class DummyEleventyConfig {
     DateTime: {};
     dynamicPermalinks: boolean;
     useGitIgnore: boolean;
-    ignores: Set<unknown>;
-    watchIgnores: Set<unknown>;
+    ignores: any;
+    watchIgnores: any;
     dataDeepMerge: boolean;
-    extensionMap: Set<unknown>;
+    extensionMap: any;
     watchJavaScriptDependencies: boolean;
     additionalWatchTargets: never[];
     serverOptions: {};
     globalData: {};
     chokidarConfig: {};
     watchThrottleWaitTime: number;
-    dataExtensions: Map<any, any>;
+    dataExtensions: any;
     quietMode: boolean;
     plugins: never[];
     _pluginExecution: boolean;
     useTemplateCache: boolean;
-    dataFilterSelectors: Set<unknown>;
+    dataFilterSelectors: any;
     libraryAmendments: {};
     serverPassthroughCopyBehavior: string;
     urlTransforms: never[];

package/dist/plugins/eleventy/index.d.ts

@@ -1,14 +1,11 @@
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
-import { DummyEleventyConfig } from './helpers.js';
-import type { EleventyConfig } from './types.js';
-type T = Partial<EleventyConfig> | ((arg: DummyEleventyConfig) => Promise<Partial<EleventyConfig>>);
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
     production: string[];
-    resolveEntryPaths: ResolveEntryPaths<T>;
-    resolveConfig: ResolveConfig<T>;
+    resolveEntryPaths: ResolveEntryPaths<any>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

package/dist/plugins/graphql-codegen/index.d.ts

@@ -2,7 +2,7 @@ import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { GraphqlCodegenTypes, GraphqlConfigTypes, GraphqlProjectsConfigTypes } from './types.js';
 declare const _default: {
     title: string;
-    enablers: (string | RegExp)[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: (manifest: import("../../types/package-json.js").PackageJson) => string;
     config: string[];

package/dist/plugins/husky/index.d.ts

@@ -3,7 +3,7 @@ declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    config: string[];
+    config: any[];
     resolveConfig: ResolveConfig<string>;
 };
 export default _default;

package/dist/plugins/jest/index.d.ts

@@ -1,12 +1,11 @@
 import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types/plugins.js';
-import type { JestConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];
-    resolveEntryPaths: ResolveEntryPaths<JestConfig>;
-    resolveConfig: ResolveConfig<JestConfig>;
+    resolveEntryPaths: ResolveEntryPaths<any>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

package/dist/plugins/lefthook/index.d.ts

@@ -3,7 +3,7 @@ declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    config: string[];
+    config: any[];
     resolveConfig: ResolveConfig;
 };
 export default _default;

package/dist/plugins/lint-staged/index.d.ts

@@ -1,11 +1,10 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { LintStagedConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<LintStagedConfig>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

package/dist/plugins/markdownlint/helpers.d.ts

@@ -1 +1 @@
-export declare const getArgumentValues: (value: string, matcher: RegExp) => string[];
+export declare const getArgumentValues: (value: string, matcher: RegExp) => any;

package/dist/plugins/netlify/helpers.d.ts

@@ -1,2 +1,2 @@
 import type { FunctionsConfig } from './types.js';
-export declare const extractFunctionsConfigProperty: (config: FunctionsConfig, property: keyof FunctionsConfig) => string[];
+export declare const extractFunctionsConfigProperty: (config: FunctionsConfig, property: keyof FunctionsConfig) => any[];

package/dist/plugins/netlify/index.d.ts

@@ -2,7 +2,7 @@ import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types
 import type { NetlifyConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: (string | RegExp)[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     production: string[];

package/dist/plugins/next/index.d.ts

@@ -4,6 +4,6 @@ declare const _default: {
     enablers: string[];
     isEnabled: IsPluginEnabled;
     entry: string[];
-    production: string[];
+    production: any[];
 };
 export default _default;

package/dist/plugins/nx/index.d.ts

@@ -2,7 +2,7 @@ import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
 import type { NxConfigRoot, NxProjectConfiguration } from './types.js';
 declare const _default: {
     title: string;
-    enablers: (string | RegExp)[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     resolveConfig: ResolveConfig<NxProjectConfiguration | NxConfigRoot>;

package/dist/plugins/playwright-ct/index.d.ts

@@ -1,7 +1,7 @@
 import type { IsPluginEnabled } from '#p/types/plugins.js';
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];

package/dist/plugins/remix/index.d.ts

@@ -1,7 +1,7 @@
 import type { IsPluginEnabled } from '#p/types/plugins.js';
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     entry: string[];
     production: string[];

package/dist/plugins/sentry/index.d.ts

@@ -1,7 +1,7 @@
 import type { IsPluginEnabled } from '#p/types/plugins.js';
 declare const _default: {
     title: string;
-    enablers: RegExp[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     entry: string[];
 };

package/dist/plugins/simple-git-hooks/index.d.ts

@@ -1,11 +1,10 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { PluginConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: import("#p/types/config.js").IgnorePatterns;
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<PluginConfig>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

package/dist/plugins/storybook/index.d.ts

@@ -2,10 +2,10 @@ import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '#p/types
 import type { StorybookConfig } from './types.js';
 declare const _default: {
     title: string;
-    enablers: (string | RegExp)[];
+    enablers: {}[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    entry: string[];
+    entry: any[];
     project: string[];
     resolveEntryPaths: ResolveEntryPaths<StorybookConfig>;
     resolveConfig: ResolveConfig<StorybookConfig>;

package/dist/plugins/svelte/index.d.ts

@@ -3,7 +3,7 @@ declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
-    entry: string[];
+    entry: any[];
     production: string[];
     project: string[];
 };

package/dist/plugins/unbuild/index.d.ts

@@ -1,10 +1,9 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { UnbuildConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
-    resolveConfig: ResolveConfig<UnbuildConfig>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

package/dist/plugins/vitest/helpers.d.ts

@@ -1,3 +1,3 @@
 import type { ViteConfig } from './types.js';
-export declare const getEnvPackageName: (env: string) => string;
-export declare const getExternalReporters: (reporters?: ViteConfig["test"]["reporters"]) => string[];
+export declare const getEnvPackageName: (env: string) => any;
+export declare const getExternalReporters: (reporters?: ViteConfig["test"]["reporters"]) => any;

package/dist/plugins/webpack/index.d.ts

@@ -3,10 +3,7 @@ import type { WebpackConfig } from './types.js';
 export declare const findWebpackDependenciesFromConfig: ({ config, cwd }: {
     config: WebpackConfig;
     cwd: string;
-}) => Promise<{
-    dependencies: Set<string>;
-    entryPatterns: Set<string>;
-}>;
+}) => unknown;
 declare const _default: {
     title: string;
     enablers: string[];

package/dist/plugins/wireit/index.d.ts

@@ -1,11 +1,12 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { WireitConfig } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<WireitConfig>;
+    resolveConfig: ResolveConfig<Record<string, {
+        command?: string;
+    }>>;
 };
 export default _default;

package/dist/plugins/yorkie/index.d.ts

@@ -1,11 +1,10 @@
 import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
-import type { LintStagedConfig } from '../lint-staged/types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     packageJsonPath: string;
     config: string[];
-    resolveConfig: ResolveConfig<LintStagedConfig>;
+    resolveConfig: ResolveConfig<any>;
 };
 export default _default;

package/dist/reporters/index.d.ts

@@ -2,7 +2,7 @@ declare const _default: {
     symbols: ({ report, issues, tagHints, configurationHints, noConfigHints, isShowProgress }: import("../index.js").ReporterOptions) => void;
     compact: ({ report, issues, isShowProgress }: import("../index.js").ReporterOptions) => void;
     codeowners: ({ report, issues, isShowProgress, options }: import("../index.js").ReporterOptions) => void;
-    json: ({ report, issues, options }: import("../index.js").ReporterOptions) => Promise<void>;
+    json: ({ report, issues, options }: import("../index.js").ReporterOptions) => any;
     markdown: ({ report, issues }: import("../index.js").ReporterOptions) => void;
 };
 export default _default;

package/dist/reporters/json.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
-declare const _default: ({ report, issues, options }: ReporterOptions) => Promise<void>;
+declare const _default: ({ report, issues, options }: ReporterOptions) => any;
 export default _default;

package/dist/reporters/util.d.ts

@@ -1,7 +1,7 @@
 import { ISSUE_TYPE_TITLE } from '../constants.js';
 import type { Issue, IssueSeverity, IssueSymbol } from '../types/issues.js';
 export declare const identity: (text: string) => string;
-export declare const getTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => string;
+export declare const getTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => Record<keyof import("../types/issues.js").Issues, string>;
 export declare const logTitle: (title: string, count: number) => void;
 type LogIssueLine = {
     owner?: string;

package/dist/typescript/SourceFileManager.d.ts

@@ -6,14 +6,14 @@ interface SourceFileManagerOptions {
 }
 export declare class SourceFileManager {
     isSkipLibs: boolean;
-    sourceFileCache: Map<string, ts.SourceFile | undefined>;
-    snapshotCache: Map<string, ts.IScriptSnapshot | undefined>;
+    sourceFileCache: any;
+    snapshotCache: any;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
     constructor({ compilers, isSkipLibs }: SourceFileManagerOptions);
     createSourceFile(filePath: string, contents: string): ts.SourceFile;
-    getSourceFile(filePath: string): ts.SourceFile | undefined;
-    getSnapshot(filePath: string): ts.IScriptSnapshot | undefined;
-    compileAndAddSourceFile(filePath: string): Promise<void>;
+    getSourceFile(filePath: string): any;
+    getSnapshot(filePath: string): any;
+    compileAndAddSourceFile(filePath: string): any;
 }
 export {};

package/dist/typescript/ast-helpers.d.ts

@@ -6,11 +6,11 @@ export declare function isAccessExpression(node: ts.Node): node is ts.AccessExpr
 export declare function isImportCall(node: ts.Node): node is ts.ImportCall;
 export declare function isRequireCall(callExpression: ts.Node): callExpression is ts.CallExpression;
 export declare function isPropertyAccessCall(node: ts.Node, identifier: string): node is ts.CallExpression;
-export declare function stripQuotes(name: string): string;
+export declare function stripQuotes(name: string): any;
 export declare function findAncestor<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T | undefined;
 export declare function findDescendants<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T[];
 export declare const isDeclarationFileExtension: (extension: string) => extension is ".d.ts" | ".d.mts" | ".d.cts";
-export declare const getJSDocTags: (node: ts.Node) => Set<string>;
+export declare const getJSDocTags: (node: ts.Node) => any;
 export declare const getLineAndCharacterOfPosition: (node: ts.Node, pos: number) => {
     line: number;
     col: number;
@@ -18,9 +18,11 @@ export declare const getLineAndCharacterOfPosition: (node: ts.Node, pos: number)
 };
 export declare const getAccessMembers: (typeChecker: ts.TypeChecker, node: ts.Identifier) => string[];
 export declare const isDestructuring: (node: ts.Node) => boolean;
-export declare const getDestructuredIds: (name: ts.ObjectBindingPattern) => string[];
-export declare const isConsiderReferencedNS: (node: ts.Identifier) => boolean;
+export declare const getDestructuredIds: (name: ts.ObjectBindingPattern) => any;
+export declare const isConsiderReferencedNS: (node: ts.Identifier) => any;
 export declare const isTopLevel: (node: ts.Node) => boolean;
 export declare const getTypeName: (node: ts.Identifier) => ts.QualifiedName | undefined;
 export declare const isImportSpecifier: (node: ts.Node) => boolean;
-export declare const isReferencedInExportedType: (node: ts.Node, symbol: ts.Symbol) => any;
+export declare const isReferencedInExportedType: (node: ts.Node) => any;
+export declare const getExportKeywordNode: (node: ts.Node) => any;
+export declare const getDefaultKeywordNode: (node: ts.Node) => any;

package/dist/typescript/ast-helpers.js

@@ -152,11 +152,21 @@ export const isImportSpecifier = (node) => ts.isImportSpecifier(node.parent) ||
     ts.isImportClause(node.parent) ||
     ts.isNamespaceImport(node.parent);
 const isExported = (node) => {
-    if (node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.ExportKeyword))
+    if (getExportKeywordNode(node))
         return true;
     return node.parent ? isExported(node.parent) : false;
 };
-export const isReferencedInExportedType = (node, symbol) => symbol.exportSymbol &&
-    !(node.transformFlags & ts.TransformFlags.ContainsTypeScript) &&
-    Boolean(node.parent.transformFlags & ts.TransformFlags.ContainsTypeScript) &&
-    isExported(node.parent);
+const isTypeDeclaration = (node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node);
+const getAncestorTypeDeclaration = (node) => {
+    while (node) {
+        if (isTypeDeclaration(node))
+            return node;
+        node = node.parent;
+    }
+};
+export const isReferencedInExportedType = (node) => {
+    const typeNode = getAncestorTypeDeclaration(node);
+    return Boolean(typeNode && isExported(typeNode));
+};
+export const getExportKeywordNode = (node) => node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
+export const getDefaultKeywordNode = (node) => node.modifiers?.find(mod => mod.kind === ts.SyntaxKind.DefaultKeyword);

package/dist/typescript/getImportsAndExports.d.ts

@@ -1,7 +1,6 @@
 import ts from 'typescript';
 import type { Tags } from '../types/cli.js';
-import type { ExportMap, ImportMap, UnresolvedImport } from '../types/dependency-graph.js';
-import type { IssueSymbol } from '../types/issues.js';
+import type { Export } from '../types/dependency-graph.js';
 import type { BoundSourceFile } from './SourceFile.js';
 export type GetImportsAndExportsOptions = {
     skipTypeOnly: boolean;
@@ -14,16 +13,16 @@ export type GetImportsAndExportsOptions = {
 };
 export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions) => {
     imports: {
-        internal: ImportMap;
-        external: Set<string>;
-        resolved: Set<string>;
-        specifiers: Set<[string, string]>;
-        unresolved: Set<UnresolvedImport>;
+        internal: Map<string, import("../types/dependency-graph.js").ImportDetails>;
+        external: any;
+        resolved: any;
+        specifiers: any;
+        unresolved: any;
     };
     exports: {
-        exported: ExportMap;
-        duplicate: IssueSymbol[][];
+        exported: Map<string, Export>;
+        duplicate: any[];
     };
-    scripts: Set<string>;
-    traceRefs: Set<string>;
+    scripts: any;
+    traceRefs: any;
 };