@aiready/context-analyzer 0.21.8 → 0.21.10

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/context-analyzer@0.21.8 build /Users/pengcao/projects/aiready/packages/context-analyzer
+> @aiready/context-analyzer@0.21.10 build /Users/pengcao/projects/aiready/packages/context-analyzer
 > tsup src/index.ts src/cli.ts --format cjs,esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -9,18 +9,18 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/cli.js   65.97 KB
-CJS dist/index.js 77.31 KB
-CJS ⚡️ Build success in 58ms
-ESM dist/cli.mjs                     4.20 KB
-ESM dist/index.mjs                   9.27 KB
-ESM dist/python-context-3GZKN3LR.mjs 4.47 KB
+CJS dist/cli.js   66.15 KB
+CJS dist/index.js 78.58 KB
+CJS ⚡️ Build success in 219ms
+ESM dist/cli.mjs                     4.38 KB
 ESM dist/chunk-D25B5LZR.mjs          57.60 KB
+ESM dist/index.mjs                   10.53 KB
 ESM dist/chunk-64U3PNO3.mjs          2.65 KB
-ESM ⚡️ Build success in 58ms
+ESM dist/python-context-3GZKN3LR.mjs 4.47 KB
+ESM ⚡️ Build success in 220ms
 DTS Build start
-DTS ⚡️ Build success in 4899ms
+DTS ⚡️ Build success in 5273ms
 DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  15.68 KB
+DTS dist/index.d.ts  20.88 KB
 DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 15.68 KB
+DTS dist/index.d.mts 20.88 KB

package/.turbo/turbo-test.log

@@ -1,41 +1,41 @@
 
 
-> @aiready/context-analyzer@0.21.7 test /Users/pengcao/projects/aiready/packages/context-analyzer
+> @aiready/context-analyzer@0.21.9 test /Users/pengcao/projects/aiready/packages/context-analyzer
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/context-analyzer
 
+ ✓ dist/__tests__/scoring.test.js (15 tests) 215ms
+ ✓ dist/__tests__/fragmentation-coupling.test.js (2 tests) 72ms
+ ✓ dist/__tests__/analyzer.test.js (14 tests) 85ms
+ ✓ dist/__tests__/auto-detection.test.js (8 tests) 183ms
+ ✓ dist/__tests__/contract.test.js (1 test) 167ms
+ ✓ src/__tests__/file-classification.test.ts (63 tests) 19ms
+ ✓ src/__tests__/auto-detection.test.ts (8 tests) 29ms
+ ✓ src/__tests__/provider.test.ts (2 tests) 4ms
+ ✓ src/__tests__/contract.test.ts (1 test) 62ms
+ ✓ src/__tests__/fragmentation-coupling.test.ts (2 tests) 66ms
+ ✓ src/__tests__/analyzer.test.ts (14 tests) 20ms
  ✓ dist/__tests__/remediation.test.js (6 tests) 3ms
  ✓ src/__tests__/remediation.test.ts (6 tests) 2ms
- ✓ src/__tests__/scoring.test.ts (15 tests) 3ms
- ✓ dist/__tests__/contract.test.js (1 test) 12ms
- ✓ dist/__tests__/fragmentation-coupling.test.js (2 tests) 15ms
- ✓ dist/__tests__/analyzer.test.js (14 tests) 25ms
- ✓ dist/__tests__/auto-detection.test.js (8 tests) 23ms
- ✓ src/__tests__/cluster-detector.test.ts (3 tests) 6ms
- ✓ src/__tests__/file-classification.test.ts (63 tests) 7ms
- ✓ src/__tests__/fragmentation-coupling.test.ts (2 tests) 12ms
- ✓ src/__tests__/auto-detection.test.ts (8 tests) 17ms
- ✓ src/__tests__/contract.test.ts (1 test) 50ms
- ✓ src/__tests__/analyzer.test.ts (14 tests) 23ms
- ✓ dist/__tests__/provider.test.js (2 tests) 3ms
- ✓ dist/__tests__/file-classification.test.js (63 tests) 6ms
- ✓ dist/__tests__/cluster-detector.test.js (3 tests) 6ms
- ✓ src/__tests__/structural-cohesion.test.ts (4 tests) 2ms
- ✓ dist/__tests__/scoring.test.js (15 tests) 8ms
- ✓ src/__tests__/provider.test.ts (2 tests) 7ms
- ✓ dist/__tests__/structural-cohesion.test.js (4 tests) 2ms
- ✓ dist/__tests__/fragmentation-log.test.js (3 tests) 3ms
- ✓ dist/__tests__/fragmentation-advanced.test.js (3 tests) 2ms
+ ✓ dist/__tests__/file-classification.test.js (63 tests) 7ms
+ ✓ src/__tests__/scoring.test.ts (15 tests) 4ms
+ ✓ dist/__tests__/provider.test.js (2 tests) 7ms
+ ✓ dist/__tests__/fragmentation-log.test.js (3 tests) 2ms
+ ✓ src/__tests__/cluster-detector.test.ts (3 tests) 2ms
+ ✓ dist/__tests__/cluster-detector.test.js (3 tests) 20ms
  ✓ dist/__tests__/enhanced-cohesion.test.js (6 tests) 3ms
- ✓ src/__tests__/enhanced-cohesion.test.ts (6 tests) 2ms
- ✓ src/__tests__/fragmentation-advanced.test.ts (3 tests) 1ms
- ✓ src/__tests__/fragmentation-log.test.ts (3 tests) 1ms
+ ✓ src/__tests__/structural-cohesion.test.ts (4 tests) 2ms
+ ✓ src/__tests__/enhanced-cohesion.test.ts (6 tests) 5ms
+ ✓ dist/__tests__/fragmentation-advanced.test.js (3 tests) 5ms
+ ✓ dist/__tests__/structural-cohesion.test.js (4 tests) 3ms
+ ✓ src/__tests__/fragmentation-advanced.test.ts (3 tests) 2ms
+ ✓ src/__tests__/fragmentation-log.test.ts (3 tests) 2ms
 
  Test Files  26 passed (26)
       Tests  260 passed (260)
-   Start at  10:36:29
-   Duration  1.74s (transform 2.12s, setup 0ms, import 11.15s, tests 244ms, environment 2ms)
+   Start at  10:12:34
+   Duration  8.91s (transform 10.79s, setup 0ms, import 61.94s, tests 991ms, environment 14ms)
 
 [?25h

package/dist/cli.js

@@ -1927,29 +1927,43 @@ async function contextActionHandler(directory, options) {
   }
 }
 
+// src/cli-definition.ts
+function defineContextCommand(program2) {
+  program2.name("aiready-context").description("Analyze AI context window cost and code structure").version("0.1.0").addHelpText(
+    "after",
+    "\nCONFIGURATION:\n  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json, aiready.config.js, .aireadyrc.js\n  CLI options override config file settings"
+  ).argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth").option(
+    "--max-context <number>",
+    "Maximum acceptable context budget (tokens)"
+  ).option(
+    "--min-cohesion <number>",
+    "Minimum acceptable cohesion score (0-1)"
+  ).option(
+    "--max-fragmentation <number>",
+    "Maximum acceptable fragmentation (0-1)"
+  ).option(
+    "--focus <type>",
+    "Analysis focus: fragmentation, cohesion, depth, all"
+  ).option("--include-node-modules", "Include node_modules in analysis").option(
+    "--include <patterns>",
+    "File patterns to include (comma-separated)"
+  ).option(
+    "--exclude <patterns>",
+    "File patterns to exclude (comma-separated)"
+  ).option(
+    "--max-results <number>",
+    "Maximum number of results to show in console output"
+  ).option(
+    "-o, --output <format>",
+    "Output format: console, json, html",
+    "console"
+  ).option("--output-file <path>", "Output file path (for json/html)").option(
+    "--interactive",
+    "Run interactive setup to suggest excludes and focus areas"
+  ).action(contextActionHandler);
+}
+
 // src/cli.ts
 var program = new import_commander.Command();
-program.name("aiready-context").description("Analyze AI context window cost and code structure").version("0.1.0").addHelpText(
-  "after",
-  "\nCONFIGURATION:\n  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json, aiready.config.js, .aireadyrc.js\n  CLI options override config file settings"
-).argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth").option(
-  "--max-context <number>",
-  "Maximum acceptable context budget (tokens)"
-).option("--min-cohesion <number>", "Minimum acceptable cohesion score (0-1)").option(
-  "--max-fragmentation <number>",
-  "Maximum acceptable fragmentation (0-1)"
-).option(
-  "--focus <type>",
-  "Analysis focus: fragmentation, cohesion, depth, all"
-).option("--include-node-modules", "Include node_modules in analysis").option("--include <patterns>", "File patterns to include (comma-separated)").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option(
-  "--max-results <number>",
-  "Maximum number of results to show in console output"
-).option(
-  "-o, --output <format>",
-  "Output format: console, json, html",
-  "console"
-).option("--output-file <path>", "Output file path (for json/html)").option(
-  "--interactive",
-  "Run interactive setup to suggest excludes and focus areas"
-).action(contextActionHandler);
+defineContextCommand(program);
 program.parse(process.argv);

package/dist/cli.mjs

@@ -90,29 +90,43 @@ async function contextActionHandler(directory, options) {
   }
 }
 
+// src/cli-definition.ts
+function defineContextCommand(program2) {
+  program2.name("aiready-context").description("Analyze AI context window cost and code structure").version("0.1.0").addHelpText(
+    "after",
+    "\nCONFIGURATION:\n  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json, aiready.config.js, .aireadyrc.js\n  CLI options override config file settings"
+  ).argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth").option(
+    "--max-context <number>",
+    "Maximum acceptable context budget (tokens)"
+  ).option(
+    "--min-cohesion <number>",
+    "Minimum acceptable cohesion score (0-1)"
+  ).option(
+    "--max-fragmentation <number>",
+    "Maximum acceptable fragmentation (0-1)"
+  ).option(
+    "--focus <type>",
+    "Analysis focus: fragmentation, cohesion, depth, all"
+  ).option("--include-node-modules", "Include node_modules in analysis").option(
+    "--include <patterns>",
+    "File patterns to include (comma-separated)"
+  ).option(
+    "--exclude <patterns>",
+    "File patterns to exclude (comma-separated)"
+  ).option(
+    "--max-results <number>",
+    "Maximum number of results to show in console output"
+  ).option(
+    "-o, --output <format>",
+    "Output format: console, json, html",
+    "console"
+  ).option("--output-file <path>", "Output file path (for json/html)").option(
+    "--interactive",
+    "Run interactive setup to suggest excludes and focus areas"
+  ).action(contextActionHandler);
+}
+
 // src/cli.ts
 var program = new Command();
-program.name("aiready-context").description("Analyze AI context window cost and code structure").version("0.1.0").addHelpText(
-  "after",
-  "\nCONFIGURATION:\n  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json, aiready.config.js, .aireadyrc.js\n  CLI options override config file settings"
-).argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth").option(
-  "--max-context <number>",
-  "Maximum acceptable context budget (tokens)"
-).option("--min-cohesion <number>", "Minimum acceptable cohesion score (0-1)").option(
-  "--max-fragmentation <number>",
-  "Maximum acceptable fragmentation (0-1)"
-).option(
-  "--focus <type>",
-  "Analysis focus: fragmentation, cohesion, depth, all"
-).option("--include-node-modules", "Include node_modules in analysis").option("--include <patterns>", "File patterns to include (comma-separated)").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option(
-  "--max-results <number>",
-  "Maximum number of results to show in console output"
-).option(
-  "-o, --output <format>",
-  "Output format: console, json, html",
-  "console"
-).option("--output-file <path>", "Output file path (for json/html)").option(
-  "--interactive",
-  "Run interactive setup to suggest excludes and focus areas"
-).action(contextActionHandler);
+defineContextCommand(program);
 program.parse(process.argv);

package/dist/index.d.mts

@@ -184,43 +184,66 @@ declare function calculateCohesion(exports: ExportInfo[], filePath?: string, opt
 declare function analyzeContext(options: ContextAnalyzerOptions): Promise<ContextAnalysisResult[]>;
 
 /**
- * Auto-detect domain keywords from workspace folder structure
+ * Auto-detect domain keywords from workspace folder structure.
+ *
+ * @param files - Array of file contents to analyze for folder patterns.
+ * @returns Array of singularized domain keywords.
  */
 declare function extractDomainKeywordsFromPaths(files: FileContent[]): string[];
 /**
- * Build a dependency graph from file contents
+ * Build a dependency graph from file contents, resolving imports and extracting metadata.
+ *
+ * @param files - Array of file contents to process.
+ * @param options - Optional configuration for domain detection.
+ * @returns Complete dependency graph with nodes, edges, and semantic matrices.
  */
 declare function buildDependencyGraph(files: FileContent[], options?: {
     domainKeywords?: string[];
 }): DependencyGraph;
 /**
- * Calculate the maximum depth of import tree for a file
+ * Calculate the maximum depth of the import tree for a specific file.
+ *
+ * @param file - File path to start depth calculation from.
+ * @param graph - The dependency graph.
+ * @param visited - Optional set to track visited nodes during traversal.
+ * @param depth - Current recursion depth.
+ * @returns Maximum depth of the import chain.
  */
 declare function calculateImportDepth(file: string, graph: DependencyGraph, visited?: Set<string>, depth?: number): number;
 /**
- * Get all transitive dependencies for a file
+ * Retrieve all transitive dependencies for a specific file.
+ *
+ * @param file - File path to analyze.
+ * @param graph - The dependency graph.
+ * @param visited - Optional set to track visited nodes.
+ * @returns Array of all reachable file paths.
  */
 declare function getTransitiveDependencies(file: string, graph: DependencyGraph, visited?: Set<string>): string[];
 /**
- * Calculate total context budget (tokens needed to understand this file)
+ * Calculate total context budget (tokens needed to understand this file and its dependencies).
+ *
+ * @param file - File path to calculate budget for.
+ * @param graph - The dependency graph.
+ * @returns Total token count including recursive dependencies.
  */
 declare function calculateContextBudget(file: string, graph: DependencyGraph): number;
 /**
- * Detect circular dependencies
+ * Detect circular dependencies (cycles) within the dependency graph.
+ *
+ * @param graph - The dependency graph to scan.
+ * @returns Array of dependency cycles (each cycle is an array of file paths).
  */
 declare function detectCircularDependencies(graph: DependencyGraph): string[][];
 
-/**
- * Calculate cohesion score (how related are exports in a file)
- */
 /**
  * Calculates a cohesion score (0-1) for a module based on its exports,
  * shared imports, and internal structure. High cohesion indicates
  * a well-focused module that is easy for AI models to reason about.
  *
- * @param exports - Exported symbols and their metadata
- * @param imports - Imported symbols and their sources
- * @returns Cohesion score between 0 and 1
+ * @param exports - Exported symbols and their metadata.
+ * @param filePath - Optional file path for context.
+ * @param options - Optional configuration for weights and co-usage context.
+ * @returns Cohesion score between 0 and 1.
  */
 declare function calculateEnhancedCohesion(exports: ExportInfo[], filePath?: string, options?: {
     coUsageMatrix?: Map<string, Map<string, number>>;
@@ -232,10 +255,19 @@ declare function calculateEnhancedCohesion(exports: ExportInfo[], filePath?: str
 }): number;
 /**
  * Calculate structural cohesion for a file based on co-usage patterns.
+ *
+ * @param file - The file path to analyze.
+ * @param coUsageMatrix - Matrix of files frequently imported together.
+ * @returns Cohesion score between 0 and 1 based on co-usage distribution.
  */
 declare function calculateStructuralCohesionFromCoUsage(file: string, coUsageMatrix?: Map<string, Map<string, number>>): number;
 /**
  * Calculate fragmentation score (how scattered is a domain)
+ *
+ * @param files - List of files belonging to the domain.
+ * @param domain - The domain identifier.
+ * @param options - Optional calculation parameters (log scale, thresholds).
+ * @returns Fragmentation score from 0 (perfect) to 1 (highly scattered).
  */
 declare function calculateFragmentation(files: string[], domain: string, options?: {
     useLogScale?: boolean;
@@ -244,11 +276,17 @@ declare function calculateFragmentation(files: string[], domain: string, options
     dependencyCount?: number;
 }): number;
 /**
- * Calculate path entropy for a set of files
+ * Calculate path entropy for a set of files to measure directory distribution.
+ *
+ * @param files - Array of file paths.
+ * @returns Entropy score representing the spread across directories.
  */
 declare function calculatePathEntropy(files: string[]): number;
 /**
- * Calculate directory-distance metric based on common ancestor depth
+ * Calculate directory-distance metric based on common ancestor depth.
+ *
+ * @param files - Array of file paths to compare.
+ * @returns Normalized distance metric (0-1).
  */
 declare function calculateDirectoryDistance(files: string[]): number;
 
@@ -308,10 +346,19 @@ declare function detectModuleClusters(graph: DependencyGraph, options?: {
 
 /**
  * Get classification-specific recommendations
+ *
+ * @param classification - The identified type of file (e.g., 'barrel-export', 'utility-module').
+ * @param file - File path or identifier.
+ * @param issues - Initial list of issues to supplement.
+ * @returns Array of tailored recommendations.
  */
 declare function getClassificationRecommendations(classification: FileClassification, file: string, issues: string[]): string[];
 /**
- * Generate general context recommendations
+ * Generate general context recommendations based on cross-tool metrics and thresholds.
+ *
+ * @param metrics - Object containing context budget, depth, circular dependencies, cohesion, and fragmentation.
+ * @param thresholds - Configurable limits for each metric.
+ * @returns Object with recommendations array, issues array, and overall severity level.
  */
 declare function getGeneralRecommendations(metrics: {
     contextBudget: number;
@@ -331,9 +378,23 @@ declare function getGeneralRecommendations(metrics: {
 };
 
 /**
- * Calculate AI Readiness Score for context efficiency (0-100)
+ * Calculate AI Readiness Score for context efficiency (0-100).
+ *
+ * Evaluates how efficiently an AI model can process the project's code context
+ * based on token budgets, import depth, and file fragmentation.
+ *
+ * @param summary - Consolidated context summary from the scan.
+ * @param costConfig - Optional configuration for business value calculations.
+ * @returns Standardized scoring output for the context analyzer tool.
+ * @lastUpdated 2026-03-18
  */
 declare function calculateContextScore(summary: ContextSummary, costConfig?: Partial<CostConfig>): ToolScoringOutput;
+/**
+ * Maps a numerical score to a human-readable rating slug.
+ *
+ * @param score - The 0-100 readiness score.
+ * @returns A formatted rating string (e.g., "excellent", "at risk").
+ */
 declare function mapScoreToRating(score: number): string;
 
 /**
@@ -347,46 +408,96 @@ declare function getSmartDefaults(directory: string, userOptions: Partial<Contex
 
 /**
  * Generate summary of context analysis results
+ *
+ * @param results - Array of individual file analysis results.
+ * @param options - Optional scan configuration for context extraction.
+ * @returns A consolidated summary of the entire context scan.
  */
 declare function generateSummary(results: ContextAnalysisResult[], options?: any): ContextSummary;
 
 /**
- * Build co-usage matrix: track which files are imported together
- * @param graph - The dependency graph to analyze
- * @returns Map of file to co-usage counts
+ * Build co-usage matrix: track which files are imported together frequently.
+ *
+ * @param graph - The dependency graph to analyze.
+ * @returns Map of file path to nested map of related files and their co-occurrence counts.
  */
 declare function buildCoUsageMatrix(graph: DependencyGraph): Map<string, Map<string, number>>;
 /**
- * Extract type dependencies from AST exports
- * @param graph - The dependency graph to analyze
- * @returns Map of type references to files that use them
+ * Extract type dependencies from AST exports to build a type-based relationship graph.
+ *
+ * @param graph - The dependency graph to analyze.
+ * @returns Map of type reference names to sets of files that consume or export them.
  */
 declare function buildTypeGraph(graph: DependencyGraph): Map<string, Set<string>>;
 /**
- * Find semantic clusters using co-usage patterns
- * @param coUsageMatrix - The co-usage matrix from buildCoUsageMatrix
- * @param minCoUsage - Minimum co-usage count to consider (default: 3)
- * @returns Map of cluster representative files to their cluster members
+ * Find semantic clusters using frequently occurring co-usage patterns.
+ *
+ * @param coUsageMatrix - The co-usage matrix from buildCoUsageMatrix.
+ * @param minCoUsage - Minimum co-usage count to consider a strong relationship (default: 3).
+ * @returns Map of cluster representative files to their associated cluster members.
  */
 declare function findSemanticClusters(coUsageMatrix: Map<string, Map<string, number>>, minCoUsage?: number): Map<string, string[]>;
 /**
- * Infer domain from semantic analysis (co-usage + types)
+ * Infer domain from semantic analysis (co-usage + types) to identify logical modules.
+ *
+ * @param file - The file path to infer domain for.
+ * @param exportName - The specific export identifier.
+ * @param graph - The full dependency graph.
+ * @param coUsageMatrix - Matrix of files frequently imported together.
+ * @param typeGraph - Map of type references to files.
+ * @param exportTypeRefs - Optional list of types referenced by the export.
+ * @returns Array of potential domain assignments with confidence scores.
  */
 declare function inferDomainFromSemantics(file: string, exportName: string, graph: DependencyGraph, coUsageMatrix: Map<string, Map<string, number>>, typeGraph: Map<string, Set<string>>, exportTypeRefs?: string[]): DomainAssignment[];
+/**
+ * Calculate confidence score for a domain assignment based on signals.
+ *
+ * @param signals - The set of semantic signals detected for a domain.
+ * @returns Numerical confidence score (0-1).
+ */
 declare function calculateDomainConfidence(signals: DomainSignals): number;
 /**
  * Regex-based export extraction (legacy/fallback)
+ *
+ * @param content - Source code content.
+ * @param filePath - Optional file path for domain context.
+ * @param domainOptions - Optional overrides for domain keywords.
+ * @param fileImports - Optional list of actual imports for semantic context.
+ * @returns Array of extracted export information.
  */
 declare function extractExports(content: string, filePath?: string, domainOptions?: {
     domainKeywords?: string[];
 }, fileImports?: string[]): ExportInfo[];
 /**
  * Infer domain from name, path, or imports
+ *
+ * @param name - The identifier name to analyze.
+ * @param filePath - Optional file path for structure context.
+ * @param domainOptions - Optional overrides for domain keywords.
+ * @param fileImports - Optional list of imports for domain context.
+ * @returns The inferred domain name (string).
  */
 declare function inferDomain(name: string, filePath?: string, domainOptions?: {
     domainKeywords?: string[];
 }, fileImports?: string[]): string;
+/**
+ * Retrieve co-usage data for a specific file.
+ *
+ * @param file - The file path to look up.
+ * @param coUsageMatrix - The global co-usage matrix.
+ * @returns Formatted co-usage data object.
+ */
 declare function getCoUsageData(file: string, coUsageMatrix: Map<string, Map<string, number>>): CoUsageData;
+/**
+ * Identify candidates for module consolidation based on high co-usage or shared types.
+ *
+ * @param graph - The dependency graph.
+ * @param coUsageMatrix - Matrix of frequently paired files.
+ * @param typeGraph - Map of shared type references.
+ * @param minCoUsage - Minimum co-usage count threshold.
+ * @param minSharedTypes - Minimum shared types threshold.
+ * @returns Array of consolidation candidates sorted by strength.
+ */
 declare function findConsolidationCandidates(graph: DependencyGraph, coUsageMatrix: Map<string, Map<string, number>>, typeGraph: Map<string, Set<string>>, minCoUsage?: number, minSharedTypes?: number): any[];
 
 /**