@lucern/graph-sync 1.0.29 → 1.0.30

package/dist/neo4jQueries-D14Putpd.d.ts

@@ -0,0 +1,839 @@
+import * as convex_server from 'convex/server';
+
+/**
+ * Neo4j Graph Queries - advanced query surfaces.
+ */
+/**
+ * Get high-priority questions (critical/high) that test beliefs
+ */
+declare const getHighPriorityQuestions: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    questions: never[];
+    error: string;
+} | {
+    questions: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get evidence filtered by methodology (expert_interview, customer_interview, etc.)
+ */
+declare const getEvidenceByMethodology: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    methodology: string;
+}, Promise<{
+    evidence: never[];
+    error: string;
+} | {
+    evidence: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get proprietary/early evidence (information asymmetry advantage)
+ */
+declare const getProprietaryEvidence: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    evidence: never[];
+    error: string;
+} | {
+    evidence: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get beliefs by epistemic status (hypothesis, emerging, established, challenged, etc.)
+ */
+declare const getBeliefsByEpistemicStatus: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    epistemicStatus: string;
+}, Promise<{
+    beliefs: never[];
+    error: string;
+} | {
+    beliefs: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get challenged beliefs that need attention
+ */
+declare const getChallengedBeliefs: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    beliefs: never[];
+    error: string;
+} | {
+    beliefs: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get predictions with deadlines
+ */
+declare const getPredictions: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    predictions: never[];
+    error: string;
+} | {
+    predictions: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get causal chains (edges with causal reasoning method)
+ */
+declare const getCausalChains: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    chains: never[];
+    error: string;
+} | {
+    chains: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get necessary evidence for beliefs (logicalRole = necessary or necessary_sufficient)
+ */
+declare const getNecessaryEvidence: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get falsification questions (designed to disprove beliefs)
+ */
+declare const getFalsificationQuestions: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    beliefIds?: string[] | undefined;
+}, Promise<{
+    questions: never[];
+    error: string;
+} | {
+    questions: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Detect confirmation bias in beliefs.
+ * Returns beliefs with high supporting:contradicting evidence ratio.
+ */
+declare const getConfirmationBiasScore: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Detect anchoring bias - old beliefs that never got challenged or forked.
+ */
+declare const getAnchoringBiasDetection: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Detect source concentration risk - beliefs where all evidence traces to single source.
+ */
+declare const getSourceConcentrationRisk: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find the minimum falsification set - smallest set of beliefs that would collapse the thesis.
+ */
+declare const getMinimumFalsificationSet: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    result: null;
+    error: string;
+} | {
+    result: unknown;
+    error?: undefined;
+}>>;
+/**
+ * Get contradiction tension map - all unresolved tensions in the graph.
+ */
+declare const getContradictionTensionMap: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get reasoning depth score - how deep is the evidence chain for each belief?
+ */
+declare const getReasoningDepthScore: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get knowledge frontier - open questions on the boundary of what we know.
+ */
+declare const getKnowledgeFrontier: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get belief half-life analysis - how long do beliefs survive before being superseded?
+ */
+declare const getBeliefHalfLife: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    result: null;
+    error: string;
+} | {
+    result: unknown;
+    error?: undefined;
+}>>;
+/**
+ * Get meeting prep brief for a person at a company.
+ */
+declare const getMeetingPrepBrief: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    personGlobalId: string;
+}, Promise<{
+    brief: null;
+    error: string;
+} | {
+    brief: unknown;
+    error?: undefined;
+}>>;
+/**
+ * Get proprietary signals - our unique insights not in public discourse.
+ */
+declare const getProprietarySignals: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get portfolio conviction dashboard - aggregate conviction metrics across all themes.
+ */
+declare const getPortfolioConviction: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    portfolio: never[];
+    error: string;
+} | {
+    portfolio: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get stale themes - themes with no recent activity.
+ */
+declare const getStaleThemes: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    themes: never[];
+    error: string;
+} | {
+    themes: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get missing question detection - high-confidence beliefs with no testing questions.
+ */
+declare const getMissingQuestionDetection: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get surprise detection - evidence that surprised us (high surprise score).
+ */
+declare const getSurpriseDetection: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get non-consensus beliefs - beliefs where we diverge from market consensus.
+ */
+declare const getNonConsensusBeliefs: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Semantic search with graph context — find nodes by embedding similarity
+ * and return their graph neighborhood for context.
+ */
+declare const semanticSearch: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    indexName?: string | undefined;
+    topK?: number | undefined;
+    minScore?: number | undefined;
+    embedding: number[];
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find semantic orphans — nodes structurally connected but semantically
+ * distant from their graph neighbors.
+ */
+declare const getSemanticOrphans: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    threshold?: number | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find soft contradictions — beliefs about the same topic (high embedding similarity)
+ * but with divergent evidence or confidence.
+ */
+declare const getSoftContradictions: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    similarityThreshold?: number | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find semantic bridges — nodes semantically similar but graph-distant.
+ * These represent potential missing connections.
+ */
+declare const getSemanticBridges: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    similarityThreshold?: number | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Graph-aware RAG search — semantic search that expands along graph structure
+ * to pull in supporting context (evidence, themes, sources).
+ */
+declare const graphAwareSearch: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    indexName?: string | undefined;
+    topK?: number | undefined;
+    minScore?: number | undefined;
+    embedding: number[];
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+
+/**
+ * Neo4j Graph Queries
+ *
+ * Convex actions that execute graph queries against Neo4j.
+ * These provide graph intelligence that's hard/impossible in Convex alone:
+ * - Multi-hop traversals
+ * - Path finding
+ * - Cross-theme patterns
+ * - Contradiction detection
+ *
+ * Architecture:
+ * - Convex action calls a tenant-owned query proxy route
+ * - Query proxy executes a predefined Cypher query
+ * - Results return to the Convex caller
+ */
+/**
+ * Get the full lineage of a node (what it was derived/extracted from)
+ * Uses Neo4j for efficient multi-hop traversal up to 10 levels deep
+ */
+declare const getNodeLineageGraph: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    globalId: string;
+}, Promise<{
+    lineage: never[];
+    error: string;
+} | {
+    lineage: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get nodes connected to a given node within N hops
+ * Much more powerful than Convex's single-hop queries
+ */
+declare const getConnectedNodesGraph: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    maxHops?: number | undefined;
+    globalId: string;
+}, Promise<{
+    nodes: never[];
+    error: string;
+} | {
+    nodes: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get all beliefs that belong to a theme
+ */
+declare const getThemeBeliefsGraph: convex_server.RegisteredAction<"public", {
+    themeGlobalId: string;
+}, Promise<{
+    beliefs: never[];
+    error: string;
+} | {
+    beliefs: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get evidence that supports a belief (through question chain OR direct link)
+ */
+declare const getBeliefEvidenceGraph: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    beliefGlobalId: string;
+}, Promise<{
+    evidence: never[];
+    error: string;
+} | {
+    evidence: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find beliefs that appear in multiple themes (cross-cutting insights)
+ */
+declare const getCrossThemeBeliefs: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    beliefs: never[];
+    error: string;
+} | {
+    beliefs: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find potential contradictions in the knowledge graph
+ * Evidence that tests conflicting beliefs
+ */
+declare const findPotentialContradictions: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    contradictions: never[];
+    error: string;
+} | {
+    contradictions: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get the full subgraph for a theme (all connected beliefs, questions, evidence)
+ */
+declare const getThemeSubgraph: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    themeGlobalId: string;
+}, Promise<{
+    subgraph: null;
+    error: string;
+} | {
+    subgraph: {} | null;
+    error?: undefined;
+}>>;
+/**
+ * Find the path from evidence to a belief (how does this evidence support this belief?)
+ */
+declare const getEvidenceToBeliefPath: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    beliefGlobalId: string;
+    evidenceGlobalId: string;
+}, Promise<{
+    path: null;
+    error: string;
+} | {
+    path: {
+        nodes: unknown[];
+        relationships: string[];
+        length: number;
+    };
+    error?: undefined;
+}>>;
+/**
+ * Get stats for a theme (counts of beliefs, questions, evidence)
+ */
+declare const getThemeStats: convex_server.RegisteredAction<"public", {
+    themeGlobalId: string;
+}, Promise<{
+    stats: null;
+    error: string;
+} | {
+    stats: {} | null;
+    error?: undefined;
+}>>;
+/**
+ * Get candidate theme-to-valuechain mappings
+ * Returns all themes and value chains for manual or AI-assisted matching
+ */
+declare const getThemeValueChainCandidates: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+}, Promise<{
+    candidates: never[];
+    error: string;
+} | {
+    candidates: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find themes that impact a specific company
+ */
+declare const getThemesImpactingCompany: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    companyName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find companies related to a theme
+ */
+declare const getCompaniesByTheme: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    themeName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find questions about a value chain
+ */
+declare const getQuestionsByValueChain: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    valueChainName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find questions about a theme
+ */
+declare const getQuestionsByTheme: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    themeName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find people/contacts related to a theme
+ */
+declare const getPeopleByTheme: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    themeName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find people at a specific company
+ */
+declare const getPeopleByCompany: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    companyName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find value chains for a theme
+ */
+declare const getValueChainsByTheme: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    themeName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find functions in a value chain
+ */
+declare const getFunctionsByValueChain: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    valueChainName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find beliefs about a company
+ */
+declare const getBeliefsByCompany: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    companyName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Find evidence about a company
+ */
+declare const getEvidenceByCompany: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    companyName: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Search all nodes by text
+ */
+declare const searchAllNodes: convex_server.RegisteredAction<"public", {
+    limit?: number | undefined;
+    searchText: string;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get all relationships from a node
+ */
+declare const getNodeRelationships: convex_server.RegisteredAction<"public", {
+    globalId?: string | undefined;
+    limit?: number | undefined;
+    searchText?: string | undefined;
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Get graph statistics (node counts by type)
+ */
+declare const getGraphStats: convex_server.RegisteredAction<"public", {}, Promise<{
+    stats: never[];
+    error: string;
+} | {
+    stats: unknown[];
+    error?: undefined;
+}>>;
+/**
+ * Flexible graph query - routes to appropriate query based on intent
+ * This is the main entry point for natural language graph queries
+ */
+declare const queryGraph: convex_server.RegisteredAction<"public", {
+    topicId?: string | undefined;
+    apiBaseUrl?: string | undefined;
+    params: {
+        globalId?: string | undefined;
+        limit?: number | undefined;
+        companyName?: string | undefined;
+        themeName?: string | undefined;
+        valueChainName?: string | undefined;
+        searchText?: string | undefined;
+    };
+    queryType: "themesImpactingCompany" | "companiesByTheme" | "questionsByValueChain" | "questionsByTheme" | "peopleByTheme" | "peopleByCompany" | "valueChainsByTheme" | "functionsByValueChain" | "beliefsByCompany" | "evidenceByCompany" | "searchAllNodes" | "nodeRelationships" | "graphStats";
+}, Promise<{
+    results: never[];
+    error: string;
+} | {
+    results: unknown[];
+    error?: undefined;
+}>>;
+
+declare const neo4jQueries_findPotentialContradictions: typeof findPotentialContradictions;
+declare const neo4jQueries_getAnchoringBiasDetection: typeof getAnchoringBiasDetection;
+declare const neo4jQueries_getBeliefEvidenceGraph: typeof getBeliefEvidenceGraph;
+declare const neo4jQueries_getBeliefHalfLife: typeof getBeliefHalfLife;
+declare const neo4jQueries_getBeliefsByCompany: typeof getBeliefsByCompany;
+declare const neo4jQueries_getBeliefsByEpistemicStatus: typeof getBeliefsByEpistemicStatus;
+declare const neo4jQueries_getCausalChains: typeof getCausalChains;
+declare const neo4jQueries_getChallengedBeliefs: typeof getChallengedBeliefs;
+declare const neo4jQueries_getCompaniesByTheme: typeof getCompaniesByTheme;
+declare const neo4jQueries_getConfirmationBiasScore: typeof getConfirmationBiasScore;
+declare const neo4jQueries_getConnectedNodesGraph: typeof getConnectedNodesGraph;
+declare const neo4jQueries_getContradictionTensionMap: typeof getContradictionTensionMap;
+declare const neo4jQueries_getCrossThemeBeliefs: typeof getCrossThemeBeliefs;
+declare const neo4jQueries_getEvidenceByCompany: typeof getEvidenceByCompany;
+declare const neo4jQueries_getEvidenceByMethodology: typeof getEvidenceByMethodology;
+declare const neo4jQueries_getEvidenceToBeliefPath: typeof getEvidenceToBeliefPath;
+declare const neo4jQueries_getFalsificationQuestions: typeof getFalsificationQuestions;
+declare const neo4jQueries_getFunctionsByValueChain: typeof getFunctionsByValueChain;
+declare const neo4jQueries_getGraphStats: typeof getGraphStats;
+declare const neo4jQueries_getHighPriorityQuestions: typeof getHighPriorityQuestions;
+declare const neo4jQueries_getKnowledgeFrontier: typeof getKnowledgeFrontier;
+declare const neo4jQueries_getMeetingPrepBrief: typeof getMeetingPrepBrief;
+declare const neo4jQueries_getMinimumFalsificationSet: typeof getMinimumFalsificationSet;
+declare const neo4jQueries_getMissingQuestionDetection: typeof getMissingQuestionDetection;
+declare const neo4jQueries_getNecessaryEvidence: typeof getNecessaryEvidence;
+declare const neo4jQueries_getNodeLineageGraph: typeof getNodeLineageGraph;
+declare const neo4jQueries_getNodeRelationships: typeof getNodeRelationships;
+declare const neo4jQueries_getNonConsensusBeliefs: typeof getNonConsensusBeliefs;
+declare const neo4jQueries_getPeopleByCompany: typeof getPeopleByCompany;
+declare const neo4jQueries_getPeopleByTheme: typeof getPeopleByTheme;
+declare const neo4jQueries_getPortfolioConviction: typeof getPortfolioConviction;
+declare const neo4jQueries_getPredictions: typeof getPredictions;
+declare const neo4jQueries_getProprietaryEvidence: typeof getProprietaryEvidence;
+declare const neo4jQueries_getProprietarySignals: typeof getProprietarySignals;
+declare const neo4jQueries_getQuestionsByTheme: typeof getQuestionsByTheme;
+declare const neo4jQueries_getQuestionsByValueChain: typeof getQuestionsByValueChain;
+declare const neo4jQueries_getReasoningDepthScore: typeof getReasoningDepthScore;
+declare const neo4jQueries_getSemanticBridges: typeof getSemanticBridges;
+declare const neo4jQueries_getSemanticOrphans: typeof getSemanticOrphans;
+declare const neo4jQueries_getSoftContradictions: typeof getSoftContradictions;
+declare const neo4jQueries_getSourceConcentrationRisk: typeof getSourceConcentrationRisk;
+declare const neo4jQueries_getStaleThemes: typeof getStaleThemes;
+declare const neo4jQueries_getSurpriseDetection: typeof getSurpriseDetection;
+declare const neo4jQueries_getThemeBeliefsGraph: typeof getThemeBeliefsGraph;
+declare const neo4jQueries_getThemeStats: typeof getThemeStats;
+declare const neo4jQueries_getThemeSubgraph: typeof getThemeSubgraph;
+declare const neo4jQueries_getThemeValueChainCandidates: typeof getThemeValueChainCandidates;
+declare const neo4jQueries_getThemesImpactingCompany: typeof getThemesImpactingCompany;
+declare const neo4jQueries_getValueChainsByTheme: typeof getValueChainsByTheme;
+declare const neo4jQueries_graphAwareSearch: typeof graphAwareSearch;
+declare const neo4jQueries_queryGraph: typeof queryGraph;
+declare const neo4jQueries_searchAllNodes: typeof searchAllNodes;
+declare const neo4jQueries_semanticSearch: typeof semanticSearch;
+declare namespace neo4jQueries {
+  export { neo4jQueries_findPotentialContradictions as findPotentialContradictions, neo4jQueries_getAnchoringBiasDetection as getAnchoringBiasDetection, neo4jQueries_getBeliefEvidenceGraph as getBeliefEvidenceGraph, neo4jQueries_getBeliefHalfLife as getBeliefHalfLife, neo4jQueries_getBeliefsByCompany as getBeliefsByCompany, neo4jQueries_getBeliefsByEpistemicStatus as getBeliefsByEpistemicStatus, neo4jQueries_getCausalChains as getCausalChains, neo4jQueries_getChallengedBeliefs as getChallengedBeliefs, neo4jQueries_getCompaniesByTheme as getCompaniesByTheme, neo4jQueries_getConfirmationBiasScore as getConfirmationBiasScore, neo4jQueries_getConnectedNodesGraph as getConnectedNodesGraph, neo4jQueries_getContradictionTensionMap as getContradictionTensionMap, neo4jQueries_getCrossThemeBeliefs as getCrossThemeBeliefs, neo4jQueries_getEvidenceByCompany as getEvidenceByCompany, neo4jQueries_getEvidenceByMethodology as getEvidenceByMethodology, neo4jQueries_getEvidenceToBeliefPath as getEvidenceToBeliefPath, neo4jQueries_getFalsificationQuestions as getFalsificationQuestions, neo4jQueries_getFunctionsByValueChain as getFunctionsByValueChain, neo4jQueries_getGraphStats as getGraphStats, neo4jQueries_getHighPriorityQuestions as getHighPriorityQuestions, neo4jQueries_getKnowledgeFrontier as getKnowledgeFrontier, neo4jQueries_getMeetingPrepBrief as getMeetingPrepBrief, neo4jQueries_getMinimumFalsificationSet as getMinimumFalsificationSet, neo4jQueries_getMissingQuestionDetection as getMissingQuestionDetection, neo4jQueries_getNecessaryEvidence as getNecessaryEvidence, neo4jQueries_getNodeLineageGraph as getNodeLineageGraph, neo4jQueries_getNodeRelationships as getNodeRelationships, neo4jQueries_getNonConsensusBeliefs as getNonConsensusBeliefs, neo4jQueries_getPeopleByCompany as getPeopleByCompany, neo4jQueries_getPeopleByTheme as getPeopleByTheme, neo4jQueries_getPortfolioConviction as getPortfolioConviction, neo4jQueries_getPredictions as getPredictions, neo4jQueries_getProprietaryEvidence as getProprietaryEvidence, neo4jQueries_getProprietarySignals as getProprietarySignals, neo4jQueries_getQuestionsByTheme as getQuestionsByTheme, neo4jQueries_getQuestionsByValueChain as getQuestionsByValueChain, neo4jQueries_getReasoningDepthScore as getReasoningDepthScore, neo4jQueries_getSemanticBridges as getSemanticBridges, neo4jQueries_getSemanticOrphans as getSemanticOrphans, neo4jQueries_getSoftContradictions as getSoftContradictions, neo4jQueries_getSourceConcentrationRisk as getSourceConcentrationRisk, neo4jQueries_getStaleThemes as getStaleThemes, neo4jQueries_getSurpriseDetection as getSurpriseDetection, neo4jQueries_getThemeBeliefsGraph as getThemeBeliefsGraph, neo4jQueries_getThemeStats as getThemeStats, neo4jQueries_getThemeSubgraph as getThemeSubgraph, neo4jQueries_getThemeValueChainCandidates as getThemeValueChainCandidates, neo4jQueries_getThemesImpactingCompany as getThemesImpactingCompany, neo4jQueries_getValueChainsByTheme as getValueChainsByTheme, neo4jQueries_graphAwareSearch as graphAwareSearch, neo4jQueries_queryGraph as queryGraph, neo4jQueries_searchAllNodes as searchAllNodes, neo4jQueries_semanticSearch as semanticSearch };
+}
+
+export { semanticSearch as $, getNodeLineageGraph as A, getNodeRelationships as B, getNonConsensusBeliefs as C, getPeopleByCompany as D, getPeopleByTheme as E, getPortfolioConviction as F, getPredictions as G, getProprietaryEvidence as H, getProprietarySignals as I, getQuestionsByTheme as J, getQuestionsByValueChain as K, getReasoningDepthScore as L, getSemanticBridges as M, getSemanticOrphans as N, getSoftContradictions as O, getSourceConcentrationRisk as P, getStaleThemes as Q, getSurpriseDetection as R, getThemeBeliefsGraph as S, getThemeStats as T, getThemeSubgraph as U, getThemeValueChainCandidates as V, getThemesImpactingCompany as W, getValueChainsByTheme as X, graphAwareSearch as Y, queryGraph as Z, searchAllNodes as _, getBeliefEvidenceGraph as a, getBeliefHalfLife as b, getBeliefsByCompany as c, getBeliefsByEpistemicStatus as d, getCausalChains as e, findPotentialContradictions as f, getAnchoringBiasDetection as g, getChallengedBeliefs as h, getCompaniesByTheme as i, getConfirmationBiasScore as j, getConnectedNodesGraph as k, getContradictionTensionMap as l, getCrossThemeBeliefs as m, neo4jQueries as n, getEvidenceByCompany as o, getEvidenceByMethodology as p, getEvidenceToBeliefPath as q, getFalsificationQuestions as r, getFunctionsByValueChain as s, getGraphStats as t, getHighPriorityQuestions as u, getKnowledgeFrontier as v, getMeetingPrepBrief as w, getMinimumFalsificationSet as x, getMissingQuestionDetection as y, getNecessaryEvidence as z };