cmp-standards 3.1.1 → 3.3.0

package/dist/schema/codewiki-types.d.ts

@@ -0,0 +1,1899 @@
+/**
+ * @file CodeWiki Types Schema - cmp-standards v3.3
+ * @description Type definitions for automated code knowledge graph system
+ *
+ * This module provides schemas for:
+ * - File metadata and content hashing
+ * - Code structure (symbols, imports, exports)
+ * - Dependency relationships
+ * - Documentation extraction
+ * - Expert analysis results
+ * - Cross-project references
+ */
+import { z } from 'zod';
+/**
+ * Programming language detection
+ */
+export declare const LanguageSchema: z.ZodEnum<["typescript", "javascript", "tsx", "jsx", "json", "markdown", "css", "scss", "html", "yaml", "sql", "shell", "unknown"]>;
+export type Language = z.infer<typeof LanguageSchema>;
+/**
+ * Symbol kind (what type of code entity)
+ */
+export declare const SymbolKindSchema: z.ZodEnum<["class", "interface", "type", "enum", "function", "arrow_function", "const", "let", "var", "namespace", "module", "component", "hook", "method", "property", "parameter", "import", "export"]>;
+export type SymbolKind = z.infer<typeof SymbolKindSchema>;
+export declare const FileMetadataContentSchema: z.ZodObject<{
+    /** Absolute file path */
+    filePath: z.ZodString;
+    /** Relative path from project root */
+    relativePath: z.ZodString;
+    /** File name with extension */
+    fileName: z.ZodString;
+    /** File extension (without dot) */
+    extension: z.ZodString;
+    /** Detected programming language */
+    language: z.ZodEnum<["typescript", "javascript", "tsx", "jsx", "json", "markdown", "css", "scss", "html", "yaml", "sql", "shell", "unknown"]>;
+    /** File size in bytes */
+    size: z.ZodNumber;
+    /** Lines of code */
+    loc: z.ZodNumber;
+    /** Non-empty lines */
+    locNonEmpty: z.ZodNumber;
+    /** Comment lines */
+    locComments: z.ZodNumber;
+    /** SHA-256 content hash for change detection */
+    hash: z.ZodString;
+    /** Last modified timestamp (ISO) */
+    lastModified: z.ZodString;
+    /** Project identifier */
+    projectId: z.ZodString;
+    /** Git branch (if in repo) */
+    branch: z.ZodOptional<z.ZodString>;
+    /** Git commit hash (if in repo) */
+    commit: z.ZodOptional<z.ZodString>;
+    /** First indexed timestamp */
+    firstIndexedAt: z.ZodString;
+    /** Last indexed timestamp */
+    lastIndexedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    filePath: string;
+    language: "unknown" | "json" | "sql" | "typescript" | "javascript" | "tsx" | "jsx" | "markdown" | "css" | "scss" | "html" | "yaml" | "shell";
+    hash: string;
+    relativePath: string;
+    fileName: string;
+    extension: string;
+    size: number;
+    loc: number;
+    locNonEmpty: number;
+    locComments: number;
+    lastModified: string;
+    projectId: string;
+    firstIndexedAt: string;
+    lastIndexedAt: string;
+    branch?: string | undefined;
+    commit?: string | undefined;
+}, {
+    filePath: string;
+    language: "unknown" | "json" | "sql" | "typescript" | "javascript" | "tsx" | "jsx" | "markdown" | "css" | "scss" | "html" | "yaml" | "shell";
+    hash: string;
+    relativePath: string;
+    fileName: string;
+    extension: string;
+    size: number;
+    loc: number;
+    locNonEmpty: number;
+    locComments: number;
+    lastModified: string;
+    projectId: string;
+    firstIndexedAt: string;
+    lastIndexedAt: string;
+    branch?: string | undefined;
+    commit?: string | undefined;
+}>;
+export type FileMetadataContent = z.infer<typeof FileMetadataContentSchema>;
+export declare const CodeSymbolSchema: z.ZodObject<{
+    /** Symbol name */
+    name: z.ZodString;
+    /** Full qualified name (e.g., ClassName.methodName) */
+    qualifiedName: z.ZodOptional<z.ZodString>;
+    /** Symbol kind */
+    kind: z.ZodEnum<["class", "interface", "type", "enum", "function", "arrow_function", "const", "let", "var", "namespace", "module", "component", "hook", "method", "property", "parameter", "import", "export"]>;
+    /** Start line number (1-based) */
+    lineStart: z.ZodNumber;
+    /** End line number (1-based) */
+    lineEnd: z.ZodNumber;
+    /** Column start */
+    columnStart: z.ZodOptional<z.ZodNumber>;
+    /** Column end */
+    columnEnd: z.ZodOptional<z.ZodNumber>;
+    /** Is exported */
+    isExported: z.ZodDefault<z.ZodBoolean>;
+    /** Is default export */
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    /** Is async (for functions) */
+    isAsync: z.ZodOptional<z.ZodBoolean>;
+    /** Is generator (for functions) */
+    isGenerator: z.ZodOptional<z.ZodBoolean>;
+    /** Type signature */
+    signature: z.ZodOptional<z.ZodString>;
+    /** Return type (for functions) */
+    returnType: z.ZodOptional<z.ZodString>;
+    /** Parameters (for functions) */
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        optional: z.ZodDefault<z.ZodBoolean>;
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        optional: boolean;
+        type?: string | undefined;
+        defaultValue?: string | undefined;
+    }, {
+        name: string;
+        type?: string | undefined;
+        optional?: boolean | undefined;
+        defaultValue?: string | undefined;
+    }>, "many">>;
+    /** Generic type parameters */
+    generics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Decorators */
+    decorators: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Modifiers (public, private, protected, static, readonly, abstract) */
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** JSDoc documentation */
+    jsdoc: z.ZodOptional<z.ZodString>;
+    /** Parent symbol (for nested symbols) */
+    parentSymbol: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    lineStart: number;
+    lineEnd: number;
+    kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+    isExported: boolean;
+    isDefault: boolean;
+    generics: string[];
+    decorators: string[];
+    modifiers: string[];
+    parameters?: {
+        name: string;
+        optional: boolean;
+        type?: string | undefined;
+        defaultValue?: string | undefined;
+    }[] | undefined;
+    jsdoc?: string | undefined;
+    qualifiedName?: string | undefined;
+    columnStart?: number | undefined;
+    columnEnd?: number | undefined;
+    isAsync?: boolean | undefined;
+    isGenerator?: boolean | undefined;
+    signature?: string | undefined;
+    returnType?: string | undefined;
+    parentSymbol?: string | undefined;
+}, {
+    name: string;
+    lineStart: number;
+    lineEnd: number;
+    kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+    parameters?: {
+        name: string;
+        type?: string | undefined;
+        optional?: boolean | undefined;
+        defaultValue?: string | undefined;
+    }[] | undefined;
+    jsdoc?: string | undefined;
+    qualifiedName?: string | undefined;
+    columnStart?: number | undefined;
+    columnEnd?: number | undefined;
+    isExported?: boolean | undefined;
+    isDefault?: boolean | undefined;
+    isAsync?: boolean | undefined;
+    isGenerator?: boolean | undefined;
+    signature?: string | undefined;
+    returnType?: string | undefined;
+    generics?: string[] | undefined;
+    decorators?: string[] | undefined;
+    modifiers?: string[] | undefined;
+    parentSymbol?: string | undefined;
+}>;
+export type CodeSymbol = z.infer<typeof CodeSymbolSchema>;
+export declare const ImportSchema: z.ZodObject<{
+    /** Import source module */
+    source: z.ZodString;
+    /** Is external (node_modules) */
+    isExternal: z.ZodBoolean;
+    /** Is type-only import */
+    isTypeOnly: z.ZodDefault<z.ZodBoolean>;
+    /** Is namespace import (import * as X) */
+    isNamespace: z.ZodDefault<z.ZodBoolean>;
+    /** Is default import */
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    /** Imported names */
+    names: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        alias?: string | undefined;
+    }, {
+        name: string;
+        alias?: string | undefined;
+    }>, "many">;
+    /** Line number */
+    line: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    line: number;
+    isDefault: boolean;
+    isExternal: boolean;
+    isTypeOnly: boolean;
+    isNamespace: boolean;
+    names: {
+        name: string;
+        alias?: string | undefined;
+    }[];
+}, {
+    source: string;
+    line: number;
+    isExternal: boolean;
+    names: {
+        name: string;
+        alias?: string | undefined;
+    }[];
+    isDefault?: boolean | undefined;
+    isTypeOnly?: boolean | undefined;
+    isNamespace?: boolean | undefined;
+}>;
+export type Import = z.infer<typeof ImportSchema>;
+export declare const ExportSchema: z.ZodObject<{
+    /** Exported name */
+    name: z.ZodString;
+    /** Is default export */
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    /** Is type export */
+    isType: z.ZodDefault<z.ZodBoolean>;
+    /** Is re-export */
+    isReExport: z.ZodDefault<z.ZodBoolean>;
+    /** Re-export source */
+    source: z.ZodOptional<z.ZodString>;
+    /** Line number */
+    line: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    line: number;
+    name: string;
+    isDefault: boolean;
+    isType: boolean;
+    isReExport: boolean;
+    source?: string | undefined;
+}, {
+    line: number;
+    name: string;
+    source?: string | undefined;
+    isDefault?: boolean | undefined;
+    isType?: boolean | undefined;
+    isReExport?: boolean | undefined;
+}>;
+export type Export = z.infer<typeof ExportSchema>;
+export declare const CodeStructureContentSchema: z.ZodObject<{
+    /** File path */
+    filePath: z.ZodString;
+    /** Parent file_metadata item ID */
+    fileMetadataId: z.ZodString;
+    /** All symbols defined in file */
+    symbols: z.ZodArray<z.ZodObject<{
+        /** Symbol name */
+        name: z.ZodString;
+        /** Full qualified name (e.g., ClassName.methodName) */
+        qualifiedName: z.ZodOptional<z.ZodString>;
+        /** Symbol kind */
+        kind: z.ZodEnum<["class", "interface", "type", "enum", "function", "arrow_function", "const", "let", "var", "namespace", "module", "component", "hook", "method", "property", "parameter", "import", "export"]>;
+        /** Start line number (1-based) */
+        lineStart: z.ZodNumber;
+        /** End line number (1-based) */
+        lineEnd: z.ZodNumber;
+        /** Column start */
+        columnStart: z.ZodOptional<z.ZodNumber>;
+        /** Column end */
+        columnEnd: z.ZodOptional<z.ZodNumber>;
+        /** Is exported */
+        isExported: z.ZodDefault<z.ZodBoolean>;
+        /** Is default export */
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        /** Is async (for functions) */
+        isAsync: z.ZodOptional<z.ZodBoolean>;
+        /** Is generator (for functions) */
+        isGenerator: z.ZodOptional<z.ZodBoolean>;
+        /** Type signature */
+        signature: z.ZodOptional<z.ZodString>;
+        /** Return type (for functions) */
+        returnType: z.ZodOptional<z.ZodString>;
+        /** Parameters (for functions) */
+        parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodOptional<z.ZodString>;
+            optional: z.ZodDefault<z.ZodBoolean>;
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            optional: boolean;
+            type?: string | undefined;
+            defaultValue?: string | undefined;
+        }, {
+            name: string;
+            type?: string | undefined;
+            optional?: boolean | undefined;
+            defaultValue?: string | undefined;
+        }>, "many">>;
+        /** Generic type parameters */
+        generics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Decorators */
+        decorators: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Modifiers (public, private, protected, static, readonly, abstract) */
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** JSDoc documentation */
+        jsdoc: z.ZodOptional<z.ZodString>;
+        /** Parent symbol (for nested symbols) */
+        parentSymbol: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        lineStart: number;
+        lineEnd: number;
+        kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+        isExported: boolean;
+        isDefault: boolean;
+        generics: string[];
+        decorators: string[];
+        modifiers: string[];
+        parameters?: {
+            name: string;
+            optional: boolean;
+            type?: string | undefined;
+            defaultValue?: string | undefined;
+        }[] | undefined;
+        jsdoc?: string | undefined;
+        qualifiedName?: string | undefined;
+        columnStart?: number | undefined;
+        columnEnd?: number | undefined;
+        isAsync?: boolean | undefined;
+        isGenerator?: boolean | undefined;
+        signature?: string | undefined;
+        returnType?: string | undefined;
+        parentSymbol?: string | undefined;
+    }, {
+        name: string;
+        lineStart: number;
+        lineEnd: number;
+        kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+        parameters?: {
+            name: string;
+            type?: string | undefined;
+            optional?: boolean | undefined;
+            defaultValue?: string | undefined;
+        }[] | undefined;
+        jsdoc?: string | undefined;
+        qualifiedName?: string | undefined;
+        columnStart?: number | undefined;
+        columnEnd?: number | undefined;
+        isExported?: boolean | undefined;
+        isDefault?: boolean | undefined;
+        isAsync?: boolean | undefined;
+        isGenerator?: boolean | undefined;
+        signature?: string | undefined;
+        returnType?: string | undefined;
+        generics?: string[] | undefined;
+        decorators?: string[] | undefined;
+        modifiers?: string[] | undefined;
+        parentSymbol?: string | undefined;
+    }>, "many">;
+    /** Imports */
+    imports: z.ZodArray<z.ZodObject<{
+        /** Import source module */
+        source: z.ZodString;
+        /** Is external (node_modules) */
+        isExternal: z.ZodBoolean;
+        /** Is type-only import */
+        isTypeOnly: z.ZodDefault<z.ZodBoolean>;
+        /** Is namespace import (import * as X) */
+        isNamespace: z.ZodDefault<z.ZodBoolean>;
+        /** Is default import */
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        /** Imported names */
+        names: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            alias: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            alias?: string | undefined;
+        }, {
+            name: string;
+            alias?: string | undefined;
+        }>, "many">;
+        /** Line number */
+        line: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        line: number;
+        isDefault: boolean;
+        isExternal: boolean;
+        isTypeOnly: boolean;
+        isNamespace: boolean;
+        names: {
+            name: string;
+            alias?: string | undefined;
+        }[];
+    }, {
+        source: string;
+        line: number;
+        isExternal: boolean;
+        names: {
+            name: string;
+            alias?: string | undefined;
+        }[];
+        isDefault?: boolean | undefined;
+        isTypeOnly?: boolean | undefined;
+        isNamespace?: boolean | undefined;
+    }>, "many">;
+    /** Exports */
+    exports: z.ZodArray<z.ZodObject<{
+        /** Exported name */
+        name: z.ZodString;
+        /** Is default export */
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        /** Is type export */
+        isType: z.ZodDefault<z.ZodBoolean>;
+        /** Is re-export */
+        isReExport: z.ZodDefault<z.ZodBoolean>;
+        /** Re-export source */
+        source: z.ZodOptional<z.ZodString>;
+        /** Line number */
+        line: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        line: number;
+        name: string;
+        isDefault: boolean;
+        isType: boolean;
+        isReExport: boolean;
+        source?: string | undefined;
+    }, {
+        line: number;
+        name: string;
+        source?: string | undefined;
+        isDefault?: boolean | undefined;
+        isType?: boolean | undefined;
+        isReExport?: boolean | undefined;
+    }>, "many">;
+    /** Framework detected (react, next, express, etc.) */
+    framework: z.ZodOptional<z.ZodString>;
+    /** Is React component file */
+    isComponent: z.ZodDefault<z.ZodBoolean>;
+    /** Is test file */
+    isTest: z.ZodDefault<z.ZodBoolean>;
+    /** Is type definition file */
+    isTypeDefinition: z.ZodDefault<z.ZodBoolean>;
+    /** Cyclomatic complexity estimate */
+    complexity: z.ZodOptional<z.ZodNumber>;
+    /** Analysis timestamp */
+    analyzedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    filePath: string;
+    fileMetadataId: string;
+    symbols: {
+        name: string;
+        lineStart: number;
+        lineEnd: number;
+        kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+        isExported: boolean;
+        isDefault: boolean;
+        generics: string[];
+        decorators: string[];
+        modifiers: string[];
+        parameters?: {
+            name: string;
+            optional: boolean;
+            type?: string | undefined;
+            defaultValue?: string | undefined;
+        }[] | undefined;
+        jsdoc?: string | undefined;
+        qualifiedName?: string | undefined;
+        columnStart?: number | undefined;
+        columnEnd?: number | undefined;
+        isAsync?: boolean | undefined;
+        isGenerator?: boolean | undefined;
+        signature?: string | undefined;
+        returnType?: string | undefined;
+        parentSymbol?: string | undefined;
+    }[];
+    imports: {
+        source: string;
+        line: number;
+        isDefault: boolean;
+        isExternal: boolean;
+        isTypeOnly: boolean;
+        isNamespace: boolean;
+        names: {
+            name: string;
+            alias?: string | undefined;
+        }[];
+    }[];
+    exports: {
+        line: number;
+        name: string;
+        isDefault: boolean;
+        isType: boolean;
+        isReExport: boolean;
+        source?: string | undefined;
+    }[];
+    isComponent: boolean;
+    isTest: boolean;
+    isTypeDefinition: boolean;
+    analyzedAt: string;
+    framework?: string | undefined;
+    complexity?: number | undefined;
+}, {
+    filePath: string;
+    fileMetadataId: string;
+    symbols: {
+        name: string;
+        lineStart: number;
+        lineEnd: number;
+        kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+        parameters?: {
+            name: string;
+            type?: string | undefined;
+            optional?: boolean | undefined;
+            defaultValue?: string | undefined;
+        }[] | undefined;
+        jsdoc?: string | undefined;
+        qualifiedName?: string | undefined;
+        columnStart?: number | undefined;
+        columnEnd?: number | undefined;
+        isExported?: boolean | undefined;
+        isDefault?: boolean | undefined;
+        isAsync?: boolean | undefined;
+        isGenerator?: boolean | undefined;
+        signature?: string | undefined;
+        returnType?: string | undefined;
+        generics?: string[] | undefined;
+        decorators?: string[] | undefined;
+        modifiers?: string[] | undefined;
+        parentSymbol?: string | undefined;
+    }[];
+    imports: {
+        source: string;
+        line: number;
+        isExternal: boolean;
+        names: {
+            name: string;
+            alias?: string | undefined;
+        }[];
+        isDefault?: boolean | undefined;
+        isTypeOnly?: boolean | undefined;
+        isNamespace?: boolean | undefined;
+    }[];
+    exports: {
+        line: number;
+        name: string;
+        source?: string | undefined;
+        isDefault?: boolean | undefined;
+        isType?: boolean | undefined;
+        isReExport?: boolean | undefined;
+    }[];
+    analyzedAt: string;
+    framework?: string | undefined;
+    isComponent?: boolean | undefined;
+    isTest?: boolean | undefined;
+    isTypeDefinition?: boolean | undefined;
+    complexity?: number | undefined;
+}>;
+export type CodeStructureContent = z.infer<typeof CodeStructureContentSchema>;
+export declare const DependencyTypeSchema: z.ZodEnum<["import", "require", "dynamic", "type_only", "reference", "inheritance", "re_export"]>;
+export type DependencyType = z.infer<typeof DependencyTypeSchema>;
+export declare const CodeDependencyContentSchema: z.ZodObject<{
+    /** Source file path */
+    sourceFile: z.ZodString;
+    /** Source file metadata ID */
+    sourceFileId: z.ZodString;
+    /** Target file path (resolved) */
+    targetFile: z.ZodString;
+    /** Target file metadata ID (if internal) */
+    targetFileId: z.ZodOptional<z.ZodString>;
+    /** Is external dependency (node_modules) */
+    isExternal: z.ZodBoolean;
+    /** Package name (for external) */
+    packageName: z.ZodOptional<z.ZodString>;
+    /** Dependency type */
+    dependencyType: z.ZodEnum<["import", "require", "dynamic", "type_only", "reference", "inheritance", "re_export"]>;
+    /** Imported/referenced symbols */
+    symbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Line number where dependency occurs */
+    line: z.ZodNumber;
+    /** Is circular dependency */
+    isCircular: z.ZodDefault<z.ZodBoolean>;
+    /** Detection timestamp */
+    detectedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    line: number;
+    detectedAt: string;
+    isExternal: boolean;
+    symbols: string[];
+    sourceFile: string;
+    sourceFileId: string;
+    targetFile: string;
+    dependencyType: "dynamic" | "import" | "require" | "type_only" | "reference" | "inheritance" | "re_export";
+    isCircular: boolean;
+    targetFileId?: string | undefined;
+    packageName?: string | undefined;
+}, {
+    line: number;
+    detectedAt: string;
+    isExternal: boolean;
+    sourceFile: string;
+    sourceFileId: string;
+    targetFile: string;
+    dependencyType: "dynamic" | "import" | "require" | "type_only" | "reference" | "inheritance" | "re_export";
+    symbols?: string[] | undefined;
+    targetFileId?: string | undefined;
+    packageName?: string | undefined;
+    isCircular?: boolean | undefined;
+}>;
+export type CodeDependencyContent = z.infer<typeof CodeDependencyContentSchema>;
+export declare const DocumentationSourceSchema: z.ZodEnum<["jsdoc", "tsdoc", "inline_comment", "block_comment", "readme", "markdown"]>;
+export type DocumentationSource = z.infer<typeof DocumentationSourceSchema>;
+export declare const CodeDocumentationContentSchema: z.ZodObject<{
+    /** File path */
+    filePath: z.ZodString;
+    /** Symbol name (if for specific symbol) */
+    symbolName: z.ZodOptional<z.ZodString>;
+    /** Documentation source type */
+    source: z.ZodEnum<["jsdoc", "tsdoc", "inline_comment", "block_comment", "readme", "markdown"]>;
+    /** Raw documentation text */
+    content: z.ZodString;
+    /** @param tags */
+    params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        optional: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        name: string;
+        optional: boolean;
+        type?: string | undefined;
+    }, {
+        description: string;
+        name: string;
+        type?: string | undefined;
+        optional?: boolean | undefined;
+    }>, "many">>;
+    /** @returns description */
+    returns: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        type?: string | undefined;
+    }, {
+        description: string;
+        type?: string | undefined;
+    }>>;
+    /** @throws tags */
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        type?: string | undefined;
+    }, {
+        description: string;
+        type?: string | undefined;
+    }>, "many">>;
+    /** @example code blocks */
+    examples: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Tags (@deprecated, @internal, @beta, etc.) */
+    tags: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        value?: string | undefined;
+    }, {
+        name: string;
+        value?: string | undefined;
+    }>, "many">>;
+    /** @see references */
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Extracted timestamp */
+    extractedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: "jsdoc" | "readme" | "markdown" | "tsdoc" | "inline_comment" | "block_comment";
+    params: {
+        description: string;
+        name: string;
+        optional: boolean;
+        type?: string | undefined;
+    }[];
+    filePath: string;
+    content: string;
+    tags: {
+        name: string;
+        value?: string | undefined;
+    }[];
+    throws: {
+        description: string;
+        type?: string | undefined;
+    }[];
+    examples: string[];
+    seeAlso: string[];
+    extractedAt: string;
+    symbolName?: string | undefined;
+    returns?: {
+        description: string;
+        type?: string | undefined;
+    } | undefined;
+}, {
+    source: "jsdoc" | "readme" | "markdown" | "tsdoc" | "inline_comment" | "block_comment";
+    filePath: string;
+    content: string;
+    extractedAt: string;
+    params?: {
+        description: string;
+        name: string;
+        type?: string | undefined;
+        optional?: boolean | undefined;
+    }[] | undefined;
+    tags?: {
+        name: string;
+        value?: string | undefined;
+    }[] | undefined;
+    symbolName?: string | undefined;
+    returns?: {
+        description: string;
+        type?: string | undefined;
+    } | undefined;
+    throws?: {
+        description: string;
+        type?: string | undefined;
+    }[] | undefined;
+    examples?: string[] | undefined;
+    seeAlso?: string[] | undefined;
+}>;
+export type CodeDocumentationContent = z.infer<typeof CodeDocumentationContentSchema>;
+export declare const AnalysisTypeSchema: z.ZodEnum<["security", "performance", "quality", "complexity", "maintainability", "documentation", "test_coverage", "accessibility", "best_practices"]>;
+export type AnalysisType = z.infer<typeof AnalysisTypeSchema>;
+export declare const AnalysisFindingSchema: z.ZodObject<{
+    /** Finding ID */
+    id: z.ZodString;
+    /** Severity */
+    severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+    /** Category */
+    category: z.ZodString;
+    /** Finding message */
+    message: z.ZodString;
+    /** Line number */
+    line: z.ZodOptional<z.ZodNumber>;
+    /** Code snippet */
+    snippet: z.ZodOptional<z.ZodString>;
+    /** Suggested fix */
+    suggestion: z.ZodOptional<z.ZodString>;
+    /** Fix code */
+    fixCode: z.ZodOptional<z.ZodString>;
+    /** Confidence score (0-1) */
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    severity: "critical" | "high" | "medium" | "low" | "info";
+    id: string;
+    category: string;
+    line?: number | undefined;
+    suggestion?: string | undefined;
+    confidence?: number | undefined;
+    snippet?: string | undefined;
+    fixCode?: string | undefined;
+}, {
+    message: string;
+    severity: "critical" | "high" | "medium" | "low" | "info";
+    id: string;
+    category: string;
+    line?: number | undefined;
+    suggestion?: string | undefined;
+    confidence?: number | undefined;
+    snippet?: string | undefined;
+    fixCode?: string | undefined;
+}>;
+export type AnalysisFinding = z.infer<typeof AnalysisFindingSchema>;
+export declare const CodeAnalysisContentSchema: z.ZodObject<{
+    /** File path */
+    filePath: z.ZodString;
+    /** File metadata ID */
+    fileMetadataId: z.ZodString;
+    /** Analysis type */
+    analysisType: z.ZodEnum<["security", "performance", "quality", "complexity", "maintainability", "documentation", "test_coverage", "accessibility", "best_practices"]>;
+    /** Expert that performed analysis */
+    expertId: z.ZodString;
+    /** Findings */
+    findings: z.ZodArray<z.ZodObject<{
+        /** Finding ID */
+        id: z.ZodString;
+        /** Severity */
+        severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+        /** Category */
+        category: z.ZodString;
+        /** Finding message */
+        message: z.ZodString;
+        /** Line number */
+        line: z.ZodOptional<z.ZodNumber>;
+        /** Code snippet */
+        snippet: z.ZodOptional<z.ZodString>;
+        /** Suggested fix */
+        suggestion: z.ZodOptional<z.ZodString>;
+        /** Fix code */
+        fixCode: z.ZodOptional<z.ZodString>;
+        /** Confidence score (0-1) */
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        severity: "critical" | "high" | "medium" | "low" | "info";
+        id: string;
+        category: string;
+        line?: number | undefined;
+        suggestion?: string | undefined;
+        confidence?: number | undefined;
+        snippet?: string | undefined;
+        fixCode?: string | undefined;
+    }, {
+        message: string;
+        severity: "critical" | "high" | "medium" | "low" | "info";
+        id: string;
+        category: string;
+        line?: number | undefined;
+        suggestion?: string | undefined;
+        confidence?: number | undefined;
+        snippet?: string | undefined;
+        fixCode?: string | undefined;
+    }>, "many">;
+    /** Overall score (0-1) */
+    score: z.ZodOptional<z.ZodNumber>;
+    /** Metrics */
+    metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    /** Analysis timestamp */
+    analyzedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    filePath: string;
+    expertId: string;
+    fileMetadataId: string;
+    analyzedAt: string;
+    analysisType: "documentation" | "performance" | "security" | "test_coverage" | "accessibility" | "complexity" | "quality" | "maintainability" | "best_practices";
+    findings: {
+        message: string;
+        severity: "critical" | "high" | "medium" | "low" | "info";
+        id: string;
+        category: string;
+        line?: number | undefined;
+        suggestion?: string | undefined;
+        confidence?: number | undefined;
+        snippet?: string | undefined;
+        fixCode?: string | undefined;
+    }[];
+    metrics?: Record<string, number> | undefined;
+    score?: number | undefined;
+}, {
+    filePath: string;
+    expertId: string;
+    fileMetadataId: string;
+    analyzedAt: string;
+    analysisType: "documentation" | "performance" | "security" | "test_coverage" | "accessibility" | "complexity" | "quality" | "maintainability" | "best_practices";
+    findings: {
+        message: string;
+        severity: "critical" | "high" | "medium" | "low" | "info";
+        id: string;
+        category: string;
+        line?: number | undefined;
+        suggestion?: string | undefined;
+        confidence?: number | undefined;
+        snippet?: string | undefined;
+        fixCode?: string | undefined;
+    }[];
+    metrics?: Record<string, number> | undefined;
+    score?: number | undefined;
+}>;
+export type CodeAnalysisContent = z.infer<typeof CodeAnalysisContentSchema>;
+export declare const CrossProjectRefTypeSchema: z.ZodEnum<["similar_pattern", "shared_dependency", "shared_concept", "api_usage", "design_pattern", "anti_pattern", "best_practice", "duplicate_code"]>;
+export type CrossProjectRefType = z.infer<typeof CrossProjectRefTypeSchema>;
+export declare const CrossProjectRefContentSchema: z.ZodObject<{
+    /** Source project system ID */
+    sourceProject: z.ZodString;
+    /** Source file path */
+    sourceFile: z.ZodString;
+    /** Source symbol */
+    sourceSymbol: z.ZodOptional<z.ZodString>;
+    /** Target project system ID */
+    targetProject: z.ZodString;
+    /** Target file path */
+    targetFile: z.ZodOptional<z.ZodString>;
+    /** Target symbol */
+    targetSymbol: z.ZodOptional<z.ZodString>;
+    /** Reference type */
+    referenceType: z.ZodEnum<["similar_pattern", "shared_dependency", "shared_concept", "api_usage", "design_pattern", "anti_pattern", "best_practice", "duplicate_code"]>;
+    /** Similarity score (0-1) */
+    similarity: z.ZodNumber;
+    /** Description */
+    description: z.ZodString;
+    /** Is bidirectional */
+    bidirectional: z.ZodDefault<z.ZodBoolean>;
+    /** Detected timestamp */
+    detectedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    detectedAt: string;
+    similarity: number;
+    sourceFile: string;
+    sourceProject: string;
+    targetProject: string;
+    referenceType: "similar_pattern" | "shared_dependency" | "shared_concept" | "api_usage" | "design_pattern" | "anti_pattern" | "best_practice" | "duplicate_code";
+    bidirectional: boolean;
+    targetFile?: string | undefined;
+    sourceSymbol?: string | undefined;
+    targetSymbol?: string | undefined;
+}, {
+    description: string;
+    detectedAt: string;
+    similarity: number;
+    sourceFile: string;
+    sourceProject: string;
+    targetProject: string;
+    referenceType: "similar_pattern" | "shared_dependency" | "shared_concept" | "api_usage" | "design_pattern" | "anti_pattern" | "best_practice" | "duplicate_code";
+    targetFile?: string | undefined;
+    sourceSymbol?: string | undefined;
+    targetSymbol?: string | undefined;
+    bidirectional?: boolean | undefined;
+}>;
+export type CrossProjectRefContent = z.infer<typeof CrossProjectRefContentSchema>;
+export declare const IndexRunStatusSchema: z.ZodEnum<["running", "completed", "failed", "cancelled"]>;
+export type IndexRunStatus = z.infer<typeof IndexRunStatusSchema>;
+export declare const IndexRunContentSchema: z.ZodObject<{
+    /** Project ID being indexed */
+    projectId: z.ZodString;
+    /** Index run status */
+    status: z.ZodEnum<["running", "completed", "failed", "cancelled"]>;
+    /** Start timestamp */
+    startedAt: z.ZodString;
+    /** End timestamp */
+    completedAt: z.ZodOptional<z.ZodString>;
+    /** Duration in ms */
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    /** Index depth (quick, standard, thorough) */
+    depth: z.ZodEnum<["quick", "standard", "thorough"]>;
+    /** Statistics */
+    stats: z.ZodObject<{
+        filesScanned: z.ZodNumber;
+        filesIndexed: z.ZodNumber;
+        filesSkipped: z.ZodNumber;
+        filesChanged: z.ZodNumber;
+        symbolsExtracted: z.ZodNumber;
+        dependenciesFound: z.ZodNumber;
+        embeddingsGenerated: z.ZodNumber;
+        errorsEncountered: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        filesChanged: number;
+        filesScanned: number;
+        filesIndexed: number;
+        filesSkipped: number;
+        symbolsExtracted: number;
+        dependenciesFound: number;
+        embeddingsGenerated: number;
+        errorsEncountered: number;
+    }, {
+        filesChanged: number;
+        filesScanned: number;
+        filesIndexed: number;
+        filesSkipped: number;
+        symbolsExtracted: number;
+        dependenciesFound: number;
+        embeddingsGenerated: number;
+        errorsEncountered: number;
+    }>;
+    /** Errors encountered */
+    errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        error: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        file: string;
+        stack?: string | undefined;
+    }, {
+        error: string;
+        file: string;
+        stack?: string | undefined;
+    }>, "many">>;
+    /** Paths indexed */
+    paths: z.ZodArray<z.ZodString, "many">;
+    /** Exclude patterns used */
+    excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "completed" | "cancelled" | "running";
+    startedAt: string;
+    stats: {
+        filesChanged: number;
+        filesScanned: number;
+        filesIndexed: number;
+        filesSkipped: number;
+        symbolsExtracted: number;
+        dependenciesFound: number;
+        embeddingsGenerated: number;
+        errorsEncountered: number;
+    };
+    errors: {
+        error: string;
+        file: string;
+        stack?: string | undefined;
+    }[];
+    paths: string[];
+    depth: "quick" | "standard" | "thorough";
+    projectId: string;
+    excludePatterns: string[];
+    completedAt?: string | undefined;
+    durationMs?: number | undefined;
+}, {
+    status: "failed" | "completed" | "cancelled" | "running";
+    startedAt: string;
+    stats: {
+        filesChanged: number;
+        filesScanned: number;
+        filesIndexed: number;
+        filesSkipped: number;
+        symbolsExtracted: number;
+        dependenciesFound: number;
+        embeddingsGenerated: number;
+        errorsEncountered: number;
+    };
+    paths: string[];
+    depth: "quick" | "standard" | "thorough";
+    projectId: string;
+    completedAt?: string | undefined;
+    durationMs?: number | undefined;
+    errors?: {
+        error: string;
+        file: string;
+        stack?: string | undefined;
+    }[] | undefined;
+    excludePatterns?: string[] | undefined;
+}>;
+export type IndexRunContent = z.infer<typeof IndexRunContentSchema>;
+export declare const CodeWikiItemTypeSchema: z.ZodEnum<["file_metadata", "code_structure", "code_dependency", "code_documentation", "code_analysis", "cross_project_ref", "index_run"]>;
+export type CodeWikiItemType = z.infer<typeof CodeWikiItemTypeSchema>;
+/**
+ * Create file metadata content
+ */
+export declare function createFileMetadata(filePath: string, options: Partial<FileMetadataContent>): FileMetadataContent;
+/**
+ * Create code structure content
+ */
+export declare function createCodeStructure(filePath: string, fileMetadataId: string, options?: Partial<Omit<CodeStructureContent, 'filePath' | 'fileMetadataId' | 'analyzedAt'>>): CodeStructureContent;
+/**
+ * Create code dependency content
+ */
+export declare function createCodeDependency(sourceFile: string, targetFile: string, options: Partial<Omit<CodeDependencyContent, 'sourceFile' | 'targetFile' | 'detectedAt'>>): CodeDependencyContent;
+/**
+ * Create index run content
+ */
+export declare function createIndexRun(projectId: string, paths: string[], depth?: IndexRunContent['depth']): IndexRunContent;
+/**
+ * Detect language from file extension
+ */
+export declare function detectLanguage(extension: string): Language;
+/**
+ * Detect if file is a test file
+ */
+export declare function isTestFile(filePath: string): boolean;
+/**
+ * Detect if file is a type definition
+ */
+export declare function isTypeDefinitionFile(filePath: string): boolean;
+declare const _default: {
+    FileMetadataContentSchema: z.ZodObject<{
+        /** Absolute file path */
+        filePath: z.ZodString;
+        /** Relative path from project root */
+        relativePath: z.ZodString;
+        /** File name with extension */
+        fileName: z.ZodString;
+        /** File extension (without dot) */
+        extension: z.ZodString;
+        /** Detected programming language */
+        language: z.ZodEnum<["typescript", "javascript", "tsx", "jsx", "json", "markdown", "css", "scss", "html", "yaml", "sql", "shell", "unknown"]>;
+        /** File size in bytes */
+        size: z.ZodNumber;
+        /** Lines of code */
+        loc: z.ZodNumber;
+        /** Non-empty lines */
+        locNonEmpty: z.ZodNumber;
+        /** Comment lines */
+        locComments: z.ZodNumber;
+        /** SHA-256 content hash for change detection */
+        hash: z.ZodString;
+        /** Last modified timestamp (ISO) */
+        lastModified: z.ZodString;
+        /** Project identifier */
+        projectId: z.ZodString;
+        /** Git branch (if in repo) */
+        branch: z.ZodOptional<z.ZodString>;
+        /** Git commit hash (if in repo) */
+        commit: z.ZodOptional<z.ZodString>;
+        /** First indexed timestamp */
+        firstIndexedAt: z.ZodString;
+        /** Last indexed timestamp */
+        lastIndexedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        filePath: string;
+        language: "unknown" | "json" | "sql" | "typescript" | "javascript" | "tsx" | "jsx" | "markdown" | "css" | "scss" | "html" | "yaml" | "shell";
+        hash: string;
+        relativePath: string;
+        fileName: string;
+        extension: string;
+        size: number;
+        loc: number;
+        locNonEmpty: number;
+        locComments: number;
+        lastModified: string;
+        projectId: string;
+        firstIndexedAt: string;
+        lastIndexedAt: string;
+        branch?: string | undefined;
+        commit?: string | undefined;
+    }, {
+        filePath: string;
+        language: "unknown" | "json" | "sql" | "typescript" | "javascript" | "tsx" | "jsx" | "markdown" | "css" | "scss" | "html" | "yaml" | "shell";
+        hash: string;
+        relativePath: string;
+        fileName: string;
+        extension: string;
+        size: number;
+        loc: number;
+        locNonEmpty: number;
+        locComments: number;
+        lastModified: string;
+        projectId: string;
+        firstIndexedAt: string;
+        lastIndexedAt: string;
+        branch?: string | undefined;
+        commit?: string | undefined;
+    }>;
+    CodeStructureContentSchema: z.ZodObject<{
+        /** File path */
+        filePath: z.ZodString;
+        /** Parent file_metadata item ID */
+        fileMetadataId: z.ZodString;
+        /** All symbols defined in file */
+        symbols: z.ZodArray<z.ZodObject<{
+            /** Symbol name */
+            name: z.ZodString;
+            /** Full qualified name (e.g., ClassName.methodName) */
+            qualifiedName: z.ZodOptional<z.ZodString>;
+            /** Symbol kind */
+            kind: z.ZodEnum<["class", "interface", "type", "enum", "function", "arrow_function", "const", "let", "var", "namespace", "module", "component", "hook", "method", "property", "parameter", "import", "export"]>;
+            /** Start line number (1-based) */
+            lineStart: z.ZodNumber;
+            /** End line number (1-based) */
+            lineEnd: z.ZodNumber;
+            /** Column start */
+            columnStart: z.ZodOptional<z.ZodNumber>;
+            /** Column end */
+            columnEnd: z.ZodOptional<z.ZodNumber>;
+            /** Is exported */
+            isExported: z.ZodDefault<z.ZodBoolean>;
+            /** Is default export */
+            isDefault: z.ZodDefault<z.ZodBoolean>;
+            /** Is async (for functions) */
+            isAsync: z.ZodOptional<z.ZodBoolean>;
+            /** Is generator (for functions) */
+            isGenerator: z.ZodOptional<z.ZodBoolean>;
+            /** Type signature */
+            signature: z.ZodOptional<z.ZodString>;
+            /** Return type (for functions) */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Parameters (for functions) */
+            parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodOptional<z.ZodString>;
+                optional: z.ZodDefault<z.ZodBoolean>;
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                optional: boolean;
+                type?: string | undefined;
+                defaultValue?: string | undefined;
+            }, {
+                name: string;
+                type?: string | undefined;
+                optional?: boolean | undefined;
+                defaultValue?: string | undefined;
+            }>, "many">>;
+            /** Generic type parameters */
+            generics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /** Decorators */
+            decorators: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /** Modifiers (public, private, protected, static, readonly, abstract) */
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /** JSDoc documentation */
+            jsdoc: z.ZodOptional<z.ZodString>;
+            /** Parent symbol (for nested symbols) */
+            parentSymbol: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            lineStart: number;
+            lineEnd: number;
+            kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+            isExported: boolean;
+            isDefault: boolean;
+            generics: string[];
+            decorators: string[];
+            modifiers: string[];
+            parameters?: {
+                name: string;
+                optional: boolean;
+                type?: string | undefined;
+                defaultValue?: string | undefined;
+            }[] | undefined;
+            jsdoc?: string | undefined;
+            qualifiedName?: string | undefined;
+            columnStart?: number | undefined;
+            columnEnd?: number | undefined;
+            isAsync?: boolean | undefined;
+            isGenerator?: boolean | undefined;
+            signature?: string | undefined;
+            returnType?: string | undefined;
+            parentSymbol?: string | undefined;
+        }, {
+            name: string;
+            lineStart: number;
+            lineEnd: number;
+            kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+            parameters?: {
+                name: string;
+                type?: string | undefined;
+                optional?: boolean | undefined;
+                defaultValue?: string | undefined;
+            }[] | undefined;
+            jsdoc?: string | undefined;
+            qualifiedName?: string | undefined;
+            columnStart?: number | undefined;
+            columnEnd?: number | undefined;
+            isExported?: boolean | undefined;
+            isDefault?: boolean | undefined;
+            isAsync?: boolean | undefined;
+            isGenerator?: boolean | undefined;
+            signature?: string | undefined;
+            returnType?: string | undefined;
+            generics?: string[] | undefined;
+            decorators?: string[] | undefined;
+            modifiers?: string[] | undefined;
+            parentSymbol?: string | undefined;
+        }>, "many">;
+        /** Imports */
+        imports: z.ZodArray<z.ZodObject<{
+            /** Import source module */
+            source: z.ZodString;
+            /** Is external (node_modules) */
+            isExternal: z.ZodBoolean;
+            /** Is type-only import */
+            isTypeOnly: z.ZodDefault<z.ZodBoolean>;
+            /** Is namespace import (import * as X) */
+            isNamespace: z.ZodDefault<z.ZodBoolean>;
+            /** Is default import */
+            isDefault: z.ZodDefault<z.ZodBoolean>;
+            /** Imported names */
+            names: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                alias: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                alias?: string | undefined;
+            }, {
+                name: string;
+                alias?: string | undefined;
+            }>, "many">;
+            /** Line number */
+            line: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            source: string;
+            line: number;
+            isDefault: boolean;
+            isExternal: boolean;
+            isTypeOnly: boolean;
+            isNamespace: boolean;
+            names: {
+                name: string;
+                alias?: string | undefined;
+            }[];
+        }, {
+            source: string;
+            line: number;
+            isExternal: boolean;
+            names: {
+                name: string;
+                alias?: string | undefined;
+            }[];
+            isDefault?: boolean | undefined;
+            isTypeOnly?: boolean | undefined;
+            isNamespace?: boolean | undefined;
+        }>, "many">;
+        /** Exports */
+        exports: z.ZodArray<z.ZodObject<{
+            /** Exported name */
+            name: z.ZodString;
+            /** Is default export */
+            isDefault: z.ZodDefault<z.ZodBoolean>;
+            /** Is type export */
+            isType: z.ZodDefault<z.ZodBoolean>;
+            /** Is re-export */
+            isReExport: z.ZodDefault<z.ZodBoolean>;
+            /** Re-export source */
+            source: z.ZodOptional<z.ZodString>;
+            /** Line number */
+            line: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            line: number;
+            name: string;
+            isDefault: boolean;
+            isType: boolean;
+            isReExport: boolean;
+            source?: string | undefined;
+        }, {
+            line: number;
+            name: string;
+            source?: string | undefined;
+            isDefault?: boolean | undefined;
+            isType?: boolean | undefined;
+            isReExport?: boolean | undefined;
+        }>, "many">;
+        /** Framework detected (react, next, express, etc.) */
+        framework: z.ZodOptional<z.ZodString>;
+        /** Is React component file */
+        isComponent: z.ZodDefault<z.ZodBoolean>;
+        /** Is test file */
+        isTest: z.ZodDefault<z.ZodBoolean>;
+        /** Is type definition file */
+        isTypeDefinition: z.ZodDefault<z.ZodBoolean>;
+        /** Cyclomatic complexity estimate */
+        complexity: z.ZodOptional<z.ZodNumber>;
+        /** Analysis timestamp */
+        analyzedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        filePath: string;
+        fileMetadataId: string;
+        symbols: {
+            name: string;
+            lineStart: number;
+            lineEnd: number;
+            kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+            isExported: boolean;
+            isDefault: boolean;
+            generics: string[];
+            decorators: string[];
+            modifiers: string[];
+            parameters?: {
+                name: string;
+                optional: boolean;
+                type?: string | undefined;
+                defaultValue?: string | undefined;
+            }[] | undefined;
+            jsdoc?: string | undefined;
+            qualifiedName?: string | undefined;
+            columnStart?: number | undefined;
+            columnEnd?: number | undefined;
+            isAsync?: boolean | undefined;
+            isGenerator?: boolean | undefined;
+            signature?: string | undefined;
+            returnType?: string | undefined;
+            parentSymbol?: string | undefined;
+        }[];
+        imports: {
+            source: string;
+            line: number;
+            isDefault: boolean;
+            isExternal: boolean;
+            isTypeOnly: boolean;
+            isNamespace: boolean;
+            names: {
+                name: string;
+                alias?: string | undefined;
+            }[];
+        }[];
+        exports: {
+            line: number;
+            name: string;
+            isDefault: boolean;
+            isType: boolean;
+            isReExport: boolean;
+            source?: string | undefined;
+        }[];
+        isComponent: boolean;
+        isTest: boolean;
+        isTypeDefinition: boolean;
+        analyzedAt: string;
+        framework?: string | undefined;
+        complexity?: number | undefined;
+    }, {
+        filePath: string;
+        fileMetadataId: string;
+        symbols: {
+            name: string;
+            lineStart: number;
+            lineEnd: number;
+            kind: "function" | "type" | "module" | "method" | "component" | "hook" | "export" | "import" | "interface" | "namespace" | "class" | "enum" | "arrow_function" | "const" | "let" | "var" | "property" | "parameter";
+            parameters?: {
+                name: string;
+                type?: string | undefined;
+                optional?: boolean | undefined;
+                defaultValue?: string | undefined;
+            }[] | undefined;
+            jsdoc?: string | undefined;
+            qualifiedName?: string | undefined;
+            columnStart?: number | undefined;
+            columnEnd?: number | undefined;
+            isExported?: boolean | undefined;
+            isDefault?: boolean | undefined;
+            isAsync?: boolean | undefined;
+            isGenerator?: boolean | undefined;
+            signature?: string | undefined;
+            returnType?: string | undefined;
+            generics?: string[] | undefined;
+            decorators?: string[] | undefined;
+            modifiers?: string[] | undefined;
+            parentSymbol?: string | undefined;
+        }[];
+        imports: {
+            source: string;
+            line: number;
+            isExternal: boolean;
+            names: {
+                name: string;
+                alias?: string | undefined;
+            }[];
+            isDefault?: boolean | undefined;
+            isTypeOnly?: boolean | undefined;
+            isNamespace?: boolean | undefined;
+        }[];
+        exports: {
+            line: number;
+            name: string;
+            source?: string | undefined;
+            isDefault?: boolean | undefined;
+            isType?: boolean | undefined;
+            isReExport?: boolean | undefined;
+        }[];
+        analyzedAt: string;
+        framework?: string | undefined;
+        isComponent?: boolean | undefined;
+        isTest?: boolean | undefined;
+        isTypeDefinition?: boolean | undefined;
+        complexity?: number | undefined;
+    }>;
+    CodeDependencyContentSchema: z.ZodObject<{
+        /** Source file path */
+        sourceFile: z.ZodString;
+        /** Source file metadata ID */
+        sourceFileId: z.ZodString;
+        /** Target file path (resolved) */
+        targetFile: z.ZodString;
+        /** Target file metadata ID (if internal) */
+        targetFileId: z.ZodOptional<z.ZodString>;
+        /** Is external dependency (node_modules) */
+        isExternal: z.ZodBoolean;
+        /** Package name (for external) */
+        packageName: z.ZodOptional<z.ZodString>;
+        /** Dependency type */
+        dependencyType: z.ZodEnum<["import", "require", "dynamic", "type_only", "reference", "inheritance", "re_export"]>;
+        /** Imported/referenced symbols */
+        symbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Line number where dependency occurs */
+        line: z.ZodNumber;
+        /** Is circular dependency */
+        isCircular: z.ZodDefault<z.ZodBoolean>;
+        /** Detection timestamp */
+        detectedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        line: number;
+        detectedAt: string;
+        isExternal: boolean;
+        symbols: string[];
+        sourceFile: string;
+        sourceFileId: string;
+        targetFile: string;
+        dependencyType: "dynamic" | "import" | "require" | "type_only" | "reference" | "inheritance" | "re_export";
+        isCircular: boolean;
+        targetFileId?: string | undefined;
+        packageName?: string | undefined;
+    }, {
+        line: number;
+        detectedAt: string;
+        isExternal: boolean;
+        sourceFile: string;
+        sourceFileId: string;
+        targetFile: string;
+        dependencyType: "dynamic" | "import" | "require" | "type_only" | "reference" | "inheritance" | "re_export";
+        symbols?: string[] | undefined;
+        targetFileId?: string | undefined;
+        packageName?: string | undefined;
+        isCircular?: boolean | undefined;
+    }>;
+    CodeDocumentationContentSchema: z.ZodObject<{
+        /** File path */
+        filePath: z.ZodString;
+        /** Symbol name (if for specific symbol) */
+        symbolName: z.ZodOptional<z.ZodString>;
+        /** Documentation source type */
+        source: z.ZodEnum<["jsdoc", "tsdoc", "inline_comment", "block_comment", "readme", "markdown"]>;
+        /** Raw documentation text */
+        content: z.ZodString;
+        /** @param tags */
+        params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+            optional: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            name: string;
+            optional: boolean;
+            type?: string | undefined;
+        }, {
+            description: string;
+            name: string;
+            type?: string | undefined;
+            optional?: boolean | undefined;
+        }>, "many">>;
+        /** @returns description */
+        returns: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            type?: string | undefined;
+        }, {
+            description: string;
+            type?: string | undefined;
+        }>>;
+        /** @throws tags */
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            type?: string | undefined;
+        }, {
+            description: string;
+            type?: string | undefined;
+        }>, "many">>;
+        /** @example code blocks */
+        examples: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Tags (@deprecated, @internal, @beta, etc.) */
+        tags: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            value?: string | undefined;
+        }, {
+            name: string;
+            value?: string | undefined;
+        }>, "many">>;
+        /** @see references */
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Extracted timestamp */
+        extractedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: "jsdoc" | "readme" | "markdown" | "tsdoc" | "inline_comment" | "block_comment";
+        params: {
+            description: string;
+            name: string;
+            optional: boolean;
+            type?: string | undefined;
+        }[];
+        filePath: string;
+        content: string;
+        tags: {
+            name: string;
+            value?: string | undefined;
+        }[];
+        throws: {
+            description: string;
+            type?: string | undefined;
+        }[];
+        examples: string[];
+        seeAlso: string[];
+        extractedAt: string;
+        symbolName?: string | undefined;
+        returns?: {
+            description: string;
+            type?: string | undefined;
+        } | undefined;
+    }, {
+        source: "jsdoc" | "readme" | "markdown" | "tsdoc" | "inline_comment" | "block_comment";
+        filePath: string;
+        content: string;
+        extractedAt: string;
+        params?: {
+            description: string;
+            name: string;
+            type?: string | undefined;
+            optional?: boolean | undefined;
+        }[] | undefined;
+        tags?: {
+            name: string;
+            value?: string | undefined;
+        }[] | undefined;
+        symbolName?: string | undefined;
+        returns?: {
+            description: string;
+            type?: string | undefined;
+        } | undefined;
+        throws?: {
+            description: string;
+            type?: string | undefined;
+        }[] | undefined;
+        examples?: string[] | undefined;
+        seeAlso?: string[] | undefined;
+    }>;
+    CodeAnalysisContentSchema: z.ZodObject<{
+        /** File path */
+        filePath: z.ZodString;
+        /** File metadata ID */
+        fileMetadataId: z.ZodString;
+        /** Analysis type */
+        analysisType: z.ZodEnum<["security", "performance", "quality", "complexity", "maintainability", "documentation", "test_coverage", "accessibility", "best_practices"]>;
+        /** Expert that performed analysis */
+        expertId: z.ZodString;
+        /** Findings */
+        findings: z.ZodArray<z.ZodObject<{
+            /** Finding ID */
+            id: z.ZodString;
+            /** Severity */
+            severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+            /** Category */
+            category: z.ZodString;
+            /** Finding message */
+            message: z.ZodString;
+            /** Line number */
+            line: z.ZodOptional<z.ZodNumber>;
+            /** Code snippet */
+            snippet: z.ZodOptional<z.ZodString>;
+            /** Suggested fix */
+            suggestion: z.ZodOptional<z.ZodString>;
+            /** Fix code */
+            fixCode: z.ZodOptional<z.ZodString>;
+            /** Confidence score (0-1) */
+            confidence: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            severity: "critical" | "high" | "medium" | "low" | "info";
+            id: string;
+            category: string;
+            line?: number | undefined;
+            suggestion?: string | undefined;
+            confidence?: number | undefined;
+            snippet?: string | undefined;
+            fixCode?: string | undefined;
+        }, {
+            message: string;
+            severity: "critical" | "high" | "medium" | "low" | "info";
+            id: string;
+            category: string;
+            line?: number | undefined;
+            suggestion?: string | undefined;
+            confidence?: number | undefined;
+            snippet?: string | undefined;
+            fixCode?: string | undefined;
+        }>, "many">;
+        /** Overall score (0-1) */
+        score: z.ZodOptional<z.ZodNumber>;
+        /** Metrics */
+        metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        /** Analysis timestamp */
+        analyzedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        filePath: string;
+        expertId: string;
+        fileMetadataId: string;
+        analyzedAt: string;
+        analysisType: "documentation" | "performance" | "security" | "test_coverage" | "accessibility" | "complexity" | "quality" | "maintainability" | "best_practices";
+        findings: {
+            message: string;
+            severity: "critical" | "high" | "medium" | "low" | "info";
+            id: string;
+            category: string;
+            line?: number | undefined;
+            suggestion?: string | undefined;
+            confidence?: number | undefined;
+            snippet?: string | undefined;
+            fixCode?: string | undefined;
+        }[];
+        metrics?: Record<string, number> | undefined;
+        score?: number | undefined;
+    }, {
+        filePath: string;
+        expertId: string;
+        fileMetadataId: string;
+        analyzedAt: string;
+        analysisType: "documentation" | "performance" | "security" | "test_coverage" | "accessibility" | "complexity" | "quality" | "maintainability" | "best_practices";
+        findings: {
+            message: string;
+            severity: "critical" | "high" | "medium" | "low" | "info";
+            id: string;
+            category: string;
+            line?: number | undefined;
+            suggestion?: string | undefined;
+            confidence?: number | undefined;
+            snippet?: string | undefined;
+            fixCode?: string | undefined;
+        }[];
+        metrics?: Record<string, number> | undefined;
+        score?: number | undefined;
+    }>;
+    CrossProjectRefContentSchema: z.ZodObject<{
+        /** Source project system ID */
+        sourceProject: z.ZodString;
+        /** Source file path */
+        sourceFile: z.ZodString;
+        /** Source symbol */
+        sourceSymbol: z.ZodOptional<z.ZodString>;
+        /** Target project system ID */
+        targetProject: z.ZodString;
+        /** Target file path */
+        targetFile: z.ZodOptional<z.ZodString>;
+        /** Target symbol */
+        targetSymbol: z.ZodOptional<z.ZodString>;
+        /** Reference type */
+        referenceType: z.ZodEnum<["similar_pattern", "shared_dependency", "shared_concept", "api_usage", "design_pattern", "anti_pattern", "best_practice", "duplicate_code"]>;
+        /** Similarity score (0-1) */
+        similarity: z.ZodNumber;
+        /** Description */
+        description: z.ZodString;
+        /** Is bidirectional */
+        bidirectional: z.ZodDefault<z.ZodBoolean>;
+        /** Detected timestamp */
+        detectedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        detectedAt: string;
+        similarity: number;
+        sourceFile: string;
+        sourceProject: string;
+        targetProject: string;
+        referenceType: "similar_pattern" | "shared_dependency" | "shared_concept" | "api_usage" | "design_pattern" | "anti_pattern" | "best_practice" | "duplicate_code";
+        bidirectional: boolean;
+        targetFile?: string | undefined;
+        sourceSymbol?: string | undefined;
+        targetSymbol?: string | undefined;
+    }, {
+        description: string;
+        detectedAt: string;
+        similarity: number;
+        sourceFile: string;
+        sourceProject: string;
+        targetProject: string;
+        referenceType: "similar_pattern" | "shared_dependency" | "shared_concept" | "api_usage" | "design_pattern" | "anti_pattern" | "best_practice" | "duplicate_code";
+        targetFile?: string | undefined;
+        sourceSymbol?: string | undefined;
+        targetSymbol?: string | undefined;
+        bidirectional?: boolean | undefined;
+    }>;
+    IndexRunContentSchema: z.ZodObject<{
+        /** Project ID being indexed */
+        projectId: z.ZodString;
+        /** Index run status */
+        status: z.ZodEnum<["running", "completed", "failed", "cancelled"]>;
+        /** Start timestamp */
+        startedAt: z.ZodString;
+        /** End timestamp */
+        completedAt: z.ZodOptional<z.ZodString>;
+        /** Duration in ms */
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        /** Index depth (quick, standard, thorough) */
+        depth: z.ZodEnum<["quick", "standard", "thorough"]>;
+        /** Statistics */
+        stats: z.ZodObject<{
+            filesScanned: z.ZodNumber;
+            filesIndexed: z.ZodNumber;
+            filesSkipped: z.ZodNumber;
+            filesChanged: z.ZodNumber;
+            symbolsExtracted: z.ZodNumber;
+            dependenciesFound: z.ZodNumber;
+            embeddingsGenerated: z.ZodNumber;
+            errorsEncountered: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            filesChanged: number;
+            filesScanned: number;
+            filesIndexed: number;
+            filesSkipped: number;
+            symbolsExtracted: number;
+            dependenciesFound: number;
+            embeddingsGenerated: number;
+            errorsEncountered: number;
+        }, {
+            filesChanged: number;
+            filesScanned: number;
+            filesIndexed: number;
+            filesSkipped: number;
+            symbolsExtracted: number;
+            dependenciesFound: number;
+            embeddingsGenerated: number;
+            errorsEncountered: number;
+        }>;
+        /** Errors encountered */
+        errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            error: z.ZodString;
+            stack: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            error: string;
+            file: string;
+            stack?: string | undefined;
+        }, {
+            error: string;
+            file: string;
+            stack?: string | undefined;
+        }>, "many">>;
+        /** Paths indexed */
+        paths: z.ZodArray<z.ZodString, "many">;
+        /** Exclude patterns used */
+        excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        status: "failed" | "completed" | "cancelled" | "running";
+        startedAt: string;
+        stats: {
+            filesChanged: number;
+            filesScanned: number;
+            filesIndexed: number;
+            filesSkipped: number;
+            symbolsExtracted: number;
+            dependenciesFound: number;
+            embeddingsGenerated: number;
+            errorsEncountered: number;
+        };
+        errors: {
+            error: string;
+            file: string;
+            stack?: string | undefined;
+        }[];
+        paths: string[];
+        depth: "quick" | "standard" | "thorough";
+        projectId: string;
+        excludePatterns: string[];
+        completedAt?: string | undefined;
+        durationMs?: number | undefined;
+    }, {
+        status: "failed" | "completed" | "cancelled" | "running";
+        startedAt: string;
+        stats: {
+            filesChanged: number;
+            filesScanned: number;
+            filesIndexed: number;
+            filesSkipped: number;
+            symbolsExtracted: number;
+            dependenciesFound: number;
+            embeddingsGenerated: number;
+            errorsEncountered: number;
+        };
+        paths: string[];
+        depth: "quick" | "standard" | "thorough";
+        projectId: string;
+        completedAt?: string | undefined;
+        durationMs?: number | undefined;
+        errors?: {
+            error: string;
+            file: string;
+            stack?: string | undefined;
+        }[] | undefined;
+        excludePatterns?: string[] | undefined;
+    }>;
+    createFileMetadata: typeof createFileMetadata;
+    createCodeStructure: typeof createCodeStructure;
+    createCodeDependency: typeof createCodeDependency;
+    createIndexRun: typeof createIndexRun;
+    detectLanguage: typeof detectLanguage;
+    isTestFile: typeof isTestFile;
+    isTypeDefinitionFile: typeof isTypeDefinitionFile;
+};
+export default _default;
+//# sourceMappingURL=codewiki-types.d.ts.map