@omiron33/omi-neuron-web 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1484 @@
+import { b as NeuronNode, c as NeuronEdge, d as NeuronNodeCreate, R as RelationshipType, E as EdgeEvidence, N as NeuronVisualNode, a as NeuronVisualEdge, e as NeuronNodeUpdate } from './edge-BzsYe2Ed.js';
+export { A as AnalysisStatus, B as BuiltInRelationshipType, k as EdgeSource, I as InferredRelationship, f as NeuronEdgeCreate, g as NeuronEdgeUpdate, i as NeuronNodeBase, j as NeuronNodeBatchCreate, h as NodeTier } from './edge-BzsYe2Ed.js';
+import { A as AnalysisRun, a as NeuronCluster, b as NeuronSettings, T as ClusterMembership, V as ClusteringAlgorithm, N as NeuronConfig, L as ListNodesParams, k as ListNodesResponse, m as GetNodeResponse, C as CreateNodesRequest, l as CreateNodesResponse, U as UpdateNodeRequest, D as DeleteNodeResponse, n as ListEdgesParams, o as ListEdgesResponse, p as CreateEdgesRequest, q as CreateEdgesResponse, r as UpdateEdgeRequest, s as DeleteEdgeResponse, G as GetGraphParams, d as GetGraphResponse, E as ExpandGraphRequest, e as ExpandGraphResponse, F as FindPathRequest, f as FindPathResponse, g as AnalysisRequest, h as AnalysisResponse, t as GetAnalysisJobResponse, u as CancelAnalysisResponse, I as GetSettingsResponse, J as UpdateSettingsRequest, K as UpdateSettingsResponse, M as ResetSettingsResponse, v as SemanticSearchRequest, x as SemanticSearchResponse, z as FindSimilarRequest, H as FindSimilarResponse, X as NeuronVisualCluster, j as GraphFilters, c as NeuronSettingsUpdate, Y as VisualizationSettings, y as SearchResult, w as SemanticSearchOptions, B as FindSimilarOptions } from './query-helpers-DvQTA2_Z.js';
+export { a1 as AnalysisJobStatus, a5 as AnalysisPipelineConfig, a0 as AnalysisRunType, ab as AnalysisSettings, O as ApiErrorResponse, ae as ApiSettings, $ as ClusteringConfig, a4 as ClusteringResult, ah as DEFAULT_ANALYSIS_SETTINGS, ag as DEFAULT_VISUALIZATION_SETTINGS, ad as DatabaseSettings, a9 as DomainConfig, a6 as EmbeddingModel, a3 as EmbeddingResult, Q as HealthCheckResponse, a2 as InferredRelationshipResult, ac as InstanceSettings, af as LoggingSettings, Z as NeuronClusterCreate, _ as NeuronClusterUpdate, a8 as NodeTypeConfig, i as PaginationMeta, P as PaginationParams, a7 as PerformanceMode, aa as RelationshipTypeConfig, R as ResetSettingsRequest, S as SelectOptions, W as WhereClause, am as buildDelete, aj as buildInsert, al as buildSelect, ak as buildUpdate, ai as buildWhereClause } from './query-helpers-DvQTA2_Z.js';
+import { z } from 'zod';
+import { D as Database, a as DatabaseConfig } from './database-B0vplyA4.js';
+export { P as PoolStats } from './database-B0vplyA4.js';
+export { Migration, MigrationRunner, MigrationStatus, migration001, migration002, migration003, migration004, migrations } from './migration/index.js';
+import * as React from 'react';
+import React__default from 'react';
+import 'pg';
+
+/**
+ * Event Types for omi-neuron-web
+ * Defines the event system for extensibility and integration
+ */
+
+/**
+ * All event types in the system
+ */
+type NeuronEventType = 'node:created' | 'node:updated' | 'node:deleted' | 'node:batch_created' | 'edge:created' | 'edge:updated' | 'edge:deleted' | 'analysis:started' | 'analysis:progress' | 'analysis:completed' | 'analysis:failed' | 'analysis:cancelled' | 'cluster:created' | 'cluster:updated' | 'cluster:membership_changed' | 'relationship:inferred' | 'relationship:rejected' | 'viz:node_focused' | 'viz:node_selected' | 'viz:node_hovered' | 'viz:path_started' | 'viz:path_completed' | 'viz:filter_applied' | 'viz:camera_changed' | 'settings:updated';
+/**
+ * Event source - where the event originated
+ */
+type EventSource = 'api' | 'ui' | 'analysis' | 'system';
+/**
+ * Base event interface
+ */
+interface NeuronEvent<T = unknown> {
+    type: NeuronEventType;
+    timestamp: Date;
+    payload: T;
+    source: EventSource;
+}
+interface NodeCreatedEventPayload {
+    node: NeuronNode;
+    source: 'manual' | 'import' | 'analysis';
+}
+interface NodeUpdatedEventPayload {
+    node: NeuronNode;
+    previousNode: NeuronNode;
+    changedFields: string[];
+}
+interface NodeDeletedEventPayload {
+    nodeId: string;
+    slug: string;
+    edgesRemoved: number;
+}
+interface NodeBatchCreatedEventPayload {
+    nodes: NeuronNode[];
+    skipped: Array<{
+        slug: string;
+        reason: string;
+    }>;
+    source: 'manual' | 'import';
+}
+interface EdgeCreatedEventPayload {
+    edge: NeuronEdge;
+    source: 'manual' | 'ai_inferred' | 'imported';
+}
+interface EdgeUpdatedEventPayload {
+    edge: NeuronEdge;
+    previousEdge: NeuronEdge;
+    changedFields: string[];
+}
+interface EdgeDeletedEventPayload {
+    edgeId: string;
+    fromNodeId: string;
+    toNodeId: string;
+}
+interface AnalysisStartedEventPayload {
+    jobId: string;
+    runType: AnalysisRun['runType'];
+    nodeCount: number;
+}
+interface AnalysisProgressEventPayload {
+    jobId: string;
+    progress: number;
+    currentStep: string;
+    nodesProcessed: number;
+    totalNodes: number;
+}
+interface AnalysisCompletedEventPayload {
+    job: AnalysisRun;
+}
+interface AnalysisFailedEventPayload {
+    jobId: string;
+    error: string;
+    partialResults?: AnalysisRun['results'];
+}
+interface AnalysisCancelledEventPayload {
+    jobId: string;
+    reason: string;
+}
+interface ClusterCreatedEventPayload {
+    cluster: NeuronCluster;
+    nodeIds: string[];
+}
+interface ClusterUpdatedEventPayload {
+    cluster: NeuronCluster;
+    previousCluster: NeuronCluster;
+}
+interface ClusterMembershipChangedEventPayload {
+    clusterId: string;
+    addedNodeIds: string[];
+    removedNodeIds: string[];
+}
+interface RelationshipInferredEventPayload {
+    edge: NeuronEdge;
+    confidence: number;
+    reasoning: string;
+}
+interface RelationshipRejectedEventPayload {
+    fromNodeId: string;
+    toNodeId: string;
+    confidence: number;
+    reason: string;
+}
+interface VizNodeFocusedEventPayload {
+    node: NeuronNode;
+    previousNode?: NeuronNode;
+    source: 'click' | 'search' | 'path' | 'api';
+}
+interface VizNodeSelectedEventPayload {
+    node: NeuronNode | null;
+    previousNode?: NeuronNode | null;
+}
+interface VizNodeHoveredEventPayload {
+    node: NeuronNode | null;
+}
+interface VizPathStartedEventPayload {
+    path: NeuronNode[];
+    label?: string;
+}
+interface VizPathCompletedEventPayload {
+    path: NeuronNode[];
+    completed: boolean;
+}
+interface VizFilterAppliedEventPayload {
+    filters: {
+        domains?: string[];
+        nodeTypes?: string[];
+        search?: string;
+    };
+    visibleNodeCount: number;
+}
+interface VizCameraChangedEventPayload {
+    position: [number, number, number];
+    target: [number, number, number];
+}
+interface SettingsUpdatedEventPayload {
+    settings: NeuronSettings;
+    previousSettings: NeuronSettings;
+    changedSections: string[];
+}
+/**
+ * Event handler type
+ */
+type EventHandler<T = unknown> = (event: NeuronEvent<T>) => void | Promise<void>;
+/**
+ * Event subscription
+ */
+interface EventSubscription {
+    unsubscribe: () => void;
+}
+/**
+ * Event filter options
+ */
+interface EventFilterOptions {
+    types?: NeuronEventType[];
+    sources?: EventSource[];
+}
+/**
+ * Event emitter interface
+ */
+interface NeuronEventEmitter {
+    emit<T>(event: NeuronEvent<T>): void;
+    subscribe<T>(type: NeuronEventType, handler: EventHandler<T>): EventSubscription;
+    subscribeAll(handler: EventHandler<unknown>): EventSubscription;
+    unsubscribeAll(): void;
+}
+
+declare const nodeTierSchema: z.ZodEnum<{
+    primary: "primary";
+    secondary: "secondary";
+    tertiary: "tertiary";
+    insight: "insight";
+}>;
+declare const nodeCreateSchema: z.ZodPipe<z.ZodObject<{
+    slug: z.ZodOptional<z.ZodString>;
+    label: z.ZodString;
+    nodeType: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tier: z.ZodOptional<z.ZodEnum<{
+        primary: "primary";
+        secondary: "secondary";
+        tertiary: "tertiary";
+        insight: "insight";
+    }>>;
+}, z.core.$strip>, z.ZodTransform<{
+    slug: string;
+    label: string;
+    nodeType?: string | undefined;
+    domain?: string | undefined;
+    summary?: string | undefined;
+    description?: string | undefined;
+    content?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    tier?: "primary" | "secondary" | "tertiary" | "insight" | undefined;
+}, {
+    label: string;
+    slug?: string | undefined;
+    nodeType?: string | undefined;
+    domain?: string | undefined;
+    summary?: string | undefined;
+    description?: string | undefined;
+    content?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    tier?: "primary" | "secondary" | "tertiary" | "insight" | undefined;
+}>>;
+declare const nodeUpdateSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    domain: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodEnum<{
+        primary: "primary";
+        secondary: "secondary";
+        tertiary: "tertiary";
+        insight: "insight";
+    }>>;
+    positionOverride: z.ZodOptional<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+}, z.core.$strip>;
+declare const nodeBatchCreateSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodPipe<z.ZodObject<{
+        slug: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+        nodeType: z.ZodOptional<z.ZodString>;
+        domain: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tier: z.ZodOptional<z.ZodEnum<{
+            primary: "primary";
+            secondary: "secondary";
+            tertiary: "tertiary";
+            insight: "insight";
+        }>>;
+    }, z.core.$strip>, z.ZodTransform<{
+        slug: string;
+        label: string;
+        nodeType?: string | undefined;
+        domain?: string | undefined;
+        summary?: string | undefined;
+        description?: string | undefined;
+        content?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        tier?: "primary" | "secondary" | "tertiary" | "insight" | undefined;
+    }, {
+        label: string;
+        slug?: string | undefined;
+        nodeType?: string | undefined;
+        domain?: string | undefined;
+        summary?: string | undefined;
+        description?: string | undefined;
+        content?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        tier?: "primary" | "secondary" | "tertiary" | "insight" | undefined;
+    }>>>;
+    options: z.ZodOptional<z.ZodObject<{
+        skipDuplicates: z.ZodOptional<z.ZodBoolean>;
+        updateOnConflict: z.ZodOptional<z.ZodBoolean>;
+        autoAnalyze: z.ZodOptional<z.ZodBoolean>;
+        analysisDepth: z.ZodOptional<z.ZodEnum<{
+            embeddings: "embeddings";
+            cluster: "cluster";
+            full: "full";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const nodeFilterSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    nodeType: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    domain: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    clusterId: z.ZodOptional<z.ZodString>;
+    analysisStatus: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        createdAt: "createdAt";
+        updatedAt: "updatedAt";
+        label: "label";
+        connectionCount: "connectionCount";
+    }>>;
+    sortOrder: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    includeEmbeddings: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    includeStats: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+type NodeCreateInput = z.infer<typeof nodeCreateSchema>;
+type NodeUpdateInput = z.infer<typeof nodeUpdateSchema>;
+type NodeBatchCreateInput = z.infer<typeof nodeBatchCreateSchema>;
+type NodeFilterInput = z.infer<typeof nodeFilterSchema>;
+
+declare const edgeEvidenceSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        text: "text";
+        url: "url";
+        citation: "citation";
+        ai_inference: "ai_inference";
+    }>;
+    content: z.ZodString;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    sourceId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const edgeCreateSchema: z.ZodObject<{
+    fromNodeId: z.ZodString;
+    toNodeId: z.ZodString;
+    relationshipType: z.ZodOptional<z.ZodString>;
+    strength: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            text: "text";
+            url: "url";
+            citation: "citation";
+            ai_inference: "ai_inference";
+        }>;
+        content: z.ZodString;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        sourceId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    bidirectional: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const edgeUpdateSchema: z.ZodObject<{
+    strength: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    relationshipType: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            text: "text";
+            url: "url";
+            citation: "citation";
+            ai_inference: "ai_inference";
+        }>;
+        content: z.ZodString;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        sourceId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const edgeFilterSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    fromNodeId: z.ZodOptional<z.ZodString>;
+    toNodeId: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    relationshipType: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    source: z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        ai_inferred: "ai_inferred";
+        imported: "imported";
+    }>>;
+    minStrength: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    minConfidence: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+type EdgeEvidenceInput = z.infer<typeof edgeEvidenceSchema>;
+type EdgeCreateInput = z.infer<typeof edgeCreateSchema>;
+type EdgeUpdateInput = z.infer<typeof edgeUpdateSchema>;
+type EdgeFilterInput = z.infer<typeof edgeFilterSchema>;
+
+declare const clusteringConfigSchema: z.ZodObject<{
+    algorithm: z.ZodEnum<{
+        kmeans: "kmeans";
+        dbscan: "dbscan";
+        hierarchical: "hierarchical";
+    }>;
+    clusterCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    minClusterSize: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    similarityThreshold: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    epsilon: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    minSamples: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const clusterCreateSchema: z.ZodObject<{
+    label: z.ZodString;
+    clusterType: z.ZodOptional<z.ZodString>;
+    centroid: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    memberCount: z.ZodOptional<z.ZodNumber>;
+    avgSimilarity: z.ZodOptional<z.ZodNumber>;
+    cohesion: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const clusterUpdateSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    clusterType: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    centroid: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodNumber>>>;
+    memberCount: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    avgSimilarity: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    cohesion: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+type ClusteringConfigInput = z.infer<typeof clusteringConfigSchema>;
+type ClusterCreateInput = z.infer<typeof clusterCreateSchema>;
+type ClusterUpdateInput = z.infer<typeof clusterUpdateSchema>;
+
+declare const analysisOptionsSchema: z.ZodObject<{
+    nodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    forceRecompute: z.ZodOptional<z.ZodBoolean>;
+    skipEmbeddings: z.ZodOptional<z.ZodBoolean>;
+    embeddingModel: z.ZodOptional<z.ZodString>;
+    skipClustering: z.ZodOptional<z.ZodBoolean>;
+    clusterCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    clusteringAlgorithm: z.ZodOptional<z.ZodEnum<{
+        kmeans: "kmeans";
+        dbscan: "dbscan";
+        hierarchical: "hierarchical";
+    }>>;
+    skipRelationships: z.ZodOptional<z.ZodBoolean>;
+    relationshipThreshold: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    maxRelationshipsPerNode: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const analysisRequestSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        embeddings: "embeddings";
+        cluster: "cluster";
+        full: "full";
+        infer_relationships: "infer_relationships";
+    }>;
+    options: z.ZodOptional<z.ZodObject<{
+        nodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        forceRecompute: z.ZodOptional<z.ZodBoolean>;
+        skipEmbeddings: z.ZodOptional<z.ZodBoolean>;
+        embeddingModel: z.ZodOptional<z.ZodString>;
+        skipClustering: z.ZodOptional<z.ZodBoolean>;
+        clusterCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        clusteringAlgorithm: z.ZodOptional<z.ZodEnum<{
+            kmeans: "kmeans";
+            dbscan: "dbscan";
+            hierarchical: "hierarchical";
+        }>>;
+        skipRelationships: z.ZodOptional<z.ZodBoolean>;
+        relationshipThreshold: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        maxRelationshipsPerNode: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type AnalysisOptionsInput = z.infer<typeof analysisOptionsSchema>;
+type AnalysisRequestInput = z.infer<typeof analysisRequestSchema>;
+
+declare const nodeTypeConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    defaultDomain: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    analysisPrompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const domainConfigSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    color: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const relationshipTypeConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    bidirectional: z.ZodBoolean;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const visualizationSettingsSchema: z.ZodObject<{
+    domainColors: z.ZodRecord<z.ZodString, z.ZodString>;
+    defaultDomainColor: z.ZodString;
+    edgeColor: z.ZodString;
+    edgeActiveColor: z.ZodString;
+    backgroundColor: z.ZodString;
+    defaultCameraPosition: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    defaultCameraTarget: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    minZoomDistance: z.ZodNumber;
+    maxZoomDistance: z.ZodNumber;
+    enableStarfield: z.ZodBoolean;
+    starfieldCount: z.ZodNumber;
+    labelDistance: z.ZodNumber;
+    maxVisibleLabels: z.ZodNumber;
+    performanceMode: z.ZodEnum<{
+        auto: "auto";
+        normal: "normal";
+        degraded: "degraded";
+        fallback: "fallback";
+    }>;
+    nodeCountThreshold: z.ZodNumber;
+    pixelRatioCap: z.ZodNumber;
+    enableAnimations: z.ZodBoolean;
+    focusTweenDuration: z.ZodNumber;
+    filterTransitionDuration: z.ZodNumber;
+    enableHover: z.ZodBoolean;
+    enableClick: z.ZodBoolean;
+    enableDoubleClick: z.ZodBoolean;
+    enablePan: z.ZodBoolean;
+    enableZoom: z.ZodBoolean;
+    enableRotate: z.ZodBoolean;
+}, z.core.$strip>;
+declare const analysisSettingsSchema: z.ZodObject<{
+    embeddingModel: z.ZodEnum<{
+        "text-embedding-ada-002": "text-embedding-ada-002";
+        "text-embedding-3-small": "text-embedding-3-small";
+        "text-embedding-3-large": "text-embedding-3-large";
+    }>;
+    embeddingDimensions: z.ZodNumber;
+    embeddingBatchSize: z.ZodNumber;
+    embeddingCacheTTL: z.ZodNumber;
+    clusteringAlgorithm: z.ZodEnum<{
+        kmeans: "kmeans";
+        dbscan: "dbscan";
+        hierarchical: "hierarchical";
+    }>;
+    defaultClusterCount: z.ZodNumber;
+    minClusterSize: z.ZodNumber;
+    clusterSimilarityThreshold: z.ZodNumber;
+    relationshipInferenceModel: z.ZodString;
+    relationshipMinConfidence: z.ZodNumber;
+    relationshipMaxPerNode: z.ZodNumber;
+    openaiRateLimit: z.ZodNumber;
+    maxConcurrentAnalysis: z.ZodNumber;
+}, z.core.$strip>;
+declare const databaseSettingsSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        docker: "docker";
+        external: "external";
+    }>;
+    port: z.ZodNumber;
+    containerName: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    pool: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        idleTimeoutMs: z.ZodNumber;
+        connectionTimeoutMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    resources: z.ZodOptional<z.ZodObject<{
+        memoryLimit: z.ZodString;
+        cpuLimit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const neuronSettingsSchema: z.ZodObject<{
+    instance: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        repoName: z.ZodString;
+    }, z.core.$strip>;
+    visualization: z.ZodObject<{
+        domainColors: z.ZodRecord<z.ZodString, z.ZodString>;
+        defaultDomainColor: z.ZodString;
+        edgeColor: z.ZodString;
+        edgeActiveColor: z.ZodString;
+        backgroundColor: z.ZodString;
+        defaultCameraPosition: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        defaultCameraTarget: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        minZoomDistance: z.ZodNumber;
+        maxZoomDistance: z.ZodNumber;
+        enableStarfield: z.ZodBoolean;
+        starfieldCount: z.ZodNumber;
+        labelDistance: z.ZodNumber;
+        maxVisibleLabels: z.ZodNumber;
+        performanceMode: z.ZodEnum<{
+            auto: "auto";
+            normal: "normal";
+            degraded: "degraded";
+            fallback: "fallback";
+        }>;
+        nodeCountThreshold: z.ZodNumber;
+        pixelRatioCap: z.ZodNumber;
+        enableAnimations: z.ZodBoolean;
+        focusTweenDuration: z.ZodNumber;
+        filterTransitionDuration: z.ZodNumber;
+        enableHover: z.ZodBoolean;
+        enableClick: z.ZodBoolean;
+        enableDoubleClick: z.ZodBoolean;
+        enablePan: z.ZodBoolean;
+        enableZoom: z.ZodBoolean;
+        enableRotate: z.ZodBoolean;
+    }, z.core.$strip>;
+    analysis: z.ZodObject<{
+        embeddingModel: z.ZodEnum<{
+            "text-embedding-ada-002": "text-embedding-ada-002";
+            "text-embedding-3-small": "text-embedding-3-small";
+            "text-embedding-3-large": "text-embedding-3-large";
+        }>;
+        embeddingDimensions: z.ZodNumber;
+        embeddingBatchSize: z.ZodNumber;
+        embeddingCacheTTL: z.ZodNumber;
+        clusteringAlgorithm: z.ZodEnum<{
+            kmeans: "kmeans";
+            dbscan: "dbscan";
+            hierarchical: "hierarchical";
+        }>;
+        defaultClusterCount: z.ZodNumber;
+        minClusterSize: z.ZodNumber;
+        clusterSimilarityThreshold: z.ZodNumber;
+        relationshipInferenceModel: z.ZodString;
+        relationshipMinConfidence: z.ZodNumber;
+        relationshipMaxPerNode: z.ZodNumber;
+        openaiRateLimit: z.ZodNumber;
+        maxConcurrentAnalysis: z.ZodNumber;
+    }, z.core.$strip>;
+    nodeTypes: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        defaultDomain: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        analysisPrompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    domains: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    relationshipTypes: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        bidirectional: z.ZodBoolean;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const neuronSettingsUpdateSchema: z.ZodObject<{
+    visualization: z.ZodOptional<z.ZodObject<{
+        domainColors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        defaultDomainColor: z.ZodOptional<z.ZodString>;
+        edgeColor: z.ZodOptional<z.ZodString>;
+        edgeActiveColor: z.ZodOptional<z.ZodString>;
+        backgroundColor: z.ZodOptional<z.ZodString>;
+        defaultCameraPosition: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        defaultCameraTarget: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        minZoomDistance: z.ZodOptional<z.ZodNumber>;
+        maxZoomDistance: z.ZodOptional<z.ZodNumber>;
+        enableStarfield: z.ZodOptional<z.ZodBoolean>;
+        starfieldCount: z.ZodOptional<z.ZodNumber>;
+        labelDistance: z.ZodOptional<z.ZodNumber>;
+        maxVisibleLabels: z.ZodOptional<z.ZodNumber>;
+        performanceMode: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            normal: "normal";
+            degraded: "degraded";
+            fallback: "fallback";
+        }>>;
+        nodeCountThreshold: z.ZodOptional<z.ZodNumber>;
+        pixelRatioCap: z.ZodOptional<z.ZodNumber>;
+        enableAnimations: z.ZodOptional<z.ZodBoolean>;
+        focusTweenDuration: z.ZodOptional<z.ZodNumber>;
+        filterTransitionDuration: z.ZodOptional<z.ZodNumber>;
+        enableHover: z.ZodOptional<z.ZodBoolean>;
+        enableClick: z.ZodOptional<z.ZodBoolean>;
+        enableDoubleClick: z.ZodOptional<z.ZodBoolean>;
+        enablePan: z.ZodOptional<z.ZodBoolean>;
+        enableZoom: z.ZodOptional<z.ZodBoolean>;
+        enableRotate: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    analysis: z.ZodOptional<z.ZodObject<{
+        embeddingModel: z.ZodOptional<z.ZodEnum<{
+            "text-embedding-ada-002": "text-embedding-ada-002";
+            "text-embedding-3-small": "text-embedding-3-small";
+            "text-embedding-3-large": "text-embedding-3-large";
+        }>>;
+        embeddingDimensions: z.ZodOptional<z.ZodNumber>;
+        embeddingBatchSize: z.ZodOptional<z.ZodNumber>;
+        embeddingCacheTTL: z.ZodOptional<z.ZodNumber>;
+        clusteringAlgorithm: z.ZodOptional<z.ZodEnum<{
+            kmeans: "kmeans";
+            dbscan: "dbscan";
+            hierarchical: "hierarchical";
+        }>>;
+        defaultClusterCount: z.ZodOptional<z.ZodNumber>;
+        minClusterSize: z.ZodOptional<z.ZodNumber>;
+        clusterSimilarityThreshold: z.ZodOptional<z.ZodNumber>;
+        relationshipInferenceModel: z.ZodOptional<z.ZodString>;
+        relationshipMinConfidence: z.ZodOptional<z.ZodNumber>;
+        relationshipMaxPerNode: z.ZodOptional<z.ZodNumber>;
+        openaiRateLimit: z.ZodOptional<z.ZodNumber>;
+        maxConcurrentAnalysis: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    nodeTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        defaultDomain: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        analysisPrompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    domains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    relationshipTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        bidirectional: z.ZodBoolean;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const neuronConfigSchema: z.ZodObject<{
+    instance: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        repoName: z.ZodString;
+    }, z.core.$strip>;
+    visualization: z.ZodObject<{
+        domainColors: z.ZodRecord<z.ZodString, z.ZodString>;
+        defaultDomainColor: z.ZodString;
+        edgeColor: z.ZodString;
+        edgeActiveColor: z.ZodString;
+        backgroundColor: z.ZodString;
+        defaultCameraPosition: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        defaultCameraTarget: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        minZoomDistance: z.ZodNumber;
+        maxZoomDistance: z.ZodNumber;
+        enableStarfield: z.ZodBoolean;
+        starfieldCount: z.ZodNumber;
+        labelDistance: z.ZodNumber;
+        maxVisibleLabels: z.ZodNumber;
+        performanceMode: z.ZodEnum<{
+            auto: "auto";
+            normal: "normal";
+            degraded: "degraded";
+            fallback: "fallback";
+        }>;
+        nodeCountThreshold: z.ZodNumber;
+        pixelRatioCap: z.ZodNumber;
+        enableAnimations: z.ZodBoolean;
+        focusTweenDuration: z.ZodNumber;
+        filterTransitionDuration: z.ZodNumber;
+        enableHover: z.ZodBoolean;
+        enableClick: z.ZodBoolean;
+        enableDoubleClick: z.ZodBoolean;
+        enablePan: z.ZodBoolean;
+        enableZoom: z.ZodBoolean;
+        enableRotate: z.ZodBoolean;
+    }, z.core.$strip>;
+    analysis: z.ZodObject<{
+        embeddingModel: z.ZodEnum<{
+            "text-embedding-ada-002": "text-embedding-ada-002";
+            "text-embedding-3-small": "text-embedding-3-small";
+            "text-embedding-3-large": "text-embedding-3-large";
+        }>;
+        embeddingDimensions: z.ZodNumber;
+        embeddingBatchSize: z.ZodNumber;
+        embeddingCacheTTL: z.ZodNumber;
+        clusteringAlgorithm: z.ZodEnum<{
+            kmeans: "kmeans";
+            dbscan: "dbscan";
+            hierarchical: "hierarchical";
+        }>;
+        defaultClusterCount: z.ZodNumber;
+        minClusterSize: z.ZodNumber;
+        clusterSimilarityThreshold: z.ZodNumber;
+        relationshipInferenceModel: z.ZodString;
+        relationshipMinConfidence: z.ZodNumber;
+        relationshipMaxPerNode: z.ZodNumber;
+        openaiRateLimit: z.ZodNumber;
+        maxConcurrentAnalysis: z.ZodNumber;
+    }, z.core.$strip>;
+    nodeTypes: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        defaultDomain: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        analysisPrompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    domains: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    relationshipTypes: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        bidirectional: z.ZodBoolean;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    openai: z.ZodObject<{
+        apiKey: z.ZodString;
+        organization: z.ZodOptional<z.ZodString>;
+        requestsPerMinute: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    database: z.ZodObject<{
+        mode: z.ZodEnum<{
+            docker: "docker";
+            external: "external";
+        }>;
+        port: z.ZodNumber;
+        containerName: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        pool: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+            idleTimeoutMs: z.ZodNumber;
+            connectionTimeoutMs: z.ZodNumber;
+        }, z.core.$strip>>;
+        resources: z.ZodOptional<z.ZodObject<{
+            memoryLimit: z.ZodString;
+            cpuLimit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    api: z.ZodObject<{
+        basePath: z.ZodString;
+        enableCors: z.ZodBoolean;
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            windowMs: z.ZodNumber;
+            max: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    logging: z.ZodObject<{
+        level: z.ZodEnum<{
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+            error: "error";
+        }>;
+        prettyPrint: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type NodeTypeConfigInput = z.infer<typeof nodeTypeConfigSchema>;
+type DomainConfigInput = z.infer<typeof domainConfigSchema>;
+type RelationshipTypeConfigInput = z.infer<typeof relationshipTypeConfigSchema>;
+type VisualizationSettingsInput = z.infer<typeof visualizationSettingsSchema>;
+type AnalysisSettingsInput = z.infer<typeof analysisSettingsSchema>;
+type DatabaseSettingsInput = z.infer<typeof databaseSettingsSchema>;
+type NeuronSettingsInput = z.infer<typeof neuronSettingsSchema>;
+type NeuronSettingsUpdateInput = z.infer<typeof neuronSettingsUpdateSchema>;
+type NeuronConfigInput = z.infer<typeof neuronConfigSchema>;
+
+declare const paginationSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const listNodesParamsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    nodeType: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    domain: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    clusterId: z.ZodOptional<z.ZodString>;
+    analysisStatus: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        createdAt: "createdAt";
+        updatedAt: "updatedAt";
+        label: "label";
+        connectionCount: "connectionCount";
+    }>>;
+    sortOrder: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    includeEmbeddings: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    includeStats: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+declare const listEdgesParamsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    fromNodeId: z.ZodOptional<z.ZodString>;
+    toNodeId: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    relationshipType: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    source: z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        ai_inferred: "ai_inferred";
+        imported: "imported";
+    }>>;
+    minStrength: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    minConfidence: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const getGraphParamsSchema: z.ZodObject<{
+    nodeTypes: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    domains: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    clusterIds: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    nodeIds: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    depth: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    minEdgeStrength: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    relationshipTypes: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    maxNodes: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    includeOrphanNodes: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+declare const expandGraphRequestSchema: z.ZodObject<{
+    fromNodeIds: z.ZodArray<z.ZodString>;
+    depth: z.ZodCoercedNumber<unknown>;
+    direction: z.ZodEnum<{
+        outbound: "outbound";
+        inbound: "inbound";
+        both: "both";
+    }>;
+    maxNodes: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const findPathRequestSchema: z.ZodObject<{
+    fromNodeId: z.ZodString;
+    toNodeId: z.ZodString;
+    maxDepth: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    algorithm: z.ZodOptional<z.ZodEnum<{
+        shortest: "shortest";
+        all: "all";
+    }>>;
+}, z.core.$strip>;
+declare const semanticSearchRequestSchema: z.ZodObject<{
+    query: z.ZodString;
+    nodeTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const findSimilarRequestSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    excludeConnected: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+type PaginationInput = z.infer<typeof paginationSchema>;
+type ListNodesParamsInput = z.infer<typeof listNodesParamsSchema>;
+type ListEdgesParamsInput = z.infer<typeof listEdgesParamsSchema>;
+type GetGraphParamsInput = z.infer<typeof getGraphParamsSchema>;
+type ExpandGraphRequestInput = z.infer<typeof expandGraphRequestSchema>;
+type FindPathRequestInput = z.infer<typeof findPathRequestSchema>;
+type SemanticSearchRequestInput = z.infer<typeof semanticSearchRequestSchema>;
+type FindSimilarRequestInput = z.infer<typeof findSimilarRequestSchema>;
+
+type EventMiddleware = (event: NeuronEvent, next: () => void | Promise<void>) => void | Promise<void>;
+declare class EventBus implements NeuronEventEmitter {
+    private subscribers;
+    private globalSubscribers;
+    private middleware;
+    private history;
+    private historyLimit;
+    emit<T>(event: NeuronEvent<T>): void;
+    emitAsync<T>(event: NeuronEvent<T>): Promise<void>;
+    subscribe<T>(type: NeuronEventType, handler: EventHandler<T>): EventSubscription;
+    subscribeMany(types: NeuronEventType[], handler: EventHandler): EventSubscription;
+    subscribeAll(handler: EventHandler<unknown>): EventSubscription;
+    unsubscribe(type: NeuronEventType, handler: EventHandler): void;
+    unsubscribeAll(): void;
+    use(middleware: EventMiddleware): void;
+    getSubscriberCount(type?: NeuronEventType): number;
+    getEventHistory(limit?: number): NeuronEvent[];
+    clearHistory(): void;
+    private recordEvent;
+    private runMiddleware;
+}
+declare const createEvent: <T>(type: NeuronEventType, payload: T, source?: EventSource) => NeuronEvent<T>;
+
+declare const createNodeEvent: (type: "node:created" | "node:updated" | "node:deleted" | "node:batch_created", payload: NodeCreatedEventPayload | NodeUpdatedEventPayload | NodeDeletedEventPayload | NodeBatchCreatedEventPayload, source?: EventSource) => NeuronEvent;
+declare const createEdgeEvent: (type: "edge:created" | "edge:updated" | "edge:deleted", payload: EdgeCreatedEventPayload | EdgeUpdatedEventPayload | EdgeDeletedEventPayload, source?: EventSource) => NeuronEvent;
+declare const createAnalysisEvent: (type: "analysis:started" | "analysis:progress" | "analysis:completed" | "analysis:failed", payload: AnalysisStartedEventPayload | AnalysisProgressEventPayload | AnalysisCompletedEventPayload | AnalysisFailedEventPayload, source?: EventSource) => NeuronEvent;
+declare const createGenericEvent: <T>(type: NeuronEventType, payload: T, source?: EventSource) => NeuronEvent<T>;
+
+declare const loggingMiddleware: EventMiddleware;
+
+declare const validationMiddleware: EventMiddleware;
+
+interface ProcessingOptions {
+    skipDuplicates?: boolean;
+    updateOnConflict?: boolean;
+    defaultNodeType?: string;
+    defaultDomain?: string;
+    contentFields?: string[];
+    labelField?: string;
+    slugField?: string;
+    metadataFields?: string[];
+}
+declare class DataProcessor {
+    private options;
+    constructor(options?: ProcessingOptions);
+    processItem(item: Record<string, unknown>): NeuronNodeCreate;
+    processBatch(items: Record<string, unknown>[]): {
+        nodes: NeuronNodeCreate[];
+        errors: Array<{
+            index: number;
+            error: string;
+        }>;
+    };
+    processJSON(json: string): NeuronNodeCreate[];
+    processCSV(csv: string): NeuronNodeCreate[];
+    generateSlug(label: string, existingSlugs?: Set<string>): string;
+    extractContent(item: Record<string, unknown>): string;
+    detectDuplicates(nodes: NeuronNodeCreate[]): {
+        unique: NeuronNodeCreate[];
+        duplicates: Array<{
+            node: NeuronNodeCreate;
+            reason: string;
+        }>;
+    };
+    private extractMetadata;
+}
+
+interface EmbeddingsConfig {
+    openaiApiKey: string;
+    model: 'text-embedding-ada-002' | 'text-embedding-3-small' | 'text-embedding-3-large';
+    dimensions?: number;
+    batchSize: number;
+    rateLimit: number;
+    cacheTTL: number;
+    maxRetries: number;
+}
+interface EmbeddingResult {
+    nodeId: string;
+    embedding: number[];
+    model: string;
+    tokenCount: number;
+    cached: boolean;
+}
+declare class EmbeddingsService {
+    private config;
+    private db;
+    private client;
+    constructor(config: EmbeddingsConfig, db: Database);
+    generateEmbedding(text: string): Promise<number[]>;
+    generateBatchEmbeddings(texts: string[]): Promise<number[][]>;
+    embedNode(nodeId: string): Promise<EmbeddingResult>;
+    embedNodes(nodeIds: string[]): Promise<{
+        results: EmbeddingResult[];
+        errors: Array<{
+            nodeId: string;
+            error: string;
+        }>;
+    }>;
+    getCachedEmbedding(nodeId: string): Promise<number[] | null>;
+    cacheEmbedding(nodeId: string, embedding: number[], model: string): Promise<void>;
+    invalidateCache(nodeIds?: string[]): Promise<void>;
+    countTokens(text: string): number;
+    estimateCost(nodeCount: number): {
+        tokens: number;
+        cost: number;
+    };
+    private withRetry;
+    private applyRateLimit;
+}
+
+interface ClusteringConfig {
+    algorithm: 'kmeans' | 'dbscan' | 'hierarchical';
+    clusterCount?: number;
+    minClusterSize?: number;
+    similarityThreshold?: number;
+    epsilon?: number;
+    minSamples?: number;
+}
+interface ClusteringResult {
+    clusterId: string;
+    label: string;
+    nodeIds: string[];
+    centroid: number[];
+    avgSimilarity: number;
+    cohesion: number;
+}
+declare class ClusteringEngine {
+    private db;
+    private embeddings;
+    constructor(db: Database, embeddings: EmbeddingsService);
+    clusterNodes(config: ClusteringConfig): Promise<{
+        clusters: ClusteringResult[];
+        unassigned: string[];
+    }>;
+    recluster(config: ClusteringConfig): Promise<ClusteringResult[]>;
+    assignToCluster(nodeId: string): Promise<ClusterMembership | null>;
+    findBestCluster(embedding: number[]): Promise<{
+        clusterId: string;
+        similarity: number;
+    } | null>;
+    recomputeCentroid(clusterId: string): Promise<void>;
+    recomputeAllCentroids(): Promise<void>;
+    generateClusterLabel(clusterId: string): Promise<string>;
+    generateAllLabels(): Promise<void>;
+    calculateSilhouetteScore(clusters: ClusteringResult[]): number;
+    calculateCohesion(cluster: ClusteringResult): number;
+    private fetchNodesWithEmbeddings;
+    private runKmeans;
+    private runDbscan;
+    private findNeighbors;
+    private persistClusters;
+}
+
+interface InferenceConfig {
+    model: string;
+    minConfidence: number;
+    maxPerNode: number;
+    similarityThreshold: number;
+    includeExisting: boolean;
+    batchSize: number;
+    rateLimit: number;
+}
+interface InferredRelationship {
+    fromNodeId: string;
+    toNodeId: string;
+    relationshipType: RelationshipType;
+    confidence: number;
+    reasoning: string;
+    evidence: EdgeEvidence[];
+}
+declare class RelationshipEngine {
+    private db;
+    private config;
+    private client;
+    constructor(db: Database, config: InferenceConfig);
+    inferForNode(nodeId: string): Promise<InferredRelationship[]>;
+    inferForNodes(nodeIds: string[]): Promise<{
+        inferred: InferredRelationship[];
+        errors: Array<{
+            nodeId: string;
+            error: string;
+        }>;
+    }>;
+    inferAll(): Promise<InferredRelationship[]>;
+    findCandidates(nodeId: string): Promise<Array<{
+        nodeId: string;
+        similarity: number;
+    }>>;
+    validateRelationship(rel: InferredRelationship): Promise<boolean>;
+    createEdgesFromInferences(inferences: InferredRelationship[], autoApprove?: boolean): Promise<NeuronEdge[]>;
+    private inferPair;
+    private applyRateLimit;
+}
+
+interface ScoringConfig {
+    similarityWeight: number;
+    connectionWeight: number;
+    recencyWeight: number;
+    domainBoost: number;
+}
+interface ScoredNode {
+    node: NeuronNode;
+    score: number;
+    breakdown: {
+        similarity: number;
+        connections: number;
+        recency: number;
+        domainMatch: number;
+    };
+}
+declare class ScoringEngine {
+    private db;
+    private config;
+    constructor(db: Database, config?: ScoringConfig);
+    cosineSimilarity(a: number[], b: number[]): number;
+    semanticSimilarity(nodeA: string, nodeB: string): Promise<number>;
+    scoreForQuery(queryEmbedding: number[], nodeIds?: string[]): Promise<ScoredNode[]>;
+    findSimilar(nodeId: string, limit?: number, excludeConnected?: boolean): Promise<ScoredNode[]>;
+    calculateNodeImportance(nodeId: string): Promise<number>;
+    rankAllNodes(): Promise<Array<{
+        nodeId: string;
+        importance: number;
+    }>>;
+    scoreRelevance(sourceNodeId: string, candidateNodeIds: string[], context?: string): Promise<ScoredNode[]>;
+    private applyScoring;
+}
+
+interface PipelineOptions {
+    nodeIds?: string[];
+    forceRecompute?: boolean;
+    skipEmbeddings?: boolean;
+    embeddingModel?: string;
+    skipClustering?: boolean;
+    clusterCount?: number;
+    clusteringAlgorithm?: ClusteringAlgorithm;
+    skipRelationships?: boolean;
+    relationshipThreshold?: number;
+    maxRelationshipsPerNode?: number;
+    onProgress?: (progress: PipelineProgress) => void;
+    webhookUrl?: string;
+}
+interface PipelineProgress {
+    stage: 'embeddings' | 'clustering' | 'relationships' | 'complete';
+    progress: number;
+    currentItem: string;
+    itemsProcessed: number;
+    totalItems: number;
+    estimatedTimeRemaining?: number;
+}
+declare class AnalysisPipeline {
+    private db;
+    private embeddings;
+    private clustering;
+    private relationships;
+    private events;
+    private activeJobs;
+    constructor(db: Database, embeddings: EmbeddingsService, clustering: ClusteringEngine, relationships: RelationshipEngine, events: EventBus);
+    runFull(options?: PipelineOptions): Promise<AnalysisRun>;
+    runEmbeddings(options?: PipelineOptions): Promise<AnalysisRun>;
+    runClustering(options?: PipelineOptions): Promise<AnalysisRun>;
+    runRelationships(options?: PipelineOptions): Promise<AnalysisRun>;
+    getJob(jobId: string): Promise<AnalysisRun | null>;
+    listJobs(options?: {
+        status?: string;
+        limit?: number;
+    }): Promise<AnalysisRun[]>;
+    cancelJob(jobId: string): Promise<boolean>;
+    getActiveJobs(): AnalysisRun[];
+    isRunning(): boolean;
+    private runEmbeddingsStage;
+    private runClusteringStage;
+    private runRelationshipsStage;
+    private createJob;
+    private completeJob;
+    private failJob;
+    private updateJobResults;
+    private resolveNodeIds;
+}
+
+interface DockerConfig {
+    repoName: string;
+    port: number;
+    containerName?: string;
+    image?: string;
+    user?: string;
+    password?: string;
+    database?: string;
+    memoryLimit?: string;
+}
+interface StartOptions {
+    forceRecreate?: boolean;
+    waitForReady?: boolean;
+    timeoutMs?: number;
+}
+interface StopOptions {
+    removeVolumes?: boolean;
+    timeoutMs?: number;
+}
+interface EnsureOptions {
+    waitForReady?: boolean;
+}
+interface HealthCheckResult {
+    containerRunning: boolean;
+    databaseReady: boolean;
+    connectionString: string;
+    details?: string;
+}
+interface ContainerStats {
+    cpuPercent?: string;
+    memoryUsage?: string;
+    memoryPercent?: string;
+    netIO?: string;
+    blockIO?: string;
+}
+interface LogOptions {
+    tail?: number;
+    since?: string;
+}
+declare class DockerManager {
+    private config;
+    private composeFilePath;
+    constructor(config: DockerConfig);
+    start(options?: StartOptions): Promise<void>;
+    stop(options?: StopOptions): Promise<void>;
+    ensureRunning(options?: EnsureOptions): Promise<void>;
+    isRunning(): Promise<boolean>;
+    healthCheck(): Promise<HealthCheckResult>;
+    getStats(): Promise<ContainerStats>;
+    getConnectionString(): Promise<string>;
+    getLogs(options?: LogOptions): Promise<string>;
+    execSql(sql: string): Promise<string>;
+    updatePort(newPort: number): Promise<void>;
+    private assertDockerAvailable;
+    private getComposeCommand;
+    private getContainerName;
+    private getVolumeName;
+    private ensureComposeFile;
+    private renderTemplate;
+    private ensurePortAvailable;
+    private isPortAvailable;
+    private waitForReady;
+    private execPgIsReady;
+    private inspectContainer;
+}
+
+declare function createDatabase(config: NeuronConfig): Database;
+declare function createDatabaseFromEnv(): Database;
+declare function getDatabase(config?: DatabaseConfig): Database;
+declare function resetDatabaseSingleton(): void;
+
+declare const defineNeuronConfig: (config: NeuronConfig) => NeuronConfig;
+
+declare class NeuronApiClient {
+    private basePath;
+    constructor(basePath: string);
+    private request;
+    nodes: {
+        list: (params?: ListNodesParams) => Promise<ListNodesResponse>;
+        get: (id: string) => Promise<GetNodeResponse>;
+        create: (data: CreateNodesRequest) => Promise<CreateNodesResponse>;
+        update: (id: string, data: UpdateNodeRequest) => Promise<unknown>;
+        delete: (id: string) => Promise<DeleteNodeResponse>;
+    };
+    edges: {
+        list: (params?: ListEdgesParams) => Promise<ListEdgesResponse>;
+        create: (data: CreateEdgesRequest) => Promise<CreateEdgesResponse>;
+        update: (id: string, data: UpdateEdgeRequest) => Promise<unknown>;
+        delete: (id: string) => Promise<DeleteEdgeResponse>;
+    };
+    graph: {
+        get: (params?: GetGraphParams) => Promise<GetGraphResponse>;
+        expand: (data: ExpandGraphRequest) => Promise<ExpandGraphResponse>;
+        findPath: (data: FindPathRequest) => Promise<FindPathResponse>;
+    };
+    analyze: {
+        start: (data: AnalysisRequest) => Promise<AnalysisResponse>;
+        getStatus: (jobId: string) => Promise<GetAnalysisJobResponse>;
+        cancel: (jobId: string) => Promise<CancelAnalysisResponse>;
+    };
+    settings: {
+        get: () => Promise<GetSettingsResponse>;
+        update: (data: UpdateSettingsRequest) => Promise<UpdateSettingsResponse>;
+        reset: () => Promise<ResetSettingsResponse>;
+    };
+    search: {
+        semantic: (data: SemanticSearchRequest) => Promise<SemanticSearchResponse>;
+        similar: (data: FindSimilarRequest) => Promise<FindSimilarResponse>;
+    };
+}
+
+interface ErrorContext {
+    message: string;
+}
+interface NeuronContextValue {
+    config: NeuronConfig;
+    settings: NeuronSettings;
+    api: NeuronApiClient;
+    events: EventBus;
+    isInitialized: boolean;
+    error: Error | null;
+    updateSettings: (settings: Partial<NeuronSettings>) => Promise<void>;
+    resetSettings: () => Promise<void>;
+    onEvent?: (event: NeuronEvent) => void;
+    onError?: (error: Error, context: ErrorContext) => void;
+}
+
+declare function useNeuronContext(): NeuronContextValue;
+
+interface UseNeuronGraphOptions {
+    domains?: string[];
+    nodeTypes?: string[];
+    minEdgeStrength?: number;
+    autoRefresh?: boolean;
+    refreshInterval?: number;
+}
+declare function useNeuronGraph(options?: UseNeuronGraphOptions): {
+    nodes: NeuronVisualNode[];
+    edges: NeuronVisualEdge[];
+    clusters: NeuronVisualCluster[];
+    isLoading: boolean;
+    error: Error | null;
+    filters: GraphFilters;
+    setFilters: (next: Partial<GraphFilters>) => void;
+    clearFilters: () => void;
+    selectedNode: NeuronVisualNode | null;
+    selectNode: (nodeId: string | null) => void;
+    clearSelection: () => void;
+    refetch: () => Promise<void>;
+    expandFromNode: (nodeId: string, depth?: number) => Promise<void>;
+    findPath: (fromId: string, toId: string) => Promise<FindPathResponse["paths"][number]>;
+};
+
+interface UseNeuronNodesOptions {
+    initialFilters?: ListNodesParams;
+    pageSize?: number;
+}
+declare function useNeuronNodes(options?: UseNeuronNodesOptions): {
+    nodes: NeuronNode[];
+    isLoading: boolean;
+    error: Error | null;
+    createNode: (data: NeuronNodeCreate) => Promise<NeuronNode>;
+    updateNode: (id: string, data: NeuronNodeUpdate) => Promise<NeuronNode>;
+    deleteNode: (id: string) => Promise<void>;
+    batchCreate: (nodesInput: NeuronNodeCreate[]) => Promise<NeuronNode[]>;
+    search: (query: string) => Promise<void>;
+    pagination: {
+        page: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    };
+    setPage: React.Dispatch<React.SetStateAction<number>>;
+    nextPage: () => void;
+    prevPage: () => void;
+};
+
+declare function useNeuronAnalysis(): {
+    activeJobs: AnalysisRun[];
+    jobHistory: AnalysisRun[];
+    startAnalysis: (request: AnalysisRequest) => Promise<AnalysisResponse>;
+    cancelJob: (jobId: string) => Promise<void>;
+    getJobStatus: (jobId: string) => Promise<AnalysisRun>;
+    isRunning: boolean;
+    currentProgress: number | null;
+};
+
+declare function useNeuronSettings(): {
+    settings: NeuronSettings;
+    isLoading: boolean;
+    isUpdating: boolean;
+    error: Error | null;
+    updateSettings: (updates: NeuronSettingsUpdate) => Promise<void>;
+    resetSettings: (sections?: string[]) => Promise<void>;
+    setDomainColor: (domain: string, color: string) => Promise<void>;
+    setVisualization: (updates: Partial<VisualizationSettings>) => Promise<void>;
+};
+
+declare function useNeuronSearch(): {
+    results: SearchResult[];
+    isSearching: boolean;
+    error: Error | null;
+    search: (query: string, options?: SemanticSearchOptions) => Promise<void>;
+    findSimilar: (nodeId: string, options?: FindSimilarOptions) => Promise<void>;
+    clearResults: () => void;
+};
+
+declare function useNeuronEvents(): {
+    subscribe: <T>(type: NeuronEventType, handler: EventHandler<T>) => void;
+    emit: <T>(type: NeuronEventType, payload: T) => void;
+};
+declare function useNodeEvents(handlers: {
+    onCreated?: (node: NeuronNode) => void;
+    onUpdated?: (node: NeuronNode) => void;
+    onDeleted?: (nodeId: string) => void;
+}): void;
+declare function useAnalysisEvents(handlers: {
+    onStarted?: (jobId: string) => void;
+    onProgress?: (jobId: string, progress: number) => void;
+    onCompleted?: (job: AnalysisRun) => void;
+    onFailed?: (jobId: string, error: string) => void;
+}): void;
+
+interface NeuronWebProviderProps {
+    children: React__default.ReactNode;
+    config: {
+        openaiApiKey?: string;
+        databaseUrl?: string;
+        settings?: Partial<NeuronSettings>;
+        onEvent?: (event: NeuronEvent) => void;
+        onError?: (error: Error, context: ErrorContext) => void;
+    };
+}
+declare function NeuronWebProvider({ children, config }: NeuronWebProviderProps): React__default.ReactElement;
+
+/**
+ * omi-neuron-web
+ * A drop-in Next.js library for data analysis and 3D visualization
+ */
+
+declare const VERSION = "0.1.0";
+
+export { type AnalysisCancelledEventPayload, type AnalysisCompletedEventPayload, type AnalysisFailedEventPayload, type AnalysisOptionsInput, AnalysisPipeline, type AnalysisProgressEventPayload, AnalysisRequest, type AnalysisRequestInput, AnalysisResponse, AnalysisRun, type AnalysisSettingsInput, type AnalysisStartedEventPayload, CancelAnalysisResponse, type ClusterCreateInput, type ClusterCreatedEventPayload, ClusterMembership, type ClusterMembershipChangedEventPayload, type ClusterUpdateInput, type ClusterUpdatedEventPayload, ClusteringAlgorithm, type ClusteringConfigInput, ClusteringEngine, type ContainerStats, CreateEdgesRequest, CreateEdgesResponse, CreateNodesRequest, CreateNodesResponse, DataProcessor, Database, DatabaseConfig, type DatabaseSettingsInput, DeleteEdgeResponse, DeleteNodeResponse, type DockerConfig, DockerManager, type DomainConfigInput, type EdgeCreateInput, type EdgeCreatedEventPayload, type EdgeDeletedEventPayload, EdgeEvidence, type EdgeEvidenceInput, type EdgeFilterInput, type EdgeUpdateInput, type EdgeUpdatedEventPayload, EmbeddingsService, type EnsureOptions, EventBus, type EventFilterOptions, type EventHandler, type EventMiddleware, type EventSource, type EventSubscription, ExpandGraphRequest, type ExpandGraphRequestInput, ExpandGraphResponse, FindPathRequest, type FindPathRequestInput, FindPathResponse, FindSimilarOptions, FindSimilarRequest, type FindSimilarRequestInput, FindSimilarResponse, GetAnalysisJobResponse, GetGraphParams, type GetGraphParamsInput, GetGraphResponse, GetNodeResponse, GetSettingsResponse, GraphFilters, type HealthCheckResult, ListEdgesParams, type ListEdgesParamsInput, ListEdgesResponse, ListNodesParams, type ListNodesParamsInput, ListNodesResponse, type LogOptions, NeuronCluster, NeuronConfig, type NeuronConfigInput, NeuronEdge, type NeuronEvent, type NeuronEventEmitter, type NeuronEventType, NeuronNode, NeuronNodeCreate, NeuronNodeUpdate, NeuronSettings, type NeuronSettingsInput, NeuronSettingsUpdate, type NeuronSettingsUpdateInput, NeuronVisualCluster, NeuronVisualEdge, NeuronVisualNode, NeuronWebProvider, type NodeBatchCreateInput, type NodeBatchCreatedEventPayload, type NodeCreateInput, type NodeCreatedEventPayload, type NodeDeletedEventPayload, type NodeFilterInput, type NodeTypeConfigInput, type NodeUpdateInput, type NodeUpdatedEventPayload, type PaginationInput, RelationshipEngine, type RelationshipInferredEventPayload, type RelationshipRejectedEventPayload, RelationshipType, type RelationshipTypeConfigInput, ResetSettingsResponse, ScoringEngine, SearchResult, SemanticSearchOptions, SemanticSearchRequest, type SemanticSearchRequestInput, SemanticSearchResponse, type SettingsUpdatedEventPayload, type StartOptions, type StopOptions, UpdateEdgeRequest, UpdateNodeRequest, UpdateSettingsRequest, UpdateSettingsResponse, type UseNeuronGraphOptions, type UseNeuronNodesOptions, VERSION, VisualizationSettings, type VisualizationSettingsInput, type VizCameraChangedEventPayload, type VizFilterAppliedEventPayload, type VizNodeFocusedEventPayload, type VizNodeHoveredEventPayload, type VizNodeSelectedEventPayload, type VizPathCompletedEventPayload, type VizPathStartedEventPayload, analysisOptionsSchema, analysisRequestSchema, analysisSettingsSchema, clusterCreateSchema, clusterUpdateSchema, clusteringConfigSchema, createAnalysisEvent, createDatabase, createDatabaseFromEnv, createEdgeEvent, createEvent, createGenericEvent, createNodeEvent, databaseSettingsSchema, defineNeuronConfig, domainConfigSchema, edgeCreateSchema, edgeEvidenceSchema, edgeFilterSchema, edgeUpdateSchema, expandGraphRequestSchema, findPathRequestSchema, findSimilarRequestSchema, getDatabase, getGraphParamsSchema, listEdgesParamsSchema, listNodesParamsSchema, loggingMiddleware, neuronConfigSchema, neuronSettingsSchema, neuronSettingsUpdateSchema, nodeBatchCreateSchema, nodeCreateSchema, nodeFilterSchema, nodeTierSchema, nodeTypeConfigSchema, nodeUpdateSchema, paginationSchema, relationshipTypeConfigSchema, resetDatabaseSingleton, semanticSearchRequestSchema, useAnalysisEvents, useNeuronAnalysis, useNeuronContext, useNeuronEvents, useNeuronGraph, useNeuronNodes, useNeuronSearch, useNeuronSettings, useNodeEvents, validationMiddleware, visualizationSettingsSchema };