@memnexus-ai/sdk 1.55.2

package/dist/index.d.ts

@@ -0,0 +1,4291 @@
+/**
+ * Native fetch-based HTTP transport for the MemNexus Node.js SDK.
+ * Auto-generated by sdk-generator — do not edit manually.
+ *
+ * Requires Node.js >= 18 (built-in fetch).
+ */
+/** Thrown when the API returns a non-2xx response after all retries. */
+declare class SdkError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly data: unknown;
+    constructor(status: number, statusText: string, data: unknown);
+}
+/** Typed HTTP response returned by every service method. */
+interface HttpResponse<T = unknown> {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    data: T;
+}
+interface HttpClientOptions {
+    /** Bearer token for authentication. Falls back to MEMNEXUS_API_KEY env var. */
+    apiKey?: string;
+    /** Base URL for all requests. Defaults to https://api.memnexus.ai */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 30 000. */
+    timeoutMs?: number;
+}
+/** Request options for a single API call */
+interface RequestOptions {
+    pathParams?: Record<string, string | number | boolean>;
+    queryParams?: Record<string, string | number | boolean | null | undefined>;
+    headers?: Record<string, string>;
+    body?: unknown;
+    method: string;
+    path: string;
+}
+/**
+ * Lightweight HTTP client using native fetch with exponential-backoff retry.
+ *
+ * @example
+ * const client = new HttpClient({ apiKey: 'key' });
+ * const response = await client.request({ method: 'GET', path: '/memories' });
+ */
+declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    constructor(options?: HttpClientOptions);
+    request<T = unknown>(opts: RequestOptions): Promise<HttpResponse<T>>;
+}
+
+/**
+ * TypeScript interfaces for the MemNexus API.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+interface Error$1 {
+    /** Error message */
+    error: string;
+    /** Optional constructor name of the underlying error. Present on selected 500 responses for client diagnostics; absent on most error responses. */
+    errorClass?: string;
+}
+interface Pagination {
+    /** Maximum number of items per page */
+    limit: number;
+    /** Number of items to skip */
+    offset: number;
+    /** Total number of items */
+    count: number;
+}
+/** Environment context for memory scoping — product, service, team, component, role. */
+interface CodeContext {
+    /** Product name (e.g. 'memnexus', 'spearmint') */
+    product?: string;
+    /** Repository name, if different from product */
+    repo?: string;
+    /** Service or package name (e.g. 'core-api', 'mcp-server', 'cli') */
+    service?: string;
+    /** Subsystem or component (e.g. 'extraction-pipeline', 'search', 'billing') */
+    component?: string;
+    /** Team that produced this knowledge (e.g. 'extraction', 'mcp', 'platform') */
+    team?: string;
+    /** Agent role or persona (e.g. 'team-lead', 'implementer', 'reviewer') */
+    role?: string;
+    /** Additional project-specific scope tags */
+    extra?: Record<string, unknown>;
+}
+interface Memory {
+    /** Unique memory identifier */
+    id: string;
+    /** Optional human-readable name for deterministic retrieval. Only the HEAD version carries the name. */
+    name?: string;
+    /** Version number for named memories (1 for first version, increments on update) */
+    version?: number;
+    /** Memory content */
+    content: string;
+    /** Type of memory */
+    memoryType: 'episodic' | 'semantic' | 'procedural';
+    /** Context or domain of the memory */
+    context?: string;
+    /** Associated topics */
+    topics?: string[];
+    /** System ingestion timestamp (when the system learned about this) */
+    timestamp?: string;
+    /** Event time (when the event actually occurred in reality) */
+    eventTime?: string;
+    /** Validity start time (when this fact becomes valid) */
+    validFrom?: string;
+    /** Validity end time (when this fact expires, null means never expires) */
+    validTo?: string | null;
+    /** Environment context for memory scoping — product, service, team, component, role. */
+    codeContext?: CodeContext;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+    /** Confidence score (0-1) for this memory's accuracy */
+    confidenceScore?: number;
+    /** Basis for the confidence score */
+    confidenceBasis?: 'direct-statement' | 'repeated-mention' | 'single-mention' | 'hedged' | 'inference' | 'external-source' | 'contradicted';
+    /** Effective state of the memory in the narrative */
+    effectiveState?: 'current' | 'superseded' | 'contradicted' | 'duplicate';
+    /** Authority level: directive (mandates) > decision (choices with reasoning) > observation (learned during work) > auto-captured (generated content) */
+    authority?: 'directive' | 'decision' | 'observation' | 'auto-captured';
+    /** Legacy aggregate extraction status. DERIVED on read from the six per-stage statuses (contentEmbeddingStatus, summaryStatus, questionsStatus, summaryEmbeddingStatus, questionsEmbeddingStatus, graphStatus). Preserved for SDK compatibility per PRD memory-creation-pipeline-v2 §5 Q7. */
+    extractionStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** When extraction was completed */
+    extractionCompletedAt?: string;
+    /** Pipeline 2 content-embedding stage status. Tracks the queue lifecycle for writing m.embedding (primary content embedding). */
+    contentEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** AI-generated summary of the memory content */
+    summary?: string;
+    /** Pipeline 1 summary stage status. Tracks generation of m.summary by the summary-qna LLM call. */
+    summaryStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** Pipeline 1 questions stage status. Tracks generation of anticipated Question nodes by the summary-qna LLM call. */
+    questionsStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** Pipeline 2 summary-embedding stage status. Tracks the queue lifecycle for writing m.summaryEmbedding (depends on summaryStatus=completed). */
+    summaryEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** Pipeline 2 question-embedding stage status. Tracks the queue lifecycle for writing Question.embedding for each anticipated question (depends on questionsStatus=completed). */
+    questionsEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** Pipeline 3 graph-extraction stage status. Tracks generation of entities, facts, topics, authority, and memory-type. Replaces the role formerly played by the monolithic extractionStatus writer. */
+    graphStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** When graphStatus=skipped, records why graph extraction was skipped. Mirrors the legacy extractionSkipReason field but scoped to the graph pipeline. */
+    graphSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy' | 'budget_exhausted' | null;
+    /** When extractionStatus=skipped, records why extraction was skipped. global_disabled = GRAPH_EXTRACTION_ENABLED=false kill switch. */
+    extractionSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy';
+    /** Status of primary (Ollama) embedding generation via durable queue */
+    embeddingStatus?: 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** Status of secondary (OpenAI) dual-write embedding generation via durable queue */
+    embeddingOpenaiStatus?: 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+    /** True if the primary content embedding used a head-truncated input (model context exceeded). */
+    embeddingTruncated?: boolean;
+    /** Token count of the original content (pre-truncation, cl100k proxy). Useful for identifying under-indexed memories. */
+    embeddingOriginalTokens?: number;
+    /** Smart-field strategy used to produce the primary content embedding. */
+    embeddingStrategy?: 'full' | 'head-truncated' | 'summary-selected' | 'question-selected';
+    /** Number of topics extracted from content */
+    extractedTopicCount?: number;
+    /** Number of facts extracted from content */
+    extractedFactCount?: number;
+    /** Number of entities extracted from content */
+    extractedEntityCount?: number;
+    /** Number of memories this memory contradicts via outgoing CONTRADICTS relationships */
+    conflictCount?: number;
+    /** Memory visibility level. Null/undefined treated as 'private' for backward compatibility. 'admin_visible' is computed at retrieval time when an org owner/admin queries another member's post-join memory and is never accepted on writes. */
+    visibility?: 'private' | 'shared_with_users' | 'shared_with_org' | 'admin_visible';
+    /** User IDs this memory is shared with (only populated when visibility = 'shared_with_users') */
+    sharedWith?: string[];
+    /** Topics explicitly provided by the user */
+    userTopics?: string[];
+    /** Topics automatically extracted from content */
+    extractedTopics?: string[];
+    /** Entities extracted from memory content */
+    entities?: {
+        name: string;
+        type: string;
+        confidence?: number;
+    }[];
+    /** Task identifier for agentic loop memories */
+    taskId?: string | null;
+    /** Task outcome status */
+    outcome?: 'resolved' | 'unresolved' | null;
+    /** Attempt number within the task */
+    attemptNumber?: number | null;
+    /** Distillation pipeline stage status */
+    distillStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped' | null;
+    /** Reason distillation was skipped */
+    distillSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy' | 'budget_exhausted' | null;
+    /** Error message if distillation failed */
+    distillError?: string | null;
+    /** ISO 8601 timestamp when distillation completed */
+    distillCompletedAt?: string | null;
+}
+/** Privileged-only short-circuit for Pipeline 1/2 — admin/internal/test callers may pre-supply summary, questions, and/or embeddings to bypass LLM and embedding work at create time. Silently ignored for non-privileged callers. */
+interface PrecomputedMemoryFields {
+    /** Pre-computed memory summary. When supplied, summary-qna LLM call is skipped and m.summary is set inline. */
+    summary?: string;
+    /** Pre-computed anticipated questions. When supplied, the questions stage of the summary-qna LLM call is skipped and Question nodes are created inline. Hard-capped at 20. */
+    questions?: string[];
+    /** Pre-computed embeddings keyed by Pipeline 2 job kind (content / summary / question). */
+    embeddings?: {
+        content?: number[];
+        summary?: number[];
+        questions?: number[][];
+    };
+}
+interface CreateMemoryRequest {
+    /** Conversation ID - use "NEW" to always create a new conversation, provide an existing ID to append to it, or omit to auto-assign via claudeSessionId session grouping. */
+    conversationId?: string;
+    /** Agent session ID (e.g. MCP session ID, Claude Code session UUID). When conversationId is omitted, reuses or creates a conversation for this session (automatic grouping). Ignored when conversationId is explicitly provided. Works with any MCP client (Claude, Copilot, Cursor, etc.). */
+    claudeSessionId?: string;
+    /** Optional human-readable name for deterministic retrieval. Must be unique per user. */
+    name?: string;
+    /** Memory content */
+    content: string;
+    /** Type of memory */
+    memoryType?: 'episodic' | 'semantic' | 'procedural';
+    /** Role (MCP protocol compatibility) */
+    role?: 'user' | 'assistant' | 'system';
+    /** Context or domain */
+    context?: string;
+    /** Associated topics */
+    topics?: string[];
+    /** Event time (when the event actually occurred in reality, ISO 8601 format) */
+    eventTime?: string;
+    /** Validity start time (when this fact becomes valid, ISO 8601 format) */
+    validFrom?: string;
+    /** Validity end time (when this fact expires, ISO 8601 format, omit for never expires) */
+    validTo?: string;
+    codeContext?: {
+        product?: string;
+        repo?: string;
+        service?: string;
+        component?: string;
+        team?: string;
+        role?: string;
+        extra?: Record<string, unknown>;
+    };
+    /** Privileged-only short-circuit for Pipeline 1/2 — admin/internal/test callers may pre-supply summary, questions, and/or embeddings to bypass LLM and embedding work at create time. Silently ignored for non-privileged callers. */
+    precomputed?: PrecomputedMemoryFields;
+    /** Task identifier for grouping memories across agentic loop attempts */
+    taskId?: string;
+    /** Task outcome status for this memory */
+    outcome?: 'resolved' | 'unresolved';
+    /** Request distillation of this memory (Pro/Enterprise only) */
+    distill?: boolean;
+}
+interface UpdateMemoryRequest {
+    /** Updated memory content */
+    content?: string;
+    /** Assign or remove a name. Set to a valid name to assign, empty string to remove. */
+    name?: string | '';
+    /** Updated memory type */
+    memoryType?: 'episodic' | 'semantic' | 'procedural';
+    /** Updated context or domain */
+    context?: string;
+    /** Updated topics */
+    topics?: string[];
+    /** Task outcome status. Set to null to clear. */
+    outcome?: 'resolved' | 'unresolved' | null;
+}
+interface CreateMemoryResponseMeta {
+    /** Conversation ID (actual ID if "NEW" was provided) */
+    conversationId: string;
+    /** Auto-assigned session ID based on 90-minute gap detection */
+    sessionId: string;
+    /** Whether a new session was created (true) or existing session was reused (false) */
+    sessionCreated: boolean;
+    /** Whether a new conversation was created (true if conversationId was "NEW") */
+    conversationCreated: boolean;
+}
+/** Response from creating a memory, includes the memory and session/conversation metadata */
+interface CreateMemoryResponse {
+    data: Memory;
+    meta: CreateMemoryResponseMeta;
+}
+interface RelatedMemoryResult {
+    memory: {
+        id: string;
+        name?: string;
+        version?: number;
+        content: string;
+        memoryType: 'episodic' | 'semantic' | 'procedural';
+        context?: string;
+        topics?: string[];
+        timestamp?: string;
+        eventTime?: string;
+        validFrom?: string;
+        validTo?: string | null;
+        codeContext?: CodeContext;
+        createdAt: string;
+        updatedAt: string;
+        confidenceScore?: number;
+        confidenceBasis?: 'direct-statement' | 'repeated-mention' | 'single-mention' | 'hedged' | 'inference' | 'external-source' | 'contradicted';
+        effectiveState?: 'current' | 'superseded' | 'contradicted' | 'duplicate';
+        authority?: 'directive' | 'decision' | 'observation' | 'auto-captured';
+        extractionStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        extractionCompletedAt?: string;
+        contentEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        summary?: string;
+        summaryStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        questionsStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        summaryEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        questionsEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        graphStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        graphSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy' | 'budget_exhausted' | null;
+        extractionSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy';
+        embeddingStatus?: 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        embeddingOpenaiStatus?: 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        embeddingTruncated?: boolean;
+        embeddingOriginalTokens?: number;
+        embeddingStrategy?: 'full' | 'head-truncated' | 'summary-selected' | 'question-selected';
+        extractedTopicCount?: number;
+        extractedFactCount?: number;
+        extractedEntityCount?: number;
+        conflictCount?: number;
+        visibility?: 'private' | 'shared_with_users' | 'shared_with_org' | 'admin_visible';
+        sharedWith?: string[];
+        userTopics?: string[];
+        extractedTopics?: string[];
+        entities?: {
+            name: string;
+            type: string;
+            confidence?: number;
+        }[];
+        taskId?: string | null;
+        outcome?: 'resolved' | 'unresolved' | null;
+        attemptNumber?: number | null;
+        distillStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped' | null;
+        distillSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy' | 'budget_exhausted' | null;
+        distillError?: string | null;
+        distillCompletedAt?: string | null;
+    };
+    /** Relevance score (0-1). For similar: semantic similarity. For related: topic overlap ratio. For conversation: position score. */
+    score: number;
+    /** Type of relationship: similar, similar-by-topic, conversation, or topic */
+    relationship: string;
+    /** Topics shared with the source memory (only for topic relationship) */
+    sharedTopics?: string[];
+}
+/** Response from getting a memory by ID */
+interface GetMemoryResponse {
+    data: Memory;
+}
+interface UpdateNamedMemoryRequest {
+    /** New content for the named memory version */
+    content: string;
+    /** Type of memory (defaults to previous version's type) */
+    memoryType?: 'episodic' | 'semantic' | 'procedural';
+    /** Context or domain */
+    context?: string;
+    /** Associated topics */
+    topics?: string[];
+    /** Conversation to group this version with (overrides previous version's conversation) */
+    conversationId?: string;
+    codeContext?: {
+        product?: string;
+        repo?: string;
+        service?: string;
+        component?: string;
+        team?: string;
+        role?: string;
+        extra?: Record<string, unknown>;
+    };
+    /** Additional memory ID that this version supersedes (beyond the implicit version chain) */
+    supersedes?: string;
+}
+interface NamedMemoryHistoryResponse {
+    /** Human-readable name for deterministic retrieval (kebab-case, 2-64 chars) */
+    name: string;
+    versions: Array<{
+        version: number;
+        id: string;
+        content: string;
+        effectiveState?: 'current' | 'superseded' | 'contradicted' | 'duplicate';
+        createdAt: string;
+    }>;
+}
+interface BatchGetMemoriesRequest {
+    /** Array of memory IDs to retrieve. Non-existent or malformed IDs are returned in the 'missing' array rather than failing the request. */
+    ids: string[];
+    /** Detail level for each memory. 'minimal' returns raw memory only (default, backward compatible). 'standard' adds topics, entities, facts, and relationships. 'full' additionally adds conversation context and relationship target previews. */
+    detail?: 'minimal' | 'standard' | 'full';
+}
+interface BatchGetMemoriesMeta {
+    /** Number of IDs requested */
+    requested: number;
+    /** Number of memories found */
+    found: number;
+    /** IDs that were not found */
+    missing: string[];
+}
+/** Response from batch memory retrieval */
+interface BatchGetMemoriesResponse {
+    data: Memory[];
+    meta: BatchGetMemoriesMeta;
+}
+interface GraphRAGQueryRequest {
+    /** GraphRAG query string */
+    query: string;
+    /** Maximum graph traversal depth (alias: depth) */
+    maxDepth?: number;
+    /** Graph traversal depth (deprecated, use maxDepth) */
+    depth?: number;
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Include relationship data in response */
+    includeRelationships?: boolean;
+}
+interface GraphRAGQueryResponse {
+    /** Unique identifier for this query execution */
+    queryId: string;
+    /** Array of query results with graph context */
+    results: {
+        memory: Memory;
+        score: number;
+        topics: Record<string, unknown>[];
+        entities: Record<string, unknown>[];
+        relatedMemories: Record<string, unknown>[];
+    }[];
+    /** Query execution metadata */
+    metadata: {
+        query: string;
+        depth: number;
+        limit: number;
+        timestamp: string;
+    };
+}
+interface Conversation {
+    /** Unique conversation identifier */
+    id: string;
+    /** Conversation title */
+    title: string;
+    /** Conversation summary */
+    summary: string | null;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+interface CreateConversationRequest {
+    /** Conversation title */
+    title: string;
+    /** Optional conversation summary */
+    summary?: string;
+}
+interface ApiKey {
+    /** Unique API key identifier */
+    id: string;
+    /** Human-readable label for the API key */
+    label: string;
+    /** API key prefix for identification */
+    prefix: string;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Expiration timestamp (null if never expires) */
+    expiresAt: string | null;
+    /** Last usage timestamp (null if never used) */
+    lastUsedAt: string | null;
+}
+interface Topic {
+    /** Topic name */
+    name: string;
+    /** Number of memories associated with this topic */
+    count: number;
+}
+interface Pattern {
+    /** Unique pattern identifier */
+    id: string;
+    /** Pattern type */
+    type: string;
+    /** Pattern description */
+    description: string;
+    /** Confidence score (0-1) */
+    confidence: number;
+}
+interface CompileInstructionsRequest {
+    conversationContext?: string[];
+    currentQuery?: string;
+    tokenBudget?: number;
+    minConfidence?: number;
+    maxInstructions?: number;
+}
+interface CompileInstructionsResponse {
+    instructions: Array<{
+        patternId: string;
+        instruction: string;
+        confidence: number;
+        priority: number;
+        source: 'learned' | 'explicit' | 'manual';
+        patternType: string;
+        activatedBy: string[];
+        recommendationId?: string;
+        triggerContext?: string;
+        evidenceSummary?: string;
+        firstSurfacing?: boolean;
+    }>;
+    summary: string;
+    tokenCount: number;
+    patternsEvaluated: number;
+    patternsActivated: number;
+    conflictsResolved: {
+        winnerId: string;
+        loserId: string;
+        strategy: 'priority_override';
+    }[];
+    systemState?: 'ok' | 'cold_start' | 'pending_only' | 'no_match';
+    pendingCount?: number;
+    patternsExcluded?: number;
+}
+interface Recommendation {
+    id: string;
+    userId: string;
+    triggerContext: string;
+    practice: string;
+    evidenceSummary?: string;
+    source: 'explicit' | 'learned' | 'manual';
+    outcomeSignal: 'positive' | 'neutral' | 'unknown';
+    confidence: number;
+    evidenceMemoryIds?: string[];
+    triggerEmbeddingStatus: 'pending' | 'complete' | 'failed';
+    applicationCount: number;
+    provisional: boolean;
+    status: 'pending_review' | 'active' | 'paused' | 'dismissed' | 'superseded';
+    validFrom?: string;
+    validUntil?: string | null;
+    supersededBy?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateRecommendationRequest {
+    triggerContext: string;
+    practice: string;
+    evidenceSummary?: string;
+    outcomeSignal?: 'positive' | 'neutral' | 'unknown';
+    evidenceMemoryIds?: string[];
+    activateImmediately?: boolean;
+}
+interface MatchRecommendationsRequest {
+    content: string;
+    limit?: number;
+    similarityThreshold?: number;
+}
+interface ServiceCheck {
+    /** Service status */
+    status: 'up' | 'down';
+    /** Response time in milliseconds */
+    responseTime?: number;
+}
+interface HealthCheck {
+    /** Overall system health status */
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    /** Health check timestamp */
+    timestamp: string;
+    /** API version */
+    version: string;
+    /** System uptime in seconds */
+    uptime: number;
+    /** Individual service health checks */
+    checks: Record<string, unknown>;
+}
+interface SearchRequest {
+    /** Search query. On POST all methods accept up to 32768 chars; the GET endpoint caps all methods at 2000 (use POST for larger queries). For queries over 2000 chars the keyword-matching side (the keyword method, and hybrid's fulltext/entity sub-branches) searches on a representative SAMPLE of the query's most salient terms rather than the whole text; the semantic branch still embeds the full query. Queries at or under 2000 chars are searched verbatim. */
+    query: string;
+    /** Content filtering mode (defaults to unified) */
+    mode?: 'unified' | 'content' | 'facts';
+    /** Search algorithm: hybrid (combined, default), semantic (vector), or keyword (fulltext). */
+    searchMethod?: 'keyword' | 'semantic' | 'hybrid';
+    /** Maximum number of results (defaults to 20) */
+    limit?: number;
+    /** Offset for pagination (defaults to 0) */
+    offset?: number;
+    /** Weight for vector (semantic) results in hybrid search (0-1, defaults to 0.7) */
+    vectorWeight?: number;
+    /** Weight for fulltext (keyword) results in hybrid search (0-1, defaults to 0.3) */
+    fulltextWeight?: number;
+    /** Minimum similarity threshold for semantic search (0-1, defaults to 0.5) */
+    threshold?: number;
+    /** If true, include detailed explanation of how each result was matched */
+    explain?: boolean;
+    /** Point-in-time query: show what the system knew at this time (ISO 8601 format) */
+    asOfTime?: string;
+    /** Validity query: show facts that were valid at this time (ISO 8601 format) */
+    validAtTime?: string;
+    /** Event time range start (ISO 8601 format) */
+    eventTimeFrom?: string;
+    /** Event time range end (ISO 8601 format) */
+    eventTimeTo?: string;
+    /** Ingestion time range start (ISO 8601 format) */
+    ingestionTimeFrom?: string;
+    /** Ingestion time range end (ISO 8601 format) */
+    ingestionTimeTo?: string;
+    /** Include expired facts (defaults to false) */
+    includeExpired?: boolean;
+    /** Temporal query mode: 'current' (only valid now), 'historical' (as of a point in time), 'evolution' (chronological) */
+    temporalMode?: 'current' | 'historical' | 'evolution';
+    /** Filter by topics - returns memories that have ANY of the specified topics */
+    topics?: string[];
+    /** Filter by memory type */
+    memoryType?: 'episodic' | 'semantic' | 'procedural';
+    /** Filter by conversation ID */
+    conversationId?: string;
+    /** Task-scoped retrieval: returns own-history first, fills remainder with cross-task results. */
+    taskId?: string;
+    /** Filter by task outcome. Use 'resolved' to find successful approaches from past tasks. */
+    outcomeFilter?: 'resolved' | 'unresolved' | 'any';
+    /** Include topics associated with matched memories (defaults to false for performance) */
+    includeTopics?: boolean;
+    /** Include entities mentioned in matched memories (defaults to false for performance) */
+    includeEntities?: boolean;
+    /** Include facts extracted from matched memories (defaults to false for performance) */
+    includeFacts?: boolean;
+    /** Include claims associated with matched memories (defaults to true) */
+    includeClaims?: boolean;
+    /** Filter entities by type (e.g., PERSON, TECHNOLOGY, PROJECT) */
+    entityTypes?: string[];
+    /** Enable entity graph traversal branch in hybrid search (default false) */
+    expandEntities?: boolean;
+    /** Enable topic graph traversal branch in hybrid search (default true) */
+    expandTopics?: boolean;
+    /** Enable fact graph traversal branch in hybrid search (default true) */
+    expandFacts?: boolean;
+    /** Include superseded and contradicted memories in results (default false) */
+    includeSuperseded?: boolean;
+    /** Weight for entity graph branch in hybrid search (0-1, default 0.1) */
+    entityWeight?: number;
+    /** Weight for topic graph branch in hybrid search (0-1, default 0.5) */
+    topicWeight?: number;
+    /** Weight for fact graph branch in hybrid search (0-1, default 0.6) */
+    factWeight?: number;
+    /** Weight for question graph branch in hybrid search (0-1) */
+    questionWeight?: number;
+    /** Weight for claims vector branch in hybrid search (0-1, default 0.5) */
+    claimsWeight?: number;
+    /** Field to sort results by (defaults to 'relevance' for search, 'createdAt' for list) */
+    sortBy?: 'relevance' | 'createdAt' | 'updatedAt' | 'eventTime';
+    /** Sort order: 'asc' or 'desc' (defaults to 'desc' for timestamps, 'desc' for relevance) */
+    order?: 'asc' | 'desc';
+    /** Include facet aggregation (topics, memoryType, effectiveState) in response (defaults to false) */
+    includeFacets?: boolean;
+}
+interface Entity {
+    /** Entity name */
+    name?: string;
+    /** Entity type */
+    type?: string;
+}
+interface SearchResult {
+    /** Unique memory identifier */
+    id: string;
+    /** Full memory content */
+    content: string;
+    /** Truncated content preview (max 200 chars) */
+    preview: string;
+    /** Optional human-readable name for deterministic retrieval */
+    name?: string | null;
+    /** Type of memory */
+    memoryType: 'episodic' | 'semantic' | 'procedural';
+    /** Associated topics */
+    topics?: string[];
+    /** Conversation this memory belongs to */
+    conversationId?: string | null;
+    /** System ingestion timestamp */
+    timestamp?: string;
+    /** Event time (when the event actually occurred) */
+    eventTime?: string;
+    /** Validity start time */
+    validFrom?: string;
+    /** Creation timestamp */
+    createdAt?: string;
+    /** Last update timestamp */
+    updatedAt?: string;
+    /** Effective state of the memory */
+    effectiveState?: string;
+    /** Confidence score (0-1) */
+    confidenceScore?: number;
+    /** Overall relevance score for this result */
+    score?: number | null;
+    /** Entities mentioned in this memory */
+    entities?: Entity[];
+    /** Facts extracted from this memory */
+    facts?: {
+        subject: string;
+        predicate: string;
+        object: string;
+        confidence?: number;
+    }[];
+    /** Combined RRF score for hybrid search */
+    hybridScore?: number | null;
+    /** Vector similarity score (0-1) */
+    vectorScore?: number;
+    /** Rank in vector search results */
+    vectorRank?: number | null;
+    /** Fulltext search score */
+    fulltextScore?: number;
+    /** Rank in fulltext search results */
+    fulltextRank?: number | null;
+    /** Search branches that contributed to this result (e.g. ['semantic', 'entity']) */
+    matchedVia?: string[];
+    /** Per-branch RRF scores for this result */
+    branchScores?: Record<string, unknown>;
+    /** Raw cross-encoder rerank score; present only when the reranker reordered this request's top-K (null otherwise) */
+    rerankScore?: number | null;
+    /** Detailed explanation of the match (only when explain=true) */
+    explanation?: {
+        matchReason: string;
+        matchedTerms?: string[];
+        semanticSimilarity?: number;
+        contributingFactors?: string[];
+    };
+}
+/** Temporal query metadata (present when temporal filters are used) */
+interface TemporalMetadata {
+    /** Temporal query mode used */
+    temporalMode: string;
+    /** Point-in-time timestamp */
+    asOfTime: string | null;
+    /** Validity timestamp */
+    validAtTime: string | null;
+    /** Event time range filter */
+    eventTimeRange: {
+        from: string | null;
+        to: string | null;
+    } | null;
+    /** Ingestion time range filter */
+    ingestionTimeRange: {
+        from: string | null;
+        to: string | null;
+    } | null;
+    /** Whether expired facts are included */
+    includeExpired: boolean;
+    /** Whether temporal fields are included in results */
+    temporalFieldsIncluded: boolean;
+}
+/** Search metadata including pagination, timing, and method */
+interface SearchMeta {
+    /** Total number of results matching the query */
+    total: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Number of results per page */
+    pageSize: number;
+    /** Search duration in milliseconds */
+    searchTime: number;
+    /** Search method used for this query */
+    searchMethod: string;
+    /** Temporal query metadata (present when temporal filters are used) */
+    temporalMetadata?: TemporalMetadata;
+}
+interface FacetEntry {
+    /** Facet value */
+    value: string;
+    /** Number of results with this value */
+    count: number;
+}
+/** Facet aggregations (only present when includeFacets=true) */
+interface Facets {
+    /** Topic facet counts (top 20 by frequency) */
+    topics: FacetEntry[];
+    /** Memory type facet counts */
+    memoryType: FacetEntry[];
+    /** Effective state facet counts */
+    effectiveState: FacetEntry[];
+}
+interface ClaimGroupClaim {
+    /** Claim ID */
+    id: string;
+    /** Claim content text */
+    content: string;
+    /** Memory this claim was extracted from */
+    memoryId: string;
+    /** Claim creation timestamp */
+    createdAt: string;
+    /** When the claimed event occurred */
+    occurredStart?: string;
+}
+/** Computed signals about the claim cluster */
+interface ClaimGroupSignals {
+    /** Number of claims in this group */
+    n_claims: number;
+    /** Minimum LLM-judged alignment score among all pairs in the group (0=conflict, 1=corroborate) */
+    alignment_min: number;
+    /** Days between earliest and latest claim in the group */
+    temporal_spread_days: number;
+    /** True if alignment_min < 0.85, indicating potential conflict */
+    has_low_alignment_pair: boolean;
+    /** True if alignment_min < 0.4 — claims directly conflict or one supersedes the other */
+    has_conflict: boolean;
+    /** True if temporal_spread_days > 30 */
+    has_temporal_spread: boolean;
+}
+interface ClaimGroup {
+    /** Deterministic group ID */
+    id: string;
+    /** Claims in this group, sorted by createdAt descending (newest first) */
+    claims: ClaimGroupClaim[];
+    /** Computed signals about the claim cluster */
+    signals: ClaimGroupSignals;
+}
+interface SearchResponse {
+    /** Flattened search results with memory fields and search metadata */
+    data: SearchResult[];
+    /** Search metadata including pagination, timing, and method */
+    meta: SearchMeta;
+    /** Facet aggregations (only present when includeFacets=true) */
+    facets?: Facets;
+    /** Reader instructions for interpreting claims and resolving conflicts */
+    instructions?: string;
+    /** Clusters of related claims that may conflict. Only present when relevant groups exist. Claims within each group are sorted newest-first. */
+    claim_groups?: ClaimGroup[];
+}
+interface Fact {
+    /** Unique identifier for the fact */
+    id: string;
+    /** User ID who owns this fact */
+    userId: string;
+    /** The subject of the fact (what the fact is about) */
+    subject: string;
+    /** The relationship or property type */
+    predicate: string;
+    /** The value or target of the relationship */
+    object: string;
+    /** Fact name/label (deprecated, use subject) */
+    name?: string;
+    /** Entity type (deprecated, use predicate) */
+    type?: string;
+    /** Fact description (deprecated) */
+    description?: string | null;
+    /** Confidence score (0-1) */
+    confidence?: number;
+    /** ID of the memory this fact was extracted from */
+    sourceMemoryId?: string;
+    /** When this fact was extracted */
+    extractedAt?: string;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+interface CreateFactRequest {
+    /** Fact subject (entity name) */
+    subject: string;
+    /** Relationship type */
+    predicate: string;
+    /** Fact object (related entity) */
+    object: string;
+}
+interface UpdateFactRequest {
+    /** Fact subject (entity name) */
+    subject?: string;
+    /** Relationship type */
+    predicate?: string;
+    /** Fact object (related entity) */
+    object?: string;
+    /** Confidence score (0-1) */
+    confidence?: number;
+}
+interface FactSearchRequest {
+    /** Search query string */
+    query: string;
+    /** Maximum number of results to return */
+    limit?: number;
+}
+interface Community {
+    /** Unique identifier for the community */
+    id: string;
+    /** Community name */
+    name: string;
+    /** Community description */
+    description?: string | null;
+    /** Number of topics in this community */
+    topicCount?: number;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+interface EntityNode {
+    /** Unique identifier for the entity */
+    id: string;
+    /** User ID who owns this entity */
+    userId: string;
+    /** Entity display name */
+    name: string;
+    /** Normalized (lowercase) name for deduplication */
+    normalizedName: string;
+    /** Entity type classification (v2: PERSON, ORGANIZATION, CONCEPT; legacy types accepted) */
+    type: 'PERSON' | 'ORGANIZATION' | 'CONCEPT' | 'PROJECT' | 'TECHNOLOGY' | 'COMPONENT' | 'API_ENDPOINT' | 'FILE' | 'LOCATION';
+    /** Alternative names for this entity */
+    aliases?: string[];
+    /** Extraction confidence score (0-1) */
+    confidence: number;
+    /** When this entity was first extracted */
+    firstSeenAt: string;
+    /** When this entity was most recently seen */
+    lastSeenAt: string;
+    /** Number of memories that mention this entity */
+    mentionCount: number;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+interface Artifact {
+    /** Unique identifier for the artifact */
+    id: string;
+    /** User ID who owns this artifact */
+    userId: string;
+    /** Artifact content */
+    content: string;
+    /** Artifact type (e.g., note, document, code) */
+    type: string;
+    /** Artifact name */
+    name?: string | null;
+    /** Artifact description */
+    description?: string | null;
+    /** Associated memory ID */
+    memoryId?: string | null;
+    /** Associated conversation ID */
+    conversationId?: string | null;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+interface CreateArtifactRequest {
+    /** Artifact content */
+    content: string;
+    /** Artifact type (e.g., note, document, code) */
+    type: string;
+    /** Artifact name */
+    name?: string;
+    /** Artifact description */
+    description?: string;
+    /** Associated memory ID */
+    memoryId?: string;
+    /** Associated conversation ID */
+    conversationId?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+interface UpdateArtifactRequest {
+    /** Artifact content */
+    content?: string;
+    /** Artifact type (e.g., note, document, code) */
+    type?: string;
+    /** Artifact name */
+    name?: string;
+    /** Artifact description */
+    description?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+interface MemoryRelationship {
+    /** Unique relationship identifier */
+    id: string;
+    /** ID of the source memory (the memory that has the relationship) */
+    sourceMemoryId: string;
+    /** ID of the target memory (the memory being related to) */
+    targetMemoryId: string;
+    /** Type of relationship between memories */
+    type: 'SUPERSEDES' | 'FOLLOWS' | 'RESOLVES' | 'CONTRADICTS' | 'REFERENCES' | 'DUPLICATES';
+    /** Confidence score for the relationship (0-1) */
+    confidence: number;
+    /** How the relationship was created */
+    creationMethod: 'manual' | 'auto-semantic' | 'auto-temporal' | 'auto-llm';
+    /** Human-readable explanation for why this relationship exists */
+    reason?: string;
+    /** When the relationship was created */
+    createdAt: string;
+}
+interface CreateMemoryRelationshipRequest {
+    /** ID of the target memory to create a relationship with */
+    targetMemoryId: string;
+    /** Type of relationship between memories */
+    type: 'SUPERSEDES' | 'FOLLOWS' | 'RESOLVES' | 'CONTRADICTS' | 'REFERENCES' | 'DUPLICATES';
+    /** Confidence score for the relationship (0-1, defaults to 1.0 for manual) */
+    confidence?: number;
+    /** Optional explanation for the relationship */
+    reason?: string;
+}
+interface MemoryRelationshipsResponse {
+    data: MemoryRelationship[];
+    /** The source memory ID these relationships are for */
+    sourceMemoryId: string;
+    /** Direction of relationships returned */
+    direction: 'outgoing' | 'incoming' | 'both';
+}
+interface NarrativeThread {
+    /** Unique narrative thread identifier */
+    id: string;
+    /** User ID who owns this narrative */
+    userId: string;
+    /** Title describing the narrative thread */
+    title: string;
+    /** Current state of the narrative thread */
+    state: 'open' | 'resolved' | 'reopened' | 'superseded';
+    /** ID of the first memory in this narrative */
+    rootMemoryId: string;
+    /** ID of the most recent memory in this narrative */
+    currentMemoryId?: string;
+    /** ID of the memory that resolved this narrative (if resolved) */
+    resolutionMemoryId?: string;
+    /** Topics associated with this narrative */
+    topics: string[];
+    /** Number of memories in this narrative */
+    memoryCount: number;
+    /** When the narrative was created */
+    createdAt: string;
+    /** When the narrative was last updated */
+    updatedAt: string;
+}
+interface CreateNarrativeRequest {
+    /** Title for the narrative thread */
+    title: string;
+    /** ID of the first memory in this narrative */
+    rootMemoryId: string;
+    /** Topics to associate with this narrative */
+    topics?: string[];
+}
+interface UpdateNarrativeRequest {
+    /** Updated title for the narrative */
+    title?: string;
+    /** Current state of the narrative thread */
+    state?: 'open' | 'resolved' | 'reopened' | 'superseded';
+    /** ID of the memory that resolves this narrative */
+    resolutionMemoryId?: string;
+    /** Updated topics for the narrative */
+    topics?: string[];
+}
+interface AddMemoryToNarrativeRequest {
+    /** ID of the memory to add to the narrative */
+    memoryId: string;
+    /** Position in the narrative (0-indexed, omit for append) */
+    position?: number;
+}
+interface NarrativeMemory {
+    memory: {
+        id: string;
+        name?: string;
+        version?: number;
+        content: string;
+        memoryType: 'episodic' | 'semantic' | 'procedural';
+        context?: string;
+        topics?: string[];
+        timestamp?: string;
+        eventTime?: string;
+        validFrom?: string;
+        validTo?: string | null;
+        codeContext?: CodeContext;
+        createdAt: string;
+        updatedAt: string;
+        confidenceScore?: number;
+        confidenceBasis?: 'direct-statement' | 'repeated-mention' | 'single-mention' | 'hedged' | 'inference' | 'external-source' | 'contradicted';
+        effectiveState?: 'current' | 'superseded' | 'contradicted' | 'duplicate';
+        authority?: 'directive' | 'decision' | 'observation' | 'auto-captured';
+        extractionStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        extractionCompletedAt?: string;
+        contentEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        summary?: string;
+        summaryStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        questionsStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        summaryEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        questionsEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        graphStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        graphSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy' | 'budget_exhausted' | null;
+        extractionSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy';
+        embeddingStatus?: 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        embeddingOpenaiStatus?: 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+        embeddingTruncated?: boolean;
+        embeddingOriginalTokens?: number;
+        embeddingStrategy?: 'full' | 'head-truncated' | 'summary-selected' | 'question-selected';
+        extractedTopicCount?: number;
+        extractedFactCount?: number;
+        extractedEntityCount?: number;
+        conflictCount?: number;
+        visibility?: 'private' | 'shared_with_users' | 'shared_with_org' | 'admin_visible';
+        sharedWith?: string[];
+        userTopics?: string[];
+        extractedTopics?: string[];
+        entities?: {
+            name: string;
+            type: string;
+            confidence?: number;
+        }[];
+        taskId?: string | null;
+        outcome?: 'resolved' | 'unresolved' | null;
+        attemptNumber?: number | null;
+        distillStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped' | null;
+        distillSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy' | 'budget_exhausted' | null;
+        distillError?: string | null;
+        distillCompletedAt?: string | null;
+    };
+    /** Position of this memory in the narrative (0-indexed) */
+    position: number;
+    /** Effective state of this memory in the narrative context */
+    effectiveState?: 'current' | 'superseded' | 'contradicted';
+}
+interface NarrativeTimelineResponse {
+    data: NarrativeMemory[];
+    narrative: NarrativeThread;
+    pagination: {
+        limit: number;
+        offset: number;
+        total: number;
+    };
+}
+interface GetNarrativeResponse {
+    data: NarrativeThread;
+}
+interface ListNarrativesResponse {
+    data: NarrativeThread[];
+    pagination: {
+        limit: number;
+        offset: number;
+        count: number;
+    };
+}
+interface User {
+    id: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    profilePictureUrl: string | null;
+    status: 'active' | 'suspended' | 'disabled';
+    plan: 'free' | 'pro' | 'enterprise';
+    memoryLimit: number;
+    retentionDays: number | null;
+    isTestUser: boolean;
+    isPreviewUser: boolean;
+    isInternalUser: boolean;
+    deletionStatus: 'none' | 'pending_deletion' | 'deleting' | 'deleted' | 'deletion_failed';
+    deletionScheduledFor: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface UserUsage {
+    memoriesUsed: number;
+    memoryLimit: number;
+    memoriesRemaining: number;
+    percentUsed: number;
+    plan: 'free' | 'pro' | 'enterprise';
+    periodStart: string;
+    periodEnd: string;
+}
+interface Subscription {
+    /** Stripe subscription ID */
+    id: string;
+    /** Current subscription status */
+    status: 'active' | 'canceled' | 'incomplete' | 'incomplete_expired' | 'past_due' | 'paused' | 'trialing' | 'unpaid';
+    /** Plan type */
+    plan: 'free' | 'pro' | 'enterprise';
+    /** Current period start date */
+    currentPeriodStart: string;
+    /** Current period end date */
+    currentPeriodEnd: string;
+    /** Whether subscription cancels at period end */
+    cancelAtPeriodEnd: boolean;
+    /** When subscription was canceled */
+    canceledAt: string | null;
+}
+interface Invoice {
+    /** Stripe invoice ID */
+    id: string;
+    /** Invoice number */
+    number: string | null;
+    /** Invoice status */
+    status: 'draft' | 'open' | 'paid' | 'uncollectible' | 'void';
+    /** Amount due in cents */
+    amountDue: number;
+    /** Amount paid in cents */
+    amountPaid: number;
+    /** Three-letter ISO currency code */
+    currency: string;
+    /** Start of billing period */
+    periodStart: string;
+    /** End of billing period */
+    periodEnd: string;
+    /** When invoice was created */
+    created: string;
+    /** URL to view invoice */
+    hostedInvoiceUrl: string | null;
+    /** URL to download invoice PDF */
+    invoicePdf: string | null;
+}
+interface PaymentMethod {
+    /** Stripe payment method ID */
+    id: string;
+    /** Payment method type (card, etc.) */
+    type: string;
+    /** Card details if type is card */
+    card: {
+        brand: string;
+        last4: string;
+        expMonth: number;
+        expYear: number;
+    } | null;
+    /** Whether this is the default payment method */
+    isDefault: boolean;
+}
+interface BillingOverview {
+    subscription: {
+        id: string;
+        status: 'active' | 'canceled' | 'incomplete' | 'incomplete_expired' | 'past_due' | 'paused' | 'trialing' | 'unpaid';
+        plan: 'free' | 'pro' | 'enterprise';
+        currentPeriodStart: string;
+        currentPeriodEnd: string;
+        cancelAtPeriodEnd: boolean;
+        canceledAt: string | null;
+    };
+    defaultPaymentMethod: {
+        id: string;
+        type: string;
+        card: {
+            brand: string;
+            last4: string;
+            expMonth: number;
+            expYear: number;
+        } | null;
+        isDefault: boolean;
+    };
+    /** Upcoming invoice preview */
+    upcomingInvoice: {
+        amountDue: number;
+        currency: string;
+        periodEnd: string;
+    } | null;
+}
+interface CreateCheckoutSessionRequest {
+    /** Stripe price ID (defaults to Pro price) */
+    priceId?: string;
+    /** URL to redirect after successful checkout */
+    successUrl: string;
+    /** URL to redirect if checkout is canceled */
+    cancelUrl: string;
+}
+interface CheckoutSessionResponse {
+    /** Stripe checkout session ID */
+    sessionId: string;
+    /** URL to redirect user to Stripe checkout */
+    url: string;
+}
+interface CreatePortalSessionRequest {
+    /** URL to redirect after leaving the portal */
+    returnUrl: string;
+}
+interface PortalSessionResponse {
+    /** URL to redirect user to Stripe billing portal */
+    url: string;
+}
+interface ListInvoicesResponse {
+    /** List of invoices */
+    data: Invoice[];
+    /** Whether there are more invoices */
+    hasMore: boolean;
+}
+interface ListPaymentMethodsResponse {
+    /** List of payment methods */
+    data: PaymentMethod[];
+}
+interface DigestRequest {
+    /** The topic or subject to generate a digest for */
+    query: string;
+    /** Time window filter (e.g., "7d", "24h", "2w", "30m"). Only considers memories within this window. */
+    recent?: string;
+    /** Filter to memories with these topics */
+    topics?: string[];
+    /** Limit to specific conversation IDs */
+    conversationIds?: string[];
+    /** Output format: "structured" (sections with headers), "narrative" (chronological prose), "timeline" (dated event list), "status-report" (done/in-progress/blocked) */
+    format?: 'structured' | 'narrative' | 'timeline' | 'status-report';
+    /** Maximum number of memories to consider (1-500, default 100) */
+    maxSources?: number;
+    /** Whether to include source memory IDs in the response */
+    includeMemoryIds?: boolean;
+    /** Number of most-recent matching memories to return VERBATIM (full stored content, untouched) in `recentMemories`, instead of synthesizing them into `digest`. The remaining (older) memories are still synthesized into `digest` as usual. Recency is determined by event time when present, else system timestamp, else creation time. Default 0 = current behavior (synthesize all memories, `recentMemories` empty). When the total matched count is <= verbatimRecent, all matches are returned in `recentMemories` and `digest` is an empty string (no older memories to synthesize). Range 0-50. */
+    verbatimRecent?: number;
+}
+/** Time range of the source memories (null if no sources found) */
+interface DigestTimeRange {
+    /** Earliest memory timestamp in the digest sources */
+    earliest: string;
+    /** Latest memory timestamp in the digest sources */
+    latest: string;
+}
+/** Generation metadata including source statistics */
+interface DigestMetadata {
+    /** The query used to generate the digest */
+    query: string;
+    /** Total number of memories gathered (search + expansion) before synthesis */
+    sourcesConsidered: number;
+    /** Number of memories fed into the synthesis step */
+    sourcesUsed: number;
+    /** Number of distinct conversations the sources come from */
+    conversationsSpanned: number;
+    /** Time range of the source memories (null if no sources found) */
+    timeRange: DigestTimeRange;
+    /** Output format used for this digest */
+    format: 'structured' | 'narrative' | 'timeline' | 'status-report';
+    /** Average relevance score (0-1) of the source memories used in synthesis. Low values (<0.02) indicate the query may not have strong matches. */
+    averageRelevance?: number;
+    /** True when averageRelevance falls in the narrow-window band (>= DIGEST_RELEVANCE_THRESHOLD but < NARROW_WINDOW_FALLBACK_CEILING) — the digest synthesised from weak matches that may not represent strong context. Consumers should surface a warning to the calling agent. */
+    narrowWindowFallback?: boolean;
+    /** True when the digest is in the narrow-window band AND the source memories span 2+ distinct codeContext.product values (or none share a product). Indicates the synthesis is drawn from heterogeneous, possibly cross-project sources — likely the wrong project for the calling agent. See support#183. */
+    crossProjectFallback?: boolean;
+    /** ISO 8601 timestamp when the digest was generated */
+    generatedAt: string;
+    /** Recursion stats (only present when recursive synthesis is used) */
+    recursion?: {
+        enabled: boolean;
+        leafGroups: number;
+        llmCallsUsed: number;
+        maxDepthReached: number;
+    };
+}
+interface DigestSource {
+    /** Source memory ID */
+    memoryId: string;
+    /** Relevance score (0-1) for this source memory */
+    relevance: number;
+    /** Conversation ID this memory belongs to */
+    conversation?: string;
+}
+interface DigestKeyFact {
+    /** Fact subject */
+    subject: string;
+    /** Relationship type */
+    predicate: string;
+    /** Fact value */
+    object: string;
+    /** Confidence score */
+    confidence: number;
+}
+interface DigestEntity {
+    /** Entity name */
+    name: string;
+    /** Entity type */
+    type: string;
+}
+/** Breakdown of source memories by effective state (current/superseded/contradicted) */
+interface EffectiveStateBreakdown {
+    /** Active memories used in synthesis */
+    current: number;
+    /** Superseded memories (deprioritized in synthesis) */
+    superseded: number;
+    /** Contradicted memories (deprioritized in synthesis) */
+    contradicted: number;
+}
+interface DigestResponse {
+    /** The generated digest content (markdown formatted) */
+    digest: string;
+    /** Generation metadata including source statistics */
+    metadata: DigestMetadata;
+    /** Source memories used to generate the digest, for traceability */
+    sources: DigestSource[];
+    /** The N most-recent matching memories returned VERBATIM (full stored content, untouched), where N = the request's verbatimRecent. Ordered newest-first. Empty/omitted when verbatimRecent is 0 (the default). These memories are NOT synthesized into `digest` — the synthesis covers only the older remainder. Lets callers preserve the exact structure of recent items (per-item status, identifiers, next-step) while still condensing the older tail. */
+    recentMemories?: Memory[];
+    /** Top extracted facts relevant to the digest, deduplicated and ranked by frequency */
+    keyFacts?: DigestKeyFact[];
+    /** Key entities mentioned across source memories */
+    entities?: DigestEntity[];
+    /** Breakdown of source memories by effective state (current/superseded/contradicted) */
+    effectiveStateBreakdown?: EffectiveStateBreakdown;
+}
+interface ExportRequest {
+    /** Optional search query to filter memories for export */
+    query?: string;
+    /** Filter by topics */
+    topics?: string[];
+    /** Filter by memory type */
+    memoryType?: 'episodic' | 'semantic' | 'procedural';
+    /** Export format: json or csv (default: json) */
+    format?: 'json' | 'csv';
+    /** Optional field selection. If omitted, all standard fields are included. */
+    fields?: string[];
+    /** Maximum results to export (default 100, max 1000) */
+    limit?: number;
+}
+interface BulkUpdateRequest {
+    /** Memory IDs to update (max 100) */
+    ids: string[];
+    /** Fields to update on all specified memories */
+    updates: {
+        topics?: string[];
+        memoryType?: 'episodic' | 'semantic' | 'procedural';
+    };
+}
+interface BulkUpdateResponse {
+    /** Number of memories successfully updated */
+    updated: number;
+    /** Number of memories that failed to update */
+    failed: number;
+    /** Per-item error details */
+    errors: {
+        id: string;
+        error: string;
+    }[];
+}
+interface BulkDeleteRequest {
+    /** Memory IDs to delete (max 100) */
+    ids: string[];
+    /** Must be true to confirm bulk deletion */
+    confirmDeletion: true;
+}
+interface BulkDeleteResponse {
+    /** Number of memories successfully deleted */
+    deleted: number;
+    /** Number of memories that failed to delete */
+    failed: number;
+    /** Per-item error details */
+    errors: {
+        id: string;
+        error: string;
+    }[];
+}
+interface BulkTagRequest {
+    /** Memory IDs to modify tags on (max 100) */
+    ids: string[];
+    /** Topics to add to all specified memories */
+    addTopics?: string[];
+    /** Topics to remove from all specified memories */
+    removeTopics?: string[];
+}
+interface BulkTagResponse {
+    /** Number of memories successfully modified */
+    modified: number;
+    /** Number of memories that failed to modify */
+    failed: number;
+    /** Per-item error details */
+    errors: {
+        id: string;
+        error: string;
+    }[];
+}
+interface BuildContextRequest {
+    /** What you are about to work on */
+    context: string;
+    /** File paths you will be touching */
+    files?: string[];
+    /** How far back to look for recent activity (hours, default 24) */
+    recentHours?: number;
+}
+/** Most relevant active conversation, or null if none found */
+interface BuildContextActiveWork {
+    /** Conversation ID */
+    conversationId: string;
+    /** Conversation title */
+    title: string | null;
+    /** ISO 8601 timestamp of last activity */
+    lastActivity: string;
+    /** Most recent memory in this conversation */
+    lastMemory: {
+        id: string;
+        summary: string;
+    };
+}
+interface BuildContextFact {
+    /** Fact subject */
+    subject: string;
+    /** Fact predicate */
+    predicate: string;
+    /** Fact object */
+    object: string;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Memory this fact was extracted from */
+    sourceMemoryId: string;
+}
+interface BuildContextGotcha {
+    /** The gotcha fact text */
+    fact: string;
+    /** Number of distinct source memories mentioning this */
+    sourceCount: number;
+    /** Source memory IDs */
+    sourceMemories: string[];
+    /** ISO 8601 timestamp of most recent source */
+    lastSeen: string;
+}
+interface BuildContextActivity {
+    /** Memory ID */
+    id: string;
+    /** Truncated content summary (max 200 chars) */
+    summary: string;
+    /** ISO 8601 timestamp */
+    date: string;
+    /** Conversation ID */
+    conversationId: string | null;
+}
+interface BuildContextPattern {
+    /** Pattern description */
+    pattern: string;
+    /** Confidence score (0-1) */
+    confidence: number;
+}
+/** Request metadata for transparency */
+interface BuildContextMeta {
+    /** Search terms extracted from the context and files */
+    contextTerms: string[];
+    /** Hours window used for recent activity */
+    recentHours: number;
+    /** Sections whose backing query exceeded the per-branch timeout and were returned empty. Present only when at least one branch timed out, so an empty section can otherwise be read as 'no data'. */
+    timedOutSections?: string[];
+}
+interface BuildContextResponse {
+    /** Most relevant active conversation, or null if none found */
+    activeWork: BuildContextActiveWork;
+    /** Facts related to the context terms */
+    relevantFacts: BuildContextFact[];
+    /** Gotchas — facts appearing in 2+ source memories */
+    gotchas: BuildContextGotcha[];
+    /** Recent relevant memories within the time window */
+    recentActivity: BuildContextActivity[];
+    /** Behavioral patterns related to the context */
+    relatedPatterns: BuildContextPattern[];
+    /** Request metadata for transparency */
+    meta: BuildContextMeta;
+}
+interface SystemAlert {
+    id: string;
+    title: string;
+    body: string;
+    severity: 'info' | 'warning' | 'critical';
+    active?: boolean;
+    dismissible?: boolean;
+    targetAllUsers?: boolean;
+    targetUserIds?: string[];
+    createdAt: string;
+    expiresAt: string | null;
+    createdBy: string;
+}
+interface CreateSystemAlertRequest {
+    title: string;
+    body: string;
+    severity?: 'info' | 'warning' | 'critical';
+    active?: boolean;
+    dismissible?: boolean;
+    targetAllUsers?: boolean;
+    targetUserIds?: string[];
+    expiresAt?: string | null;
+}
+interface UpdateSystemAlertRequest {
+    title?: string;
+    body?: string;
+    severity?: 'info' | 'warning' | 'critical';
+    active?: boolean;
+    dismissible?: boolean;
+    targetAllUsers?: boolean;
+    targetUserIds?: string[];
+    expiresAt?: string | null;
+}
+
+/**
+ * UsersService — User management and profile endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** User management and profile endpoints */
+declare class Users {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Sync user from WorkOS
+     *
+     * Called by the customer portal after WorkOS authentication.
+     * Creates a new user if they don't exist, or updates their profile if they do.
+     * This is the main entry point for user provisioning.
+     * When the invite gate is closed and a new user is created, the inviteCode
+     * is redeemed atomically to track which code was used for registration.
+     *
+     * @param body — Request body
+     */
+    syncUser(body: {
+        workosId: string;
+        email: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        profilePictureUrl?: string | null;
+        inviteCode?: string;
+    }): Promise<HttpResponse<{
+        data?: User;
+        created?: boolean;
+    }>>;
+    /**
+     * Get current user
+     *
+     * Get the currently authenticated user's profile and usage information
+     */
+    getCurrentUser(): Promise<HttpResponse<{
+        data?: User;
+        usage?: UserUsage;
+    }>>;
+    /**
+     * Update current user
+     *
+     * Update the currently authenticated user's profile
+     * @param options — Optional parameters
+     */
+    updateCurrentUser(options?: {
+        body?: {
+            firstName?: string | null;
+            lastName?: string | null;
+            profilePictureUrl?: string | null;
+        };
+    }): Promise<HttpResponse<{
+        data?: User;
+    }>>;
+    /**
+     * Get current user's usage
+     *
+     * Get the currently authenticated user's memory usage statistics
+     */
+    getCurrentUserUsage(): Promise<HttpResponse<{
+        data?: UserUsage;
+    }>>;
+    /**
+     * Export all user data
+     *
+     * Export all user data as a JSON archive. Includes profile, memories,
+     * conversations, facts, and patterns. Supports GDPR Article 20
+     * (right to data portability). Sensitive fields (Stripe customer ID,
+     * WorkOS ID, embeddings) are excluded.
+     *
+     */
+    exportUserData(): Promise<HttpResponse<{
+        exportVersion?: string;
+        exportedAt?: string;
+        counts?: {
+            memories?: number;
+            conversations?: number;
+            facts?: number;
+            patterns?: number;
+        };
+        profile?: Record<string, unknown>;
+        memories?: Memory[];
+        conversations?: Conversation[];
+        facts?: Fact[];
+        patterns?: Pattern[];
+    }>>;
+    /**
+     * Initiate account deletion
+     *
+     * Schedule the current user's account for deletion after a 7-day grace period.
+     * Requires email confirmation. Immediately revokes API keys and cancels
+     * any active subscription. The account enters read-only mode.
+     *
+     * @param body — Request body
+     */
+    initiateAccountDeletion(body: {
+        confirmationEmail: string;
+    }): Promise<HttpResponse<{
+        data?: User;
+        message?: string;
+    }>>;
+    /**
+     * Cancel account deletion
+     *
+     * Cancel a pending account deletion during the grace period.
+     * Note: Previously revoked API keys are not restored — new keys must be created.
+     * Stripe subscription may need manual reactivation via the billing portal.
+     *
+     */
+    cancelAccountDeletion(): Promise<HttpResponse<{
+        data?: User;
+        message?: string;
+    }>>;
+    /**
+     * Get user by ID
+     *
+     * Get a user by their internal ID (admin only)
+     * @param id
+     */
+    getUserById(id: string): Promise<HttpResponse<{
+        data?: User;
+    }>>;
+}
+
+/**
+ * TopicsService — Topic detection, clustering, and management endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Topic detection, clustering, and management endpoints */
+declare class Topics {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List topics
+     *
+     * List all topics with pagination
+     * @param options — Optional parameters
+     */
+    listTopics(options?: {
+        limit?: number;
+        offset?: number;
+        sortBy?: 'name' | 'memoryCount';
+        order?: 'asc' | 'desc';
+    }): Promise<HttpResponse<{
+        data?: Topic[];
+        pagination?: {
+            limit?: number;
+            offset?: number;
+            count?: number;
+        };
+    }>>;
+    /**
+     * Get topic by ID
+     *
+     * Retrieve a specific topic by its ID
+     * @param id — The topic ID
+     */
+    getTopicById(id: string): Promise<HttpResponse<{
+        data?: Topic;
+    }>>;
+    /**
+     * Merge topics
+     *
+     * Merge two topics into one
+     * @param body — Request body
+     */
+    mergeTopics(body: {
+        sourceTopicId: string;
+        targetTopicId: string;
+    }): Promise<HttpResponse<{
+        data?: Topic;
+    }>>;
+    /**
+     * Discover related topics
+     *
+     * Discover topics related to a given topic
+     * @param body — Request body
+     */
+    discoverRelatedTopics(body: {
+        topicId: string;
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: Topic[];
+    }>>;
+    /**
+     * Calculate topic similarity
+     *
+     * Calculate similarity score between two topics
+     * @param body — Request body
+     */
+    calculateTopicSimilarity(body: {
+        topicId1: string;
+        topicId2: string;
+    }): Promise<HttpResponse<{
+        data?: {
+            similarity?: number;
+        };
+    }>>;
+    /**
+     * Find similar topics
+     *
+     * Find topics similar to a given topic
+     * @param body — Request body
+     */
+    findSimilarTopics(body: {
+        topicId: string;
+        threshold?: number;
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: {
+            topic?: Topic;
+            similarity?: number;
+        }[];
+    }>>;
+    /**
+     * Cluster topics
+     *
+     * Cluster topics using community detection algorithms
+     * @param options — Optional parameters
+     */
+    clusterTopics(options?: {
+        body?: {
+            minClusterSize?: number;
+        };
+    }): Promise<HttpResponse<{
+        data?: {
+            clusters?: Record<string, unknown>[];
+            clusterCount?: number;
+        };
+    }>>;
+    /**
+     * Detect communities
+     *
+     * Detect communities in the topic graph using specified algorithm
+     * @param options — Optional parameters
+     */
+    detectCommunities(options?: {
+        body?: {
+            algorithm?: string;
+        };
+    }): Promise<HttpResponse<{
+        data?: {
+            communities?: Community[];
+            communityCount?: number;
+        };
+    }>>;
+    /**
+     * Search topics
+     *
+     * Search topics by query string using fulltext search
+     * @param body — Request body
+     */
+    searchTopics(body: {
+        query: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpResponse<{
+        data?: Record<string, unknown>[];
+        total?: number;
+        limit?: number;
+        offset?: number;
+    }>>;
+}
+
+/**
+ * SystemService — System health, monitoring, and configuration endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** System health, monitoring, and configuration endpoints */
+declare class System {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Get system health status
+     *
+     * Get the current health status of the system including database connectivity
+     */
+    getSystemHealth(): Promise<HttpResponse<{
+        data?: {
+            status?: 'healthy' | 'unhealthy';
+            database?: Record<string, unknown>;
+            uptime?: number;
+        };
+    }>>;
+    /**
+     * Get context status
+     *
+     * Get database statistics and context information
+     */
+    getContextStatus(): Promise<HttpResponse<{
+        data?: Record<string, unknown>;
+    }>>;
+    /**
+     * Get feature flags
+     *
+     * Get all feature flags for the authenticated user
+     */
+    getFeatureFlags(): Promise<HttpResponse<{
+        data?: Record<string, unknown>;
+    }>>;
+    /**
+     * Evaluate feature flag
+     *
+     * Evaluate a specific feature flag for the authenticated user
+     * @param body — Request body
+     */
+    evaluateFeatureFlag(body: {
+        flagName: string;
+        context?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: {
+            enabled?: boolean;
+            flagName?: string;
+        };
+    }>>;
+    /**
+     * Analyze memory quality distribution
+     *
+     * Analyze the quality distribution of memories for the authenticated user
+     * @param options — Optional parameters
+     */
+    analyzeMemoryQuality(options?: {
+        includeDetails?: boolean;
+        minQualityThreshold?: number;
+    }): Promise<HttpResponse<{
+        data?: {
+            totalMemories?: number;
+            qualityDistribution?: {
+                high?: number;
+                medium?: number;
+                low?: number;
+            };
+            averageQuality?: number;
+            pruningCandidates?: number;
+        };
+    }>>;
+    /**
+     * Prune low-quality memories
+     *
+     * Prune (soft delete) low-quality memories for the authenticated user
+     * @param options — Optional parameters
+     */
+    pruneMemories(options?: {
+        body?: {
+            targetReduction?: number;
+            minQualityThreshold?: number;
+            preserveRecent?: boolean;
+            recentDaysToPreserve?: number;
+            dryRun?: boolean;
+        };
+    }): Promise<HttpResponse<{
+        data?: {
+            prunedCount?: number;
+            prunedIds?: string[];
+            dryRun?: boolean;
+        };
+    }>>;
+    /**
+     * Get OpenAPI specification
+     *
+     * Returns the OpenAPI 3.x specification for the entire API. This endpoint is used by CI/CD to sync the API Gateway.
+     * @param options — Optional parameters
+     */
+    getOpenApiSpec(options?: {
+        noCache?: '1' | 'true';
+    }): Promise<HttpResponse<Record<string, unknown>>>;
+}
+
+/**
+ * PatternsService — Pattern detection and behavioral analysis endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Pattern detection and behavioral analysis endpoints */
+declare class Patterns {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List patterns
+     *
+     * List all patterns for the authenticated user
+     * @param options — Optional parameters
+     */
+    listPatterns(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpResponse<{
+        data?: Pattern[];
+        pagination?: {
+            limit?: number;
+            offset?: number;
+            count?: number;
+        };
+    }>>;
+    /**
+     * Compile patterns
+     *
+     * Compile patterns from user's memories
+     * @param options — Optional parameters
+     */
+    compilePatterns(options?: {
+        body?: {
+            minOccurrences?: number;
+            timeWindow?: string;
+        };
+    }): Promise<HttpResponse<{
+        data?: Pattern[];
+        count?: number;
+    }>>;
+    /**
+     * Detect behavioral patterns
+     *
+     * Run pattern detection algorithms to identify recurring behavioral patterns
+     * @param options — Optional parameters
+     */
+    detectPatterns(options?: {
+        body?: {
+            contextFilter?: string;
+            timeframeStart?: string;
+            timeframeEnd?: string;
+            minConfidence?: number;
+            maxResults?: number;
+            autoStore?: boolean;
+        };
+    }): Promise<HttpResponse<{
+        data?: {
+            detectedPatterns?: Pattern[];
+            count?: number;
+            stored?: number;
+            confidence?: {
+                average?: number;
+                highest?: number;
+            };
+        };
+    }>>;
+    /**
+     * Analyze pattern trends
+     *
+     * Analyze pattern trends, correlations, and generate insights
+     * @param options — Optional parameters
+     */
+    analyzePatterns(options?: {
+        body?: {
+            timeRange?: number;
+            groupBy?: 'type' | 'context' | 'confidence';
+            includeDetails?: boolean;
+        };
+    }): Promise<HttpResponse<{
+        data?: {
+            analysis?: {
+                totalPatterns?: number;
+                recentPatterns?: number;
+                trends?: Record<string, unknown>;
+                insights?: string[];
+                recommendations?: string[];
+            };
+            timeRange?: number;
+            analyzedAt?: string;
+        };
+    }>>;
+    /**
+     * Update pattern
+     *
+     * Update an existing pattern with partial data
+     * @param id — The pattern ID
+     * @param body — Request body
+     */
+    updatePattern(id: string, body: {
+        name?: string;
+        description?: string;
+        confidence?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: Pattern;
+    }>>;
+    /**
+     * Record pattern feedback
+     *
+     * Record feedback on a pattern
+     * @param body — Request body
+     */
+    recordPatternFeedback(body: {
+        patternId: string;
+        feedback: string;
+    }): Promise<HttpResponse<{
+        data?: Pattern;
+    }>>;
+    /**
+     * Compile behavioral instructions from stored patterns
+     *
+     * Converts stored behavioral patterns into actionable instructions suitable for injection into AI agent context at conversation start. Uses template-based (non-LLM) generation for deterministic output within the P95 <100ms budget.
+     *
+     * @param options — Optional parameters
+     */
+    compileInstructions(options?: {
+        body?: {
+            conversationContext?: string[];
+            currentQuery?: string;
+            tokenBudget?: number;
+            minConfidence?: number;
+            maxInstructions?: number;
+        };
+    }): Promise<HttpResponse<{
+        instructions: Array<{
+            patternId: string;
+            instruction: string;
+            confidence: number;
+            priority: number;
+            source: 'learned' | 'explicit' | 'manual';
+            patternType: string;
+            activatedBy: string[];
+            recommendationId?: string;
+            triggerContext?: string;
+            evidenceSummary?: string;
+            firstSurfacing?: boolean;
+        }>;
+        summary: string;
+        tokenCount: number;
+        patternsEvaluated: number;
+        patternsActivated: number;
+        conflictsResolved: {
+            winnerId: string;
+            loserId: string;
+            strategy: 'priority_override';
+        }[];
+        systemState?: 'ok' | 'cold_start' | 'pending_only' | 'no_match';
+        pendingCount?: number;
+        patternsExcluded?: number;
+    }>>;
+}
+
+/**
+ * BehaviorService — Behavioral pattern tracking and state management endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Behavioral pattern tracking and state management endpoints */
+declare class Behavior {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Get behavioral state
+     *
+     * Get current behavioral state for the authenticated user
+     */
+    getBehavioralState(): Promise<HttpResponse<{
+        data?: Record<string, unknown>;
+    }>>;
+    /**
+     * Update behavioral state
+     *
+     * Update or mutate behavioral state
+     * @param options — Optional parameters
+     */
+    updateBehavioralState(options?: {
+        body?: {
+            state?: Record<string, unknown>;
+            mutations?: Record<string, unknown>;
+        };
+    }): Promise<HttpResponse<{
+        data?: Record<string, unknown>;
+    }>>;
+}
+
+/**
+ * RecommendationsService — Behavioral recommendation management endpoints (v2) API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Behavioral recommendation management endpoints (v2) */
+declare class Recommendations {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Create an explicit recommendation
+     *
+     * Create a new explicit recommendation (triggerContext + practice pair). Source is set to 'explicit'; triggerEmbedding is generated synchronously before return. SEC-BL-v2-002: practice content is validated against a prompt-injection deny-list. SEC-BL-v2-003: evidenceMemoryIds ownership is verified against the authenticated user.
+     *
+     * @param body — Request body
+     */
+    createRecommendation(body: {
+        triggerContext: string;
+        practice: string;
+        evidenceSummary?: string;
+        outcomeSignal?: 'positive' | 'neutral' | 'unknown';
+        evidenceMemoryIds?: string[];
+        activateImmediately?: boolean;
+    }): Promise<HttpResponse<{
+        data?: Recommendation;
+    }>>;
+    /**
+     * List pending recommendations
+     *
+     * Returns recommendations with status='pending_review' for the authenticated user, ordered by confidence DESC, createdAt ASC.
+     *
+     * @param options — Optional parameters
+     */
+    listPendingRecommendations(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpResponse<{
+        data?: Recommendation[];
+        pagination?: {
+            limit?: number;
+            offset?: number;
+            count?: number;
+        };
+    }>>;
+    /**
+     * Approve a pending recommendation
+     *
+     * Transitions a recommendation from status='pending_review' to status='active'. Returns 404 if the recommendation is not found, not owned by the authenticated user, or is not in pending_review status.
+     *
+     * @param id — Recommendation ID
+     * @param options — Optional parameters
+     */
+    approveRecommendation(id: string, options?: {
+        body?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: Recommendation;
+    }>>;
+    /**
+     * Dismiss a recommendation
+     *
+     * Permanently dismisses a recommendation (any non-dismissed status → dismissed). This transition is terminal — dismissed recommendations cannot be reactivated. Returns 404 if not found, not owned by the authenticated user, or already dismissed.
+     *
+     * @param id — Recommendation ID
+     * @param options — Optional parameters
+     */
+    dismissRecommendation(id: string, options?: {
+        body?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: Recommendation;
+    }>>;
+    /**
+     * List active recommendations
+     *
+     * Returns recommendations with status='active' for the authenticated user, ordered by confidence DESC. These are the behavioral preferences currently surfacing in Claude via compile-instructions and build_context. SEC-BL-v2-003: results are scoped to the authenticated user — no cross-user data.
+     *
+     * @param options — Optional parameters
+     */
+    listActiveRecommendations(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpResponse<{
+        data?: Recommendation[];
+        pagination?: {
+            limit?: number;
+            offset?: number;
+            count?: number;
+        };
+    }>>;
+    /**
+     * Match active recommendations to content
+     *
+     * Embeds the supplied content and returns active Recommendations whose triggerContext is semantically similar. Used by the MCP server for just-in-time behavioral nudges on memory save. Results are scoped to the authenticated user — no cross-user data is returned.
+     *
+     * @param body — Request body
+     */
+    matchRecommendations(body: {
+        content: string;
+        limit?: number;
+        similarityThreshold?: number;
+    }): Promise<HttpResponse<{
+        data: Recommendation[];
+    }>>;
+    /**
+     * Pause an active recommendation
+     *
+     * Transitions a recommendation from status='active' to status='paused'. Paused recommendations are excluded from compile-instructions and build_context surfacing. Returns 404 if the recommendation is not found, not owned by the authenticated user, or is not in active status. SEC-BL-v2-003: MATCH includes userId — no IDOR.
+     *
+     * @param id — Recommendation ID
+     * @param options — Optional parameters
+     */
+    pauseRecommendation(id: string, options?: {
+        body?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: Recommendation;
+    }>>;
+}
+
+/**
+ * NarrativesService — Narrative thread management endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Narrative thread management endpoints */
+declare class Narratives {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List narrative threads
+     *
+     * List all narrative threads for the authenticated user.
+     * Narratives group related memories into coherent storylines.
+     *
+     * @param options — Optional parameters
+     */
+    listNarratives(options?: {
+        limit?: number;
+        offset?: number;
+        state?: 'open' | 'resolved' | 'reopened' | 'superseded';
+        topics?: string;
+    }): Promise<HttpResponse<{
+        data: NarrativeThread[];
+        pagination: {
+            limit: number;
+            offset: number;
+            count: number;
+        };
+    }>>;
+    /**
+     * Create a narrative thread
+     *
+     * Create a new narrative thread starting from a root memory.
+     * Narratives help organize related memories into coherent storylines.
+     *
+     * @param body — Request body
+     */
+    createNarrative(body: {
+        title: string;
+        rootMemoryId: string;
+        topics?: string[];
+    }): Promise<HttpResponse<{
+        data: NarrativeThread;
+    }>>;
+    /**
+     * Get a narrative thread
+     *
+     * Retrieve a specific narrative thread by ID
+     * @param id — The narrative ID
+     */
+    getNarrative(id: string): Promise<HttpResponse<{
+        data: NarrativeThread;
+    }>>;
+    /**
+     * Delete a narrative thread
+     *
+     * Delete a narrative thread.
+     * This does not delete the associated memories, only the narrative structure.
+     *
+     * @param id — The narrative ID
+     */
+    deleteNarrative(id: string): Promise<HttpResponse<unknown>>;
+    /**
+     * Update a narrative thread
+     *
+     * Update a narrative thread's title, topics, or state.
+     * Use this to resolve, reopen, or modify narratives.
+     *
+     * @param id — The narrative ID
+     * @param body — Request body
+     */
+    updateNarrative(id: string, body: {
+        title?: string;
+        state?: 'open' | 'resolved' | 'reopened' | 'superseded';
+        resolutionMemoryId?: string;
+        topics?: string[];
+    }): Promise<HttpResponse<{
+        data: NarrativeThread;
+    }>>;
+    /**
+     * Get narrative timeline
+     *
+     * Get all memories in a narrative, ordered by their position in the narrative.
+     * Each memory includes its position and effective state.
+     *
+     * @param id — The narrative ID
+     * @param options — Optional parameters
+     */
+    getNarrativeTimeline(id: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpResponse<{
+        data: NarrativeMemory[];
+        narrative: NarrativeThread;
+        pagination: {
+            limit: number;
+            offset: number;
+            total: number;
+        };
+    }>>;
+    /**
+     * Add a memory to a narrative
+     *
+     * Add an existing memory to a narrative thread.
+     * Optionally specify a position to insert the memory at.
+     *
+     * @param id — The narrative ID
+     * @param body — Request body
+     */
+    addMemoryToNarrative(id: string, body: {
+        memoryId: string;
+        position?: number;
+    }): Promise<HttpResponse<{
+        data: NarrativeThread;
+    }>>;
+    /**
+     * Remove a memory from a narrative
+     *
+     * Remove a memory from a narrative thread.
+     * This does not delete the memory itself, only removes it from the narrative.
+     *
+     * @param id — The narrative ID
+     * @param memoryId — The memory ID to remove
+     */
+    removeMemoryFromNarrative(id: string, memoryId: string): Promise<HttpResponse<unknown>>;
+}
+
+/**
+ * MonitoringService — Observability and metrics endpoints for production monitoring API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Observability and metrics endpoints for production monitoring */
+declare class Monitoring {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Prometheus metrics endpoint
+     *
+     * Returns Prometheus-formatted metrics for monitoring and observability.
+     * This endpoint is public and requires no authentication.
+     * Designed to be scraped by Prometheus at regular intervals.
+     *
+     */
+    getMetrics(): Promise<HttpResponse<unknown>>;
+}
+
+/**
+ * MemoriesService — Memory management and retrieval endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Memory management and retrieval endpoints */
+declare class Memories {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Get memory by ID
+     *
+     * Retrieve a specific memory by its ID with configurable detail level.
+     *
+     * **Detail levels:**
+     * - `minimal` — raw memory only, no extra queries
+     * - `standard` (default) — adds userTopics, extractedTopics, entities, facts, relationships
+     * - `full` — adds conversationContext (title, memoryCount, position) and relationship target previews
+     *
+     * @param id — The memory ID
+     * @param options — Optional parameters
+     */
+    getMemoryById(id: string, options?: {
+        detail?: 'minimal' | 'standard' | 'full';
+    }): Promise<HttpResponse<{
+        data: Memory;
+    }>>;
+    /**
+     * Update a memory
+     *
+     * Update an existing memory for the authenticated user
+     * @param id — Memory ID
+     * @param body — Request body
+     */
+    updateMemory(id: string, body: {
+        content?: string;
+        name?: string | '';
+        memoryType?: 'episodic' | 'semantic' | 'procedural';
+        context?: string;
+        topics?: string[];
+        outcome?: 'resolved' | 'unresolved' | null;
+    }): Promise<HttpResponse<{
+        data?: Memory;
+    }>>;
+    /**
+     * Delete memory
+     *
+     * Delete a memory by its ID
+     * @param id — The memory ID
+     */
+    deleteMemory(id: string): Promise<HttpResponse<unknown>>;
+    /**
+     * Aggregated memory analytics
+     *
+     * Return aggregated memory counts grouped by a time dimension (day, week, month)
+     * or by topic. Useful for activity dashboards and trend analysis.
+     *
+     * @param options — Optional parameters
+     */
+    getMemoriesStats(options?: {
+        groupBy: 'day' | 'week' | 'month' | 'topic';
+        after?: string;
+        before?: string;
+        recent?: string;
+        topic?: string;
+        limit?: number;
+    }): Promise<HttpResponse<{
+        groupBy?: 'day' | 'week' | 'month' | 'topic';
+        data?: {
+            bucket?: string;
+            count?: number;
+        }[];
+        total?: number;
+        filters?: {
+            after?: string | null;
+            before?: string | null;
+            topic?: string | null;
+        };
+    }>>;
+    /**
+     * List memories
+     *
+     * List all memories for the authenticated user with pagination.
+     *
+     * **ID Prefix Search:**
+     * Use the `idPrefix` parameter for git-style short ID lookup. This enables efficient
+     * server-side filtering instead of fetching all memories and filtering client-side.
+     * - Minimum 6 characters required for `idPrefix`
+     * - Returns matching memories directly (no need for secondary fetch)
+     * - Example: `?idPrefix=2d09116a` finds memories starting with that prefix
+     *
+     * @param options — Optional parameters
+     */
+    listMemories(options?: {
+        idPrefix?: string;
+        limit?: number;
+        offset?: number;
+        page?: number;
+        sortBy?: 'createdAt' | 'updatedAt' | 'eventTime';
+        order?: 'asc' | 'desc';
+        from$?: string;
+        to?: string;
+        recent?: string;
+        topics?: string;
+        excludeTopics?: string;
+        conversationId?: string;
+        scope?: string;
+    }): Promise<HttpResponse<{
+        data?: Memory[];
+        pagination?: Pagination;
+        filtersApplied?: {
+            from?: string | null;
+            to?: string | null;
+            topics?: string[] | null;
+            excludeTopics?: string[] | null;
+            conversationId?: string | null;
+            scope?: Record<string, unknown> | null;
+        };
+    }>>;
+    /**
+     * Create a memory
+     *
+     * Create a new memory for the authenticated user.
+     *
+     * **Conversation Management:**
+     * - Use `conversationId: "NEW"` to create a new conversation automatically
+     * - Provide an existing conversation ID to add to that conversation
+     *
+     * **Session Management:**
+     * - Sessions are automatically assigned based on 90-minute gap detection
+     * - If the last memory in the conversation was within 90 minutes, the same session is reused
+     * - If the gap exceeds 90 minutes, a new session is created
+     *
+     * **Response:**
+     * - Returns the created memory in `data` field
+     * - Returns session/conversation metadata in `meta` field
+     *
+     * @param body — Request body
+     */
+    createMemory(body: {
+        conversationId?: string;
+        claudeSessionId?: string;
+        name?: string;
+        content: string;
+        memoryType?: 'episodic' | 'semantic' | 'procedural';
+        role?: 'user' | 'assistant' | 'system';
+        context?: string;
+        topics?: string[];
+        eventTime?: string;
+        validFrom?: string;
+        validTo?: string;
+        codeContext?: {
+            product?: string;
+            repo?: string;
+            service?: string;
+            component?: string;
+            team?: string;
+            role?: string;
+            extra?: Record<string, unknown>;
+        };
+        precomputed?: PrecomputedMemoryFields;
+        taskId?: string;
+        outcome?: 'resolved' | 'unresolved';
+        distill?: boolean;
+    }): Promise<HttpResponse<{
+        data: Memory;
+        meta: CreateMemoryResponseMeta;
+    }>>;
+    /**
+     * Search memories (GET)
+     *
+     * Search memories using query parameters. Provides the same functionality as
+     * POST /api/memories/search but accepts parameters via query string.
+     *
+     * **Benefits of GET:**
+     * - Faster response times (~3x improvement)
+     * - Browser/CDN caching support
+     * - Simpler integration for read-only clients
+     *
+     * **Search Methods:**
+     * - **hybrid** (default): Combines semantic and keyword search with Reciprocal Rank Fusion
+     * - **semantic**: Vector-based semantic search using OpenAI embeddings
+     * - **keyword**: Traditional fulltext search using Lucene
+     *
+     * **Array Parameters:**
+     * - `topics`: Provide as comma-separated values (e.g., `topics=typescript,api-design`)
+     *
+     * @param options — Optional parameters
+     */
+    searchMemoriesGet(options?: {
+        q?: string;
+        searchMethod?: 'keyword' | 'semantic' | 'hybrid';
+        limit?: number;
+        offset?: number;
+        threshold?: number;
+        mode?: 'unified' | 'content' | 'facts';
+        vectorWeight?: number;
+        fulltextWeight?: number;
+        topics?: string;
+        excludeTopics?: string;
+        memoryType?: 'episodic' | 'semantic' | 'procedural';
+        conversationId?: string;
+        explain?: boolean;
+        includeTopics?: boolean;
+        includeEntities?: boolean;
+        includeFacts?: boolean;
+        includeClaims?: boolean;
+        asOfTime?: string;
+        validAtTime?: string;
+        eventTimeFrom?: string;
+        eventTimeTo?: string;
+        ingestionTimeFrom?: string;
+        ingestionTimeTo?: string;
+        includeExpired?: boolean;
+        temporalMode?: 'current' | 'historical' | 'evolution';
+        sortBy?: 'relevance' | 'createdAt' | 'updatedAt' | 'eventTime';
+        order?: 'asc' | 'desc';
+        expandEntities?: boolean;
+        expandTopics?: boolean;
+        expandFacts?: boolean;
+        includeSuperseded?: boolean;
+        entityWeight?: number;
+        topicWeight?: number;
+        factWeight?: number;
+        questionWeight?: number;
+        claimsWeight?: number;
+        includeFacets?: boolean;
+        embeddingProvider?: 'ollama' | 'openai' | 'voyage';
+        scope?: string;
+        taskId?: string;
+        outcomeFilter?: 'resolved' | 'unresolved' | 'any';
+    }): Promise<HttpResponse<{
+        data: SearchResult[];
+        meta: SearchMeta;
+        facets?: Facets;
+        instructions?: string;
+        claim_groups?: ClaimGroup[];
+    }>>;
+    /**
+     * Search all memories
+     *
+     * Search memories using different search methods:
+     * - **hybrid** (default): Combines semantic and keyword search with Reciprocal Rank Fusion
+     * - **semantic**: Vector-based semantic search using OpenAI embeddings
+     * - **keyword**: Traditional fulltext search using Lucene
+     *
+     * The `mode` parameter controls content filtering (unified, content, facts).
+     * The `searchMethod` parameter controls the search algorithm.
+     *
+     * @param body — Request body
+     */
+    searchMemories(body: {
+        query: string;
+        mode?: 'unified' | 'content' | 'facts';
+        searchMethod?: 'keyword' | 'semantic' | 'hybrid';
+        limit?: number;
+        offset?: number;
+        vectorWeight?: number;
+        fulltextWeight?: number;
+        threshold?: number;
+        explain?: boolean;
+        asOfTime?: string;
+        validAtTime?: string;
+        eventTimeFrom?: string;
+        eventTimeTo?: string;
+        ingestionTimeFrom?: string;
+        ingestionTimeTo?: string;
+        includeExpired?: boolean;
+        temporalMode?: 'current' | 'historical' | 'evolution';
+        topics?: string[];
+        memoryType?: 'episodic' | 'semantic' | 'procedural';
+        conversationId?: string;
+        taskId?: string;
+        outcomeFilter?: 'resolved' | 'unresolved' | 'any';
+        includeTopics?: boolean;
+        includeEntities?: boolean;
+        includeFacts?: boolean;
+        includeClaims?: boolean;
+        entityTypes?: string[];
+        expandEntities?: boolean;
+        expandTopics?: boolean;
+        expandFacts?: boolean;
+        includeSuperseded?: boolean;
+        entityWeight?: number;
+        topicWeight?: number;
+        factWeight?: number;
+        questionWeight?: number;
+        claimsWeight?: number;
+        sortBy?: 'relevance' | 'createdAt' | 'updatedAt' | 'eventTime';
+        order?: 'asc' | 'desc';
+        includeFacets?: boolean;
+    }): Promise<HttpResponse<{
+        data: SearchResult[];
+        meta: SearchMeta;
+        facets?: Facets;
+        instructions?: string;
+        claim_groups?: ClaimGroup[];
+    }>>;
+    /**
+     * Get multiple memories by IDs
+     *
+     * Retrieve multiple memories by their IDs in a single request.
+     * More efficient than making multiple individual GET requests.
+     *
+     * Returns memories in the order requested, with metadata about
+     * which IDs were found or missing.
+     *
+     * @param body — Request body
+     */
+    getMemoriesBatch(body: {
+        ids: string[];
+        detail?: 'minimal' | 'standard' | 'full';
+    }): Promise<HttpResponse<{
+        data: Memory[];
+        meta: BatchGetMemoriesMeta;
+    }>>;
+    /**
+     * Generate memory digest
+     *
+     * Synthesizes a comprehensive, structured briefing from all relevant memories
+     * on a topic. Instead of multiple search rounds, one call returns a complete digest.
+     *
+     * **Formats:**
+     * - `structured` (default): Sections with headers, bullet points, key decisions
+     * - `narrative`: Chronological prose narrative
+     * - `timeline`: Dated event list
+     * - `status-report`: Done/In Progress/Blocked grouping
+     *
+     * **Pipeline:**
+     * 1. Gather: High-limit search + conversation expansion
+     * 2. Organize: Group by conversation, status, timeline
+     * 3. Synthesize: LLM generates formatted digest
+     *
+     * Requires an LLM provider to be configured (EXTRACTION_ENABLED=true).
+     * Returns 503 if the LLM provider is unavailable and 3+ memories are found.
+     *
+     * @param body — Request body
+     */
+    generateMemoryDigest(body: {
+        query: string;
+        recent?: string;
+        topics?: string[];
+        conversationIds?: string[];
+        format?: 'structured' | 'narrative' | 'timeline' | 'status-report';
+        maxSources?: number;
+        includeMemoryIds?: boolean;
+        verbatimRecent?: number;
+    }): Promise<HttpResponse<{
+        digest: string;
+        metadata: DigestMetadata;
+        sources: DigestSource[];
+        recentMemories?: Memory[];
+        keyFacts?: DigestKeyFact[];
+        entities?: DigestEntity[];
+        effectiveStateBreakdown?: EffectiveStateBreakdown;
+    }>>;
+    /**
+     * Generate memory digest (SSE streaming)
+     *
+     * Same as POST /api/memories/digest but uses Server-Sent Events (SSE) to stream
+     * the response. Sends `: heartbeat` comments every 10 seconds during processing
+     * to prevent gateway read-timeout (default 60s) from killing long-running digests.
+     *
+     * **Event sequence:**
+     * - `: heartbeat` — keep-alive comment, sent every 10s during processing
+     * - `event: result` / `data: <DigestResponse JSON>` — digest completed successfully
+     * - `event: error` / `data: {"error":"...","statusCode":N}` — digest failed
+     * - `event: done` / `data: {}` — stream complete (sent after result)
+     *
+     * **Formats and pipeline:** identical to POST /api/memories/digest.
+     *
+     * @param body — Request body
+     */
+    streamMemoryDigest(body: {
+        query: string;
+        recent?: string;
+        topics?: string[];
+        conversationIds?: string[];
+        format?: 'structured' | 'narrative' | 'timeline' | 'status-report';
+        maxSources?: number;
+        includeMemoryIds?: boolean;
+        verbatimRecent?: number;
+    }): Promise<HttpResponse<unknown>>;
+    /**
+     * Build a context briefing
+     *
+     * Answers "What should I know before working on X?" by combining active work
+     * detection, fact retrieval, gotcha detection, recent activity, and pattern
+     * matching into a single call. Eliminates the 5+ round-trip pattern agents
+     * use today.
+     *
+     * @param body — Request body
+     */
+    buildContext(body: {
+        context: string;
+        files?: string[];
+        recentHours?: number;
+    }): Promise<HttpResponse<{
+        activeWork: BuildContextActiveWork;
+        relevantFacts: BuildContextFact[];
+        gotchas: BuildContextGotcha[];
+        recentActivity: BuildContextActivity[];
+        relatedPatterns: BuildContextPattern[];
+        meta: BuildContextMeta;
+    }>>;
+    /**
+     * Get version history for a named memory
+     *
+     * Returns the full version chain for a named memory, ordered newest-first.
+     * Walks the SUPERSEDES chain from HEAD backwards.
+     *
+     * @param name — Memory name (kebab-case, 2-64 chars)
+     * @param options — Optional parameters
+     */
+    getNamedMemoryHistory(name: string, options?: {
+        limit?: number;
+    }): Promise<HttpResponse<{
+        name: string;
+        versions: Array<{
+            version: number;
+            id: string;
+            content: string;
+            effectiveState?: 'current' | 'superseded' | 'contradicted' | 'duplicate';
+            createdAt: string;
+        }>;
+    }>>;
+    /**
+     * Get a memory by name
+     *
+     * Retrieve the current HEAD version of a named memory by its user-assigned name.
+     * Supports the same detail levels as GET /api/memories/{id}.
+     *
+     * @param name — Memory name (kebab-case, 2-64 chars)
+     * @param options — Optional parameters
+     */
+    getMemoryByName(name: string, options?: {
+        detail?: 'minimal' | 'standard' | 'full';
+    }): Promise<HttpResponse<{
+        data: Memory;
+    }>>;
+    /**
+     * Update a named memory (create new version)
+     *
+     * Creates a new version of a named memory. The name pointer moves to the new version,
+     * and a SUPERSEDES relationship links the new version to the old one.
+     * The old version's effectiveState becomes 'superseded'.
+     *
+     * @param name — Memory name (kebab-case, 2-64 chars)
+     * @param body — Request body
+     */
+    updateNamedMemory(name: string, body: {
+        content: string;
+        memoryType?: 'episodic' | 'semantic' | 'procedural';
+        context?: string;
+        topics?: string[];
+        conversationId?: string;
+        codeContext?: {
+            product?: string;
+            repo?: string;
+            service?: string;
+            component?: string;
+            team?: string;
+            role?: string;
+            extra?: Record<string, unknown>;
+        };
+        supersedes?: string;
+    }): Promise<HttpResponse<{
+        data?: Memory;
+        meta?: {
+            previousVersionId?: string;
+            version?: number;
+        };
+    }>>;
+    /**
+     * Bulk delete multiple memories
+     *
+     * Soft-delete multiple memories at once. Requires confirmDeletion=true.
+     * Each memory is verified to belong to the authenticated user.
+     * Maximum 100 IDs per request.
+     *
+     * @param body — Request body
+     */
+    bulkDeleteMemories(body: {
+        ids: string[];
+        confirmDeletion: true;
+    }): Promise<HttpResponse<{
+        deleted: number;
+        failed: number;
+        errors: {
+            id: string;
+            error: string;
+        }[];
+    }>>;
+    /**
+     * Repair orphaned effectiveState values
+     *
+     * Finds memories with effectiveState='superseded' or 'contradicted' but no
+     * corresponding incoming SUPERSEDES/CONTRADICTS edges, and resets them to 'current'.
+     * This handles cases where edges were deleted but effectiveState wasn't recalculated.
+     *
+     */
+    repairEffectiveState(): Promise<HttpResponse<{
+        repaired?: number;
+        memories?: {
+            memoryId?: string;
+            previousState?: string;
+        }[];
+    }>>;
+    /**
+     * Record behavioral feedback on a search result
+     *
+     * Record whether a search result was selected or ignored by the user.
+     * Used to build behavioral signals for retrieval quality measurement.
+     *
+     * @param body — Request body
+     */
+    recordSearchResultFeedback(body: {
+        memoryId: string;
+        action: 'selected' | 'not_selected';
+        searchMethod?: string;
+        searchSessionId?: string;
+        resultPosition?: number;
+    }): Promise<HttpResponse<unknown>>;
+    /**
+     * Find similar memories
+     *
+     * Find memories that are semantically similar to the given memory.
+     *
+     * Uses vector similarity search if embeddings are available for the memory.
+     * Falls back to topic-based similarity if embeddings are not available.
+     *
+     * The `relationship` field in results indicates the method used:
+     * - `similar` - Found via vector/semantic similarity
+     * - `similar-by-topic` - Fallback using shared topics
+     *
+     * @param id — The source memory ID
+     * @param options — Optional parameters
+     */
+    getSimilarMemories(id: string, options?: {
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: RelatedMemoryResult[];
+        sourceMemory?: Memory;
+    }>>;
+    /**
+     * Find memories from same conversation
+     *
+     * Find other memories that belong to the same conversation as the given memory.
+     *
+     * Returns memories sorted chronologically (oldest first) to show the conversation flow.
+     * If the memory doesn't belong to a conversation, returns an empty array.
+     *
+     * @param id — The source memory ID
+     * @param options — Optional parameters
+     */
+    getConversationMemories(id: string, options?: {
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: RelatedMemoryResult[];
+        sourceMemory?: Memory;
+        conversationId?: string | null;
+    }>>;
+    /**
+     * Find related memories by topics
+     *
+     * Find memories that share topics with the given memory.
+     *
+     * The score indicates the ratio of shared topics (1.0 = all topics match).
+     * Results are sorted by score (most related first), then by timestamp.
+     *
+     * If the source memory has no topics, returns an empty array.
+     *
+     * @param id — The source memory ID
+     * @param options — Optional parameters
+     */
+    getRelatedMemories(id: string, options?: {
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: Array<{
+            memory: {
+                id: string;
+                name?: string;
+                version?: number;
+                content: string;
+                memoryType: 'episodic' | 'semantic' | 'procedural';
+                context?: string;
+                topics?: string[];
+                timestamp?: string;
+                eventTime?: string;
+                validFrom?: string;
+                validTo?: string | null;
+                codeContext?: CodeContext;
+                createdAt: string;
+                updatedAt: string;
+                confidenceScore?: number;
+                confidenceBasis?: 'direct-statement' | 'repeated-mention' | 'single-mention' | 'hedged' | 'inference' | 'external-source' | 'contradicted';
+                effectiveState?: 'current' | 'superseded' | 'contradicted' | 'duplicate';
+                authority?: 'directive' | 'decision' | 'observation' | 'auto-captured';
+                extractionStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                extractionCompletedAt?: string;
+                contentEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                summary?: string;
+                summaryStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                questionsStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                summaryEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                questionsEmbeddingStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                graphStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                graphSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy' | 'budget_exhausted' | null;
+                extractionSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy';
+                embeddingStatus?: 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                embeddingOpenaiStatus?: 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+                embeddingTruncated?: boolean;
+                embeddingOriginalTokens?: number;
+                embeddingStrategy?: 'full' | 'head-truncated' | 'summary-selected' | 'question-selected';
+                extractedTopicCount?: number;
+                extractedFactCount?: number;
+                extractedEntityCount?: number;
+                conflictCount?: number;
+                visibility?: 'private' | 'shared_with_users' | 'shared_with_org' | 'admin_visible';
+                sharedWith?: string[];
+                userTopics?: string[];
+                extractedTopics?: string[];
+                entities?: {
+                    name: string;
+                    type: string;
+                    confidence?: number;
+                }[];
+                taskId?: string | null;
+                outcome?: 'resolved' | 'unresolved' | null;
+                attemptNumber?: number | null;
+                distillStatus?: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped' | null;
+                distillSkipReason?: 'global_disabled' | 'plan_excluded' | 'user_opt_out' | 'content_too_short' | 'legacy' | 'budget_exhausted' | null;
+                distillError?: string | null;
+                distillCompletedAt?: string | null;
+            };
+            score: number;
+            relationship: string;
+            sharedTopics?: string[];
+        }>;
+        sourceMemory?: Memory;
+    }>>;
+    /**
+     * Get relationships for a memory
+     *
+     * Retrieve all relationships for a memory.
+     *
+     * **Direction Options:**
+     * - **outgoing**: Relationships where this memory is the source
+     * - **incoming**: Relationships where this memory is the target
+     * - **both**: All relationships involving this memory
+     *
+     * @param id — The memory ID
+     * @param options — Optional parameters
+     */
+    getMemoryRelationships(id: string, options?: {
+        direction?: 'outgoing' | 'incoming' | 'both';
+    }): Promise<HttpResponse<{
+        data: MemoryRelationship[];
+        sourceMemoryId: string;
+        direction: 'outgoing' | 'incoming' | 'both';
+    }>>;
+    /**
+     * Create a relationship between memories
+     *
+     * Create a relationship between the source memory and a target memory.
+     *
+     * **Relationship Types:**
+     * - **SUPERSEDES**: The source memory replaces/updates the target memory
+     * - **FOLLOWS**: The source memory follows chronologically from the target
+     * - **RESOLVES**: The source memory resolves an issue mentioned in the target
+     * - **CONTRADICTS**: The source memory contradicts the target memory
+     * - **REFERENCES**: The source memory references the target memory
+     *
+     * When creating SUPERSEDES or CONTRADICTS relationships, the target memory's
+     * effectiveState will be automatically updated.
+     *
+     * @param id — The source memory ID
+     * @param body — Request body
+     */
+    createMemoryRelationship(id: string, body: {
+        targetMemoryId: string;
+        type: 'SUPERSEDES' | 'FOLLOWS' | 'RESOLVES' | 'CONTRADICTS' | 'REFERENCES' | 'DUPLICATES';
+        confidence?: number;
+        reason?: string;
+    }): Promise<HttpResponse<{
+        data?: MemoryRelationship;
+    }>>;
+    /**
+     * Delete a relationship
+     *
+     * Delete a specific relationship from a memory
+     * @param id — The source memory ID
+     * @param relationshipId — The relationship ID to delete
+     */
+    deleteMemoryRelationship(id: string, relationshipId: string): Promise<HttpResponse<unknown>>;
+    /**
+     * Get timeline context for a memory
+     *
+     * Get the chronological context around a memory.
+     * Returns preceding and following memories ordered by event time.
+     * Useful for understanding the narrative flow.
+     *
+     * @param id — The memory ID
+     * @param options — Optional parameters
+     */
+    getMemoryTimeline(id: string, options?: {
+        before?: number;
+        after?: number;
+    }): Promise<HttpResponse<{
+        data?: {
+            memory?: Memory;
+            preceding?: Memory[];
+            following?: Memory[];
+        };
+    }>>;
+    /**
+     * Detect potential relationships for a memory
+     *
+     * Analyze a memory and detect potential relationships with other memories.
+     * Uses semantic similarity and pattern detection to suggest relationships.
+     *
+     * Set `autoCreate: true` to automatically create high-confidence relationships.
+     *
+     * @param id — The memory ID
+     * @param options — Optional parameters
+     */
+    detectMemoryRelationships(id: string, options?: {
+        body?: {
+            autoCreate?: boolean;
+            minConfidence?: number;
+        };
+    }): Promise<HttpResponse<{
+        data?: Array<{
+            targetMemoryId?: string;
+            type?: 'SUPERSEDES' | 'FOLLOWS' | 'RESOLVES' | 'CONTRADICTS' | 'REFERENCES';
+            confidence?: number;
+            reason?: string;
+        }>;
+        autoCreated?: boolean;
+    }>>;
+    /**
+     * Generate LLM explanation for a memory relationship
+     *
+     * Uses an LLM to explain why two memories have been flagged with a
+     * particular relationship (e.g. contradiction). Returns a short
+     * plain-text explanation highlighting the specific differences.
+     *
+     * @param id — The ID of the source memory
+     * @param body — Request body
+     */
+    explainMemoryRelationship(id: string, body: {
+        otherMemoryId: string;
+        relationshipType: string;
+    }): Promise<HttpResponse<{
+        data?: {
+            explanation?: string;
+        };
+    }>>;
+    /**
+     * Export memories matching filters
+     *
+     * Export memories matching an optional search query and filters to JSON or CSV format.
+     * When a query is provided, uses hybrid search. When no query is provided, lists memories
+     * with optional topic and memoryType filters. Maximum 1000 results per export.
+     *
+     * @param body — Request body
+     */
+    exportMemories(body: {
+        query?: string;
+        topics?: string[];
+        memoryType?: 'episodic' | 'semantic' | 'procedural';
+        format?: 'json' | 'csv';
+        fields?: string[];
+        limit?: number;
+    }): Promise<HttpResponse<Record<string, unknown>[]>>;
+    /**
+     * Bulk update multiple memories
+     *
+     * Update multiple memories at once. Supports updating topics and memoryType.
+     * Each memory is verified to belong to the authenticated user.
+     * Maximum 100 IDs per request.
+     *
+     * @param body — Request body
+     */
+    bulkUpdateMemories(body: {
+        ids: string[];
+        updates: {
+            topics?: string[];
+            memoryType?: 'episodic' | 'semantic' | 'procedural';
+        };
+    }): Promise<HttpResponse<{
+        updated: number;
+        failed: number;
+        errors: {
+            id: string;
+            error: string;
+        }[];
+    }>>;
+    /**
+     * Bulk add or remove topics from memories
+     *
+     * Add and/or remove topics from multiple memories at once.
+     * At least one of addTopics or removeTopics must be provided.
+     * Each memory is verified to belong to the authenticated user.
+     * Maximum 100 IDs per request.
+     *
+     * @param body — Request body
+     */
+    bulkTagMemories(body: {
+        ids: string[];
+        addTopics?: string[];
+        removeTopics?: string[];
+    }): Promise<HttpResponse<{
+        modified: number;
+        failed: number;
+        errors: {
+            id: string;
+            error: string;
+        }[];
+    }>>;
+}
+
+/**
+ * InvitesService — Invite code validation and gate status endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Invite code validation and gate status endpoints */
+declare class Invites {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Check invite gate status
+     *
+     * Check whether the invite gate is currently open or closed.
+     * When gated is true, new signups require a valid invite code.
+     * Response is cached server-side (30-second TTL).
+     *
+     */
+    getGateStatus(): Promise<HttpResponse<{
+        gated?: boolean;
+    }>>;
+    /**
+     * Validate an invite code
+     *
+     * Validate an invite code without redeeming it.
+     * Rate limited to 10 requests per minute per IP to prevent enumeration.
+     * Error messages are intentionally generic.
+     *
+     * @param body — Request body
+     */
+    validateInviteCode(body: {
+        code: string;
+        email: string;
+    }): Promise<HttpResponse<{
+        valid?: boolean;
+        error?: string;
+    }>>;
+}
+
+/**
+ * HealthService — Health check endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Health check endpoints */
+declare class Health {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Liveness probe endpoint
+     *
+     * Returns 200 if the process is alive. Does not check external dependencies.
+     * Used by Kubernetes liveness probes to determine if the container should be restarted.
+     * Unlike /health, this endpoint does not query the database — a database outage
+     * should not cause the API process to be killed and restarted.
+     *
+     */
+    livenessCheck(): Promise<HttpResponse<{
+        status?: 'alive';
+        uptime?: number;
+    }>>;
+    /**
+     * API health check endpoint
+     *
+     * Returns the health status and uptime of the API service.
+     * This endpoint is public and requires no authentication.
+     * Use this endpoint for monitoring, health checks, and service availability verification.
+     * Returns 200 when healthy, 503 when the database is unreachable.
+     *
+     */
+    healthCheck(): Promise<HttpResponse<{
+        status: 'healthy' | 'degraded' | 'unhealthy';
+        timestamp: string;
+        version: string;
+        uptime: number;
+        checks: Record<string, unknown>;
+    }>>;
+}
+
+/**
+ * GraphragService — Graph-based retrieval augmented generation endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Graph-based retrieval augmented generation endpoints */
+declare class Graphrag {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Explain a GraphRAG query
+     *
+     * Get explanation for a previously executed GraphRAG query result
+     * @param options — Optional parameters
+     */
+    explainGraphRAGQuery(options?: {
+        queryId: string;
+    }): Promise<HttpResponse<{
+        data?: Record<string, unknown>;
+    }>>;
+    /**
+     * Query communities
+     *
+     * Query communities for relevant information using semantic search
+     * @param body — Request body
+     */
+    queryCommunities(body: {
+        query: string;
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: Record<string, unknown>[];
+    }>>;
+    /**
+     * Execute a GraphRAG query
+     *
+     * Execute a graph-based retrieval augmented generation query
+     * @param body — Request body
+     */
+    executeGraphRAGQuery(body: {
+        query: string;
+        maxDepth?: number;
+        depth?: number;
+        limit?: number;
+        includeRelationships?: boolean;
+    }): Promise<HttpResponse<{
+        data?: GraphRAGQueryResponse;
+    }>>;
+}
+
+/**
+ * FactsService — Fact extraction and management endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Fact extraction and management endpoints */
+declare class Facts {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List facts
+     *
+     * List all facts for the authenticated user
+     * @param options — Optional parameters
+     */
+    listFacts(options?: {
+        limit?: number;
+        offset?: number;
+        memoryId?: string;
+        sortBy?: 'confidence' | 'createdAt';
+        order?: 'asc' | 'desc';
+    }): Promise<HttpResponse<{
+        data?: Fact[];
+        count?: number;
+    }>>;
+    /**
+     * Create fact
+     *
+     * Create a new semantic fact
+     * @param body — Request body
+     */
+    createFact(body: {
+        subject: string;
+        predicate: string;
+        object: string;
+    }): Promise<HttpResponse<{
+        data?: Fact;
+    }>>;
+    /**
+     * Get fact by ID
+     *
+     * Retrieve a specific fact by its ID
+     * @param id — The fact ID
+     */
+    getFactById(id: string): Promise<HttpResponse<{
+        data?: Fact;
+    }>>;
+    /**
+     * Update fact
+     *
+     * Update an existing fact completely
+     * @param id — The fact ID
+     * @param body — Request body
+     */
+    updateFact(id: string, body: {
+        subject?: string;
+        predicate?: string;
+        object?: string;
+        confidence?: number;
+    }): Promise<HttpResponse<{
+        data?: Fact;
+    }>>;
+    /**
+     * Delete fact
+     *
+     * Delete a fact by its ID
+     * @param id — The fact ID
+     */
+    deleteFact(id: string): Promise<HttpResponse<unknown>>;
+    /**
+     * Search facts
+     *
+     * Search semantic facts by query string
+     * @param body — Request body
+     */
+    searchFacts(body: {
+        query: string;
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: Fact[];
+        count?: number;
+        metadata?: {
+            query?: string;
+        };
+    }>>;
+}
+
+/**
+ * EntitiesService — Entity extraction and discovery endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Entity extraction and discovery endpoints */
+declare class Entities {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List entities
+     *
+     * List all entities for the authenticated user, optionally filtered by type
+     * @param options — Optional parameters
+     */
+    listEntities(options?: {
+        query?: string;
+        type$?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpResponse<{
+        data?: EntityNode[];
+        pagination?: {
+            limit?: number;
+            offset?: number;
+            count?: number;
+        };
+    }>>;
+    /**
+     * Get entity by ID
+     *
+     * Retrieve a specific entity by its ID
+     * @param id — The entity ID
+     */
+    getEntityById(id: string): Promise<HttpResponse<{
+        data?: EntityNode;
+    }>>;
+    /**
+     * Get memories mentioning entity
+     *
+     * Get all memories that mention a specific entity
+     * @param id — The entity ID
+     * @param options — Optional parameters
+     */
+    getEntityMemories(id: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpResponse<{
+        data?: {
+            memory?: Memory;
+            confidence?: number;
+        }[];
+        pagination?: {
+            limit?: number;
+            offset?: number;
+            count?: number;
+        };
+    }>>;
+    /**
+     * Get graph health metrics
+     *
+     * Returns knowledge graph health metrics including entity counts, fact counts, topic counts, and extraction coverage
+     */
+    getGraphHealth(): Promise<HttpResponse<{
+        data?: {
+            totalMemories?: number;
+            totalEntities?: number;
+            totalFacts?: number;
+            totalTopics?: number;
+            memoriesWithEntities?: number;
+            entityCoverage?: number;
+        };
+    }>>;
+}
+
+/**
+ * ConversationsService — Conversation tracking and analysis endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Conversation tracking and analysis endpoints */
+declare class Conversations {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List conversations
+     *
+     * List all conversations for the authenticated user with pagination
+     * @param options — Optional parameters
+     */
+    listConversations(options?: {
+        limit?: number;
+        offset?: number;
+        since?: string;
+        sortBy?: 'lastActivityAt' | 'createdAt' | 'memoryCount';
+        order?: 'asc' | 'desc';
+        minMemories?: number;
+    }): Promise<HttpResponse<{
+        data?: Conversation[];
+        pagination?: {
+            limit?: number;
+            offset?: number;
+            count?: number;
+        };
+    }>>;
+    /**
+     * Create conversation
+     *
+     * Create a new conversation for the authenticated user
+     * @param body — Request body
+     */
+    createConversation(body: {
+        title: string;
+        summary?: string;
+    }): Promise<HttpResponse<{
+        data?: Conversation;
+    }>>;
+    /**
+     * Get conversation summary
+     *
+     * Retrieve a conversation summary by its ID
+     * @param conversationId — The conversation ID
+     */
+    getConversationSummary(conversationId: string): Promise<HttpResponse<{
+        data?: Conversation;
+    }>>;
+    /**
+     * Delete conversation
+     *
+     * Delete a conversation and soft-delete all associated memories
+     * @param conversationId — The conversation ID
+     */
+    deleteConversation(conversationId: string): Promise<HttpResponse<unknown>>;
+    /**
+     * Get conversation timeline
+     *
+     * Get all memories in a conversation in chronological order
+     * @param conversationId — The conversation ID
+     */
+    getConversationTimeline(conversationId: string): Promise<HttpResponse<{
+        data?: Memory[];
+        count?: number;
+    }>>;
+    /**
+     * Search conversations
+     *
+     * Search conversations by query string
+     * @param body — Request body
+     */
+    searchConversations(body: {
+        query: string;
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: Conversation[];
+        count?: number;
+    }>>;
+    /**
+     * Find conversations by topic
+     *
+     * Find conversations that contain a specific topic
+     * @param body — Request body
+     */
+    findConversationsByTopic(body: {
+        topicId: string;
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: Conversation[];
+        count?: number;
+        metadata?: {
+            topicId?: string;
+        };
+    }>>;
+}
+
+/**
+ * BillingService — Subscription billing and payment management endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Subscription billing and payment management endpoints */
+declare class Billing {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Get billing overview
+     *
+     * Get subscription, payment method, and upcoming invoice information
+     */
+    getBillingOverview(): Promise<HttpResponse<{
+        data?: BillingOverview;
+    }>>;
+    /**
+     * Create checkout session
+     *
+     * Create a Stripe checkout session for subscription upgrade
+     * @param body — Request body
+     */
+    createCheckoutSession(body: {
+        priceId?: string;
+        successUrl: string;
+        cancelUrl: string;
+    }): Promise<HttpResponse<{
+        data?: CheckoutSessionResponse;
+    }>>;
+    /**
+     * Create billing portal session
+     *
+     * Create a Stripe billing portal session for managing subscription
+     * @param body — Request body
+     */
+    createPortalSession(body: {
+        returnUrl: string;
+    }): Promise<HttpResponse<{
+        data?: PortalSessionResponse;
+    }>>;
+    /**
+     * Get current subscription
+     *
+     * Get the current subscription details for the authenticated user
+     */
+    getSubscription(): Promise<HttpResponse<{
+        data?: Subscription;
+    }>>;
+    /**
+     * Cancel subscription
+     *
+     * Cancel the current subscription at the end of the billing period
+     * @param options — Optional parameters
+     */
+    cancelSubscription(options?: {
+        body?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: Subscription;
+    }>>;
+    /**
+     * Reactivate subscription
+     *
+     * Reactivate a subscription that was scheduled for cancellation
+     * @param options — Optional parameters
+     */
+    reactivateSubscription(options?: {
+        body?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: Subscription;
+    }>>;
+    /**
+     * List invoices
+     *
+     * Get a list of invoices for the authenticated user
+     * @param options — Optional parameters
+     */
+    listInvoices(options?: {
+        limit?: number;
+    }): Promise<HttpResponse<{
+        data?: ListInvoicesResponse;
+    }>>;
+    /**
+     * List payment methods
+     *
+     * Get a list of payment methods for the authenticated user
+     */
+    listPaymentMethods(): Promise<HttpResponse<{
+        data?: ListPaymentMethodsResponse;
+    }>>;
+    /**
+     * Set default payment method
+     *
+     * Set a payment method as the default for future payments
+     * @param id — The payment method ID
+     * @param options — Optional parameters
+     */
+    setDefaultPaymentMethod(id: string, options?: {
+        body?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        message?: string;
+    }>>;
+    /**
+     * Delete payment method
+     *
+     * Remove a payment method from the account
+     * @param id — The payment method ID
+     */
+    deletePaymentMethod(id: string): Promise<HttpResponse<unknown>>;
+    /**
+     * Stripe webhook endpoint
+     *
+     * Receive and process Stripe webhook events
+     * @param body — Request body
+     */
+    stripeWebhook(body: Record<string, unknown>): Promise<HttpResponse<{
+        received?: boolean;
+    }>>;
+}
+
+/**
+ * ArtifactsService — Artifact storage and retrieval endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Artifact storage and retrieval endpoints */
+declare class Artifacts {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List artifacts
+     *
+     * List all artifacts for the authenticated user with optional filters
+     * @param options — Optional parameters
+     */
+    listArtifacts(options?: {
+        limit?: number;
+        offset?: number;
+        memoryId?: string;
+        conversationId?: string;
+        type$?: string;
+    }): Promise<HttpResponse<{
+        data?: Artifact[];
+        count?: number;
+    }>>;
+    /**
+     * Create artifact
+     *
+     * Create a new artifact for the authenticated user
+     * @param body — Request body
+     */
+    createArtifact(body: {
+        content: string;
+        type: string;
+        name?: string;
+        description?: string;
+        memoryId?: string;
+        conversationId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: Artifact;
+    }>>;
+    /**
+     * Get artifact by ID
+     *
+     * Retrieve a specific artifact by its ID
+     * @param id — The artifact ID
+     */
+    getArtifactById(id: string): Promise<HttpResponse<{
+        data?: Artifact;
+    }>>;
+    /**
+     * Delete artifact
+     *
+     * Delete an artifact by its ID
+     * @param id — The artifact ID
+     */
+    deleteArtifact(id: string): Promise<HttpResponse<unknown>>;
+    /**
+     * Update artifact
+     *
+     * Update an existing artifact with partial data
+     * @param id — The artifact ID
+     * @param body — Request body
+     */
+    updateArtifact(id: string, body: {
+        content?: string;
+        type?: string;
+        name?: string;
+        description?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        data?: Artifact;
+    }>>;
+}
+
+/**
+ * ApiKeysService — API key management endpoints API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** API key management endpoints */
+declare class ApiKeys {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Get user information for current API key
+     *
+     * Debug endpoint to retrieve user ID and authentication method from the current API key
+     */
+    debugUser(): Promise<HttpResponse<{
+        data?: {
+            userId?: string;
+            authMethod?: string;
+        };
+    }>>;
+    /**
+     * List API keys
+     *
+     * List all API keys for the authenticated user
+     */
+    listApiKeys(): Promise<HttpResponse<{
+        data?: ApiKey[];
+    }>>;
+    /**
+     * Create API key
+     *
+     * Create a new API key for the authenticated user
+     * @param options — Optional parameters
+     */
+    createApiKey(options?: {
+        body?: {
+            label?: string;
+            expiresAt?: string;
+            scopes?: Array<'read' | 'write' | 'admin'>;
+        };
+    }): Promise<HttpResponse<{
+        data?: {
+            apiKey?: string;
+            keyInfo?: ApiKey;
+        };
+    }>>;
+    /**
+     * Delete API key
+     *
+     * Delete (revoke) an API key by its ID
+     * @param id — The API key ID
+     */
+    deleteApiKey(id: string): Promise<HttpResponse<unknown>>;
+}
+
+/**
+ * AlertsService — System alerts banner endpoints (customer portal) API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** System alerts banner endpoints (customer portal) */
+declare class Alerts {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List active system alerts for the current user
+     *
+     * Returns all active, non-expired system alerts that target either
+     * all users or the authenticated user specifically. Used by the
+     * customer portal to render the system alerts banner.
+     *
+     */
+    getActiveSystemAlerts(): Promise<HttpResponse<{
+        alerts?: SystemAlert[];
+    }>>;
+}
+
+/**
+ * AdminService — Admin management endpoints for invite codes and platform configuration API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Admin management endpoints for invite codes and platform configuration */
+declare class Admin {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List invite codes
+     *
+     * List all invite codes with optional status filter
+     * @param options — Optional parameters
+     */
+    adminListInviteCodes(options?: {
+        status?: 'active' | 'exhausted' | 'revoked' | 'expired';
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpResponse<{
+        invites?: Array<{
+            id?: string;
+            code?: string;
+            email?: string;
+            label?: string;
+            maxUses?: number;
+            currentUses?: number;
+            status?: string;
+            expiresAt?: string | null;
+            createdAt?: string;
+        }>;
+        total?: number;
+    }>>;
+    /**
+     * Create invite code
+     *
+     * Create a new invite code for the gated preview
+     * @param body — Request body
+     */
+    adminCreateInviteCode(body: {
+        email: string;
+        label: string;
+        maxUses?: number;
+        code?: string;
+        expiresAt?: string | null;
+        metadata?: Record<string, unknown>;
+    }): Promise<HttpResponse<{
+        id?: string;
+        code?: string;
+        label?: string;
+        maxUses?: number;
+        currentUses?: number;
+        status?: string;
+        expiresAt?: string | null;
+        createdAt?: string;
+        shareUrl?: string;
+    }>>;
+    /**
+     * Get invite system statistics
+     *
+     * Aggregate statistics for the invite system
+     */
+    adminGetInviteStats(): Promise<HttpResponse<{
+        totalCodes?: number;
+        activeCodes?: number;
+        totalRedemptions?: number;
+        totalCapacity?: number;
+        utilizationRate?: number;
+        recentRedemptions?: {
+            code?: string;
+            email?: string;
+            redeemedAt?: string;
+        }[];
+    }>>;
+    /**
+     * Get invite code details
+     *
+     * Get details for a single invite code including redemptions
+     * @param code — The invite code
+     */
+    adminGetInviteCode(code: string): Promise<HttpResponse<{
+        id?: string;
+        code?: string;
+        email?: string;
+        label?: string;
+        maxUses?: number;
+        currentUses?: number;
+        status?: string;
+        redemptions?: {
+            userId?: string;
+            email?: string;
+            redeemedAt?: string;
+        }[];
+    }>>;
+    /**
+     * Revoke an invite code
+     *
+     * Revoke an invite code. Existing accounts created with this code are unaffected.
+     * @param code
+     */
+    adminRevokeInviteCode(code: string): Promise<HttpResponse<{
+        code?: string;
+        status?: string;
+        message?: string;
+    }>>;
+    /**
+     * Get gate status with audit info
+     *
+     * Get current invite gate state with audit information
+     */
+    adminGetGateStatus(): Promise<HttpResponse<{
+        gated?: boolean;
+        updatedAt?: string | null;
+        updatedBy?: string | null;
+    }>>;
+    /**
+     * Toggle invite gate
+     *
+     * Toggle the invite gate. When enabled (true), new signups require a valid invite code.
+     * When disabled (false), registration is open. Takes effect immediately.
+     *
+     * @param body — Request body
+     */
+    adminSetGateStatus(body: {
+        enabled: boolean;
+    }): Promise<HttpResponse<{
+        gated?: boolean;
+        updatedAt?: string;
+        message?: string;
+    }>>;
+    /**
+     * Backfill per-stage memory pipeline status fields by inspecting actual graph state
+     * @param options — Optional parameters
+     */
+    adminMigratePerStageStatus(options?: {
+        body?: {
+            userId?: string;
+            limit?: number;
+            offset?: number;
+            dryRun?: boolean;
+        };
+    }): Promise<HttpResponse<{
+        scanned: number;
+        unchanged: number;
+        updated: number;
+        dryRun: boolean;
+        batchOffset: number;
+        totalCandidates: number;
+        totalRemaining: number;
+        startedAt: string;
+        completedAt: string;
+        durationMs: number;
+        errors: {
+            memoryId?: string;
+            error?: string;
+        }[];
+        toUpdate?: Record<string, unknown>[];
+        toUpdateCount?: number;
+    }>>;
+}
+
+/**
+ * AdminAlertsService — Admin endpoints for managing system alerts API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/** Admin endpoints for managing system alerts */
+declare class AdminAlerts {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * List system alerts
+     * @param options — Optional parameters
+     */
+    adminListSystemAlerts(options?: {
+        activeOnly?: boolean;
+    }): Promise<HttpResponse<{
+        alerts?: SystemAlert[];
+    }>>;
+    /**
+     * Create a system alert
+     * @param body — Request body
+     */
+    adminCreateSystemAlert(body: {
+        title: string;
+        body: string;
+        severity?: 'info' | 'warning' | 'critical';
+        active?: boolean;
+        dismissible?: boolean;
+        targetAllUsers?: boolean;
+        targetUserIds?: string[];
+        expiresAt?: string | null;
+    }): Promise<HttpResponse<{
+        id: string;
+        title: string;
+        body: string;
+        severity: 'info' | 'warning' | 'critical';
+        active?: boolean;
+        dismissible?: boolean;
+        targetAllUsers?: boolean;
+        targetUserIds?: string[];
+        createdAt: string;
+        expiresAt: string | null;
+        createdBy: string;
+    }>>;
+    /**
+     * Get a system alert by id
+     * @param id — System alert id
+     */
+    adminGetSystemAlert(id: string): Promise<HttpResponse<{
+        id: string;
+        title: string;
+        body: string;
+        severity: 'info' | 'warning' | 'critical';
+        active?: boolean;
+        dismissible?: boolean;
+        targetAllUsers?: boolean;
+        targetUserIds?: string[];
+        createdAt: string;
+        expiresAt: string | null;
+        createdBy: string;
+    }>>;
+    /**
+     * Delete a system alert
+     * @param id — System alert id
+     */
+    adminDeleteSystemAlert(id: string): Promise<HttpResponse<{
+        deleted?: boolean;
+    }>>;
+    /**
+     * Update a system alert
+     * @param id
+     * @param body — Request body
+     */
+    adminUpdateSystemAlert(id: string, body: {
+        title?: string;
+        body?: string;
+        severity?: 'info' | 'warning' | 'critical';
+        active?: boolean;
+        dismissible?: boolean;
+        targetAllUsers?: boolean;
+        targetUserIds?: string[];
+        expiresAt?: string | null;
+    }): Promise<HttpResponse<{
+        id: string;
+        title: string;
+        body: string;
+        severity: 'info' | 'warning' | 'critical';
+        active?: boolean;
+        dismissible?: boolean;
+        targetAllUsers?: boolean;
+        targetUserIds?: string[];
+        createdAt: string;
+        expiresAt: string | null;
+        createdBy: string;
+    }>>;
+}
+
+/**
+ * AdminPipelineService — Admin Pipeline API operations.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+declare class AdminPipeline {
+    private readonly _http;
+    constructor(http: HttpClient);
+    /**
+     * Re-enqueue a single memory through one pipeline
+     *
+     * Admin-only. Re-publishes the requested pipeline job for the given
+     * memory and resets the corresponding per-stage status field(s) to
+     * `queued`. Used to recover individual memories from transient
+     * worker failures or to replay a stage after a code change.
+     *
+     * @param id — Memory id (admin can target any tenant).
+     * @param body — Request body
+     */
+    adminRerunMemoryPipeline(id: string, body: {
+        pipeline: 'summary-qna' | 'embeddings' | 'graph';
+        embeddingKind?: 'content' | 'summary' | 'question';
+        questionId?: string;
+    }): Promise<HttpResponse<{
+        memoryId?: string;
+        pipeline?: string;
+        status?: string;
+    }>>;
+    /**
+     * Per-queue depth + failure counts for the memory-creation pipelines
+     *
+     * Returns BullMQ `getJobCounts()` for each known pipeline queue. Queues
+     * that have not yet been provisioned (e.g. `summary-qna` while task 2.3
+     * is in flight) are reported with `{ status: "not_configured" }` rather
+     * than throwing.
+     *
+     */
+    adminGetPipelineHealth(): Promise<HttpResponse<{
+        queues?: Record<string, unknown>;
+        timestamp?: string;
+    }>>;
+    /**
+     * Inspect per-stage pipeline status for a single memory
+     *
+     * Debugging affordance — returns the six per-stage status fields and graphSkipReason.
+     * @param id
+     */
+    adminGetMemoryPipelineStatus(id: string): Promise<HttpResponse<{
+        memoryId?: string;
+        contentEmbeddingStatus?: string | null;
+        summaryStatus?: string | null;
+        questionsStatus?: string | null;
+        summaryEmbeddingStatus?: string | null;
+        questionsEmbeddingStatus?: string | null;
+        graphStatus?: string | null;
+        graphSkipReason?: string | null;
+    }>>;
+}
+
+/**
+ * MemNexus Node.js SDK — main client.
+ * Auto-generated by sdk-generator — do not edit manually.
+ */
+
+/**
+ * MemNexus SDK client.
+ *
+ * Provides access to all MemNexus API services and convenience shorthand methods.
+ *
+ * @example
+ * ```ts
+ * import { MemNexus } from '@memnexus-ai/sdk';
+ *
+ * const client = new MemNexus({ apiKey: 'your-api-key' });
+ * await client.remember('Deployed the new feature');
+ * ```
+ */
+declare class MemNexus {
+    private readonly _http;
+    /** User management and profile endpoints */
+    readonly users: Users;
+    /** Topic detection, clustering, and management endpoints */
+    readonly topics: Topics;
+    /** System health, monitoring, and configuration endpoints */
+    readonly system: System;
+    /** Pattern detection and behavioral analysis endpoints */
+    readonly patterns: Patterns;
+    /** Behavioral pattern tracking and state management endpoints */
+    readonly behavior: Behavior;
+    /** Behavioral recommendation management endpoints (v2) */
+    readonly recommendations: Recommendations;
+    /** Narrative thread management endpoints */
+    readonly narratives: Narratives;
+    /** Observability and metrics endpoints for production monitoring */
+    readonly monitoring: Monitoring;
+    /** Memory management and retrieval endpoints */
+    readonly memories: Memories;
+    /** Invite code validation and gate status endpoints */
+    readonly invites: Invites;
+    /** Health check endpoints */
+    readonly health: Health;
+    /** Graph-based retrieval augmented generation endpoints */
+    readonly graphrag: Graphrag;
+    /** Fact extraction and management endpoints */
+    readonly facts: Facts;
+    /** Entity extraction and discovery endpoints */
+    readonly entities: Entities;
+    /** Conversation tracking and analysis endpoints */
+    readonly conversations: Conversations;
+    /** Subscription billing and payment management endpoints */
+    readonly billing: Billing;
+    /** Artifact storage and retrieval endpoints */
+    readonly artifacts: Artifacts;
+    /** API key management endpoints */
+    readonly apiKeys: ApiKeys;
+    /** System alerts banner endpoints (customer portal) */
+    readonly alerts: Alerts;
+    /** Admin management endpoints for invite codes and platform configuration */
+    readonly admin: Admin;
+    /** Admin endpoints for managing system alerts */
+    readonly adminAlerts: AdminAlerts;
+    /** Admin Pipeline operations */
+    readonly adminPipeline: AdminPipeline;
+    constructor(options?: HttpClientOptions & {
+        baseUrl?: string;
+    });
+    /**
+     * Save a memory.
+     * Convenience wrapper around `memories.createMemory`.
+     *
+     * @param content — The memory content to save.
+     * @param extra — Additional fields passed to CreateMemoryRequest.
+     */
+    remember(content: string, extra?: Record<string, unknown>): Promise<HttpResponse<unknown>>;
+    /**
+     * Get an AI-synthesized recall digest.
+     * Convenience wrapper.
+     *
+     * @param query — The recall query or topic.
+     */
+    recall(query: string, extra?: Record<string, unknown>): Promise<HttpResponse<unknown>>;
+    /**
+     * Search memories.
+     * Convenience wrapper.
+     *
+     * @param query — The search query.
+     */
+    search(query: string, extra?: Record<string, unknown>): Promise<HttpResponse<unknown>>;
+    /**
+     * Build a context briefing.
+     * Convenience wrapper.
+     *
+     * @param context — Context description for the briefing.
+     */
+    brief(context: string, extra?: Record<string, unknown>): Promise<HttpResponse<unknown>>;
+    /**
+     * Delete a memory by ID.
+     * Convenience wrapper.
+     *
+     * @param memoryId — The ID of the memory to delete.
+     */
+    forget(memoryId: string): Promise<HttpResponse<unknown>>;
+}
+
+export { type AddMemoryToNarrativeRequest, type ApiKey, type Artifact, type BatchGetMemoriesMeta, type BatchGetMemoriesRequest, type BatchGetMemoriesResponse, type BillingOverview, type BuildContextActiveWork, type BuildContextActivity, type BuildContextFact, type BuildContextGotcha, type BuildContextMeta, type BuildContextPattern, type BuildContextRequest, type BuildContextResponse, type BulkDeleteRequest, type BulkDeleteResponse, type BulkTagRequest, type BulkTagResponse, type BulkUpdateRequest, type BulkUpdateResponse, type CheckoutSessionResponse, type ClaimGroup, type ClaimGroupClaim, type ClaimGroupSignals, type CodeContext, type Community, type CompileInstructionsRequest, type CompileInstructionsResponse, type Conversation, type CreateArtifactRequest, type CreateCheckoutSessionRequest, type CreateConversationRequest, type CreateFactRequest, type CreateMemoryRelationshipRequest, type CreateMemoryRequest, type CreateMemoryResponse, type CreateMemoryResponseMeta, type CreateNarrativeRequest, type CreatePortalSessionRequest, type CreateRecommendationRequest, type CreateSystemAlertRequest, type DigestEntity, type DigestKeyFact, type DigestMetadata, type DigestRequest, type DigestResponse, type DigestSource, type DigestTimeRange, type EffectiveStateBreakdown, type Entity, type EntityNode, type Error$1 as Error, type ExportRequest, type FacetEntry, type Facets, type Fact, type FactSearchRequest, type GetMemoryResponse, type GetNarrativeResponse, type GraphRAGQueryRequest, type GraphRAGQueryResponse, type HealthCheck, type HttpClientOptions, type HttpResponse, type Invoice, type ListInvoicesResponse, type ListNarrativesResponse, type ListPaymentMethodsResponse, type MatchRecommendationsRequest, MemNexus, type Memory, type MemoryRelationship, type MemoryRelationshipsResponse, type NamedMemoryHistoryResponse, type NarrativeMemory, type NarrativeThread, type NarrativeTimelineResponse, type Pagination, type Pattern, type PaymentMethod, type PortalSessionResponse, type PrecomputedMemoryFields, type Recommendation, type RelatedMemoryResult, SdkError, type SearchMeta, type SearchRequest, type SearchResponse, type SearchResult, type ServiceCheck, type Subscription, type SystemAlert, type TemporalMetadata, type Topic, type UpdateArtifactRequest, type UpdateFactRequest, type UpdateMemoryRequest, type UpdateNamedMemoryRequest, type UpdateNarrativeRequest, type UpdateSystemAlertRequest, type User, type UserUsage };