@nebula-ai/sdk 1.3.0 → 1.4.0

package/dist/index.d.cts

@@ -0,0 +1,2824 @@
+//#region src/runtime/retry.d.ts
+interface RetryPolicy {
+  readonly maxRetries: number;
+  readonly baseMs: number;
+  readonly maxMs: number;
+}
+declare const DEFAULT_RETRY: RetryPolicy;
+declare function isRetryableStatus(status: number): boolean;
+declare function backoffMs(attempt: number, policy: RetryPolicy, retryAfterSec?: number): number;
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+//#endregion
+//#region src/runtime/client.d.ts
+interface ClientOptions {
+  baseUrl?: string;
+  apiKey?: string;
+  bearerToken?: string;
+  defaultHeaders?: Record<string, string>;
+  fetchImpl?: typeof fetch;
+  fetchOptions?: Omit<RequestInit, "method" | "headers" | "body" | "signal">;
+  timeoutMs?: number;
+  retry?: Partial<RetryPolicy>;
+  userAgent?: string;
+}
+interface RequestArgs {
+  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  path: string;
+  pathParams?: Record<string, string | number>;
+  query?: Record<string, unknown>;
+  body?: unknown;
+  headers?: Record<string, string>;
+  idempotent?: boolean;
+  signal?: AbortSignal;
+}
+declare class NebulaCore {
+  readonly baseUrl: string;
+  readonly apiKey?: string;
+  readonly bearerToken?: string;
+  readonly defaultHeaders: Record<string, string>;
+  readonly fetchImpl: typeof fetch;
+  readonly fetchOptions: Omit<RequestInit, "method" | "headers" | "body" | "signal">;
+  readonly timeoutMs: number;
+  readonly retry: RetryPolicy;
+  readonly userAgent: string;
+  constructor(options?: ClientOptions);
+  buildUrl(path: string, pathParams?: Record<string, string | number>, query?: Record<string, unknown>): string;
+  private buildHeaders;
+  request<T>(args: RequestArgs): Promise<T>;
+}
+//#endregion
+//#region src/types.d.ts
+interface components {
+  schemas: {
+    /**
+     * ActivatedEntity
+     * @description An entity activated during memory traversal with its profile.
+     *
+     *     Represents a conceptual node in memory that was activated by the query.
+     *     Contains the full EntityProfile (gestalt) filtered by relevance.
+     */
+    ActivatedEntity: {
+      /**
+       * Activation Score
+       * @default 0
+       */
+      activation_score: number; /** Category */
+      category?: string | null;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string; /** Name */
+      name: string; /** Profile */
+      profile?: unknown | null;
+    };
+    /**
+     * ActivatedEpisode
+     * @description An episodic nodegroup activated during memory traversal.
+     *
+     *     Represents a cluster of temporally related facts/events discovered
+     *     during graph traversal.
+     */
+    ActivatedEpisode: {
+      /**
+       * Activation Score
+       * @default 0
+       */
+      activation_score: number;
+      /**
+       * Category
+       * @default episodic
+       */
+      category: string; /** Description */
+      description?: string | null; /** Entity Names */
+      entity_names?: string[]; /** Evidence Ids */
+      evidence_ids?: string[];
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string;
+      /**
+       * Is Obligation
+       * @default false
+       */
+      is_obligation: boolean; /** Member Semantic Ids */
+      member_semantic_ids?: string[]; /** Modality */
+      modality?: string | null;
+      /**
+       * N Facts
+       * @default 0
+       */
+      n_facts: number; /** Name */
+      name: string; /** Resolved At */
+      resolved_at?: string | null; /** Status */
+      status?: string | null; /** T Last */
+      t_last?: string | null; /** T Start */
+      t_start?: string | null;
+    };
+    /**
+     * ActivatedProcedure
+     * @description A procedure-like memory activated during memory traversal.
+     *
+     *     This includes preference procedures, atomic traces, and trace-derived
+     *     strategies. Distinct from facts which are descriptive assertions.
+     */
+    ActivatedProcedure: {
+      /**
+       * Activation Score
+       * @default 0
+       */
+      activation_score: number; /** Belief Kind */
+      belief_kind?: string | null;
+      /**
+       * Confidence
+       * @default 0
+       */
+      confidence: number;
+      /**
+       * Derivation Type
+       * @default trivial
+       */
+      derivation_type: string; /** Entity Id */
+      entity_id?: string | null; /** Entity Name */
+      entity_name?: string | null;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string;
+      /**
+       * Is Negated
+       * @default false
+       */
+      is_negated: boolean; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      } | null; /** Statement */
+      statement: string;
+    };
+    /**
+     * ActivatedSemantic
+     * @description A semantic item activated during memory traversal.
+     *
+     *     Represents a structured assertion (fact, inference, or episodic) that was
+     *     found relevant to the query. Links back to its entity and source
+     *     utterances for provenance.
+     */
+    ActivatedSemantic: {
+      /**
+       * Activation Score
+       * @default 0
+       */
+      activation_score: number; /** Belief Kind */
+      belief_kind?: string | null;
+      /**
+       * Category
+       * @default fact
+       */
+      category: string;
+      /**
+       * Corroboration Count
+       * @default 1
+       */
+      corroboration_count: number; /** Description */
+      description?: string | null; /** Entity Id */
+      entity_id?: string | null; /** Entity Name */
+      entity_name?: string | null; /** Evidence Ids */
+      evidence_ids?: string[]; /** Evidence Refs */
+      evidence_refs?: components["schemas"]["EvidenceRef"][];
+      /**
+       * Extraction Confidence
+       * @default 0
+       */
+      extraction_confidence: number;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string; /** Is Current */
+      is_current?: boolean | null; /** Predicate */
+      predicate: string; /** Reasoning */
+      reasoning?: string | null; /** Resolved At */
+      resolved_at?: string | null; /** Source Nodegroup Ids */
+      source_nodegroup_ids?: string[]; /** Stability Confidence */
+      stability_confidence?: number | null; /** Subject */
+      subject: string; /** Temporal Precision */
+      temporal_precision?: string | null; /** Temporal Validity */
+      temporal_validity?: unknown | null; /** Truth Confidence */
+      truth_confidence?: number | null; /** Use Confidence */
+      use_confidence?: number | null; /** Value */
+      value: string;
+    };
+    /**
+     * ActivatedWorkflow
+     * @description A workflow template activated during memory traversal.
+     *
+     *     Workflows are the most structured form of procedure: ordered step
+     *     sequences derived from Stage 2B causal subgraphs, clustered by
+     *     taxonomy-triple backbone signature, and canonicalized via LLM-backed
+     *     template induction.  They answer "walk me through how I do X" and
+     *     "what comes after step Y" queries, as opposed to ActivatedProcedure
+     *     which answers "what are my preferences about X".
+     */
+    ActivatedWorkflow: {
+      /**
+       * Activation Score
+       * @default 0
+       */
+      activation_score: number;
+      /**
+       * Active Instance Count
+       * @default 0
+       */
+      active_instance_count: number; /** Backbone Signature Hash */
+      backbone_signature_hash?: string | null; /** Branches */
+      branches?: {
+        [key: string]: unknown;
+      }[];
+      /**
+       * Confidence
+       * @default 0
+       */
+      confidence: number; /** Current Step Index */
+      current_step_index?: number | null; /** Goal */
+      goal: string;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string;
+      /**
+       * Instance Count
+       * @default 0
+       */
+      instance_count: number; /** Last Observed At */
+      last_observed_at?: string | null; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      } | null; /** Name */
+      name: string;
+      predicted_next_step?: components["schemas"]["ActivatedWorkflowStep"] | null; /** Steps */
+      steps?: components["schemas"]["ActivatedWorkflowStep"][];
+      /**
+       * Taxonomy Version
+       * @default 1
+       */
+      taxonomy_version: number; /** Variable Slots */
+      variable_slots?: {
+        [key: string]: unknown;
+      };
+    };
+    /**
+     * ActivatedWorkflowStep
+     * @description A single canonical step inside an activated workflow template.
+     *
+     *     Rich context fields (how_this_works, typical_entities, typical_tools,
+     *     causes_next_because) are populated by the template inducer and carry
+     *     forward the observational detail from the instances that built this
+     *     template. They exist so an agent can understand *how* a step works,
+     *     *what tools are used*, and *why* it causes the next step — not just
+     *     *what* the step is.
+     */
+    ActivatedWorkflowStep: {
+      /** Canonical Description */canonical_description: string; /** Causes Next Because */
+      causes_next_because?: string | null; /** Entity Roles */
+      entity_roles?: string[]; /** Goal Category */
+      goal_category: string; /** How This Works */
+      how_this_works?: string | null; /** Index */
+      index: number; /** Object Type */
+      object_type: string;
+      /**
+       * Optional
+       * @default false
+       */
+      optional: boolean; /** Typical Entities */
+      typical_entities?: string[]; /** Typical Tools */
+      typical_tools?: string[]; /** Variable Slots */
+      variable_slots?: string[]; /** Verb Class */
+      verb_class: string;
+    }; /** AppendConversationMessage */
+    AppendConversationMessage: {
+      /**
+       * Authority
+       * @description Optional authority score
+       */
+      authority?: number | null;
+      /**
+       * Content
+       * @description Message content. Use a string for text-only messages or a list of content parts for multimodal content.
+       */
+      content: string | (components["schemas"]["TextContentRequest"] | components["schemas"]["FileContentRequest"] | components["schemas"]["S3FileReferenceRequest"])[];
+      /**
+       * Metadata
+       * @description Optional message-level metadata
+       */
+      metadata?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Parent Id
+       * @description Optional parent message ID
+       */
+      parent_id?: string | null;
+      /**
+       * Role
+       * @description Role: 'user', 'assistant', or 'system'
+       * @enum {string}
+       */
+      role: "user" | "assistant" | "system";
+      /**
+       * Source Role Id
+       * @description Optional SourceRole entity ID
+       */
+      source_role_id?: string | null;
+      /**
+       * Timestamp
+       * @description Semantic timestamp for when the message was authored. Drives chunk timestamps, the extraction LLM's temporal anchor, and episodic grouping. Without it, relative phrases ('this morning') resolve against ingestion wall-clock and episodes collapse.
+       */
+      timestamp?: string | null;
+    }; /** AppendMemoryRequest */
+    AppendMemoryRequest: {
+      /**
+       * Chunks
+       * @description Pre-processed text chunks to append for document memories.
+       */
+      chunks?: string[] | null;
+      /**
+       * Collection Id
+       * Format: uuid
+       * @description Target collection ID for the appended content.
+       */
+      collection_id: string; /** @description Optional ingestion configuration override. */
+      ingestion_config?: components["schemas"]["IngestionConfig"] | null;
+      /**
+       * @description Ingestion mode for document content.
+       * @default custom
+       */
+      ingestion_mode: components["schemas"]["IngestionMode"];
+      /**
+       * Messages
+       * @description Messages to append for conversation memories. Each message has content, role, and optional metadata.
+       */
+      messages?: components["schemas"]["AppendConversationMessage"][] | null;
+      /**
+       * Metadata
+       * @description Additional metadata for the appended content.
+       */
+      metadata?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Raw Text
+       * @description Raw text content to append for document memories.
+       */
+      raw_text?: string | null;
+    }; /** AppendMemoryResponse */
+    AppendMemoryResponse: {
+      /** Appended Messages */appended_messages?: components["schemas"]["AppendedMessageResponse"][];
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string;
+      message: components["schemas"]["Message"];
+      /**
+       * Metadata
+       * @default {}
+       */
+      metadata: {
+        [key: string]: unknown;
+      };
+    }; /** AppendedMessageResponse */
+    AppendedMessageResponse: {
+      /** Chunk Ids */chunk_ids?: string[]; /** Message Id */
+      message_id: string;
+    }; /** BatchDeleteResponse */
+    BatchDeleteResponse: {
+      /** Message */message: string;
+      results: components["schemas"]["BatchDeleteResult"];
+    }; /** BatchDeleteResult */
+    BatchDeleteResult: {
+      /** Failed */failed: {
+        [key: string]: unknown;
+      }[]; /** Successful */
+      successful: string[]; /** Summary */
+      summary: {
+        [key: string]: unknown;
+      };
+    };
+    /**
+     * BootstrapRecallRequest
+     * @description Top-K patterns by confidence with no anchor.
+     *
+     *     Used when a caller has no current state but wants to see what
+     *     patterns the collection knows about (onboarding, exploration).
+     */
+    BootstrapRecallRequest: {
+      /**
+       * Collection Id
+       * Format: uuid
+       * @description Collection containing the patterns to recall.
+       */
+      collection_id: string;
+      /**
+       * Intent
+       * @default bootstrap
+       * @constant
+       */
+      intent: "bootstrap";
+      /**
+       * Top K
+       * @description Maximum number of pattern hits to return.
+       * @default 10
+       */
+      top_k: number;
+    };
+    /**
+     * ChunkEnrichmentSettings
+     * @description Settings for chunk enrichment.
+     *
+     *     Model selection for the enrichment LLM call lives in
+     *     ``app.task_llms.chunk_enrichment``; the legacy ``generation_config``
+     *     field was removed in the per-task LLM cleanup pass.
+     */
+    ChunkEnrichmentSettings: {
+      /**
+       * Chunk Enrichment Prompt
+       * @description The prompt to use for chunk enrichment
+       * @default chunk_enrichment
+       */
+      chunk_enrichment_prompt: string | null;
+      /**
+       * Enable Chunk Enrichment
+       * @description Whether to enable chunk enrichment or not
+       * @default false
+       */
+      enable_chunk_enrichment: boolean;
+      /**
+       * N Chunks
+       * @description The number of preceding and succeeding chunks to include. Defaults to 2.
+       * @default 2
+       */
+      n_chunks: number;
+    }; /** CollectionResponse */
+    CollectionResponse: {
+      /**
+       * Access Tier
+       * @default private
+       */
+      access_tier: string | null;
+      /**
+       * Cache Policy
+       * @default lazy
+       */
+      cache_policy: string | null; /** Chain Type */
+      chain_type?: string | null; /** Contract Address */
+      contract_address?: string | null;
+      /**
+       * Created At
+       * Format: date-time
+       */
+      created_at: string;
+      /**
+       * Creator Royalty Bps
+       * @default 250
+       */
+      creator_royalty_bps: number | null; /** Description */
+      description: string | null; /** Engram Count */
+      engram_count: number; /** Graph Collection Status */
+      graph_collection_status: string; /** Graph Sync Status */
+      graph_sync_status: string; /** Has Preview Access */
+      has_preview_access?: boolean | null;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string; /** Is Forked */
+      is_forked?: boolean | null; /** Marketplace Metadata */
+      marketplace_metadata?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Memory Count
+       * @default 0
+       */
+      memory_count: number | null; /** Name */
+      name: string; /** Nft Collection Address */
+      nft_collection_address?: string | null; /** Owner Email */
+      owner_email?: string | null; /** Owner Id */
+      owner_id: string | null; /** Owner Name */
+      owner_name?: string | null;
+      /**
+       * Preview Query Limit
+       * @default 0
+       */
+      preview_query_limit: number | null; /** Purchase Price Usd */
+      purchase_price_usd?: string | null; /** Rental Price Monthly Usd */
+      rental_price_monthly_usd?: string | null;
+      /**
+       * Updated At
+       * Format: date-time
+       */
+      updated_at: string; /** User Count */
+      user_count: number;
+      /**
+       * Workflows Enabled
+       * @default false
+       */
+      workflows_enabled: boolean; /** Workspace Id */
+      workspace_id?: string | null;
+    };
+    /**
+     * CompactMemoryRecallResponse
+     * @description Default compact response from /v1/memories/search.
+     */
+    CompactMemoryRecallResponse: {
+      /** Episodic */episodic?: {
+        [key: string]: unknown;
+      }[]; /** Procedural */
+      procedural?: {
+        [key: string]: unknown;
+      }[]; /** Query */
+      query: string; /** Semantic */
+      semantic?: {
+        [key: string]: unknown;
+      }[]; /** Sources */
+      sources?: {
+        [key: string]: unknown;
+      }[];
+      /**
+       * Token Count
+       * @default 0
+       */
+      token_count: number;
+    }; /** ConnectRequest */
+    ConnectRequest: {
+      /**
+       * Collection Id
+       * Format: uuid
+       */
+      collection_id: string; /** Config */
+      config?: {
+        [key: string]: unknown;
+      } | null;
+    }; /** ConnectorConnectResponse */
+    ConnectorConnectResponse: {
+      /** Auth Url */auth_url: string; /** State */
+      state: string;
+    }; /** ConnectorConnectionResponse */
+    ConnectorConnectionResponse: {
+      /**
+       * Collection Id
+       * Format: uuid
+       */
+      collection_id: string; /** Config */
+      config?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Created At
+       * Format: date-time
+       */
+      created_at: string;
+      error_detail?: components["schemas"]["ConnectorErrorDetail"] | null; /** External Account Id */
+      external_account_id?: string | null; /** Health */
+      health?: ("ok" | "error") | null;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string; /** Items Synced */
+      items_synced?: number | null; /** Last Error */
+      last_error?: string | null; /** Last Synced At */
+      last_synced_at?: string | null; /** Next Sync At */
+      next_sync_at?: string | null; /** Provider */
+      provider: string;
+      /**
+       * Status
+       * @enum {string}
+       */
+      status: "active" | "pending" | "revoked"; /** Sync Cursor */
+      sync_cursor?: {
+        [key: string]: unknown;
+      } | null; /** Token Expires At */
+      token_expires_at?: string | null;
+      /**
+       * Updated At
+       * Format: date-time
+       */
+      updated_at: string;
+      /**
+       * User Id
+       * Format: uuid
+       */
+      user_id: string;
+    }; /** ConnectorDisconnectResponse */
+    ConnectorDisconnectResponse: {
+      /** Message */message: string; /** Warnings */
+      warnings?: components["schemas"]["ConnectorWarning"][];
+    }; /** ConnectorErrorDetail */
+    ConnectorErrorDetail: {
+      /** Message */message: string; /** Retryable */
+      retryable: boolean;
+    }; /** ConnectorSyncResponse */
+    ConnectorSyncResponse: {
+      /** Message */message: string;
+    }; /** ConnectorWarning */
+    ConnectorWarning: {
+      /** Code */code: string; /** Message */
+      message: string;
+    };
+    /**
+     * ConversationFields
+     * @description Conversation-specific typed fields.
+     *
+     *     Present iff ``Engram.kind == CONVERSATION``. Holds the platform-written
+     *     fields that previously lived on ``metadata`` (``conversation_id``,
+     *     ``episode_type``) so they have a typed home and are not co-mingled with
+     *     user-supplied metadata.
+     */
+    ConversationFields: {
+      /** Conversation Id */conversation_id?: string | null; /** Episode Type */
+      episode_type?: string | null;
+    };
+    /**
+     * ConversationMessage
+     * @description A message in a conversation with multimodal support.
+     */
+    ConversationMessage: {
+      /**
+       * Authority
+       * @description Optional authority score
+       */
+      authority?: number | null;
+      /**
+       * Content
+       * @description Message content. Use a string for text-only messages or a list of content parts for multimodal content.
+       */
+      content: string | (components["schemas"]["TextContentRequest"] | components["schemas"]["FileContentRequest"] | components["schemas"]["S3FileReferenceRequest"])[];
+      /**
+       * Metadata
+       * @description Optional message-level metadata
+       */
+      metadata?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Role
+       * @description Role: 'user', 'assistant', or 'system'
+       * @enum {string}
+       */
+      role: "user" | "assistant" | "system";
+      /**
+       * Timestamp
+       * @description Semantic timestamp for when the message was authored. Drives chunk timestamps, the extraction LLM's temporal anchor, and episodic grouping. Without it, relative phrases ('this morning') resolve against ingestion wall-clock and episodes collapse.
+       */
+      timestamp?: string | null;
+    }; /** CreateCollectionRequest */
+    CreateCollectionRequest: {
+      /** Description */description?: string | null; /** Name */
+      name: string;
+      /**
+       * Workflows Enabled
+       * @default false
+       */
+      workflows_enabled: boolean; /** Workspace Id */
+      workspace_id?: string | null;
+    };
+    /**
+     * CreateMemoryRequest
+     * @description Request model for creating memories (conversations or documents).
+     *
+     *     The canonical discriminator is ``kind`` (an :class:`EngramKind`).
+     *     Typed substructures (``conversation`` / ``document``) live on the
+     *     response :class:`Engram` and are populated server-side from inferred
+     *     values (``conversation_id`` is derived deterministically;
+     *     ``document_type`` and ``original_extension`` are inferred from the
+     *     file's content or extension). The request shape carries only
+     *     user-controllable inputs; ``metadata`` is reserved for user-supplied
+     *     annotations and must not carry platform discriminators or routing
+     *     markers. Unknown fields are rejected so a caller cannot accidentally
+     *     smuggle server-owned substructure into the request.
+     */
+    CreateMemoryRequest: {
+      /**
+       * Chunks
+       * @description Pre-chunked text for document kind
+       */
+      chunks?: string[] | null;
+      /**
+       * Collection Id
+       * @description Collection UUID (mutually exclusive with snapshot)
+       */
+      collection_id?: string | null;
+      /**
+       * Content Parts
+       * @description Multimodal content parts (text, images, audio, documents) for document kind.
+       */
+      content_parts?: (components["schemas"]["TextContentRequest"] | components["schemas"]["FileContentRequest"] | components["schemas"]["S3FileReferenceRequest"])[] | null;
+      /**
+       * Contents
+       * @description Batch content strings for snapshot mode
+       */
+      contents?: string[] | null; /** @description Custom ingestion config for documents */
+      ingestion_config?: components["schemas"]["IngestionConfig"] | null;
+      /**
+       * @description Ingestion mode for documents
+       * @default fast
+       */
+      ingestion_mode: components["schemas"]["IngestionMode"] | null;
+      /**
+       * @description Engram discriminator: ``document`` or ``conversation``. When omitted, ``conversation`` is inferred if ``messages`` is present; otherwise defaults to ``document``.
+       * @default document
+       */
+      kind: components["schemas"]["EngramKind"];
+      /**
+       * Messages
+       * @description Messages for conversation kind
+       */
+      messages?: components["schemas"]["ConversationMessage"][] | null;
+      /**
+       * Metadata
+       * @description User-supplied metadata for the memory. Must not carry platform discriminators or routing markers — use the ``kind`` / ``conversation`` / ``document`` fields instead.
+       */
+      metadata?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Name
+       * @description Optional name for the memory
+       */
+      name?: string | null;
+      /**
+       * Raw Text
+       * @description Raw text content for document kind
+       */
+      raw_text?: string | null; /** @description Device-memory snapshot (mutually exclusive with collection_id). */
+      snapshot?: components["schemas"]["SnapshotEnvelope-Input"] | null;
+      /**
+       * Speaker Id
+       * @description UUID of the SourceRole entity creating this memory
+       */
+      speaker_id?: string | null;
+      /**
+       * Speaker Name
+       * @description Display name of the speaker/agent creating this memory
+       */
+      speaker_name?: string | null;
+    };
+    /**
+     * CursorRecallRequest
+     * @description Locate where the caller is in known workflows.
+     *
+     *     Matches the caller's current state against pattern canonical
+     *     instances' entry states; returns ranked pattern hits with
+     *     pattern-side position metadata.
+     */
+    CursorRecallRequest: {
+      /**
+       * Collection Id
+       * Format: uuid
+       * @description Collection containing the patterns to recall.
+       */
+      collection_id: string;
+      /**
+       * Intent
+       * @default cursor
+       * @constant
+       */
+      intent: "cursor";
+      /**
+       * State Id
+       * @description Anchor: the user's current state nodegroup id.
+       */
+      state_id?: string | null;
+      /**
+       * Top K
+       * @description Maximum number of pattern hits to return.
+       * @default 10
+       */
+      top_k: number;
+      /**
+       * Trace Id
+       * @description Anchor: the user's most recent trace id. The handler resolves this trace's state_before automatically.
+       */
+      trace_id?: string | null;
+    }; /** DeleteMemoriesRequest */
+    DeleteMemoriesRequest: string | string[];
+    /**
+     * DocumentFields
+     * @description Document-specific typed fields.
+     *
+     *     Present iff ``Engram.kind == DOCUMENT``. ``document_type`` is required
+     *     because every document needs an extension/format classifier for parsing.
+     *     ``original_extension`` records the source filename's extension when it
+     *     differs from the canonical ``document_type`` (e.g. user uploaded ``.JPG``
+     *     normalized to ``jpeg``).
+     */
+    DocumentFields: {
+      document_type: components["schemas"]["DocumentType"]; /** Original Extension */
+      original_extension?: string | null;
+    };
+    /**
+     * DocumentType
+     * @description Types of file formats that can be stored as engrams.
+     * @enum {string}
+     */
+    DocumentType: "mp3" | "csv" | "eml" | "msg" | "p7s" | "epub" | "xls" | "xlsx" | "html" | "htm" | "bmp" | "heic" | "jpeg" | "png" | "tiff" | "jpg" | "svg" | "md" | "org" | "odt" | "pdf" | "txt" | "json" | "ppt" | "pptx" | "rst" | "rtf" | "tsv" | "gif" | "doc" | "docx" | "py" | "js" | "ts" | "css";
+    /**
+     * EmbeddingBlock
+     * @description A positionally-aligned masked embedding matrix.
+     */
+    EmbeddingBlock: {
+      /**
+       * Dim
+       * @default 0
+       */
+      dim: number;
+      /**
+       * Encoding
+       * @default npy-base64
+       * @constant
+       */
+      encoding: "npy-base64";
+      /**
+       * Mask B64
+       * @default
+       */
+      mask_b64: string;
+      /**
+       * Values B64
+       * @default
+       */
+      values_b64: string;
+    };
+    /**
+     * Engram
+     * @description The unified engram model: typed kind + per-kind substructure.
+     *
+     *     ``kind`` is the canonical discriminator. The per-kind ``conversation``
+     *     and ``document`` substructures hold typed fields known to the
+     *     platform; ``metadata`` is reserved for user-supplied annotations and
+     *     must never carry platform-written discriminators or routing markers.
+     *
+     *     Construction enforces shape consistency via a model validator:
+     *     ``kind=conversation`` must not carry document fields, ``kind=document``
+     *     must carry a ``DocumentFields`` substructure (``document_type`` is
+     *     required), and vice versa.
+     * @example {
+     *       "collection_ids": [
+     *         "123e4567-e89b-12d3-a456-426614174000"
+     *       ],
+     *       "created_at": "2021-01-01T00:00:00",
+     *       "document": {
+     *         "document_type": "pdf"
+     *       },
+     *       "extraction_status": "pending",
+     *       "id": "123e4567-e89b-12d3-a456-426614174000",
+     *       "ingestion_attempt_number": 0,
+     *       "ingestion_status": "pending",
+     *       "kind": "document",
+     *       "metadata": {},
+     *       "owner_id": "123e4567-e89b-12d3-a456-426614174000",
+     *       "size_in_bytes": 123456,
+     *       "title": "Sample Document",
+     *       "total_tokens": 1000,
+     *       "updated_at": "2021-01-01T00:00:00",
+     *       "version": "1.0"
+     *     }
+     */
+    Engram: {
+      /** Chunks */chunks?: unknown[] | null; /** Collection Ids */
+      collection_ids?: string[];
+      conversation?: components["schemas"]["ConversationFields"] | null; /** Created At */
+      created_at?: string | null;
+      document?: components["schemas"]["DocumentFields"] | null; /** @default pending */
+      extraction_status: components["schemas"]["GraphExtractionStatus"];
+      /**
+       * Id
+       * Format: uuid
+       */
+      id?: string; /** Ingestion Attempt Number */
+      ingestion_attempt_number?: number | null; /** @default pending */
+      ingestion_status: components["schemas"]["IngestionStatus"];
+      kind: components["schemas"]["EngramKind"]; /** Merkle Root */
+      merkle_root?: string | null; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      };
+      /**
+       * Owner Id
+       * Format: uuid
+       */
+      owner_id: string; /** Search Ready Seq */
+      search_ready_seq?: number | null; /** Size In Bytes */
+      size_in_bytes?: number | null; /** Text */
+      text?: string | null; /** Title */
+      title?: string | null; /** Total Tokens */
+      total_tokens?: number | null; /** Updated At */
+      updated_at?: string | null; /** Version */
+      version?: string | null; /** Workflow Run Id */
+      workflow_run_id?: string | null;
+    };
+    /**
+     * EngramKind
+     * @description The canonical engram discriminator.
+     *
+     *     A single source of truth: every engram is either a ``document`` or a
+     *     ``conversation``. The kind drives which typed substructure
+     *     (``Engram.document`` / ``Engram.conversation``) carries kind-specific
+     *     fields. The free-form ``metadata`` dict is reserved for user-supplied
+     *     annotations and is never inspected for routing.
+     * @enum {string}
+     */
+    EngramKind: "document" | "conversation";
+    /**
+     * EntityRecord
+     * @description Canonical entity record used in snapshots, WAL ops, and segments.
+     */
+    EntityRecord: {
+      /** Category */category?: string | null; /** Chunk Ids */
+      chunk_ids?: string[];
+      /**
+       * Collection Id
+       * @default
+       */
+      collection_id: string;
+      /**
+       * Created At
+       * Format: date-time
+       */
+      created_at: string; /** Description */
+      description?: string | null; /** Engram Id */
+      engram_id: string; /** Fts Terms */
+      fts_terms?: {
+        [key: string]: number;
+      } | null; /** Id */
+      id: string; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      }; /** Name */
+      name: string;
+      /**
+       * Relationship Count
+       * @default 0
+       */
+      relationship_count: number;
+      /**
+       * Updated At
+       * Format: date-time
+       */
+      updated_at: string;
+    };
+    /**
+     * Error
+     * @description Canonical error response envelope used across all public endpoints. SDK error classes are generated from this shape.
+     */
+    Error: {
+      /** @description Optional fine-grained error code within a category. */code?: string | null; /** @description Optional structured payload with context-specific diagnostic data. */
+      details?: unknown; /** @description Human-readable error description. */
+      message: string; /** @description Request correlation id for support-ticket lookups. */
+      request_id?: string | null; /** @description Stable machine-readable error category, e.g. 'validation_error', 'not_found', 'rate_limited'. */
+      type: string;
+    };
+    /**
+     * EvidenceRecallRequest
+     * @description Expand a specific pattern's canonical instance subgraph.
+     */
+    EvidenceRecallRequest: {
+      /**
+       * Collection Id
+       * Format: uuid
+       * @description Collection containing the patterns to recall.
+       */
+      collection_id: string;
+      /**
+       * Intent
+       * @default evidence
+       * @constant
+       */
+      intent: "evidence";
+      /**
+       * Pattern Id
+       * Format: uuid
+       * @description The pattern entity to hydrate.
+       */
+      pattern_id: string;
+      /**
+       * Top K
+       * @description Maximum number of pattern hits to return.
+       * @default 10
+       */
+      top_k: number;
+    };
+    /**
+     * EvidenceRef
+     * @description Tagged reference to a source of evidence.
+     */
+    EvidenceRef: {
+      /** Artifact Id */artifact_id?: string | null; /** Chunk Id */
+      chunk_id?: string | null; /** Collection Id */
+      collection_id?: string | null; /** Column Names */
+      column_names?: string[] | null;
+      ref_type: components["schemas"]["EvidenceRefType"]; /** Row Indices */
+      row_indices?: number[] | null; /** Table Name */
+      table_name?: string | null;
+    };
+    /**
+     * EvidenceRefType
+     * @enum {string}
+     */
+    EvidenceRefType: "chunk" | "table_artifact";
+    /**
+     * FileContentRequest
+     * @description Unified file content for multimodal messages.
+     */
+    FileContentRequest: {
+      /**
+       * Data
+       * @description Base64 encoded file data
+       */
+      data: string;
+      /**
+       * Duration Seconds
+       * @description Duration in seconds (for audio)
+       */
+      duration_seconds?: number | null;
+      /**
+       * Filename
+       * @description Original filename
+       */
+      filename?: string | null;
+      /**
+       * Media Type
+       * @description MIME type
+       * @default application/octet-stream
+       */
+      media_type: string;
+      /**
+       * @description Content kind: file, image, audio, or document. (enum property replaced by openapi-typescript)
+       * @enum {string}
+       */
+      type: "audio" | "document" | "file" | "image";
+    }; /** GenericBooleanResponse */
+    GenericBooleanResponse: {
+      /** Success */success: boolean;
+    }; /** GenericMessageResponse */
+    GenericMessageResponse: {
+      /** Id */id?: string | null; /** Memory Id */
+      memory_id?: string | null; /** Message */
+      message: string;
+    };
+    /**
+     * GraphExtractionStatus
+     * @description Status of graph creation per document.
+     * @enum {string}
+     */
+    GraphExtractionStatus: "pending" | "processing" | "success" | "failed";
+    /**
+     * GraphPayload
+     * @description A complete graph payload or a context subgraph payload.
+     */
+    GraphPayload: {
+      /** Entities */entities?: components["schemas"]["EntityRecord"][];
+      entity_description_embeddings?: components["schemas"]["EmbeddingBlock"];
+      relationship_description_embeddings?: components["schemas"]["EmbeddingBlock"];
+      relationship_relation_embeddings?: components["schemas"]["EmbeddingBlock"]; /** Relationships */
+      relationships?: components["schemas"]["RelationshipRecord"][];
+    };
+    /**
+     * GroundedSource
+     * @description A source that grounds facts in episodic memory.
+     *
+     *     This is the raw source material that supports the structured knowledge.
+     *     Provides the exact quotes and context for verification.
+     *
+     *     ``evidence_ref`` carries typed provenance so the client can distinguish
+     *     chunk-backed sources from table-artifact-backed sources (or future
+     *     modalities) without parsing opaque metadata.
+     */
+    GroundedSource: {
+      /**
+       * Activation Score
+       * @default 0
+       */
+      activation_score: number; /** Display Name */
+      display_name?: string | null; /** Engram Id */
+      engram_id?: string | null;
+      evidence_ref?: components["schemas"]["EvidenceRef"] | null;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      } | null; /** Owner Id */
+      owner_id?: string | null; /** Page Number */
+      page_number?: number | null; /** Section Path */
+      section_path?: string[] | null; /** Source Role */
+      source_role?: string | null; /** Speaker */
+      speaker?: string | null; /** Speaker Id */
+      speaker_id?: string | null; /** Structure Label */
+      structure_label?: string | null; /** Supporting Fact Ids */
+      supporting_fact_ids?: string[]; /** Text */
+      text: string; /** Timestamp */
+      timestamp?: string | null;
+    };
+    /**
+     * InferenceHint
+     * @description A lightweight inference artifact returned alongside MemoryRecall.
+     *
+     *     These are *not* asserted facts. They are "evidence + weak hints" that may have influenced
+     *     retrieval (e.g. query expansion) or may be useful for UI transparency.
+     */
+    InferenceHint: {
+      /** Confidence */confidence?: number | null; /** Inference Metadata */
+      inference_metadata?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Inferred
+       * @default false
+       */
+      inferred: boolean; /** Ledger P Stable */
+      ledger_p_stable?: number | null; /** Ledger P True */
+      ledger_p_true?: number | null; /** Ledger P Use */
+      ledger_p_use?: number | null; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      } | null; /** Object */
+      object: string; /** Object Id */
+      object_id?: string | null; /** Predicate */
+      predicate: string; /** Relationship Id */
+      relationship_id?: string | null; /** Subject Id */
+      subject_id?: string | null; /** Term */
+      term: string;
+      /**
+       * Usable For Rewrite
+       * @default false
+       */
+      usable_for_rewrite: boolean;
+      /**
+       * Used For Rewrite
+       * @default false
+       */
+      used_for_rewrite: boolean;
+    };
+    /**
+     * IngestionConfig
+     * @description Public ingestion config accepted by memory-ingestion endpoints.
+     *
+     *     This mirrors the supported request payload shape while staying independent
+     *     from the runtime provider config, which also carries internal-only fields
+     *     such as ``app`` and ``extra_fields``.
+     */
+    IngestionConfig: {
+      /** Audio Transcription Model */audio_transcription_model?: string | null;
+      /**
+       * Automatic Extraction
+       * @default false
+       */
+      automatic_extraction: boolean;
+      chunk_enrichment_settings?: components["schemas"]["ChunkEnrichmentSettings"];
+      /**
+       * Chunk Overlap
+       * @default 512
+       */
+      chunk_overlap: number;
+      /**
+       * Chunk Size
+       * @default 1024
+       */
+      chunk_size: number;
+      /**
+       * Chunking Strategy
+       * @default recursive
+       */
+      chunking_strategy: string; /** Excluded Parsers */
+      excluded_parsers?: string[]; /** Extra Parsers */
+      extra_parsers?: {
+        [key: string]: unknown;
+      };
+      /**
+       * Max Concurrent Vlm Tasks
+       * @default 5
+       */
+      max_concurrent_vlm_tasks: number; /** Parser Overrides */
+      parser_overrides?: {
+        [key: string]: string;
+      };
+      /**
+       * Provider
+       * @default nebula
+       */
+      provider: string; /** Vlm */
+      vlm?: string | null;
+      /**
+       * Vlm Batch Size
+       * @default 5
+       */
+      vlm_batch_size: number;
+      /**
+       * Vlm Max Tokens To Sample
+       * @default 1024
+       */
+      vlm_max_tokens_to_sample: number;
+      /**
+       * Vlm Ocr One Page Per Chunk
+       * @default true
+       */
+      vlm_ocr_one_page_per_chunk: boolean;
+    };
+    /**
+     * IngestionMode
+     * @enum {string}
+     */
+    IngestionMode: "hi-res" | "ocr" | "fast" | "custom";
+    /**
+     * IngestionResponse
+     * @example {
+     *       "engram_id": "9fbe403b-c11c-5aae-8ade-ef22980c3ad1",
+     *       "message": "Ingestion task queued successfully.",
+     *       "task_id": "c68dc72e-fc23-5452-8f49-d7bd46088a96"
+     *     }
+     */
+    IngestionResponse: {
+      /**
+       * Engram Id
+       * Format: uuid
+       * @description The ID of the engram that was ingested.
+       */
+      engram_id: string;
+      /**
+       * Message
+       * @description A message describing the result of the ingestion request.
+       */
+      message: string;
+      /**
+       * Task Id
+       * @description The task ID of the ingestion request.
+       */
+      task_id?: string | null;
+    };
+    /**
+     * IngestionStatus
+     * @description Status of document processing.
+     * @enum {string}
+     */
+    IngestionStatus: "pending" | "parsing" | "extracting" | "chunking" | "embedding" | "augmenting" | "storing" | "failed" | "success";
+    /**
+     * ListedEngram
+     * @description Engram as it appears in list responses, with per-row chunk-page metadata appended.
+     */
+    ListedEngram: {
+      /** Chunks */chunks?: unknown[] | null; /** @description True when ``chunks`` carries a prefix of the engram's full chunk set; fetch ``/v1/memories/{id}/chunks`` for the rest. */
+      chunks_truncated?: boolean; /** Collection Ids */
+      collection_ids?: string[];
+      conversation?: components["schemas"]["ConversationFields"] | null; /** Created At */
+      created_at?: string | null;
+      document?: components["schemas"]["DocumentFields"] | null; /** @default pending */
+      extraction_status: components["schemas"]["GraphExtractionStatus"];
+      /**
+       * Id
+       * Format: uuid
+       */
+      id?: string; /** Ingestion Attempt Number */
+      ingestion_attempt_number?: number | null; /** @default pending */
+      ingestion_status: components["schemas"]["IngestionStatus"];
+      kind: components["schemas"]["EngramKind"]; /** Merkle Root */
+      merkle_root?: string | null; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      };
+      /**
+       * Owner Id
+       * Format: uuid
+       */
+      owner_id: string; /** Search Ready Seq */
+      search_ready_seq?: number | null; /** Size In Bytes */
+      size_in_bytes?: number | null; /** Text */
+      text?: string | null; /** Title */
+      title?: string | null; /** @description Total chunks for this engram across the collection. */
+      total_chunks?: number; /** Total Tokens */
+      total_tokens?: number | null; /** Updated At */
+      updated_at?: string | null; /** Version */
+      version?: string | null; /** Workflow Run Id */
+      workflow_run_id?: string | null;
+    };
+    /**
+     * MemoryCreateAcceptedResponse
+     * @description Accepted-response envelope for async memory ingestion.
+     */
+    MemoryCreateAcceptedResponse: {
+      /**
+       * Applied Wal Seq
+       * @description WAL committed sequence number from this placeholder write, for read-your-writes assertions on the next collection-scoped list call. A non-zero value indicates the request appended a WAL entry; pass it back as `min_applied_wal_seq` on GET /v1/memories to wait for the entry's visibility before serving. Zero on idempotent observe-existing replays and on multi-shard collections (per-shard scalars are not comparable across shards) — clients should treat zero as 'no assertion to make.' Single-shard collections only.
+       * @default 0
+       */
+      applied_wal_seq: number; /** Engram Id */
+      engram_id?: string | null;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string; /** Memory Id */
+      memory_id?: string | null; /** Message */
+      message: string; /** Status */
+      status?: ("parsing" | "processing" | "queued") | null; /** Task Id */
+      task_id?: string | null;
+    };
+    /**
+     * MemoryCreateResponse
+     * @description Create-memory success response. Standard memory ingestion returns an accepted async-ingestion envelope; snapshot mode returns the updated snapshot synchronously.
+     */
+    MemoryCreateResponse: components["schemas"]["WrappedMemoryCreateAcceptedResponse"] | components["schemas"]["WrappedSnapshotMutationResult"];
+    /**
+     * MemoryRecall
+     * @description Hierarchical memory response - all layers, weighted by activation.
+     *
+     *     This is the primary response type for conceptual memory retrieval.
+     *     It contains all layers of the memory hierarchy:
+     *
+     *     1. **Entities (gestalt/schema layer)**: EntityProfiles that represent
+     *        the conceptual understanding of activated entities.
+     *
+     *     2. **Semantics (semantic layer)**: Structured assertions (facts,
+     *        inferences, tasks) scored by relevance and confidence.
+     *
+     *     3. **Episodes (temporal clusters)**: Episodic nodegroups that cluster
+     *        temporally related facts and events.
+     *
+     *     4. **Sources (episodic layer)**: The raw source material that
+     *        grounds the structured knowledge in actual moments/quotes.
+     */
+    MemoryRecall: {
+      /** Entities */entities?: components["schemas"]["ActivatedEntity"][]; /** Episodic */
+      episodic?: components["schemas"]["ActivatedEpisode"][]; /** Inference Hints */
+      inference_hints?: components["schemas"]["InferenceHint"][]; /** Procedural */
+      procedural?: components["schemas"]["ActivatedProcedure"][]; /** Query */
+      query: string; /** Semantic */
+      semantic?: components["schemas"]["ActivatedSemantic"][]; /** Sources */
+      sources?: components["schemas"]["GroundedSource"][]; /** Total Traversal Time Ms */
+      total_traversal_time_ms?: number | null; /** Workflows */
+      workflows?: components["schemas"]["ActivatedWorkflow"][];
+    };
+    /**
+     * MemorySearchRequest
+     * @description Request model for memory search.
+     *
+     *     Callers must supply exactly one of ``query`` or ``nql``. ``query``
+     *     takes the planner path; ``nql`` executes a hand-written script
+     *     directly for deterministic test/tooling use cases.
+     */
+    MemorySearchRequest: {
+      /**
+       * Collection Ids
+       * @description Optional list of collection UUIDs or names to scope the search.
+       */
+      collection_ids?: string[] | null; /** @description Compute effort budget (auto/low/medium/high). Controls traversal compute, not MemoryRecall size. */
+      effort?: components["schemas"]["SearchEffort"] | null;
+      /**
+       * Filters
+       * @description Optional filters to apply to the search.
+       */
+      filters?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Nql
+       * @description Pre-written NQL script. Executes directly without planner compilation. Mutually exclusive with ``query``.
+       */
+      nql?: string | null;
+      /**
+       * Query
+       * @description Natural-language search query. Mutually exclusive with ``nql``.
+       */
+      query?: string | null; /** @description Advanced search settings. */
+      search_settings?: components["schemas"]["SearchSettings"] | null; /** @description Device-memory snapshot for stateless search. */
+      snapshot?: components["schemas"]["SnapshotEnvelope-Input"] | null;
+    };
+    /**
+     * Message
+     * @example {
+     *       "content": "This is a test message.",
+     *       "role": "user"
+     *     }
+     */
+    Message: {
+      /** Content */content?: unknown | null; /** Function Call */
+      function_call?: {
+        [key: string]: unknown;
+      } | null; /** Image Data */
+      image_data?: {
+        [key: string]: string;
+      } | null; /** Image Url */
+      image_url?: string | null; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      } | null; /** Name */
+      name?: string | null; /** Role */
+      role: components["schemas"]["MessageType"] | string; /** Structured Content */
+      structured_content?: {
+        [key: string]: unknown;
+      }[] | null; /** Tool Call Id */
+      tool_call_id?: string | null; /** Tool Calls */
+      tool_calls?: {
+        [key: string]: unknown;
+      }[] | null;
+    };
+    /**
+     * MessageType
+     * @enum {string}
+     */
+    MessageType: "system" | "user" | "assistant" | "function" | "tool";
+    /**
+     * PaginatedCollectionResponse
+     * @description Cursor-paginated list of CollectionResponse entries. The wire envelope is ``{data, next_cursor, has_more}``.
+     */
+    PaginatedCollectionResponse: {
+      data: components["schemas"]["CollectionResponse"][]; /** @description Whether another page is available after this one. */
+      has_more: boolean; /** @description Opaque cursor for the next page. ``null`` when the caller has reached the end. */
+      next_cursor?: string | null;
+    };
+    /**
+     * PaginatedListedEngram
+     * @description Cursor-paginated list of ListedEngram entries. The wire envelope is ``{data, next_cursor, has_more}``.
+     */
+    PaginatedListedEngram: {
+      /**
+       * @description Highest WAL committed sequence number reflected in this response. Non-zero only when the request was served via the WAL-tail fast path. Pair with ``min_applied_wal_seq`` on the request for read-your-writes assertions.
+       * @default 0
+       */
+      applied_wal_seq: number;
+      data: components["schemas"]["ListedEngram"][]; /** @description Whether another page is available after this one. */
+      has_more: boolean; /** @description Opaque cursor for the next page. ``null`` when the caller has reached the end. */
+      next_cursor?: string | null;
+    };
+    /**
+     * PredictRecallRequest
+     * @description Cursor-style match plus the predicted next trace per pattern.
+     *
+     *     The "predicted next" is the canonical instance's first trace,
+     *     surfaced verbatim. This is correct for the matched-at-entry case
+     *     -- recall matches when the user's state aligns with a pattern's
+     *     entry state, so the canonical instance's first trace IS the next
+     *     step. Mid-instance prediction (advance past offset 1) is NOT
+     *     modelled in this version; callers that need it should follow up
+     *     on the returned pattern with a dedicated trace-chain walk.
+     */
+    PredictRecallRequest: {
+      /**
+       * Collection Id
+       * Format: uuid
+       * @description Collection containing the patterns to recall.
+       */
+      collection_id: string;
+      /**
+       * Intent
+       * @default predict
+       * @constant
+       */
+      intent: "predict";
+      /**
+       * State Id
+       * @description Anchor: the user's current state nodegroup id.
+       */
+      state_id?: string | null;
+      /**
+       * Top K
+       * @description Maximum number of pattern hits to return.
+       * @default 10
+       */
+      top_k: number;
+      /**
+       * Trace Id
+       * @description Anchor: the user's most recent trace id. The handler resolves this trace's state_before automatically.
+       */
+      trace_id?: string | null;
+    }; /** PresignedUploadResponse */
+    PresignedUploadResponse: {
+      /** Bucket */bucket: string; /** Download Url */
+      download_url: string; /** Expires In */
+      expires_in: number; /** Max Size */
+      max_size: number; /** S3 Key */
+      s3_key: string; /** Upload Headers */
+      upload_headers: {
+        [key: string]: string;
+      }; /** Upload Url */
+      upload_url: string;
+    };
+    /**
+     * RelationshipRecord
+     * @description Canonical relationship record used in snapshots, WAL ops, and segments.
+     */
+    RelationshipRecord: {
+      /** Category */category?: string | null; /** Chunk Ids */
+      chunk_ids?: string[];
+      /**
+       * Collection Id
+       * @default
+       */
+      collection_id: string;
+      /**
+       * Created At
+       * Format: date-time
+       */
+      created_at: string; /** Description */
+      description?: string | null; /** Engram Id */
+      engram_id?: string | null; /** Id */
+      id: string; /** Inference Metadata */
+      inference_metadata?: {
+        [key: string]: unknown;
+      } | null; /** Metadata */
+      metadata?: {
+        [key: string]: unknown;
+      }; /** Object */
+      object?: string | null; /** Object Id */
+      object_id: string;
+      /**
+       * Predicate
+       * @default
+       */
+      predicate: string; /** Relationship Type */
+      relationship_type?: string | null; /** Subject */
+      subject?: string | null; /** Subject Id */
+      subject_id: string; /** Temporal Precision */
+      temporal_precision?: string | null;
+      /**
+       * Updated At
+       * Format: date-time
+       */
+      updated_at: string; /** Valid Span */
+      valid_span?: {
+        [key: string]: unknown;
+      } | null; /** Weight */
+      weight?: number | null;
+    };
+    /**
+     * ResumeRecallRequest
+     * @description Cursor-style match biased toward deeper / further-along instances.
+     */
+    ResumeRecallRequest: {
+      /**
+       * Collection Id
+       * Format: uuid
+       * @description Collection containing the patterns to recall.
+       */
+      collection_id: string;
+      /**
+       * Intent
+       * @default resume
+       * @constant
+       */
+      intent: "resume";
+      /**
+       * State Id
+       * @description Anchor: the user's current state nodegroup id.
+       */
+      state_id?: string | null;
+      /**
+       * Top K
+       * @description Maximum number of pattern hits to return.
+       * @default 10
+       */
+      top_k: number;
+      /**
+       * Trace Id
+       * @description Anchor: the user's most recent trace id. The handler resolves this trace's state_before automatically.
+       */
+      trace_id?: string | null;
+    };
+    /**
+     * S3FileReferenceRequest
+     * @description Reference to a file uploaded to S3 (for large files).
+     */
+    S3FileReferenceRequest: {
+      /**
+       * Bucket
+       * @description S3 bucket (uses default if not specified)
+       */
+      bucket?: string | null;
+      /**
+       * Filename
+       * @description Original filename
+       */
+      filename?: string | null;
+      /**
+       * Media Type
+       * @description MIME type
+       * @default application/octet-stream
+       */
+      media_type: string;
+      /**
+       * S3 Key
+       * @description S3 object key
+       */
+      s3_key: string;
+      /**
+       * Size Bytes
+       * @description File size in bytes
+       */
+      size_bytes?: number | null;
+      /**
+       * @description discriminator enum property added by openapi-typescript
+       * @enum {string}
+       */
+      type: "s3_ref";
+    };
+    /**
+     * SearchEffort
+     * @description Compute effort budget for memory search.
+     *
+     *     Effort controls traversal compute (exploration budgets, depth, fanout), not the
+     *     size of the returned MemoryRecall projection.
+     * @enum {string}
+     */
+    SearchEffort: "auto" | "low" | "medium" | "high";
+    /**
+     * SearchSettings
+     * @description Advanced search settings for fine-tuning search behavior.
+     *
+     *     Note: Core parameters (query, collection_ids, filters) are now top-level API parameters.
+     *     This class contains advanced tuning options plus internal fields used by the retrieval service.
+     *
+     *     Memory search uses `effort` (auto/low/medium/high) to control compute.
+     * @example {
+     *       "fulltext_weight": 0.2,
+     *       "include_scores": true,
+     *       "semantic_weight": 0.8,
+     *       "verbose": false
+     *     }
+     */
+    SearchSettings: {
+      /**
+       * @description Compute effort budget (auto/low/medium/high). Controls traversal compute for memory search, not MemoryRecall size.
+       * @default auto
+       */
+      effort: components["schemas"]["SearchEffort"];
+      /**
+       * Enable Conceptual Expansion
+       * @description Enable conceptual expansion for cross-domain discovery through overlapping concepts
+       * @default false
+       */
+      enable_conceptual_expansion: boolean;
+      /**
+       * Filters
+       * @description Internal: Filters populated by the API router
+       */
+      filters?: {
+        [key: string]: unknown;
+      };
+      /**
+       * Fulltext Weight
+       * @description Weight for fulltext search in hybrid mode (0-1). Set to 0 for pure semantic search.
+       * @default 0.2
+       */
+      fulltext_weight: number;
+      /**
+       * Graph Settings
+       * @description Internal: Graph traversal settings (bfs_max_depth, semantic_threshold, etc.)
+       */
+      graph_settings?: {
+        [key: string]: unknown;
+      };
+      /**
+       * Has Pruning Gate
+       * @description Internal: Set by select_search_filters when an owner_id $in partition-pruning wrapper has been added around the filter tree. Used by the in-memory graph read engine to strip the Postgres-only wrapper before evaluating delegation.
+       * @default false
+       */
+      has_pruning_gate: boolean;
+      /**
+       * Include Scores
+       * @description Whether to include search score values in the search results
+       * @default true
+       */
+      include_scores: boolean;
+      /**
+       * Semantic Weight
+       * @description Weight for semantic search in hybrid mode (0-1). Set to 0 for pure fulltext search.
+       * @default 0.8
+       */
+      semantic_weight: number;
+      /**
+       * Verbose
+       * @description Include full internal metadata, UUIDs, and confidence fields in MemoryRecall responses. When False, returns compact LLM-optimized format.
+       * @default false
+       */
+      verbose: boolean;
+    };
+    /**
+     * SnapshotEnvelope
+     * @description Portable full snapshot owned by the client.
+     */
+    "SnapshotEnvelope-Input": {
+      /**
+       * Collection Id
+       * Format: uuid
+       */
+      collection_id: string;
+      /**
+       * Created At
+       * Format: date-time
+       */
+      created_at?: string;
+      /**
+       * Format Version
+       * @default 3
+       */
+      format_version: number;
+      /**
+       * Generation
+       * @default 0
+       */
+      generation: number;
+      graph?: components["schemas"]["GraphPayload"]; /** Root Hash */
+      root_hash: string;
+    };
+    /**
+     * SnapshotEnvelope
+     * @description Portable full snapshot owned by the client.
+     */
+    "SnapshotEnvelope-Output": {
+      /**
+       * Collection Id
+       * Format: uuid
+       */
+      collection_id: string;
+      /**
+       * Created At
+       * Format: date-time
+       */
+      created_at?: string;
+      /**
+       * Format Version
+       * @default 3
+       */
+      format_version: number;
+      /**
+       * Generation
+       * @default 0
+       */
+      generation: number;
+      graph?: components["schemas"]["GraphPayload"]; /** Root Hash */
+      root_hash: string;
+    }; /** SnapshotExportRequest */
+    SnapshotExportRequest: {
+      /**
+       * Collection Id
+       * Format: uuid
+       */
+      collection_id: string;
+    }; /** SnapshotImportRequest */
+    SnapshotImportRequest: {
+      snapshot: components["schemas"]["SnapshotEnvelope-Input"];
+    };
+    /**
+     * SnapshotImportResult
+     * @description Ephemeral collection handle returned after importing a snapshot.
+     */
+    SnapshotImportResult: {
+      /**
+       * Ephemeral Collection Id
+       * Format: uuid
+       */
+      ephemeral_collection_id: string;
+    };
+    /**
+     * SnapshotMutationResult
+     * @description Updated snapshot returned by snapshot-mode memory writes.
+     */
+    SnapshotMutationResult: {
+      snapshot: components["schemas"]["SnapshotEnvelope-Output"];
+    }; /** SnapshotSearchEntityResponse */
+    SnapshotSearchEntityResponse: {
+      /** Category */category?: string | null; /** Description */
+      description?: string | null;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string; /** Name */
+      name: string; /** Score */
+      score: number;
+    }; /** SnapshotSearchRelationshipResponse */
+    SnapshotSearchRelationshipResponse: {
+      /** Description */description?: string | null;
+      /**
+       * Id
+       * Format: uuid
+       */
+      id: string;
+      /**
+       * Object Id
+       * Format: uuid
+       */
+      object_id: string; /** Predicate */
+      predicate: string;
+      /**
+       * Subject Id
+       * Format: uuid
+       */
+      subject_id: string; /** Weight */
+      weight?: number | null;
+    };
+    /**
+     * SnapshotSearchResult
+     * @description Stateless snapshot-search response shape.
+     */
+    SnapshotSearchResult: {
+      /** Entities */entities?: components["schemas"]["SnapshotSearchEntityResponse"][]; /** Relationships */
+      relationships?: components["schemas"]["SnapshotSearchRelationshipResponse"][];
+    };
+    /**
+     * TextContentRequest
+     * @description Text content block.
+     */
+    TextContentRequest: {
+      /**
+       * Text
+       * @description Text content
+       */
+      text: string;
+      /**
+       * @description discriminator enum property added by openapi-typescript
+       * @enum {string}
+       */
+      type: "text";
+    }; /** UpdateCollectionRequest */
+    UpdateCollectionRequest: {
+      /** Access Tier */access_tier?: string | null; /** Description */
+      description?: string | null;
+      /**
+       * Generate Description
+       * @default false
+       */
+      generate_description: boolean; /** Name */
+      name?: string | null; /** Workflows Enabled */
+      workflows_enabled?: boolean | null;
+    }; /** UpdateMemoryRequest */
+    UpdateMemoryRequest: {
+      /**
+       * Collection Ids
+       * @description New collection associations
+       */
+      collection_ids?: string[] | null;
+      /**
+       * Merge Metadata
+       * @description Merge with existing metadata
+       * @default false
+       */
+      merge_metadata: boolean;
+      /**
+       * Metadata
+       * @description Metadata to update
+       */
+      metadata?: {
+        [key: string]: unknown;
+      } | null;
+      /**
+       * Name
+       * @description New name for the memory
+       */
+      name?: string | null;
+    };
+    /**
+     * WorkflowRecallResponse
+     * @description Wrapped response for the workflow recall endpoint.
+     *
+     *     The ``results`` payload shape varies per ``intent``:
+     *
+     *     * ``cursor`` / ``predict`` / ``resume`` -- ``{intent, hits[]}``
+     *       with ``hits`` containing pattern-match ranked entries.
+     *       ``predict`` additionally carries ``predicted_next_by_pattern``.
+     *     * ``evidence`` -- ``{intent, expanded}`` where ``expanded`` is the
+     *       hydrated canonical-instance subgraph.
+     *     * ``bootstrap`` -- ``{intent, hits[]}`` ranked by confidence with
+     *       no anchor.
+     *
+     *     The OpenAPI schema is intentionally typed as a generic object;
+     *     consumers should branch on ``results.intent`` and read the keys
+     *     documented in the request variants above.
+     */
+    WorkflowRecallResponse: {
+      /**
+       * Results
+       * @description Per-intent payload; see class docstring for shape.
+       */
+      results: {
+        [key: string]: unknown;
+      };
+    }; /** NebulaResults[AppendMemoryResponse] */
+    WrappedAppendMemoryResponse: {
+      results: components["schemas"]["AppendMemoryResponse"];
+    }; /** NebulaResults[CollectionResponse] */
+    WrappedCollectionResponse: {
+      results: components["schemas"]["CollectionResponse"];
+    }; /** NebulaResults[CompactMemoryRecallResponse] */
+    WrappedCompactMemoryRecallResponse: {
+      results: components["schemas"]["CompactMemoryRecallResponse"];
+    }; /** NebulaResults[ConnectorConnectResponse] */
+    WrappedConnectorConnectResponse: {
+      results: components["schemas"]["ConnectorConnectResponse"];
+    }; /** NebulaResults[ConnectorConnectionResponse] */
+    WrappedConnectorConnectionResponse: {
+      results: components["schemas"]["ConnectorConnectionResponse"];
+    }; /** NebulaResults[ConnectorDisconnectResponse] */
+    WrappedConnectorDisconnectResponse: {
+      results: components["schemas"]["ConnectorDisconnectResponse"];
+    }; /** NebulaResults[ConnectorSyncResponse] */
+    WrappedConnectorSyncResponse: {
+      results: components["schemas"]["ConnectorSyncResponse"];
+    }; /** NebulaResults[Engram] */
+    WrappedEngram: {
+      results: components["schemas"]["Engram"];
+    }; /** NebulaResults[GenericBooleanResponse] */
+    WrappedGenericBooleanResponse: {
+      results: components["schemas"]["GenericBooleanResponse"];
+    }; /** NebulaResults[GenericMessageResponse] */
+    WrappedGenericMessageResponse: {
+      results: components["schemas"]["GenericMessageResponse"];
+    }; /** NebulaResults[IngestionResponse] */
+    WrappedIngestionResponse: {
+      results: components["schemas"]["IngestionResponse"];
+    }; /** NebulaResults[list[ConnectorConnectionResponse]] */
+    WrappedListOfConnectorConnectionResponse: {
+      /** Results */results: components["schemas"]["ConnectorConnectionResponse"][];
+    }; /** NebulaResults[list[str]] */
+    WrappedListOfStr: {
+      /** Results */results: string[];
+    }; /** NebulaResults[MemoryCreateAcceptedResponse] */
+    WrappedMemoryCreateAcceptedResponse: {
+      results: components["schemas"]["MemoryCreateAcceptedResponse"];
+    }; /** NebulaResults[MemoryRecall] */
+    WrappedMemoryRecall: {
+      results: components["schemas"]["MemoryRecall"];
+    }; /** NebulaResults[PresignedUploadResponse] */
+    WrappedPresignedUploadResponse: {
+      results: components["schemas"]["PresignedUploadResponse"];
+    }; /** NebulaResults[SnapshotEnvelope] */
+    WrappedSnapshotEnvelope: {
+      results: components["schemas"]["SnapshotEnvelope-Output"];
+    }; /** NebulaResults[SnapshotImportResult] */
+    WrappedSnapshotImportResult: {
+      results: components["schemas"]["SnapshotImportResult"];
+    }; /** NebulaResults[SnapshotMutationResult] */
+    WrappedSnapshotMutationResult: {
+      results: components["schemas"]["SnapshotMutationResult"];
+    }; /** NebulaResults[SnapshotSearchResult] */
+    WrappedSnapshotSearchResult: {
+      results: components["schemas"]["SnapshotSearchResult"];
+    };
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+}
+//#endregion
+//#region src/resources/client.d.ts
+interface RequestOptions$4 {
+  signal?: AbortSignal;
+}
+declare class ClientResource {
+  private readonly core;
+  constructor(core: NebulaCore);
+  /**
+   *
+   * Health probe
+   *
+   * Lightweight liveness probe. Returns a 200 with a fixed message when the API process is up. Does not verify downstream dependencies (database, storage, workers) — use the internal status endpoints for those.
+   * @operationId client.health
+   * @endpoint GET /v1/health
+   */
+  health(options?: RequestOptions$4): Promise<components["schemas"]["WrappedGenericMessageResponse"]>;
+}
+//#endregion
+//#region src/resources/collections.d.ts
+interface RequestOptions$3 {
+  signal?: AbortSignal;
+}
+declare class CollectionsResource {
+  private readonly core;
+  constructor(core: NebulaCore);
+  /**
+   *
+   * Create a new collection
+   *
+   * Create a new collection and automatically add the creating user
+   * to it.
+   *
+   * This endpoint allows authenticated users to create a new collection
+   * with a specified name and optional description. The user creating
+   * the collection is automatically added as a member.
+   * @operationId collections.create
+   * @endpoint POST /v1/collections
+   */
+  create(params: {
+    body: components["schemas"]["CreateCollectionRequest"];
+  }, options?: RequestOptions$3): Promise<components["schemas"]["WrappedCollectionResponse"]>;
+  /**
+   *
+   * Delete collection
+   *
+   * Delete an existing collection.
+   *
+   * This endpoint allows deletion of a collection identified by its
+   * UUID. The user must have appropriate permissions to delete the
+   * collection. Deleting a collection removes all associations but does
+   * not delete the engrams within it.
+   * @operationId collections.delete
+   * @endpoint DELETE /v1/collections/{id}
+   */
+  delete(id: string, options?: RequestOptions$3): Promise<components["schemas"]["WrappedGenericBooleanResponse"]>;
+  /**
+   *
+   * List collections
+   *
+   * Returns a cursor-paginated list of collections the authenticated
+   * user has access to.
+   *
+   * Results can be filtered by providing specific collection IDs.
+   * Regular users will only see collections they own or have access to.
+   * Superusers can see all collections.
+   *
+   * The collections are returned in order of last modification, with
+   * most recent first.
+   * @operationId collections.list
+   * @endpoint GET /v1/collections
+   */
+  list(params?: {
+    /** A list of collection IDs to retrieve. If not provided, all collections will be returned. */ids?: Array<string>; /** Filter collections by name (case-insensitive exact match). */
+    name?: string | null; /** Opaque pagination cursor. Pass the ``next_cursor`` from a previous response to fetch the next page. */
+    cursor?: string | null; /** Specifies a limit on the number of objects to return, ranging between 1 and 1000. Defaults to 100. */
+    limit?: number; /** If true, only returns collections owned by the user, not all accessible collections. */
+    ownerOnly?: boolean; /** Filter by workspace ID. Pass a UUID to scope to a workspace, or omit for all. */
+    workspaceId?: string | null;
+  }, options?: RequestOptions$3): Promise<components["schemas"]["PaginatedCollectionResponse"]>;
+  /**
+   *
+   * Get collection details
+   *
+   * Get details of a specific collection.
+   *
+   * This endpoint retrieves detailed information about a single
+   * collection identified by its UUID. The user must have access to the
+   * collection to view its details.
+   * @operationId collections.retrieve
+   * @endpoint GET /v1/collections/{id}
+   */
+  retrieve(id: string, options?: RequestOptions$3): Promise<components["schemas"]["WrappedCollectionResponse"]>;
+  /**
+   *
+   * Get a collection by name
+   *
+   * Retrieve a collection by its (owner_id, name) combination.
+   *
+   * The authenticated user can only fetch collections they own, or, if
+   * superuser, from anyone.
+   * @operationId collections.retrieveByName
+   * @endpoint GET /v1/collections/name/{collection_name}
+   */
+  retrieveByName(params: {
+    /** The name of the collection */collectionName: string; /** (Superuser only) Specify the owner_id to retrieve a collection by name */
+    ownerId?: string | null;
+  }, options?: RequestOptions$3): Promise<components["schemas"]["WrappedCollectionResponse"]>;
+  /**
+   *
+   * Update collection
+   *
+   * Update an existing collection's configuration.
+   *
+   * This endpoint allows updating the name, description, and access settings of an
+   * existing collection. The user must have appropriate permissions to
+   * modify the collection.
+   * @operationId collections.update
+   * @endpoint POST /v1/collections/{id}
+   */
+  update(params: {
+    /** The unique identifier of the collection to update */id: string;
+    body: components["schemas"]["UpdateCollectionRequest"];
+  }, options?: RequestOptions$3): Promise<components["schemas"]["WrappedCollectionResponse"]>;
+}
+//#endregion
+//#region src/resources/connectors.d.ts
+interface RequestOptions$2 {
+  signal?: AbortSignal;
+}
+declare class ConnectorsResource {
+  private readonly core;
+  constructor(core: NebulaCore);
+  /**
+   *
+   * Start OAuth connection flow
+   *
+   * Start the OAuth connection flow for the given external provider. Returns the authorization URL the user should visit to grant Nebula access. After consent the provider redirects back to Nebula and the connection becomes active.
+   * @operationId connectors.connect
+   * @endpoint POST /v1/connectors/{provider}/connect
+   */
+  connect(params: {
+    provider: string;
+    body: components["schemas"]["ConnectRequest"];
+  }, options?: RequestOptions$2): Promise<components["schemas"]["WrappedConnectorConnectResponse"]>;
+  /**
+   *
+   * Disconnect an external data source
+   *
+   * Disconnect the named connection, revoking the stored OAuth credentials and stopping future syncs. Optionally pass `delete_memories=true` to also remove every memory this connection had ingested.
+   * @operationId connectors.disconnect
+   * @endpoint DELETE /v1/connectors/{connection_id}
+   */
+  disconnect(params: {
+    connectionId: string;
+    deleteMemories?: boolean;
+  }, options?: RequestOptions$2): Promise<components["schemas"]["WrappedConnectorDisconnectResponse"]>;
+  /**
+   *
+   * List active connections for a collection
+   *
+   * Return every connector connection associated with the given collection, with encrypted credentials redacted. Useful for showing the user which third-party data sources are wired up to a collection.
+   * @operationId connectors.list
+   * @endpoint GET /v1/connectors
+   */
+  list(params: {
+    collectionId: string;
+  }, options?: RequestOptions$2): Promise<components["schemas"]["WrappedListOfConnectorConnectionResponse"]>;
+  /**
+   *
+   * List available connector providers
+   *
+   * Return the set of connector provider identifiers (e.g. `google_drive`, `slack`) that this Nebula instance is configured to expose. Pass one of these to `POST /connectors/{provider}/connect` to start an OAuth flow.
+   * @operationId connectors.listProviders
+   * @endpoint GET /v1/connectors/providers
+   */
+  listProviders(options?: RequestOptions$2): Promise<components["schemas"]["WrappedListOfStr"]>;
+  /**
+   *
+   * Get a single connection by ID
+   *
+   * Fetch a single connector connection by its UUID. Returns the connection metadata plus whether the underlying subscription is active. Encrypted credentials are never returned to clients.
+   * @operationId connectors.retrieve
+   * @endpoint GET /v1/connectors/{connection_id}
+   */
+  retrieve(connectionId: string, options?: RequestOptions$2): Promise<components["schemas"]["WrappedConnectorConnectionResponse"]>;
+  /**
+   *
+   * Manually trigger a sync
+   *
+   * Schedule an immediate sync for an active connection, bypassing the normal cadence. Returns 409 if a sync is already in progress and 400 if the connection isn't in the `active` state.
+   * @operationId connectors.sync
+   * @endpoint POST /v1/connectors/{connection_id}/sync
+   */
+  sync(connectionId: string, options?: RequestOptions$2): Promise<components["schemas"]["WrappedConnectorSyncResponse"]>;
+}
+//#endregion
+//#region src/resources/memories.d.ts
+interface RequestOptions$1 {
+  signal?: AbortSignal;
+}
+declare class MemoriesResource {
+  private readonly core;
+  constructor(core: NebulaCore);
+  /**
+   *
+   * Append content to an engram
+   *
+   * Append content to an existing engram.
+   *
+   * **For conversation engrams:**
+   * - Provide `messages` array with content, role, and optional metadata
+   * - Works like `/conversations/{id}/messages` endpoint
+   *
+   * **For document engrams:**
+   * - Provide either `raw_text` or `chunks` to append additional content
+   * - Content will be processed and added to the engram
+   * @operationId memories.append
+   * @endpoint POST /v1/memories/{id}/append
+   */
+  append(params: {
+    /** The unique identifier of the engram */id: string;
+    body: components["schemas"]["AppendMemoryRequest"];
+  }, options?: RequestOptions$1): Promise<unknown>;
+  /**
+   *
+   * Create a new memory (conversation or document)
+   *
+   * Create a new memory (conversation or document) using clean JSON body.
+   *
+   * - Use `collection_id` (UUID)
+   * - `kind` is optional and inferred from payload shape:
+   *   - If `messages` present -> conversation
+   *   - Otherwise -> document
+   * - For conversations: provide `messages` array
+   * - For documents: provide `raw_text` or `chunks`
+   * - Use `snapshot` for device-memory mode (mutually exclusive with collection_id)
+   * @operationId memories.create
+   * @endpoint POST /v1/memories
+   */
+  create(params: {
+    body: components["schemas"]["CreateMemoryRequest"];
+  }, options?: RequestOptions$1): Promise<components["schemas"]["MemoryCreateResponse"]>;
+  /**
+   *
+   * Get presigned URL for large file upload
+   *
+   * Get a presigned URL for uploading large files directly to S3.
+   *
+   * Use this for files larger than 5MB that cannot be sent inline as base64.
+   * After uploading, reference the file in memory creation using S3FileReference.
+   *
+   * Args:
+   *     filename: Original filename (e.g., "image.jpg")
+   *     content_type: MIME type (e.g., "image/jpeg", "application/pdf")
+   *     file_size: Expected file size in bytes (max 100MB)
+   *
+   * Returns:
+   *     dict with:
+   *     - upload_url: Presigned URL for PUT request (expires in 1 hour)
+   *     - upload_headers: Headers that must be sent with the presigned PUT request
+   *     - s3_key: The S3 key to reference in memory creation
+   *     - bucket: S3 bucket name
+   *     - expires_in: Seconds until URL expires
+   *     - max_size: Maximum allowed file size
+   * @operationId memories.createUpload
+   * @endpoint POST /v1/memories/upload
+   */
+  createUpload(params: {
+    /** Original filename (e.g., 'image.jpg') */filename: string; /** MIME type (e.g., 'image/jpeg', 'application/pdf') */
+    contentType: string; /** Expected file size in bytes (max 100MB) */
+    fileSize: number;
+  }, options?: RequestOptions$1): Promise<components["schemas"]["WrappedPresignedUploadResponse"]>;
+  /**
+   *
+   * Delete an engram
+   *
+   * Delete a specific engram with graph awareness. All chunks corresponding to the
+   * engram are deleted, and graph components (entities/relationships) are updated
+   * or deleted based on remaining chunk references from other engrams.
+   *
+   * This method now properly handles graph components and maintains graph integrity
+   * for search operations.
+   * @operationId memories.delete
+   * @endpoint DELETE /v1/memories/{id}
+   */
+  delete(id: string, options?: RequestOptions$1): Promise<components["schemas"]["WrappedGenericBooleanResponse"]>;
+  /**
+   *
+   * Delete one or more engrams
+   *
+   * Delete one or more engrams.
+   *
+   * This endpoint efficiently handles both single and batch deletions.
+   * When multiple IDs are provided, it uses optimized batch operations.
+   *
+   * Args:
+   *     ids: Either a single UUID or a list of UUIDs to delete
+   *
+   * Returns:
+   *     For single deletion: boolean success response
+   *     For batch deletion: detailed results with successful and failed deletions
+   * @operationId memories.deleteMany
+   * @endpoint POST /v1/memories/delete
+   */
+  deleteMany(params: {
+    body: components["schemas"]["DeleteMemoriesRequest"];
+  }, options?: RequestOptions$1): Promise<unknown>;
+  /**
+   *
+   * Delete a previously uploaded S3 file
+   *
+   * Delete a file from S3 that was uploaded via a presigned URL.
+   * Verifies the caller owns the file via S3 object metadata.
+   * @operationId memories.deleteUpload
+   * @endpoint DELETE /v1/memories/upload
+   */
+  deleteUpload(params: {
+    /** S3 key of the file to delete (returned by POST /memories/upload) */s3Key: string;
+  }, options?: RequestOptions$1): Promise<components["schemas"]["WrappedGenericMessageResponse"]>;
+  /**
+   *
+   * List engrams
+   *
+   * Returns a cursor-paginated list of engrams the authenticated user
+   * has access to.
+   *
+   * Results can be filtered by providing specific engram IDs or collection IDs.
+   * Regular users will only see engrams they own or have access to through
+   * collections. Superusers can see all engrams.
+   *
+   * The engrams are returned in order of creation time, most recent
+   * first. The response includes the engram's text field if available.
+   * @operationId memories.list
+   * @endpoint GET /v1/memories
+   */
+  list(params?: {
+    /** A list of engram IDs to retrieve. If not provided, all engrams will be returned. */ids?: Array<string>; /** Opaque pagination cursor. Pass the ``next_cursor`` from a previous response to fetch the next page. */
+    cursor?: string | null; /** Specifies a limit on the number of objects to return, ranging between 1 and 1000. Defaults to 100. */
+    limit?: number; /** Maximum chunks to inline per engram. Defaults to all chunks for backwards compatibility; pass 0 to skip chunk hydration. */
+    chunksLimit?: number | null; /** If true, only returns engrams owned by the user, not all accessible engrams. */
+    ownerOnly?: boolean; /** Optional list of collection IDs to filter engrams by. If provided, exactly one collection ID must be specified. */
+    collectionIds?: Array<string> | null; /** JSON string for metadata filtering. Example: '{"metadata.source": {"$eq": "playground"}}' */
+    metadataFilters?: string | null; /** Read-your-writes assertion: the WAL-tail overlay path waits for at least this seq to be applied before serving (or returns 503 Unavailable on timeout). REQUIRES exactly one collection_ids entry — without a collection scope the request returns 422 (the per-WAL-shard scalar applied_wal_seq is meaningless across collections). When the served shard has not been migrated to wal_compaction_enabled, the field is accepted but the served path is the legacy overlay (the assertion has no effect — the response's applied_wal_seq will be 0). Pass back the value the matching upload response surfaced. */
+    minAppliedWalSeq?: number | null;
+  }, options?: RequestOptions$1): Promise<components["schemas"]["PaginatedListedEngram"]>;
+  /**
+   *
+   * Recall workflow patterns by intent
+   *
+   * Workflow-pattern recall over 5 intents.
+   *
+   * * ``cursor`` -- match the caller's anchor against pattern
+   *   canonical states, return ranked patterns + position.
+   * * ``predict`` -- like cursor but include the predicted next
+   *   trace from each pattern's canonical instance.
+   * * ``resume`` -- like cursor, biased toward longer patterns.
+   * * ``evidence`` -- expand a specific pattern via
+   *   ``hydrate_pattern``.
+   * * ``bootstrap`` -- top-K patterns by confidence with no anchor.
+   * @operationId memories.recallWorkflow
+   * @endpoint POST /v1/memories/workflow/recall
+   */
+  recallWorkflow(params: {
+    body: components["schemas"]["CursorRecallRequest"] | components["schemas"]["PredictRecallRequest"] | components["schemas"]["ResumeRecallRequest"] | components["schemas"]["EvidenceRecallRequest"] | components["schemas"]["BootstrapRecallRequest"];
+  }, options?: RequestOptions$1): Promise<components["schemas"]["WorkflowRecallResponse"]>;
+  /**
+   *
+   * Retrieve an engram
+   *
+   * Retrieves detailed information about a specific engram by its
+   * ID.
+   *
+   * This endpoint returns the engram's metadata, status, and system information. It does not
+   * return the engram's content - use the `/engrams/{id}/download` endpoint for that.
+   *
+   * Users can only retrieve engrams they own or have access to through collections.
+   * Superusers can retrieve any engram.
+   * @operationId memories.retrieve
+   * @endpoint GET /v1/memories/{id}
+   */
+  retrieve(id: string, options?: RequestOptions$1): Promise<components["schemas"]["WrappedEngram"]>;
+  /**
+   *
+   * Search memories
+   *
+   * Perform a search query across your memories.
+   *
+   * **Standard mode** (collection_ids or readable-scope search): returns hierarchical MemoryRecall
+   * with semantics, episodes, procedures, and sources.
+   *
+   * **Snapshot mode** (snapshot field): returns graph-search results with
+   * {entities, relationships} from stateless in-memory traversal.
+   * @operationId memories.search
+   * @endpoint POST /v1/memories/search
+   */
+  search(params: {
+    body: components["schemas"]["MemorySearchRequest"];
+  }, options?: RequestOptions$1): Promise<unknown>;
+  /**
+   *
+   * Update a memory
+   *
+   * Update memory-level properties including name, metadata, and collection associations.
+   *
+   * This endpoint allows updating properties of an entire memory (document or conversation)
+   * without modifying its content:
+   * - **name**: Updates the authoritative engram title
+   * - **metadata**: Can replace or merge with existing metadata
+   * - **collection_ids**: Updates authoritative engram collection associations
+   *
+   * Users can only update memories they own or have access to through collections.
+   * At least one collection association must be maintained.
+   *
+   * If collection_id is provided and the engram is shared across collections, a copy-on-write
+   * will be performed to create a collection-specific copy before modification.
+   * @operationId memories.update
+   * @endpoint PATCH /v1/memories/{id}
+   */
+  update(params: {
+    /** The unique identifier of the memory */id: string; /** Collection context for copy-on-write. If provided and engram is shared, creates a copy before modification. */
+    collectionId?: string | null;
+    body: components["schemas"]["UpdateMemoryRequest"];
+  }, options?: RequestOptions$1): Promise<components["schemas"]["WrappedEngram"]>;
+}
+//#endregion
+//#region src/resources/snapshots.d.ts
+interface RequestOptions {
+  signal?: AbortSignal;
+}
+declare class SnapshotsResource {
+  private readonly core;
+  constructor(core: NebulaCore);
+  /**
+   *
+   * Export a collection snapshot
+   *
+   * Export a collection's full graph state as a
+   * portable SnapshotEnvelope.
+   * @operationId snapshots.export
+   * @endpoint POST /v1/device-memory/snapshot/export
+   */
+  export(params: {
+    body: components["schemas"]["SnapshotExportRequest"];
+  }, options?: RequestOptions): Promise<components["schemas"]["WrappedSnapshotEnvelope"]>;
+  /**
+   *
+   * Import a snapshot into an ephemeral collection
+   *
+   * Import a SnapshotEnvelope into an ephemeral
+   * collection. Returns the ephemeral collection UUID.
+   * @operationId snapshots.import
+   * @endpoint POST /v1/device-memory/snapshot/import
+   */
+  import(params: {
+    body: components["schemas"]["SnapshotImportRequest"];
+  }, options?: RequestOptions): Promise<components["schemas"]["WrappedSnapshotImportResult"]>;
+}
+//#endregion
+//#region src/client.d.ts
+declare class NebulaClient {
+  protected readonly core: NebulaCore;
+  readonly client: ClientResource;
+  readonly collections: CollectionsResource;
+  readonly connectors: ConnectorsResource;
+  readonly memories: MemoriesResource;
+  readonly snapshots: SnapshotsResource;
+  constructor(options?: ClientOptions);
+}
+//#endregion
+//#region src/runtime/errors.d.ts
+declare class NebulaError extends Error {
+  readonly name: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+declare class NebulaConnectionError extends NebulaError {
+  readonly name = "NebulaConnectionError";
+}
+declare class NebulaTimeoutError extends NebulaError {
+  readonly name = "NebulaTimeoutError";
+}
+interface APIErrorPayload {
+  readonly status: number;
+  readonly requestId?: string;
+  readonly body: unknown;
+}
+declare class NebulaAPIError extends NebulaError {
+  readonly name: string;
+  readonly status: number;
+  readonly requestId?: string;
+  readonly body: unknown;
+  readonly type?: string;
+  readonly code?: string;
+  readonly details?: unknown;
+  constructor(payload: APIErrorPayload, message?: string);
+}
+declare class NebulaBadRequestError extends NebulaAPIError {
+  readonly name = "NebulaBadRequestError";
+}
+declare class NebulaUnauthorizedError extends NebulaAPIError {
+  readonly name = "NebulaUnauthorizedError";
+}
+declare class NebulaForbiddenError extends NebulaAPIError {
+  readonly name = "NebulaForbiddenError";
+}
+declare class NebulaNotFoundError extends NebulaAPIError {
+  readonly name = "NebulaNotFoundError";
+}
+declare class NebulaConflictError extends NebulaAPIError {
+  readonly name = "NebulaConflictError";
+}
+declare class NebulaValidationError extends NebulaAPIError {
+  readonly name = "NebulaValidationError";
+}
+declare class NebulaRateLimitError extends NebulaAPIError {
+  readonly name = "NebulaRateLimitError";
+  readonly retryAfter?: number;
+  constructor(payload: APIErrorPayload, retryAfter?: number);
+}
+declare class NebulaServerError extends NebulaAPIError {
+  readonly name = "NebulaServerError";
+}
+declare function errorFromResponse(payload: APIErrorPayload, retryAfter?: number): NebulaAPIError;
+//#endregion
+//#region src/lib/_dx_generated.d.ts
+/**
+ * Conditional type matching the runtime envelope-unwrap. If T has a
+ * `results` field, narrow to it; otherwise pass through.
+ */
+type Unwrapped<T> = T extends {
+  results: infer R;
+} ? R : T;
+/**
+ * Generated DX layer: simple unwrap/passthrough convenience methods.
+ * Signatures are derived from the underlying resource methods so
+ * callers see the same arg names + types in IDE hover.
+ */
+declare class NebulaDX extends NebulaClient {
+  /** Retrieve a single memory by id and return just the data. (generated from dx-extensions.yaml). */
+  getMemory(...args: Parameters<NebulaClient["memories"]["retrieve"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["memories"]["retrieve"]>>>>;
+  /** Update a memory by id; returns the updated record. (generated from dx-extensions.yaml). */
+  updateMemory(...args: Parameters<NebulaClient["memories"]["update"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["memories"]["update"]>>>>;
+  /** Liveness probe with the wire envelope unwrapped. (generated from dx-extensions.yaml). */
+  healthCheck(...args: Parameters<NebulaClient["client"]["health"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["client"]["health"]>>>>;
+  /** unwrap → collections.create (generated from dx-extensions.yaml). */
+  createCollection(...args: Parameters<NebulaClient["collections"]["create"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["collections"]["create"]>>>>;
+  /** unwrap → collections.retrieve (generated from dx-extensions.yaml). */
+  getCollection(...args: Parameters<NebulaClient["collections"]["retrieve"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["collections"]["retrieve"]>>>>;
+  /** unwrap → collections.retrieveByName (generated from dx-extensions.yaml). */
+  getCollectionByName(...args: Parameters<NebulaClient["collections"]["retrieveByName"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["collections"]["retrieveByName"]>>>>;
+  /** unwrap → collections.list (generated from dx-extensions.yaml). */
+  listCollections(...args: Parameters<NebulaClient["collections"]["list"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["collections"]["list"]>>>>;
+  /** unwrap → collections.update (generated from dx-extensions.yaml). */
+  updateCollection(...args: Parameters<NebulaClient["collections"]["update"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["collections"]["update"]>>>>;
+  /** unwrap → connectors.listProviders (generated from dx-extensions.yaml). */
+  listProviders(...args: Parameters<NebulaClient["connectors"]["listProviders"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["connectors"]["listProviders"]>>>>;
+  /** unwrap → connectors.retrieve (generated from dx-extensions.yaml). */
+  getConnection(...args: Parameters<NebulaClient["connectors"]["retrieve"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["connectors"]["retrieve"]>>>>;
+  /** unwrap → connectors.sync (generated from dx-extensions.yaml). */
+  triggerSync(...args: Parameters<NebulaClient["connectors"]["sync"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["connectors"]["sync"]>>>>;
+  /** unwrap → memories.createUpload (generated from dx-extensions.yaml). */
+  getUploadUrl(...args: Parameters<NebulaClient["memories"]["createUpload"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["memories"]["createUpload"]>>>>;
+  /** unwrap → snapshots.export (generated from dx-extensions.yaml). */
+  exportSnapshot(...args: Parameters<NebulaClient["snapshots"]["export"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["snapshots"]["export"]>>>>;
+  /** unwrap → snapshots.import (generated from dx-extensions.yaml). */
+  importSnapshot(...args: Parameters<NebulaClient["snapshots"]["import"]>): Promise<Unwrapped<Awaited<ReturnType<NebulaClient["snapshots"]["import"]>>>>;
+}
+//#endregion
+//#region src/lib/dx.d.ts
+type Schemas = components["schemas"];
+type SnapshotEnvelopeInput = Schemas["SnapshotEnvelope-Input"];
+type SnapshotEnvelopeOutput = Schemas["SnapshotEnvelope-Output"];
+type RequestPath = `/${string}` | `http://${string}` | `https://${string}`;
+type CompatClientOptions = ClientOptions & {
+  api_key?: string | null;
+  apiKey?: string | null;
+  baseUrl?: string | null;
+  baseURL?: string | null;
+  base_url?: string | null;
+  timeout?: number | null;
+  accessToken?: string | null;
+  bearerToken?: string | null;
+  bearer_token?: string | null;
+  access_token?: string | null;
+};
+interface MemoryCommonInput {
+  collection_id?: string | null;
+  collectionId?: string | null;
+  content?: string | string[] | unknown[] | null;
+  raw_text?: string | null;
+  chunks?: Array<string> | null;
+  messages?: unknown[] | null;
+  metadata?: {
+    [key: string]: unknown;
+  } | null;
+  ingestion_config?: unknown;
+  ingestion_mode?: string | null;
+}
+interface MemoryCreateInput extends MemoryCommonInput {
+  name?: string | null;
+  speaker_id?: string | null;
+  speaker_name?: string | null;
+  content_parts?: unknown[] | null;
+  contents?: string[] | null;
+  snapshot?: SnapshotEnvelopeInput | null;
+  memory_id?: undefined | null;
+}
+interface MemoryAppendInput extends Omit<MemoryCommonInput, "ingestion_mode" | "messages"> {
+  memory_id: string;
+  ingestion_mode?: string | null;
+  messages?: unknown[] | null;
+}
+type MemoryInput = MemoryCreateInput | MemoryAppendInput;
+declare class Nebula extends NebulaDX {
+  constructor(options?: CompatClientOptions);
+  /**
+   * Polymorphic memory creator: dispatches to memories.create or memories.append
+   * based on whether `memory_id` is set on the input. Returns the new memory's
+   * id (string), or — when `snapshot` is set — the updated snapshot envelope.
+   */
+  storeMemory(memory: MemoryInput, options?: {
+    signal?: AbortSignal;
+  }): Promise<string | SnapshotEnvelopeOutput>;
+  /**
+   * Bulk parallel version of storeMemory with a concurrency cap.
+   *
+   * Default 8 concurrent in-flight requests matches the Python DX's
+   * `asyncio.Semaphore(max_concurrency)` pattern. Use `maxConcurrency: 1`
+   * for strictly serial submission; higher values risk overwhelming the
+   * server when memories[] is large.
+   */
+  storeMemories(memories: MemoryInput[], options?: {
+    signal?: AbortSignal;
+    maxConcurrency?: number;
+  }): Promise<(string | SnapshotEnvelopeOutput)[]>;
+  /**
+   * List memories scoped to one or more collection ids (string | string[])
+   * or a full MemoryListParams object.
+   */
+  listMemories(query: string | string[] | Record<string, unknown>, options?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  /**
+   * Memory search shortcut: unwraps `results`. (Affinity-header injection
+   * is a planned enhancement; currently delegates straight to the resource.)
+   */
+  search(body: Schemas["MemorySearchRequest"], options?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  /**
+   * deleteCollection coerces the wire {success: bool} envelope into a Python-
+   * style boolean return.
+   */
+  deleteCollection(id: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<boolean>;
+  createCluster: (params: {
+    body: components["schemas"]["CreateCollectionRequest"];
+  }, options?: RequestOptions$3 | undefined) => Promise<{
+    access_tier: string | null;
+    cache_policy: string | null;
+    chain_type?: string | null;
+    contract_address?: string | null;
+    created_at: string;
+    creator_royalty_bps: number | null;
+    description: string | null;
+    engram_count: number;
+    graph_collection_status: string;
+    graph_sync_status: string;
+    has_preview_access?: boolean | null;
+    id: string;
+    is_forked?: boolean | null;
+    marketplace_metadata?: {
+      [key: string]: unknown;
+    } | null;
+    memory_count: number | null;
+    name: string;
+    nft_collection_address?: string | null;
+    owner_email?: string | null;
+    owner_id: string | null;
+    owner_name?: string | null;
+    preview_query_limit: number | null;
+    purchase_price_usd?: string | null;
+    rental_price_monthly_usd?: string | null;
+    updated_at: string;
+    user_count: number;
+    workflows_enabled: boolean;
+    workspace_id?: string | null;
+  }>;
+  getCluster: (id: string, options?: RequestOptions$3 | undefined) => Promise<{
+    access_tier: string | null;
+    cache_policy: string | null;
+    chain_type?: string | null;
+    contract_address?: string | null;
+    created_at: string;
+    creator_royalty_bps: number | null;
+    description: string | null;
+    engram_count: number;
+    graph_collection_status: string;
+    graph_sync_status: string;
+    has_preview_access?: boolean | null;
+    id: string;
+    is_forked?: boolean | null;
+    marketplace_metadata?: {
+      [key: string]: unknown;
+    } | null;
+    memory_count: number | null;
+    name: string;
+    nft_collection_address?: string | null;
+    owner_email?: string | null;
+    owner_id: string | null;
+    owner_name?: string | null;
+    preview_query_limit: number | null;
+    purchase_price_usd?: string | null;
+    rental_price_monthly_usd?: string | null;
+    updated_at: string;
+    user_count: number;
+    workflows_enabled: boolean;
+    workspace_id?: string | null;
+  }>;
+  getClusterByName: (params: {
+    collectionName: string;
+    ownerId?: string | null;
+  }, options?: RequestOptions$3 | undefined) => Promise<{
+    access_tier: string | null;
+    cache_policy: string | null;
+    chain_type?: string | null;
+    contract_address?: string | null;
+    created_at: string;
+    creator_royalty_bps: number | null;
+    description: string | null;
+    engram_count: number;
+    graph_collection_status: string;
+    graph_sync_status: string;
+    has_preview_access?: boolean | null;
+    id: string;
+    is_forked?: boolean | null;
+    marketplace_metadata?: {
+      [key: string]: unknown;
+    } | null;
+    memory_count: number | null;
+    name: string;
+    nft_collection_address?: string | null;
+    owner_email?: string | null;
+    owner_id: string | null;
+    owner_name?: string | null;
+    preview_query_limit: number | null;
+    purchase_price_usd?: string | null;
+    rental_price_monthly_usd?: string | null;
+    updated_at: string;
+    user_count: number;
+    workflows_enabled: boolean;
+    workspace_id?: string | null;
+  }>;
+  listClusters: (params?: {
+    ids?: Array<string>;
+    name?: string | null;
+    cursor?: string | null;
+    limit?: number;
+    ownerOnly?: boolean;
+    workspaceId?: string | null;
+  } | undefined, options?: RequestOptions$3 | undefined) => Promise<{
+    data: components["schemas"]["CollectionResponse"][];
+    has_more: boolean;
+    next_cursor?: string | null;
+  }>;
+  updateCluster: (params: {
+    id: string;
+    body: components["schemas"]["UpdateCollectionRequest"];
+  }, options?: RequestOptions$3 | undefined) => Promise<{
+    access_tier: string | null;
+    cache_policy: string | null;
+    chain_type?: string | null;
+    contract_address?: string | null;
+    created_at: string;
+    creator_royalty_bps: number | null;
+    description: string | null;
+    engram_count: number;
+    graph_collection_status: string;
+    graph_sync_status: string;
+    has_preview_access?: boolean | null;
+    id: string;
+    is_forked?: boolean | null;
+    marketplace_metadata?: {
+      [key: string]: unknown;
+    } | null;
+    memory_count: number | null;
+    name: string;
+    nft_collection_address?: string | null;
+    owner_email?: string | null;
+    owner_id: string | null;
+    owner_name?: string | null;
+    preview_query_limit: number | null;
+    purchase_price_usd?: string | null;
+    rental_price_monthly_usd?: string | null;
+    updated_at: string;
+    user_count: number;
+    workflows_enabled: boolean;
+    workspace_id?: string | null;
+  }>;
+  deleteCluster: (id: string, options?: {
+    signal?: AbortSignal;
+  }) => Promise<boolean>;
+  /**
+   * Positional `connectProvider(provider, collectionID, config?)` — wraps the
+   * generated `connectors.connect({provider, body})` to build the body shape.
+   */
+  connectProvider(provider: string, collectionID: string, config?: Record<string, unknown>, options?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  /** Positional listConnections(collectionID) — wraps the query wrapper. */
+  listConnections(collectionID: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  /** Positional disconnect(connectionID, deleteMemories?). */
+  disconnectConnection(connectionID: string, deleteMemories?: boolean, options?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  /** Alias for disconnectConnection (same arg shape). */
+  disconnect(connectionID: string, deleteMemories?: boolean, options?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  /** Single-id delete; coerces 204 to boolean true. */
+  deleteMemory(memoryID: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<boolean>;
+  /** Bulk delete by ids. */
+  deleteMemories(memoryIDs: string[], options?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  /**
+   * Polymorphic delete: dispatches based on argument type.
+   * - `delete("/some/path")` -> raw HTTP DELETE (escape hatch; not implemented)
+   * - `delete("memory-id")` -> deleteMemory
+   * - `delete(["id1", "id2"])` -> deleteMemories (bulk)
+   */
+  delete(pathOrMemoryIDs: RequestPath | string | string[], options?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+}
+//#endregion
+export { type APIErrorPayload, type ClientOptions, type CompatClientOptions, DEFAULT_RETRY, Nebula, Nebula as default, NebulaAPIError, NebulaBadRequestError, NebulaClient, NebulaConflictError, NebulaConnectionError, NebulaCore, NebulaError, NebulaForbiddenError, NebulaNotFoundError, NebulaRateLimitError, NebulaServerError, NebulaTimeoutError, NebulaUnauthorizedError, NebulaValidationError, type RequestArgs, type RetryPolicy, backoffMs, type components, errorFromResponse, isRetryableStatus, sleep };
+//# sourceMappingURL=index.d.cts.map