@dataparade/cli 0.0.1

package/dist/src/analyzers/typescript/parser.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+exports.buildCodeModel = buildCodeModel;
+const nodePath = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+/**
+ * Normalize a file system path to a POSIX-style string (forward slashes).
+ * This keeps path handling consistent across platforms.
+ */
+function normalizePath(p) {
+    if (!p)
+        return "";
+    return p.split("\\").join("/");
+}
+/**
+ * Build a lightweight code model for a TypeScript/JavaScript file.
+ *
+ * - Ensures the language is correctly inferred for TS/JS files.
+ * - Indexes import statements and simple require() calls.
+ * - Indexes top-level function declarations, exported functions, and basic
+ *   arrow/function expressions assigned to exported variables.
+ * - Surfaces parser/diagnostic issues as warnings instead of throwing.
+ */
+function buildCodeModel(file) {
+    const warnings = [];
+    const normalizedPath = normalizePath(file.path);
+    const language = ensureParserLanguage(file, warnings);
+    if (!language) {
+        warnings.push(`Unsupported language '${file.language}' for TS/JS parser in file '${file.path}'.`);
+        // Return a minimal, non-fatal result so callers can safely continue.
+        return {
+            file,
+            normalizedPath,
+            // Fallback language is arbitrary here; callers should rely on file.language
+            // and the warning above rather than this value when language is unsupported.
+            language: "javascript",
+            imports: [],
+            functions: [],
+            warnings,
+        };
+    }
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile(file.path, file.content ?? "", ts.ScriptTarget.Latest, 
+        /*setParentNodes*/ true, language === "typescript"
+            ? ts.ScriptKind.TSX // covers .ts and .tsx
+            : ts.ScriptKind.JSX);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown parser error creating SourceFile";
+        warnings.push(`Failed to parse '${file.path}' as ${language}: ${message}`);
+        return {
+            file,
+            normalizedPath,
+            language,
+            imports: [],
+            functions: [],
+            warnings,
+        };
+    }
+    const diagnostics = sourceFile.parseDiagnostics;
+    if (diagnostics && diagnostics.length > 0) {
+        const first = diagnostics[0];
+        const msg = ts.flattenDiagnosticMessageText(first.messageText, " ");
+        warnings.push(`Parse diagnostics in '${file.path}': ${msg}`);
+    }
+    const imports = [];
+    const functions = [];
+    const toLocation = (node) => {
+        const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        return {
+            filePath: file.path,
+            startLine: start.line + 1,
+            endLine: end.line + 1,
+        };
+    };
+    const resolveRelativeImport = (moduleSpecifier) => {
+        if (!moduleSpecifier.startsWith("."))
+            return undefined;
+        const baseDir = normalizePath(nodePath.dirname(file.path));
+        const joined = normalizePath(nodePath.join(baseDir, moduleSpecifier));
+        return joined;
+    };
+    const collectImport = (node) => {
+        const moduleSpecifier = node.moduleSpecifier.text;
+        const importedNames = [];
+        const clause = node.importClause;
+        const isTypeOnly = !!clause?.isTypeOnly;
+        if (clause) {
+            if (clause.name) {
+                importedNames.push(clause.name.text);
+            }
+            if (clause.namedBindings) {
+                if (ts.isNamespaceImport(clause.namedBindings)) {
+                    importedNames.push(clause.namedBindings.name.text);
+                }
+                else if (ts.isNamedImports(clause.namedBindings)) {
+                    for (const spec of clause.namedBindings.elements) {
+                        importedNames.push(spec.name.text);
+                    }
+                }
+            }
+        }
+        imports.push({
+            moduleSpecifier,
+            importedNames,
+            isTypeOnly,
+            resolvedPath: resolveRelativeImport(moduleSpecifier),
+            location: toLocation(node),
+        });
+    };
+    const collectRequireCall = (node) => {
+        const expression = node.expression;
+        if (!ts.isIdentifier(expression) || expression.text !== "require")
+            return;
+        if (node.arguments.length === 0)
+            return;
+        const arg = node.arguments[0];
+        if (!ts.isStringLiteral(arg))
+            return;
+        const moduleSpecifier = arg.text;
+        const importedNames = [];
+        // Try to infer the bound identifier from a simple `const x = require("y")` pattern.
+        if (ts.isVariableDeclaration(node.parent) &&
+            ts.isIdentifier(node.parent.name)) {
+            importedNames.push(node.parent.name.text);
+        }
+        imports.push({
+            moduleSpecifier,
+            importedNames,
+            isTypeOnly: false,
+            resolvedPath: resolveRelativeImport(moduleSpecifier),
+            location: toLocation(node),
+        });
+    };
+    const hasExportModifier = (modifiers) => !!modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword ||
+        m.kind === ts.SyntaxKind.DefaultKeyword);
+    const collectFunctionDeclaration = (node) => {
+        const name = node.name?.text ?? "<anonymous>";
+        const isExported = !!node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+        const exportKind = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)
+            ? "default"
+            : isExported
+                ? "named"
+                : undefined;
+        functions.push({
+            name,
+            isExported,
+            exportKind,
+            location: toLocation(node),
+        });
+    };
+    const collectVariableFunctions = (node) => {
+        const isExported = hasExportModifier(node.modifiers);
+        for (const decl of node.declarationList.declarations) {
+            const init = decl.initializer;
+            if (!init ||
+                (!ts.isArrowFunction(init) && !ts.isFunctionExpression(init))) {
+                continue;
+            }
+            let name = "<anonymous>";
+            if (ts.isIdentifier(decl.name)) {
+                name = decl.name.text;
+            }
+            functions.push({
+                name,
+                isExported,
+                exportKind: isExported ? "named" : undefined,
+                location: toLocation(init),
+            });
+        }
+    };
+    const collectMethodDeclaration = (node) => {
+        let name = "<anonymous>";
+        if (ts.isIdentifier(node.name)) {
+            name = node.name.text;
+        }
+        const parent = node.parent;
+        const parentIsExported = ts.isClassDeclaration(parent) && hasExportModifier(parent.modifiers);
+        functions.push({
+            name,
+            isExported: parentIsExported,
+            exportKind: parentIsExported ? "named" : undefined,
+            location: toLocation(node),
+        });
+    };
+    const collectExportAssignment = (node) => {
+        const expr = node.expression;
+        if (!ts.isFunctionExpression(expr) && !ts.isArrowFunction(expr))
+            return;
+        const name = "<anonymous>";
+        functions.push({
+            name,
+            isExported: true,
+            exportKind: "default",
+            location: toLocation(expr),
+        });
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            collectImport(node);
+        }
+        else if (ts.isCallExpression(node)) {
+            collectRequireCall(node);
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            collectFunctionDeclaration(node);
+        }
+        else if (ts.isVariableStatement(node)) {
+            collectVariableFunctions(node);
+        }
+        else if (ts.isMethodDeclaration(node)) {
+            collectMethodDeclaration(node);
+        }
+        else if (ts.isExportAssignment(node)) {
+            collectExportAssignment(node);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return {
+        file,
+        normalizedPath,
+        language,
+        imports,
+        functions,
+        warnings,
+    };
+}
+function ensureParserLanguage(file, warnings) {
+    const ext = nodePath.extname(file.name || file.path).toLowerCase();
+    let fromExtension;
+    if (ext === ".ts" || ext === ".tsx") {
+        fromExtension = "typescript";
+    }
+    else if (ext === ".js" ||
+        ext === ".jsx" ||
+        ext === ".mjs" ||
+        ext === ".cjs") {
+        fromExtension = "javascript";
+    }
+    if (!fromExtension) {
+        if (file.language === "typescript" || file.language === "javascript") {
+            return file.language;
+        }
+        return undefined;
+    }
+    if (file.language !== fromExtension) {
+        warnings.push(`File language '${file.language}' adjusted to '${fromExtension}' based on extension '${ext}' for '${file.path}'.`);
+    }
+    return fromExtension;
+}

package/dist/src/analyzers/typescript/third-party-detection.d.ts

@@ -0,0 +1,4 @@
+import type { FileInfo } from "../../core/types/file";
+import type { RawFinding } from "../../core/types/detection";
+import type { ParserResult } from "./parser";
+export declare function detectExternalApiCalls(file: FileInfo, model: ParserResult): RawFinding[];

package/dist/src/analyzers/typescript/third-party-detection.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectExternalApiCalls = detectExternalApiCalls;
+const engine_1 = require("../../patterns/engine");
+function detectExternalApiCalls(file, model) {
+    const importsForEngine = model.imports.map((imp) => ({
+        module: imp.moduleSpecifier,
+        names: imp.importedNames,
+    }));
+    return (0, engine_1.matchPatterns)({
+        language: model.language,
+        file,
+        imports: importsForEngine,
+        includeThirdPartyHttpLinePatterns: true,
+    }).filter((f) => f.pattern === "external_api_call");
+}

package/dist/src/analyzers/typescript/typescript-detection-config.d.ts

@@ -0,0 +1,68 @@
+import { type PatternId } from "../../core/types/detection";
+/** Normalized config entries (after validation); patternId is guaranteed valid. */
+export interface WithPatternId {
+    patternId: PatternId;
+}
+export interface RouteFrameworkConfig extends WithPatternId {
+    id: string;
+    imports: string[];
+    routeCallRegexes: RegExp[];
+    controllerDecoratorRegexes: RegExp[];
+    routeDecoratorRegexes: RegExp[];
+    confidence: number;
+}
+export interface DbClientConfig extends WithPatternId {
+    id: string;
+    databaseType: string;
+    importModules: string[];
+    creationRegexes: RegExp[];
+    /** Confidence when a creation regex matches; import-only uses confidence - 0.2 (min 0.5). */
+    confidence: number;
+}
+export interface AuthLibraryConfig extends WithPatternId {
+    id: string;
+    importFragments: string[];
+    callRegexes: RegExp[];
+    confidence: number;
+}
+export interface ConfigKeyConfig extends WithPatternId {
+    name: string;
+    confidence: number;
+}
+export interface HeuristicsConfig {
+    processEnv: {
+        regex: RegExp;
+        confidence: number;
+    };
+    sqlKeyword: {
+        regex: RegExp;
+        patternId: PatternId;
+        confidence: number;
+    };
+    nextRouteHandler: {
+        regex: RegExp;
+        confidence: number;
+    };
+    configKeyAccess: {
+        regex: RegExp;
+    };
+}
+export interface TypeScriptPatternConfig {
+    routes: {
+        frameworks: RouteFrameworkConfig[];
+    };
+    dbClients: DbClientConfig[];
+    auth: {
+        libraries: AuthLibraryConfig[];
+    };
+    heuristics: HeuristicsConfig;
+    envVariables: {
+        importantKeys: string[];
+    };
+    configKeys: {
+        keys: ConfigKeyConfig[];
+    };
+}
+/** Clears the config cache (for tests). */
+export declare function clearTypeScriptPatternConfigCache(): void;
+export declare function loadTypeScriptPatternConfig(): TypeScriptPatternConfig;

package/dist/src/analyzers/typescript/typescript-detection-config.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTypeScriptPatternConfigCache = clearTypeScriptPatternConfigCache;
+exports.loadTypeScriptPatternConfig = loadTypeScriptPatternConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const detection_1 = require("../../core/types/detection");
+/** Default confidence when not specified in YAML. */
+const DEFAULT_CONFIDENCE = 0.8;
+function validatePatternId(rawValue, context) {
+    const id = String(rawValue);
+    if (!detection_1.PATTERN_IDS.includes(id)) {
+        throw new Error(`Invalid patternId '${rawValue}' in ${context}`);
+    }
+    return id;
+}
+function compileRegex(pattern, flags) {
+    try {
+        return new RegExp(pattern, flags ?? "");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown regex compilation error";
+        throw new Error(`Invalid regex pattern '${pattern}': ${message}`);
+    }
+}
+function compileRegexList(patterns) {
+    if (!patterns || patterns.length === 0) {
+        return [];
+    }
+    return patterns.map((p) => compileRegex(p));
+}
+function normalizeRawConfig(raw) {
+    const frameworks = raw.routes?.frameworks?.map((fw) => {
+        const patternId = validatePatternId(fw.patternId, `routes.frameworks entry '${fw.id}'`);
+        return {
+            id: fw.id,
+            patternId,
+            imports: fw.imports ?? [],
+            routeCallRegexes: compileRegexList(fw.routeCallRegexes),
+            controllerDecoratorRegexes: compileRegexList(fw.controllerDecoratorRegexes),
+            routeDecoratorRegexes: compileRegexList(fw.routeDecoratorRegexes),
+            confidence: fw.confidence ?? DEFAULT_CONFIDENCE,
+        };
+    }) ?? [];
+    const dbClients = raw.db_clients?.map((c) => {
+        const patternId = validatePatternId(c.patternId, `db_clients entry '${c.id}'`);
+        return {
+            id: c.id,
+            patternId,
+            databaseType: c.databaseType,
+            importModules: c.importModules ?? [],
+            creationRegexes: compileRegexList(c.regexes),
+            confidence: c.confidence ?? DEFAULT_CONFIDENCE,
+        };
+    }) ?? [];
+    const authLibraries = raw.auth?.libraries?.map((lib) => {
+        const patternId = validatePatternId(lib.patternId, `auth.libraries entry '${lib.id}'`);
+        return {
+            id: lib.id,
+            patternId,
+            importFragments: lib.importFragments ?? [],
+            callRegexes: compileRegexList(lib.regexes),
+            confidence: lib.confidence ?? DEFAULT_CONFIDENCE,
+        };
+    }) ?? [];
+    const configKeys = raw.config_keys?.keys?.map((k) => {
+        const patternId = validatePatternId(k.patternId, `config_keys.keys entry '${k.name}'`);
+        return {
+            name: k.name,
+            patternId,
+            confidence: k.confidence ?? DEFAULT_CONFIDENCE,
+        };
+    }) ?? [];
+    const importantKeys = raw.env_variables?.importantKeys?.slice() ?? [];
+    const h = raw.heuristics;
+    if (!h?.processEnv?.regex || !h?.sqlKeyword?.regex || !h?.nextRouteHandler?.regex || !h?.configKeyAccess?.regex) {
+        throw new Error("TypeScript pattern config requires heuristics.processEnv.regex, heuristics.sqlKeyword.regex, heuristics.nextRouteHandler.regex, and heuristics.configKeyAccess.regex in the YAML file.");
+    }
+    const processEnvRegex = compileRegex(h.processEnv.regex);
+    const sqlKeywordRegex = compileRegex(h.sqlKeyword.regex, "i");
+    const nextRouteHandlerRegex = compileRegex(h.nextRouteHandler.regex);
+    const configKeyAccessRegex = compileRegex(h.configKeyAccess.regex);
+    const sqlKeywordPatternId = h.sqlKeyword.patternId
+        ? validatePatternId(h.sqlKeyword.patternId, "heuristics.sqlKeyword")
+        : "database_connection";
+    const heuristics = {
+        processEnv: {
+            regex: processEnvRegex,
+            confidence: h.processEnv.confidence ?? 0.95,
+        },
+        sqlKeyword: {
+            regex: sqlKeywordRegex,
+            patternId: sqlKeywordPatternId,
+            confidence: h.sqlKeyword.confidence ?? 0.6,
+        },
+        nextRouteHandler: {
+            regex: nextRouteHandlerRegex,
+            confidence: h.nextRouteHandler.confidence ?? 0.75,
+        },
+        configKeyAccess: { regex: configKeyAccessRegex },
+    };
+    return {
+        routes: {
+            frameworks,
+        },
+        dbClients,
+        auth: {
+            libraries: authLibraries,
+        },
+        heuristics,
+        envVariables: {
+            importantKeys,
+        },
+        configKeys: {
+            keys: configKeys,
+        },
+    };
+}
+let cachedConfig;
+/** Clears the config cache (for tests). */
+function clearTypeScriptPatternConfigCache() {
+    cachedConfig = undefined;
+}
+function getPatternsFilePath() {
+    // During tests, this module runs from src/analyzers/typescript.
+    // In the built package, it runs from dist/src/analyzers/typescript.
+    // We want the CLI package root that contains the `patterns/` directory.
+    const parts = __dirname.split(path_1.default.sep);
+    const distIndex = parts.lastIndexOf("dist");
+    let cliRoot;
+    if (distIndex !== -1) {
+        // e.g. /path/to/cli/dist/src/analyzers/typescript -> /path/to/cli
+        cliRoot = parts.slice(0, distIndex).join(path_1.default.sep);
+    }
+    else {
+        // e.g. /path/to/cli/src/analyzers/typescript -> /path/to/cli
+        cliRoot = path_1.default.resolve(__dirname, "../../..");
+    }
+    return path_1.default.join(cliRoot, "patterns", "typescript.patterns.yaml");
+}
+function loadTypeScriptPatternConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const patternsPath = getPatternsFilePath();
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(patternsPath, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`TypeScript pattern config is required but could not be read from '${patternsPath}': ${message}`);
+    }
+    const parsed = yaml_1.default.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(`TypeScript pattern config at '${patternsPath}' did not parse to an object.`);
+    }
+    try {
+        const normalized = normalizeRawConfig(parsed);
+        cachedConfig = normalized;
+        return normalized;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid TypeScript pattern config at '${patternsPath}': ${message}`);
+    }
+}

package/dist/src/analyzers/typescript/typescript-detection.d.ts

@@ -0,0 +1,10 @@
+import type { FileInfo } from "../../core/types/file";
+import type { RawFinding } from "../../core/types/detection";
+import type { ParserResult } from "./parser";
+type TsPatternDetector = (file: FileInfo, model: ParserResult) => RawFinding[];
+export declare const detectRoutePatterns: TsPatternDetector;
+export declare const detectDatabaseConnections: TsPatternDetector;
+export declare const detectExternalApiCalls: TsPatternDetector;
+export declare const detectAuthMiddleware: TsPatternDetector;
+export declare const detectConfigAndEnvUsage: TsPatternDetector;
+export {};

package/dist/src/analyzers/typescript/typescript-detection.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectConfigAndEnvUsage = exports.detectAuthMiddleware = exports.detectExternalApiCalls = exports.detectDatabaseConnections = exports.detectRoutePatterns = void 0;
+const third_party_detection_1 = require("./third-party-detection");
+const engine_1 = require("../../patterns/engine");
+function toImportLikes(model) {
+    return model.imports.map((imp) => ({
+        module: imp.moduleSpecifier,
+        names: imp.importedNames,
+    }));
+}
+const detectRoutePatterns = (file, model) => {
+    const importsForEngine = toImportLikes(model);
+    const allFindings = (0, engine_1.matchPatterns)({
+        language: model.language,
+        file,
+        imports: importsForEngine,
+        normalizedPath: model.normalizedPath,
+    });
+    return allFindings.filter((f) => f.pattern === "express_route");
+};
+exports.detectRoutePatterns = detectRoutePatterns;
+const detectDatabaseConnections = (file, model) => {
+    const importsForEngine = toImportLikes(model);
+    const allFindings = (0, engine_1.matchPatterns)({
+        language: model.language,
+        file,
+        imports: importsForEngine,
+        normalizedPath: model.normalizedPath,
+    });
+    return allFindings.filter((f) => f.pattern === "database_connection");
+};
+exports.detectDatabaseConnections = detectDatabaseConnections;
+const detectExternalApiCalls = (file, model) => (0, third_party_detection_1.detectExternalApiCalls)(file, model);
+exports.detectExternalApiCalls = detectExternalApiCalls;
+const detectAuthMiddleware = (file, model) => {
+    const importsForEngine = toImportLikes(model);
+    const allFindings = (0, engine_1.matchPatterns)({
+        language: model.language,
+        file,
+        imports: importsForEngine,
+        normalizedPath: model.normalizedPath,
+    });
+    return allFindings.filter((f) => f.pattern === "auth_middleware");
+};
+exports.detectAuthMiddleware = detectAuthMiddleware;
+const detectConfigAndEnvUsage = (file, model) => {
+    const importsForEngine = toImportLikes(model);
+    const allFindings = (0, engine_1.matchPatterns)({
+        language: model.language,
+        file,
+        imports: importsForEngine,
+        normalizedPath: model.normalizedPath,
+    });
+    return allFindings.filter((f) => f.pattern === "env_variable" || f.pattern === "config_file");
+};
+exports.detectConfigAndEnvUsage = detectConfigAndEnvUsage;

package/dist/src/classifier/application-injection.d.ts

@@ -0,0 +1,12 @@
+import type { DetectedComponent } from "../core/types/component";
+import type { ServiceSection } from "../core/sectioning/discover-service-sections";
+/** Synthetic main app created when no code hub exists (e.g. IaC-only scan). */
+export declare const INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT: "injected_project_placeholder";
+export declare function injectApplicationAssetsPerSectionIfMissing(components: DetectedComponent[], sections: ServiceSection[], opts?: {
+    projectName?: string;
+}): DetectedComponent[];
+export declare function injectApplicationAssetIfMissing(components: DetectedComponent[], opts?: {
+    projectName?: string;
+}): DetectedComponent[];
+export declare function injectActorIfMissing(components: DetectedComponent[]): DetectedComponent[];
+export declare function synthesizeSectionApiNodes(components: DetectedComponent[]): DetectedComponent[];