@memnexus-ai/sdk 1.55.2

package/dist/index.js

@@ -0,0 +1,2976 @@
+// src/http.ts
+var RETRY_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var MAX_ATTEMPTS = 5;
+var BASE_DELAY_MS = 500;
+var MAX_DELAY_MS = 1e4;
+var BACKOFF_FACTOR = 2;
+var SdkError = class extends Error {
+  status;
+  statusText;
+  data;
+  constructor(status, statusText, data) {
+    super(`HTTP ${status}: ${statusText}`);
+    this.name = "SdkError";
+    this.status = status;
+    this.statusText = statusText;
+    this.data = data;
+  }
+};
+function computeDelay(attempt) {
+  const delay = BASE_DELAY_MS * Math.pow(BACKOFF_FACTOR, attempt - 1);
+  return Math.min(delay, MAX_DELAY_MS);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildUrl(baseUrl, path, pathParams, queryParams) {
+  let url = path;
+  for (const [key, value] of Object.entries(pathParams)) {
+    url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
+  }
+  const full = `${baseUrl.replace(/\/+$/, "")}${url}`;
+  if (!queryParams) return full;
+  const qs = new URLSearchParams();
+  for (const [key, value] of Object.entries(queryParams)) {
+    if (value !== null && value !== void 0) {
+      qs.set(key, String(value));
+    }
+  }
+  const qsStr = qs.toString();
+  return qsStr ? `${full}?${qsStr}` : full;
+}
+async function parseBody(response) {
+  const ct = response.headers.get("content-type") ?? "";
+  if (ct.includes("application/json") && response.body) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function headersToRecord(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? (typeof process !== "undefined" ? process.env["MEMNEXUS_API_KEY"] : void 0);
+    if (!apiKey) {
+      throw new Error(
+        "apiKey is required. Pass it in options or set the MEMNEXUS_API_KEY environment variable."
+      );
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl ?? "https://api.memnexus.ai";
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+  }
+  async request(opts) {
+    const url = buildUrl(
+      this.baseUrl,
+      opts.path,
+      opts.pathParams ?? {},
+      opts.queryParams
+    );
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "User-Agent": "memnexus-node-sdk/1.0",
+      ...opts.headers
+    };
+    let fetchInit = {
+      method: opts.method,
+      headers
+    };
+    if (opts.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      fetchInit = { ...fetchInit, body: JSON.stringify(opts.body) };
+    }
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      const controller = new AbortController();
+      const timerId = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const response = await fetch(url, {
+          ...fetchInit,
+          signal: controller.signal
+        });
+        clearTimeout(timerId);
+        const data = await parseBody(response);
+        const respHeaders = headersToRecord(response.headers);
+        if (RETRY_STATUS_CODES.has(response.status) && attempt < MAX_ATTEMPTS) {
+          await sleep(computeDelay(attempt));
+          continue;
+        }
+        if (!response.ok) {
+          throw new SdkError(response.status, response.statusText, data);
+        }
+        return {
+          status: response.status,
+          statusText: response.statusText,
+          headers: respHeaders,
+          data
+        };
+      } catch (err) {
+        clearTimeout(timerId);
+        if (err instanceof SdkError) {
+          throw err;
+        }
+        lastError = err;
+        if (attempt < MAX_ATTEMPTS) {
+          await sleep(computeDelay(attempt));
+        }
+      }
+    }
+    throw lastError ?? new Error("Max retry attempts reached");
+  }
+};
+
+// src/services/users.ts
+var Users = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Sync user from WorkOS
+   *
+   * Called by the customer portal after WorkOS authentication.
+   * Creates a new user if they don't exist, or updates their profile if they do.
+   * This is the main entry point for user provisioning.
+   * When the invite gate is closed and a new user is created, the inviteCode
+   * is redeemed atomically to track which code was used for registration.
+   * 
+   * @param body — Request body
+   */
+  async syncUser(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/users/sync",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get current user
+   *
+   * Get the currently authenticated user's profile and usage information
+   */
+  async getCurrentUser() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/users/me",
+      pathParams
+    });
+  }
+  /**
+   * Update current user
+   *
+   * Update the currently authenticated user's profile
+   * @param options — Optional parameters
+   */
+  async updateCurrentUser(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "PATCH",
+      path: "/api/users/me",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Get current user's usage
+   *
+   * Get the currently authenticated user's memory usage statistics
+   */
+  async getCurrentUserUsage() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/users/me/usage",
+      pathParams
+    });
+  }
+  /**
+   * Export all user data
+   *
+   * Export all user data as a JSON archive. Includes profile, memories,
+   * conversations, facts, and patterns. Supports GDPR Article 20
+   * (right to data portability). Sensitive fields (Stripe customer ID,
+   * WorkOS ID, embeddings) are excluded.
+   * 
+   */
+  async exportUserData() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/users/me/export",
+      pathParams
+    });
+  }
+  /**
+   * Initiate account deletion
+   *
+   * Schedule the current user's account for deletion after a 7-day grace period.
+   * Requires email confirmation. Immediately revokes API keys and cancels
+   * any active subscription. The account enters read-only mode.
+   * 
+   * @param body — Request body
+   */
+  async initiateAccountDeletion(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/users/me/deletion",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Cancel account deletion
+   *
+   * Cancel a pending account deletion during the grace period.
+   * Note: Previously revoked API keys are not restored — new keys must be created.
+   * Stripe subscription may need manual reactivation via the billing portal.
+   * 
+   */
+  async cancelAccountDeletion() {
+    const pathParams = {};
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/users/me/deletion",
+      pathParams
+    });
+  }
+  /**
+   * Get user by ID
+   *
+   * Get a user by their internal ID (admin only)
+   * @param id
+   */
+  async getUserById(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/users/{id}",
+      pathParams
+    });
+  }
+};
+
+// src/services/topics.ts
+var Topics = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List topics
+   *
+   * List all topics with pagination
+   * @param options — Optional parameters
+   */
+  async listTopics(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset,
+      "sortBy": options?.sortBy,
+      "order": options?.order
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/topics",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Get topic by ID
+   *
+   * Retrieve a specific topic by its ID
+   * @param id — The topic ID
+   */
+  async getTopicById(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/topics/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Merge topics
+   *
+   * Merge two topics into one
+   * @param body — Request body
+   */
+  async mergeTopics(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/topics/merge",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Discover related topics
+   *
+   * Discover topics related to a given topic
+   * @param body — Request body
+   */
+  async discoverRelatedTopics(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/topics/discover-related",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Calculate topic similarity
+   *
+   * Calculate similarity score between two topics
+   * @param body — Request body
+   */
+  async calculateTopicSimilarity(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/topics/similarity",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Find similar topics
+   *
+   * Find topics similar to a given topic
+   * @param body — Request body
+   */
+  async findSimilarTopics(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/topics/similar",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Cluster topics
+   *
+   * Cluster topics using community detection algorithms
+   * @param options — Optional parameters
+   */
+  async clusterTopics(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/topics/cluster",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Detect communities
+   *
+   * Detect communities in the topic graph using specified algorithm
+   * @param options — Optional parameters
+   */
+  async detectCommunities(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/topics/detect-communities",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Search topics
+   *
+   * Search topics by query string using fulltext search
+   * @param body — Request body
+   */
+  async searchTopics(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/topics/search",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/system.ts
+var System = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Get system health status
+   *
+   * Get the current health status of the system including database connectivity
+   */
+  async getSystemHealth() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/system/health",
+      pathParams
+    });
+  }
+  /**
+   * Get context status
+   *
+   * Get database statistics and context information
+   */
+  async getContextStatus() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/system/context/status",
+      pathParams
+    });
+  }
+  /**
+   * Get feature flags
+   *
+   * Get all feature flags for the authenticated user
+   */
+  async getFeatureFlags() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/system/feature-flags",
+      pathParams
+    });
+  }
+  /**
+   * Evaluate feature flag
+   *
+   * Evaluate a specific feature flag for the authenticated user
+   * @param body — Request body
+   */
+  async evaluateFeatureFlag(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/system/feature-flags/evaluate",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Analyze memory quality distribution
+   *
+   * Analyze the quality distribution of memories for the authenticated user
+   * @param options — Optional parameters
+   */
+  async analyzeMemoryQuality(options) {
+    const pathParams = {};
+    const queryParams = {
+      "includeDetails": options?.includeDetails,
+      "minQualityThreshold": options?.minQualityThreshold
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/system/memory/quality",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Prune low-quality memories
+   *
+   * Prune (soft delete) low-quality memories for the authenticated user
+   * @param options — Optional parameters
+   */
+  async pruneMemories(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/system/memory/prune",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Get OpenAPI specification
+   *
+   * Returns the OpenAPI 3.x specification for the entire API. This endpoint is used by CI/CD to sync the API Gateway.
+   * @param options — Optional parameters
+   */
+  async getOpenApiSpec(options) {
+    const pathParams = {};
+    const queryParams = {
+      "noCache": options?.noCache
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/openapi.json",
+      pathParams,
+      queryParams
+    });
+  }
+};
+
+// src/services/patterns.ts
+var Patterns = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List patterns
+   *
+   * List all patterns for the authenticated user
+   * @param options — Optional parameters
+   */
+  async listPatterns(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/patterns",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Compile patterns
+   *
+   * Compile patterns from user's memories
+   * @param options — Optional parameters
+   */
+  async compilePatterns(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/patterns/compile",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Detect behavioral patterns
+   *
+   * Run pattern detection algorithms to identify recurring behavioral patterns
+   * @param options — Optional parameters
+   */
+  async detectPatterns(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/patterns/detect",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Analyze pattern trends
+   *
+   * Analyze pattern trends, correlations, and generate insights
+   * @param options — Optional parameters
+   */
+  async analyzePatterns(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/patterns/analyze",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Update pattern
+   *
+   * Update an existing pattern with partial data
+   * @param id — The pattern ID
+   * @param body — Request body
+   */
+  async updatePattern(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PATCH",
+      path: "/api/patterns/{id}",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Record pattern feedback
+   *
+   * Record feedback on a pattern
+   * @param body — Request body
+   */
+  async recordPatternFeedback(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/patterns/feedback",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Compile behavioral instructions from stored patterns
+   *
+   * Converts stored behavioral patterns into actionable instructions suitable for injection into AI agent context at conversation start. Uses template-based (non-LLM) generation for deterministic output within the P95 <100ms budget.
+   * 
+   * @param options — Optional parameters
+   */
+  async compileInstructions(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/patterns/compile-instructions",
+      pathParams,
+      body: options?.body
+    });
+  }
+};
+
+// src/services/behavior.ts
+var Behavior = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Get behavioral state
+   *
+   * Get current behavioral state for the authenticated user
+   */
+  async getBehavioralState() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/patterns/behavior/state",
+      pathParams
+    });
+  }
+  /**
+   * Update behavioral state
+   *
+   * Update or mutate behavioral state
+   * @param options — Optional parameters
+   */
+  async updateBehavioralState(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/patterns/behavior/state",
+      pathParams,
+      body: options?.body
+    });
+  }
+};
+
+// src/services/recommendations.ts
+var Recommendations = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Create an explicit recommendation
+   *
+   * Create a new explicit recommendation (triggerContext + practice pair). Source is set to 'explicit'; triggerEmbedding is generated synchronously before return. SEC-BL-v2-002: practice content is validated against a prompt-injection deny-list. SEC-BL-v2-003: evidenceMemoryIds ownership is verified against the authenticated user.
+   * 
+   * @param body — Request body
+   */
+  async createRecommendation(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/patterns/recommendations",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * List pending recommendations
+   *
+   * Returns recommendations with status='pending_review' for the authenticated user, ordered by confidence DESC, createdAt ASC.
+   * 
+   * @param options — Optional parameters
+   */
+  async listPendingRecommendations(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/patterns/recommendations/pending",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Approve a pending recommendation
+   *
+   * Transitions a recommendation from status='pending_review' to status='active'. Returns 404 if the recommendation is not found, not owned by the authenticated user, or is not in pending_review status.
+   * 
+   * @param id — Recommendation ID
+   * @param options — Optional parameters
+   */
+  async approveRecommendation(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PATCH",
+      path: "/api/patterns/recommendations/{id}/approve",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Dismiss a recommendation
+   *
+   * Permanently dismisses a recommendation (any non-dismissed status → dismissed). This transition is terminal — dismissed recommendations cannot be reactivated. Returns 404 if not found, not owned by the authenticated user, or already dismissed.
+   * 
+   * @param id — Recommendation ID
+   * @param options — Optional parameters
+   */
+  async dismissRecommendation(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PATCH",
+      path: "/api/patterns/recommendations/{id}/dismiss",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * List active recommendations
+   *
+   * Returns recommendations with status='active' for the authenticated user, ordered by confidence DESC. These are the behavioral preferences currently surfacing in Claude via compile-instructions and build_context. SEC-BL-v2-003: results are scoped to the authenticated user — no cross-user data.
+   * 
+   * @param options — Optional parameters
+   */
+  async listActiveRecommendations(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/patterns/recommendations/active",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Match active recommendations to content
+   *
+   * Embeds the supplied content and returns active Recommendations whose triggerContext is semantically similar. Used by the MCP server for just-in-time behavioral nudges on memory save. Results are scoped to the authenticated user — no cross-user data is returned.
+   * 
+   * @param body — Request body
+   */
+  async matchRecommendations(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/patterns/recommendations/match",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Pause an active recommendation
+   *
+   * Transitions a recommendation from status='active' to status='paused'. Paused recommendations are excluded from compile-instructions and build_context surfacing. Returns 404 if the recommendation is not found, not owned by the authenticated user, or is not in active status. SEC-BL-v2-003: MATCH includes userId — no IDOR.
+   * 
+   * @param id — Recommendation ID
+   * @param options — Optional parameters
+   */
+  async pauseRecommendation(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PATCH",
+      path: "/api/patterns/recommendations/{id}/pause",
+      pathParams,
+      body: options?.body
+    });
+  }
+};
+
+// src/services/narratives.ts
+var Narratives = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List narrative threads
+   *
+   * List all narrative threads for the authenticated user.
+   * Narratives group related memories into coherent storylines.
+   * 
+   * @param options — Optional parameters
+   */
+  async listNarratives(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset,
+      "state": options?.state,
+      "topics": options?.topics
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/narratives",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Create a narrative thread
+   *
+   * Create a new narrative thread starting from a root memory.
+   * Narratives help organize related memories into coherent storylines.
+   * 
+   * @param body — Request body
+   */
+  async createNarrative(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/narratives",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get a narrative thread
+   *
+   * Retrieve a specific narrative thread by ID
+   * @param id — The narrative ID
+   */
+  async getNarrative(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/narratives/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Delete a narrative thread
+   *
+   * Delete a narrative thread.
+   * This does not delete the associated memories, only the narrative structure.
+   * 
+   * @param id — The narrative ID
+   */
+  async deleteNarrative(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/narratives/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Update a narrative thread
+   *
+   * Update a narrative thread's title, topics, or state.
+   * Use this to resolve, reopen, or modify narratives.
+   * 
+   * @param id — The narrative ID
+   * @param body — Request body
+   */
+  async updateNarrative(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PATCH",
+      path: "/api/narratives/{id}",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get narrative timeline
+   *
+   * Get all memories in a narrative, ordered by their position in the narrative.
+   * Each memory includes its position and effective state.
+   * 
+   * @param id — The narrative ID
+   * @param options — Optional parameters
+   */
+  async getNarrativeTimeline(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/narratives/{id}/timeline",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Add a memory to a narrative
+   *
+   * Add an existing memory to a narrative thread.
+   * Optionally specify a position to insert the memory at.
+   * 
+   * @param id — The narrative ID
+   * @param body — Request body
+   */
+  async addMemoryToNarrative(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "POST",
+      path: "/api/narratives/{id}/memories",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Remove a memory from a narrative
+   *
+   * Remove a memory from a narrative thread.
+   * This does not delete the memory itself, only removes it from the narrative.
+   * 
+   * @param id — The narrative ID
+   * @param memoryId — The memory ID to remove
+   */
+  async removeMemoryFromNarrative(id, memoryId) {
+    const pathParams = {
+      "id": id,
+      "memoryId": memoryId
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/narratives/{id}/memories/{memoryId}",
+      pathParams
+    });
+  }
+};
+
+// src/services/monitoring.ts
+var Monitoring = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Prometheus metrics endpoint
+   *
+   * Returns Prometheus-formatted metrics for monitoring and observability.
+   * This endpoint is public and requires no authentication.
+   * Designed to be scraped by Prometheus at regular intervals.
+   * 
+   */
+  async getMetrics() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/metrics",
+      pathParams
+    });
+  }
+};
+
+// src/services/memories.ts
+var Memories = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Get memory by ID
+   *
+   * Retrieve a specific memory by its ID with configurable detail level.
+   * 
+   * **Detail levels:**
+   * - `minimal` — raw memory only, no extra queries
+   * - `standard` (default) — adds userTopics, extractedTopics, entities, facts, relationships
+   * - `full` — adds conversationContext (title, memoryCount, position) and relationship target previews
+   * 
+   * @param id — The memory ID
+   * @param options — Optional parameters
+   */
+  async getMemoryById(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    const queryParams = {
+      "detail": options?.detail
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/{id}",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Update a memory
+   *
+   * Update an existing memory for the authenticated user
+   * @param id — Memory ID
+   * @param body — Request body
+   */
+  async updateMemory(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PUT",
+      path: "/api/memories/{id}",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Delete memory
+   *
+   * Delete a memory by its ID
+   * @param id — The memory ID
+   */
+  async deleteMemory(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/memories/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Aggregated memory analytics
+   *
+   * Return aggregated memory counts grouped by a time dimension (day, week, month)
+   * or by topic. Useful for activity dashboards and trend analysis.
+   * 
+   * @param options — Optional parameters
+   */
+  async getMemoriesStats(options) {
+    const pathParams = {};
+    const queryParams = {
+      "groupBy": options?.groupBy,
+      "after": options?.after,
+      "before": options?.before,
+      "recent": options?.recent,
+      "topic": options?.topic,
+      "limit": options?.limit
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/stats",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * List memories
+   *
+   * List all memories for the authenticated user with pagination.
+   * 
+   * **ID Prefix Search:**
+   * Use the `idPrefix` parameter for git-style short ID lookup. This enables efficient
+   * server-side filtering instead of fetching all memories and filtering client-side.
+   * - Minimum 6 characters required for `idPrefix`
+   * - Returns matching memories directly (no need for secondary fetch)
+   * - Example: `?idPrefix=2d09116a` finds memories starting with that prefix
+   * 
+   * @param options — Optional parameters
+   */
+  async listMemories(options) {
+    const pathParams = {};
+    const queryParams = {
+      "idPrefix": options?.idPrefix,
+      "limit": options?.limit,
+      "offset": options?.offset,
+      "page": options?.page,
+      "sortBy": options?.sortBy,
+      "order": options?.order,
+      "from": options?.from$,
+      "to": options?.to,
+      "recent": options?.recent,
+      "topics": options?.topics,
+      "excludeTopics": options?.excludeTopics,
+      "conversationId": options?.conversationId,
+      "scope": options?.scope
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Create a memory
+   *
+   * Create a new memory for the authenticated user.
+   * 
+   * **Conversation Management:**
+   * - Use `conversationId: "NEW"` to create a new conversation automatically
+   * - Provide an existing conversation ID to add to that conversation
+   * 
+   * **Session Management:**
+   * - Sessions are automatically assigned based on 90-minute gap detection
+   * - If the last memory in the conversation was within 90 minutes, the same session is reused
+   * - If the gap exceeds 90 minutes, a new session is created
+   * 
+   * **Response:**
+   * - Returns the created memory in `data` field
+   * - Returns session/conversation metadata in `meta` field
+   * 
+   * @param body — Request body
+   */
+  async createMemory(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Search memories (GET)
+   *
+   * Search memories using query parameters. Provides the same functionality as
+   * POST /api/memories/search but accepts parameters via query string.
+   * 
+   * **Benefits of GET:**
+   * - Faster response times (~3x improvement)
+   * - Browser/CDN caching support
+   * - Simpler integration for read-only clients
+   * 
+   * **Search Methods:**
+   * - **hybrid** (default): Combines semantic and keyword search with Reciprocal Rank Fusion
+   * - **semantic**: Vector-based semantic search using OpenAI embeddings
+   * - **keyword**: Traditional fulltext search using Lucene
+   * 
+   * **Array Parameters:**
+   * - `topics`: Provide as comma-separated values (e.g., `topics=typescript,api-design`)
+   * 
+   * @param options — Optional parameters
+   */
+  async searchMemoriesGet(options) {
+    const pathParams = {};
+    const queryParams = {
+      "q": options?.q,
+      "searchMethod": options?.searchMethod,
+      "limit": options?.limit,
+      "offset": options?.offset,
+      "threshold": options?.threshold,
+      "mode": options?.mode,
+      "vectorWeight": options?.vectorWeight,
+      "fulltextWeight": options?.fulltextWeight,
+      "topics": options?.topics,
+      "excludeTopics": options?.excludeTopics,
+      "memoryType": options?.memoryType,
+      "conversationId": options?.conversationId,
+      "explain": options?.explain,
+      "includeTopics": options?.includeTopics,
+      "includeEntities": options?.includeEntities,
+      "includeFacts": options?.includeFacts,
+      "includeClaims": options?.includeClaims,
+      "asOfTime": options?.asOfTime,
+      "validAtTime": options?.validAtTime,
+      "eventTimeFrom": options?.eventTimeFrom,
+      "eventTimeTo": options?.eventTimeTo,
+      "ingestionTimeFrom": options?.ingestionTimeFrom,
+      "ingestionTimeTo": options?.ingestionTimeTo,
+      "includeExpired": options?.includeExpired,
+      "temporalMode": options?.temporalMode,
+      "sortBy": options?.sortBy,
+      "order": options?.order,
+      "expandEntities": options?.expandEntities,
+      "expandTopics": options?.expandTopics,
+      "expandFacts": options?.expandFacts,
+      "includeSuperseded": options?.includeSuperseded,
+      "entityWeight": options?.entityWeight,
+      "topicWeight": options?.topicWeight,
+      "factWeight": options?.factWeight,
+      "questionWeight": options?.questionWeight,
+      "claimsWeight": options?.claimsWeight,
+      "includeFacets": options?.includeFacets,
+      "embeddingProvider": options?.embeddingProvider,
+      "scope": options?.scope,
+      "taskId": options?.taskId,
+      "outcomeFilter": options?.outcomeFilter
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/search",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Search all memories
+   *
+   * Search memories using different search methods:
+   * - **hybrid** (default): Combines semantic and keyword search with Reciprocal Rank Fusion
+   * - **semantic**: Vector-based semantic search using OpenAI embeddings
+   * - **keyword**: Traditional fulltext search using Lucene
+   * 
+   * The `mode` parameter controls content filtering (unified, content, facts).
+   * The `searchMethod` parameter controls the search algorithm.
+   * 
+   * @param body — Request body
+   */
+  async searchMemories(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/search",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get multiple memories by IDs
+   *
+   * Retrieve multiple memories by their IDs in a single request.
+   * More efficient than making multiple individual GET requests.
+   * 
+   * Returns memories in the order requested, with metadata about
+   * which IDs were found or missing.
+   * 
+   * @param body — Request body
+   */
+  async getMemoriesBatch(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/batch",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Generate memory digest
+   *
+   * Synthesizes a comprehensive, structured briefing from all relevant memories
+   * on a topic. Instead of multiple search rounds, one call returns a complete digest.
+   * 
+   * **Formats:**
+   * - `structured` (default): Sections with headers, bullet points, key decisions
+   * - `narrative`: Chronological prose narrative
+   * - `timeline`: Dated event list
+   * - `status-report`: Done/In Progress/Blocked grouping
+   * 
+   * **Pipeline:**
+   * 1. Gather: High-limit search + conversation expansion
+   * 2. Organize: Group by conversation, status, timeline
+   * 3. Synthesize: LLM generates formatted digest
+   * 
+   * Requires an LLM provider to be configured (EXTRACTION_ENABLED=true).
+   * Returns 503 if the LLM provider is unavailable and 3+ memories are found.
+   * 
+   * @param body — Request body
+   */
+  async generateMemoryDigest(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/digest",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Generate memory digest (SSE streaming)
+   *
+   * Same as POST /api/memories/digest but uses Server-Sent Events (SSE) to stream
+   * the response. Sends `: heartbeat` comments every 10 seconds during processing
+   * to prevent gateway read-timeout (default 60s) from killing long-running digests.
+   * 
+   * **Event sequence:**
+   * - `: heartbeat` — keep-alive comment, sent every 10s during processing
+   * - `event: result` / `data: <DigestResponse JSON>` — digest completed successfully
+   * - `event: error` / `data: {"error":"...","statusCode":N}` — digest failed
+   * - `event: done` / `data: {}` — stream complete (sent after result)
+   * 
+   * **Formats and pipeline:** identical to POST /api/memories/digest.
+   * 
+   * @param body — Request body
+   */
+  async streamMemoryDigest(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/digest/stream",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Build a context briefing
+   *
+   * Answers "What should I know before working on X?" by combining active work
+   * detection, fact retrieval, gotcha detection, recent activity, and pattern
+   * matching into a single call. Eliminates the 5+ round-trip pattern agents
+   * use today.
+   * 
+   * @param body — Request body
+   */
+  async buildContext(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/build-context",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get version history for a named memory
+   *
+   * Returns the full version chain for a named memory, ordered newest-first.
+   * Walks the SUPERSEDES chain from HEAD backwards.
+   * 
+   * @param name — Memory name (kebab-case, 2-64 chars)
+   * @param options — Optional parameters
+   */
+  async getNamedMemoryHistory(name, options) {
+    const pathParams = {
+      "name": name
+    };
+    const queryParams = {
+      "limit": options?.limit
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/named/{name}/history",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Get a memory by name
+   *
+   * Retrieve the current HEAD version of a named memory by its user-assigned name.
+   * Supports the same detail levels as GET /api/memories/{id}.
+   * 
+   * @param name — Memory name (kebab-case, 2-64 chars)
+   * @param options — Optional parameters
+   */
+  async getMemoryByName(name, options) {
+    const pathParams = {
+      "name": name
+    };
+    const queryParams = {
+      "detail": options?.detail
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/named/{name}",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Update a named memory (create new version)
+   *
+   * Creates a new version of a named memory. The name pointer moves to the new version,
+   * and a SUPERSEDES relationship links the new version to the old one.
+   * The old version's effectiveState becomes 'superseded'.
+   * 
+   * @param name — Memory name (kebab-case, 2-64 chars)
+   * @param body — Request body
+   */
+  async updateNamedMemory(name, body) {
+    const pathParams = {
+      "name": name
+    };
+    return this._http.request({
+      method: "PUT",
+      path: "/api/memories/named/{name}",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Bulk delete multiple memories
+   *
+   * Soft-delete multiple memories at once. Requires confirmDeletion=true.
+   * Each memory is verified to belong to the authenticated user.
+   * Maximum 100 IDs per request.
+   * 
+   * @param body — Request body
+   */
+  async bulkDeleteMemories(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/memories/bulk",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Repair orphaned effectiveState values
+   *
+   * Finds memories with effectiveState='superseded' or 'contradicted' but no
+   * corresponding incoming SUPERSEDES/CONTRADICTS edges, and resets them to 'current'.
+   * This handles cases where edges were deleted but effectiveState wasn't recalculated.
+   * 
+   */
+  async repairEffectiveState() {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/repair-effective-state",
+      pathParams
+    });
+  }
+  /**
+   * Record behavioral feedback on a search result
+   *
+   * Record whether a search result was selected or ignored by the user.
+   * Used to build behavioral signals for retrieval quality measurement.
+   * 
+   * @param body — Request body
+   */
+  async recordSearchResultFeedback(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/search/feedback",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Find similar memories
+   *
+   * Find memories that are semantically similar to the given memory.
+   * 
+   * Uses vector similarity search if embeddings are available for the memory.
+   * Falls back to topic-based similarity if embeddings are not available.
+   * 
+   * The `relationship` field in results indicates the method used:
+   * - `similar` - Found via vector/semantic similarity
+   * - `similar-by-topic` - Fallback using shared topics
+   * 
+   * @param id — The source memory ID
+   * @param options — Optional parameters
+   */
+  async getSimilarMemories(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    const queryParams = {
+      "limit": options?.limit
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/{id}/similar",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Find memories from same conversation
+   *
+   * Find other memories that belong to the same conversation as the given memory.
+   * 
+   * Returns memories sorted chronologically (oldest first) to show the conversation flow.
+   * If the memory doesn't belong to a conversation, returns an empty array.
+   * 
+   * @param id — The source memory ID
+   * @param options — Optional parameters
+   */
+  async getConversationMemories(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    const queryParams = {
+      "limit": options?.limit
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/{id}/conversation-memories",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Find related memories by topics
+   *
+   * Find memories that share topics with the given memory.
+   * 
+   * The score indicates the ratio of shared topics (1.0 = all topics match).
+   * Results are sorted by score (most related first), then by timestamp.
+   * 
+   * If the source memory has no topics, returns an empty array.
+   * 
+   * @param id — The source memory ID
+   * @param options — Optional parameters
+   */
+  async getRelatedMemories(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    const queryParams = {
+      "limit": options?.limit
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/{id}/related",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Get relationships for a memory
+   *
+   * Retrieve all relationships for a memory.
+   * 
+   * **Direction Options:**
+   * - **outgoing**: Relationships where this memory is the source
+   * - **incoming**: Relationships where this memory is the target
+   * - **both**: All relationships involving this memory
+   * 
+   * @param id — The memory ID
+   * @param options — Optional parameters
+   */
+  async getMemoryRelationships(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    const queryParams = {
+      "direction": options?.direction
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/{id}/relationships",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Create a relationship between memories
+   *
+   * Create a relationship between the source memory and a target memory.
+   * 
+   * **Relationship Types:**
+   * - **SUPERSEDES**: The source memory replaces/updates the target memory
+   * - **FOLLOWS**: The source memory follows chronologically from the target
+   * - **RESOLVES**: The source memory resolves an issue mentioned in the target
+   * - **CONTRADICTS**: The source memory contradicts the target memory
+   * - **REFERENCES**: The source memory references the target memory
+   * 
+   * When creating SUPERSEDES or CONTRADICTS relationships, the target memory's
+   * effectiveState will be automatically updated.
+   * 
+   * @param id — The source memory ID
+   * @param body — Request body
+   */
+  async createMemoryRelationship(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/{id}/relationships",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Delete a relationship
+   *
+   * Delete a specific relationship from a memory
+   * @param id — The source memory ID
+   * @param relationshipId — The relationship ID to delete
+   */
+  async deleteMemoryRelationship(id, relationshipId) {
+    const pathParams = {
+      "id": id,
+      "relationshipId": relationshipId
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/memories/{id}/relationships/{relationshipId}",
+      pathParams
+    });
+  }
+  /**
+   * Get timeline context for a memory
+   *
+   * Get the chronological context around a memory.
+   * Returns preceding and following memories ordered by event time.
+   * Useful for understanding the narrative flow.
+   * 
+   * @param id — The memory ID
+   * @param options — Optional parameters
+   */
+  async getMemoryTimeline(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    const queryParams = {
+      "before": options?.before,
+      "after": options?.after
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/memories/{id}/timeline",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Detect potential relationships for a memory
+   *
+   * Analyze a memory and detect potential relationships with other memories.
+   * Uses semantic similarity and pattern detection to suggest relationships.
+   * 
+   * Set `autoCreate: true` to automatically create high-confidence relationships.
+   * 
+   * @param id — The memory ID
+   * @param options — Optional parameters
+   */
+  async detectMemoryRelationships(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/{id}/detect-relationships",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Generate LLM explanation for a memory relationship
+   *
+   * Uses an LLM to explain why two memories have been flagged with a
+   * particular relationship (e.g. contradiction). Returns a short
+   * plain-text explanation highlighting the specific differences.
+   * 
+   * @param id — The ID of the source memory
+   * @param body — Request body
+   */
+  async explainMemoryRelationship(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/{id}/explain-relationship",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Export memories matching filters
+   *
+   * Export memories matching an optional search query and filters to JSON or CSV format.
+   * When a query is provided, uses hybrid search. When no query is provided, lists memories
+   * with optional topic and memoryType filters. Maximum 1000 results per export.
+   * 
+   * @param body — Request body
+   */
+  async exportMemories(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/export",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Bulk update multiple memories
+   *
+   * Update multiple memories at once. Supports updating topics and memoryType.
+   * Each memory is verified to belong to the authenticated user.
+   * Maximum 100 IDs per request.
+   * 
+   * @param body — Request body
+   */
+  async bulkUpdateMemories(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/bulk-update",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Bulk add or remove topics from memories
+   *
+   * Add and/or remove topics from multiple memories at once.
+   * At least one of addTopics or removeTopics must be provided.
+   * Each memory is verified to belong to the authenticated user.
+   * Maximum 100 IDs per request.
+   * 
+   * @param body — Request body
+   */
+  async bulkTagMemories(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/memories/bulk-tag",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/invites.ts
+var Invites = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Check invite gate status
+   *
+   * Check whether the invite gate is currently open or closed.
+   * When gated is true, new signups require a valid invite code.
+   * Response is cached server-side (30-second TTL).
+   * 
+   */
+  async getGateStatus() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/invites/gate-status",
+      pathParams
+    });
+  }
+  /**
+   * Validate an invite code
+   *
+   * Validate an invite code without redeeming it.
+   * Rate limited to 10 requests per minute per IP to prevent enumeration.
+   * Error messages are intentionally generic.
+   * 
+   * @param body — Request body
+   */
+  async validateInviteCode(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/invites/validate",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/health.ts
+var Health = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Liveness probe endpoint
+   *
+   * Returns 200 if the process is alive. Does not check external dependencies.
+   * Used by Kubernetes liveness probes to determine if the container should be restarted.
+   * Unlike /health, this endpoint does not query the database — a database outage
+   * should not cause the API process to be killed and restarted.
+   * 
+   */
+  async livenessCheck() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/livez",
+      pathParams
+    });
+  }
+  /**
+   * API health check endpoint
+   *
+   * Returns the health status and uptime of the API service.
+   * This endpoint is public and requires no authentication.
+   * Use this endpoint for monitoring, health checks, and service availability verification.
+   * Returns 200 when healthy, 503 when the database is unreachable.
+   * 
+   */
+  async healthCheck() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/health",
+      pathParams
+    });
+  }
+};
+
+// src/services/graphrag.ts
+var Graphrag = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Explain a GraphRAG query
+   *
+   * Get explanation for a previously executed GraphRAG query result
+   * @param options — Optional parameters
+   */
+  async explainGraphRAGQuery(options) {
+    const pathParams = {};
+    const queryParams = {
+      "queryId": options?.queryId
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/graphrag/explain",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Query communities
+   *
+   * Query communities for relevant information using semantic search
+   * @param body — Request body
+   */
+  async queryCommunities(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/graphrag/query-communities",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Execute a GraphRAG query
+   *
+   * Execute a graph-based retrieval augmented generation query
+   * @param body — Request body
+   */
+  async executeGraphRAGQuery(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/graphrag/query",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/facts.ts
+var Facts = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List facts
+   *
+   * List all facts for the authenticated user
+   * @param options — Optional parameters
+   */
+  async listFacts(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset,
+      "memoryId": options?.memoryId,
+      "sortBy": options?.sortBy,
+      "order": options?.order
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/facts",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Create fact
+   *
+   * Create a new semantic fact
+   * @param body — Request body
+   */
+  async createFact(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/facts",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get fact by ID
+   *
+   * Retrieve a specific fact by its ID
+   * @param id — The fact ID
+   */
+  async getFactById(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/facts/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Update fact
+   *
+   * Update an existing fact completely
+   * @param id — The fact ID
+   * @param body — Request body
+   */
+  async updateFact(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PUT",
+      path: "/api/facts/{id}",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Delete fact
+   *
+   * Delete a fact by its ID
+   * @param id — The fact ID
+   */
+  async deleteFact(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/facts/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Search facts
+   *
+   * Search semantic facts by query string
+   * @param body — Request body
+   */
+  async searchFacts(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/facts/search",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/entities.ts
+var Entities = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List entities
+   *
+   * List all entities for the authenticated user, optionally filtered by type
+   * @param options — Optional parameters
+   */
+  async listEntities(options) {
+    const pathParams = {};
+    const queryParams = {
+      "query": options?.query,
+      "type": options?.type$,
+      "limit": options?.limit,
+      "offset": options?.offset
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/entities",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Get entity by ID
+   *
+   * Retrieve a specific entity by its ID
+   * @param id — The entity ID
+   */
+  async getEntityById(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/entities/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Get memories mentioning entity
+   *
+   * Get all memories that mention a specific entity
+   * @param id — The entity ID
+   * @param options — Optional parameters
+   */
+  async getEntityMemories(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/entities/{id}/memories",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Get graph health metrics
+   *
+   * Returns knowledge graph health metrics including entity counts, fact counts, topic counts, and extraction coverage
+   */
+  async getGraphHealth() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/entities/health",
+      pathParams
+    });
+  }
+};
+
+// src/services/conversations.ts
+var Conversations = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List conversations
+   *
+   * List all conversations for the authenticated user with pagination
+   * @param options — Optional parameters
+   */
+  async listConversations(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset,
+      "since": options?.since,
+      "sortBy": options?.sortBy,
+      "order": options?.order,
+      "minMemories": options?.minMemories
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/conversations",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Create conversation
+   *
+   * Create a new conversation for the authenticated user
+   * @param body — Request body
+   */
+  async createConversation(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/conversations",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get conversation summary
+   *
+   * Retrieve a conversation summary by its ID
+   * @param conversationId — The conversation ID
+   */
+  async getConversationSummary(conversationId) {
+    const pathParams = {
+      "conversationId": conversationId
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/conversations/{conversationId}",
+      pathParams
+    });
+  }
+  /**
+   * Delete conversation
+   *
+   * Delete a conversation and soft-delete all associated memories
+   * @param conversationId — The conversation ID
+   */
+  async deleteConversation(conversationId) {
+    const pathParams = {
+      "conversationId": conversationId
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/conversations/{conversationId}",
+      pathParams
+    });
+  }
+  /**
+   * Get conversation timeline
+   *
+   * Get all memories in a conversation in chronological order
+   * @param conversationId — The conversation ID
+   */
+  async getConversationTimeline(conversationId) {
+    const pathParams = {
+      "conversationId": conversationId
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/conversations/{conversationId}/timeline",
+      pathParams
+    });
+  }
+  /**
+   * Search conversations
+   *
+   * Search conversations by query string
+   * @param body — Request body
+   */
+  async searchConversations(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/conversations/search",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Find conversations by topic
+   *
+   * Find conversations that contain a specific topic
+   * @param body — Request body
+   */
+  async findConversationsByTopic(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/conversations/by-topic",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/billing.ts
+var Billing = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Get billing overview
+   *
+   * Get subscription, payment method, and upcoming invoice information
+   */
+  async getBillingOverview() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/billing/overview",
+      pathParams
+    });
+  }
+  /**
+   * Create checkout session
+   *
+   * Create a Stripe checkout session for subscription upgrade
+   * @param body — Request body
+   */
+  async createCheckoutSession(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/billing/checkout",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Create billing portal session
+   *
+   * Create a Stripe billing portal session for managing subscription
+   * @param body — Request body
+   */
+  async createPortalSession(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/billing/portal",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get current subscription
+   *
+   * Get the current subscription details for the authenticated user
+   */
+  async getSubscription() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/billing/subscription",
+      pathParams
+    });
+  }
+  /**
+   * Cancel subscription
+   *
+   * Cancel the current subscription at the end of the billing period
+   * @param options — Optional parameters
+   */
+  async cancelSubscription(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/billing/subscription/cancel",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Reactivate subscription
+   *
+   * Reactivate a subscription that was scheduled for cancellation
+   * @param options — Optional parameters
+   */
+  async reactivateSubscription(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/billing/subscription/reactivate",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * List invoices
+   *
+   * Get a list of invoices for the authenticated user
+   * @param options — Optional parameters
+   */
+  async listInvoices(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/billing/invoices",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * List payment methods
+   *
+   * Get a list of payment methods for the authenticated user
+   */
+  async listPaymentMethods() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/billing/payment-methods",
+      pathParams
+    });
+  }
+  /**
+   * Set default payment method
+   *
+   * Set a payment method as the default for future payments
+   * @param id — The payment method ID
+   * @param options — Optional parameters
+   */
+  async setDefaultPaymentMethod(id, options) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "POST",
+      path: "/api/billing/payment-methods/{id}/default",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Delete payment method
+   *
+   * Remove a payment method from the account
+   * @param id — The payment method ID
+   */
+  async deletePaymentMethod(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/billing/payment-methods/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Stripe webhook endpoint
+   *
+   * Receive and process Stripe webhook events
+   * @param body — Request body
+   */
+  async stripeWebhook(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/billing/webhooks",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/artifacts.ts
+var Artifacts = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List artifacts
+   *
+   * List all artifacts for the authenticated user with optional filters
+   * @param options — Optional parameters
+   */
+  async listArtifacts(options) {
+    const pathParams = {};
+    const queryParams = {
+      "limit": options?.limit,
+      "offset": options?.offset,
+      "memoryId": options?.memoryId,
+      "conversationId": options?.conversationId,
+      "type": options?.type$
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/artifacts",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Create artifact
+   *
+   * Create a new artifact for the authenticated user
+   * @param body — Request body
+   */
+  async createArtifact(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/artifacts",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get artifact by ID
+   *
+   * Retrieve a specific artifact by its ID
+   * @param id — The artifact ID
+   */
+  async getArtifactById(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/artifacts/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Delete artifact
+   *
+   * Delete an artifact by its ID
+   * @param id — The artifact ID
+   */
+  async deleteArtifact(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/artifacts/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Update artifact
+   *
+   * Update an existing artifact with partial data
+   * @param id — The artifact ID
+   * @param body — Request body
+   */
+  async updateArtifact(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PATCH",
+      path: "/api/artifacts/{id}",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/api-keys.ts
+var ApiKeys = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Get user information for current API key
+   *
+   * Debug endpoint to retrieve user ID and authentication method from the current API key
+   */
+  async debugUser() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/apikeys/debug-user",
+      pathParams
+    });
+  }
+  /**
+   * List API keys
+   *
+   * List all API keys for the authenticated user
+   */
+  async listApiKeys() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/apikeys",
+      pathParams
+    });
+  }
+  /**
+   * Create API key
+   *
+   * Create a new API key for the authenticated user
+   * @param options — Optional parameters
+   */
+  async createApiKey(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/apikeys",
+      pathParams,
+      body: options?.body
+    });
+  }
+  /**
+   * Delete API key
+   *
+   * Delete (revoke) an API key by its ID
+   * @param id — The API key ID
+   */
+  async deleteApiKey(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/apikeys/{id}",
+      pathParams
+    });
+  }
+};
+
+// src/services/alerts.ts
+var Alerts = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List active system alerts for the current user
+   *
+   * Returns all active, non-expired system alerts that target either
+   * all users or the authenticated user specifically. Used by the
+   * customer portal to render the system alerts banner.
+   * 
+   */
+  async getActiveSystemAlerts() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/alerts/active",
+      pathParams
+    });
+  }
+};
+
+// src/services/admin.ts
+var Admin = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List invite codes
+   *
+   * List all invite codes with optional status filter
+   * @param options — Optional parameters
+   */
+  async adminListInviteCodes(options) {
+    const pathParams = {};
+    const queryParams = {
+      "status": options?.status,
+      "limit": options?.limit,
+      "offset": options?.offset
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/admin/invites",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Create invite code
+   *
+   * Create a new invite code for the gated preview
+   * @param body — Request body
+   */
+  async adminCreateInviteCode(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/admin/invites",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get invite system statistics
+   *
+   * Aggregate statistics for the invite system
+   */
+  async adminGetInviteStats() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/admin/invites/stats",
+      pathParams
+    });
+  }
+  /**
+   * Get invite code details
+   *
+   * Get details for a single invite code including redemptions
+   * @param code — The invite code
+   */
+  async adminGetInviteCode(code) {
+    const pathParams = {
+      "code": code
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/admin/invites/{code}",
+      pathParams
+    });
+  }
+  /**
+   * Revoke an invite code
+   *
+   * Revoke an invite code. Existing accounts created with this code are unaffected.
+   * @param code
+   */
+  async adminRevokeInviteCode(code) {
+    const pathParams = {
+      "code": code
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/admin/invites/{code}",
+      pathParams
+    });
+  }
+  /**
+   * Get gate status with audit info
+   *
+   * Get current invite gate state with audit information
+   */
+  async adminGetGateStatus() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/admin/gate",
+      pathParams
+    });
+  }
+  /**
+   * Toggle invite gate
+   *
+   * Toggle the invite gate. When enabled (true), new signups require a valid invite code.
+   * When disabled (false), registration is open. Takes effect immediately.
+   * 
+   * @param body — Request body
+   */
+  async adminSetGateStatus(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/admin/gate",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Backfill per-stage memory pipeline status fields by inspecting actual graph state
+   * @param options — Optional parameters
+   */
+  async adminMigratePerStageStatus(options) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/admin/migrate/per-stage-status",
+      pathParams,
+      body: options?.body
+    });
+  }
+};
+
+// src/services/admin-alerts.ts
+var AdminAlerts = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * List system alerts
+   * @param options — Optional parameters
+   */
+  async adminListSystemAlerts(options) {
+    const pathParams = {};
+    const queryParams = {
+      "activeOnly": options?.activeOnly
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/admin/alerts",
+      pathParams,
+      queryParams
+    });
+  }
+  /**
+   * Create a system alert
+   * @param body — Request body
+   */
+  async adminCreateSystemAlert(body) {
+    const pathParams = {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/admin/alerts",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Get a system alert by id
+   * @param id — System alert id
+   */
+  async adminGetSystemAlert(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/admin/alerts/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Delete a system alert
+   * @param id — System alert id
+   */
+  async adminDeleteSystemAlert(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "DELETE",
+      path: "/api/admin/alerts/{id}",
+      pathParams
+    });
+  }
+  /**
+   * Update a system alert
+   * @param id
+   * @param body — Request body
+   */
+  async adminUpdateSystemAlert(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "PATCH",
+      path: "/api/admin/alerts/{id}",
+      pathParams,
+      body
+    });
+  }
+};
+
+// src/services/admin-pipeline.ts
+var AdminPipeline = class {
+  _http;
+  constructor(http) {
+    this._http = http;
+  }
+  /**
+   * Re-enqueue a single memory through one pipeline
+   *
+   * Admin-only. Re-publishes the requested pipeline job for the given
+   * memory and resets the corresponding per-stage status field(s) to
+   * `queued`. Used to recover individual memories from transient
+   * worker failures or to replay a stage after a code change.
+   * 
+   * @param id — Memory id (admin can target any tenant).
+   * @param body — Request body
+   */
+  async adminRerunMemoryPipeline(id, body) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "POST",
+      path: "/api/admin/memories/{id}/rerun",
+      pathParams,
+      body
+    });
+  }
+  /**
+   * Per-queue depth + failure counts for the memory-creation pipelines
+   *
+   * Returns BullMQ `getJobCounts()` for each known pipeline queue. Queues
+   * that have not yet been provisioned (e.g. `summary-qna` while task 2.3
+   * is in flight) are reported with `{ status: "not_configured" }` rather
+   * than throwing.
+   * 
+   */
+  async adminGetPipelineHealth() {
+    const pathParams = {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/admin/pipeline/health",
+      pathParams
+    });
+  }
+  /**
+   * Inspect per-stage pipeline status for a single memory
+   *
+   * Debugging affordance — returns the six per-stage status fields and graphSkipReason.
+   * @param id
+   */
+  async adminGetMemoryPipelineStatus(id) {
+    const pathParams = {
+      "id": id
+    };
+    return this._http.request({
+      method: "GET",
+      path: "/api/admin/memories/{id}/pipeline-status",
+      pathParams
+    });
+  }
+};
+
+// src/client.ts
+var MemNexus = class {
+  _http;
+  /** User management and profile endpoints */
+  users;
+  /** Topic detection, clustering, and management endpoints */
+  topics;
+  /** System health, monitoring, and configuration endpoints */
+  system;
+  /** Pattern detection and behavioral analysis endpoints */
+  patterns;
+  /** Behavioral pattern tracking and state management endpoints */
+  behavior;
+  /** Behavioral recommendation management endpoints (v2) */
+  recommendations;
+  /** Narrative thread management endpoints */
+  narratives;
+  /** Observability and metrics endpoints for production monitoring */
+  monitoring;
+  /** Memory management and retrieval endpoints */
+  memories;
+  /** Invite code validation and gate status endpoints */
+  invites;
+  /** Health check endpoints */
+  health;
+  /** Graph-based retrieval augmented generation endpoints */
+  graphrag;
+  /** Fact extraction and management endpoints */
+  facts;
+  /** Entity extraction and discovery endpoints */
+  entities;
+  /** Conversation tracking and analysis endpoints */
+  conversations;
+  /** Subscription billing and payment management endpoints */
+  billing;
+  /** Artifact storage and retrieval endpoints */
+  artifacts;
+  /** API key management endpoints */
+  apiKeys;
+  /** System alerts banner endpoints (customer portal) */
+  alerts;
+  /** Admin management endpoints for invite codes and platform configuration */
+  admin;
+  /** Admin endpoints for managing system alerts */
+  adminAlerts;
+  /** Admin Pipeline operations */
+  adminPipeline;
+  constructor(options = {}) {
+    this._http = new HttpClient({ baseUrl: "https://api.memnexus.ai", ...options });
+    this.users = new Users(this._http);
+    this.topics = new Topics(this._http);
+    this.system = new System(this._http);
+    this.patterns = new Patterns(this._http);
+    this.behavior = new Behavior(this._http);
+    this.recommendations = new Recommendations(this._http);
+    this.narratives = new Narratives(this._http);
+    this.monitoring = new Monitoring(this._http);
+    this.memories = new Memories(this._http);
+    this.invites = new Invites(this._http);
+    this.health = new Health(this._http);
+    this.graphrag = new Graphrag(this._http);
+    this.facts = new Facts(this._http);
+    this.entities = new Entities(this._http);
+    this.conversations = new Conversations(this._http);
+    this.billing = new Billing(this._http);
+    this.artifacts = new Artifacts(this._http);
+    this.apiKeys = new ApiKeys(this._http);
+    this.alerts = new Alerts(this._http);
+    this.admin = new Admin(this._http);
+    this.adminAlerts = new AdminAlerts(this._http);
+    this.adminPipeline = new AdminPipeline(this._http);
+  }
+  /**
+   * Save a memory.
+   * Convenience wrapper around `memories.createMemory`.
+   *
+   * @param content — The memory content to save.
+   * @param extra — Additional fields passed to CreateMemoryRequest.
+   */
+  async remember(content, extra = {}) {
+    return this.memories.createMemory({ content, ...extra });
+  }
+  /**
+   * Get an AI-synthesized recall digest.
+   * Convenience wrapper.
+   *
+   * @param query — The recall query or topic.
+   */
+  async recall(query, extra = {}) {
+    return this.memories.generateMemoryDigest({ query, ...extra });
+  }
+  /**
+   * Search memories.
+   * Convenience wrapper.
+   *
+   * @param query — The search query.
+   */
+  async search(query, extra = {}) {
+    return this.memories.searchMemories({ query, ...extra });
+  }
+  /**
+   * Build a context briefing.
+   * Convenience wrapper.
+   *
+   * @param context — Context description for the briefing.
+   */
+  async brief(context, extra = {}) {
+    return this.memories.buildContext({ context, ...extra });
+  }
+  /**
+   * Delete a memory by ID.
+   * Convenience wrapper.
+   *
+   * @param memoryId — The ID of the memory to delete.
+   */
+  async forget(memoryId) {
+    return this.memories.deleteMemory(memoryId);
+  }
+};
+export {
+  MemNexus,
+  SdkError
+};