@memnexus-ai/typescript-sdk 1.14.12 → 1.14.18

package/dist/index.cjs

@@ -0,0 +1,4438 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiKeysService: () => ApiKeysService,
+  ArtifactsService: () => ArtifactsService,
+  BehaviorService: () => BehaviorService,
+  CommunitiesService: () => CommunitiesService,
+  ContentType: () => ContentType,
+  ConversationsService: () => ConversationsService,
+  Environment: () => Environment,
+  FactsService: () => FactsService,
+  GraphragService: () => GraphragService,
+  HealthService: () => HealthService,
+  Memnexus: () => Memnexus,
+  MemoriesService: () => MemoriesService,
+  NarrativesService: () => NarrativesService,
+  PatternsService: () => PatternsService,
+  SerializationStyle: () => SerializationStyle,
+  SystemService: () => SystemService,
+  TopicsService: () => TopicsService,
+  UsersService: () => UsersService,
+  addMemoryToNarrativeRequest: () => addMemoryToNarrativeRequest,
+  apiKey: () => apiKey,
+  artifact: () => artifact,
+  community: () => community,
+  conversation: () => conversation,
+  createArtifactRequest: () => createArtifactRequest,
+  createConversationRequest: () => createConversationRequest,
+  createFactRequest: () => createFactRequest,
+  createMemoryRelationshipRequest: () => createMemoryRelationshipRequest,
+  createMemoryRequest: () => createMemoryRequest,
+  createMemoryResponse: () => createMemoryResponse,
+  createMemoryResponseMeta: () => createMemoryResponseMeta,
+  createNarrativeRequest: () => createNarrativeRequest,
+  default: () => index_default,
+  entity: () => entity,
+  error: () => error,
+  fact: () => fact,
+  factSearchRequest: () => factSearchRequest,
+  getMemoryResponse: () => getMemoryResponse,
+  getNarrativeResponse: () => getNarrativeResponse,
+  graphRAGQueryRequest: () => graphRAGQueryRequest,
+  graphRAGQueryResponse: () => graphRAGQueryResponse,
+  healthCheck: () => healthCheck,
+  listNarrativesResponse: () => listNarrativesResponse,
+  memory: () => memory,
+  memoryRelationship: () => memoryRelationship,
+  memoryRelationshipsResponse: () => memoryRelationshipsResponse,
+  mergeCommunitiesRequest: () => mergeCommunitiesRequest,
+  narrativeMemory: () => narrativeMemory,
+  narrativeThread: () => narrativeThread,
+  narrativeTimelineResponse: () => narrativeTimelineResponse,
+  pagination: () => pagination,
+  pattern: () => pattern,
+  relatedMemoryResult: () => relatedMemoryResult,
+  searchRequest: () => searchRequest,
+  searchResponse: () => searchResponse,
+  searchResult: () => searchResult,
+  serviceCheck: () => serviceCheck,
+  temporalMetadata: () => temporalMetadata,
+  topic: () => topic,
+  topicReference: () => topicReference,
+  updateArtifactRequest: () => updateArtifactRequest,
+  updateFactRequest: () => updateFactRequest,
+  updateMemoryRequest: () => updateMemoryRequest,
+  updateNarrativeRequest: () => updateNarrativeRequest,
+  user: () => user,
+  userUsage: () => userUsage
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http/handlers.ts
+var BaseHandler = class {
+  nextHandler;
+  setNext(handler) {
+    this.nextHandler = handler;
+    return handler;
+  }
+  async callNext(request) {
+    if (!this.nextHandler) {
+      throw new Error("No next handler in chain");
+    }
+    return this.nextHandler.handle(request);
+  }
+};
+var RetryHandler = class extends BaseHandler {
+  maxAttempts;
+  delayMs;
+  maxDelayMs;
+  jitterMs;
+  backoffFactor;
+  httpCodesToRetry;
+  httpMethodsToRetry;
+  constructor(options) {
+    super();
+    this.maxAttempts = options?.attempts ?? 3;
+    this.delayMs = options?.delayMs ?? 150;
+    this.maxDelayMs = options?.maxDelayMs ?? 5e3;
+    this.jitterMs = options?.jitterMs ?? 50;
+    this.backoffFactor = options?.backoffFactor ?? 2;
+    this.httpCodesToRetry = new Set(options?.httpCodesToRetry ?? [408, 429, 500, 502, 503, 504]);
+    this.httpMethodsToRetry = new Set(options?.httpMethodsToRetry ?? ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+  }
+  async handle(request) {
+    let lastError;
+    let attempt = 0;
+    while (attempt < this.maxAttempts) {
+      try {
+        const response = await this.callNext(request);
+        if (this.shouldRetry(request.method, response.metadata.status)) {
+          lastError = new Error(`HTTP ${response.metadata.status}`);
+          attempt++;
+          await this.delay(attempt);
+          continue;
+        }
+        return response;
+      } catch (error2) {
+        lastError = error2;
+        attempt++;
+        if (attempt >= this.maxAttempts) {
+          break;
+        }
+        await this.delay(attempt);
+      }
+    }
+    throw lastError || new Error("Max retry attempts reached");
+  }
+  shouldRetry(method, status) {
+    return this.httpMethodsToRetry.has(method) && this.httpCodesToRetry.has(status);
+  }
+  async delay(attempt) {
+    const exponentialDelay = this.delayMs * Math.pow(this.backoffFactor, attempt - 1);
+    const jitter = Math.random() * this.jitterMs;
+    const delay = Math.min(exponentialDelay + jitter, this.maxDelayMs);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+};
+var ValidationHandler = class extends BaseHandler {
+  async handle(request) {
+    if (request.requestSchema && request.body) {
+      const result = request.requestSchema.safeParse(request.body);
+      if (!result.success) {
+        throw new Error(`Request validation failed: ${result.error.message}`);
+      }
+    }
+    const response = await this.callNext(request);
+    if (request.validation?.responseValidation && response.data) {
+      const matchingResponse = request.responses.find(
+        (r) => r.status === response.metadata.status
+      );
+      if (matchingResponse) {
+        const result = matchingResponse.schema.safeParse(response.data);
+        if (!result.success) {
+          throw new Error(`Response validation failed: ${result.error.message}`);
+        }
+      }
+    }
+    return response;
+  }
+};
+var HookHandler = class extends BaseHandler {
+  hook;
+  constructor(hook) {
+    super();
+    this.hook = hook;
+  }
+  async handle(request) {
+    const httpRequest = {
+      baseUrl: request.baseUrl,
+      method: request.method,
+      path: request.path,
+      headers: new Map(Object.entries(request.getHeaders())),
+      queryParams: /* @__PURE__ */ new Map(),
+      pathParams: /* @__PURE__ */ new Map(),
+      body: request.body
+    };
+    const modifiedRequest = await this.hook.beforeRequest(httpRequest, /* @__PURE__ */ new Map());
+    const response = await this.callNext(request);
+    const modifiedResponse = await this.hook.afterResponse(modifiedRequest, response, /* @__PURE__ */ new Map());
+    return modifiedResponse;
+  }
+};
+var ExecuteHandler = class extends BaseHandler {
+  async handle(request) {
+    const url = request.constructFullUrl();
+    const headers = request.getHeaders();
+    if (request.body && typeof request.body === "object") {
+      headers["Content-Type"] = "application/json";
+    }
+    if (request.config.token) {
+      headers["Authorization"] = `Bearer ${request.config.token}`;
+    }
+    const fetchOptions = {
+      method: request.method,
+      headers
+    };
+    if (request.body && request.method !== "GET") {
+      fetchOptions.body = typeof request.body === "string" ? request.body : JSON.stringify(request.body);
+    }
+    if (request.config.timeoutMs) {
+      const controller = new AbortController();
+      setTimeout(() => controller.abort(), request.config.timeoutMs);
+      fetchOptions.signal = controller.signal;
+    }
+    const response = await fetch(url, fetchOptions);
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    const raw = await response.arrayBuffer();
+    let data;
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json") && raw.byteLength > 0) {
+      const text = new TextDecoder().decode(raw);
+      try {
+        data = JSON.parse(text);
+      } catch {
+      }
+    }
+    const httpResponse = {
+      data,
+      metadata: {
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders
+      },
+      raw
+    };
+    if (!response.ok) {
+      const error2 = new Error(`HTTP ${response.status}: ${response.statusText}`);
+      error2.response = httpResponse;
+      throw error2;
+    }
+    return httpResponse;
+  }
+};
+var CustomHook = class {
+  async beforeRequest(request, params) {
+    return request;
+  }
+  async afterResponse(request, response, params) {
+    return response;
+  }
+  async onError(request, response, params) {
+    return {
+      error: response.metadata.statusText,
+      metadata: response.metadata
+    };
+  }
+};
+
+// src/http/http-client.ts
+var HttpClient = class {
+  config;
+  requestHandlerChain;
+  constructor(config, hook) {
+    this.config = config;
+    const executeHandler = new ExecuteHandler();
+    const hookHandler = new HookHandler(hook || new CustomHook());
+    const validationHandler = new ValidationHandler();
+    const retryHandler = new RetryHandler(config.retry);
+    retryHandler.setNext(validationHandler);
+    validationHandler.setNext(hookHandler);
+    hookHandler.setNext(executeHandler);
+    this.requestHandlerChain = retryHandler;
+  }
+  /**
+   * Execute an HTTP request
+   */
+  async call(request) {
+    return this.requestHandlerChain.handle(request);
+  }
+  /**
+   * Update base URL
+   */
+  setBaseUrl(url) {
+    this.config.baseUrl = url;
+  }
+  /**
+   * Update config
+   */
+  setConfig(config) {
+    this.config = config;
+  }
+};
+
+// src/http/base-service.ts
+var BaseService = class {
+  config;
+  client;
+  constructor(config) {
+    this.config = config;
+    this.client = new HttpClient(config);
+  }
+  /**
+   * Set the base URL for API requests
+   */
+  set baseUrl(baseUrl) {
+    this.config.baseUrl = baseUrl;
+    this.client.setBaseUrl(baseUrl);
+  }
+  /**
+   * Set the environment
+   */
+  set environment(environment) {
+    this.config.environment = environment;
+    this.client.setBaseUrl(environment);
+  }
+  /**
+   * Set the request timeout in milliseconds
+   */
+  set timeoutMs(timeoutMs) {
+    this.config.timeoutMs = timeoutMs;
+  }
+  /**
+   * Set the bearer token for authentication
+   */
+  set token(token) {
+    this.config.token = token;
+  }
+};
+
+// src/http/serialization.ts
+function serializeParameter(param) {
+  const { value, style, explode } = param;
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return serializeArray(value, style, explode);
+  }
+  return serializeObject(value, style, explode);
+}
+function serializeArray(value, style, explode) {
+  if (explode) {
+    return value.map(String);
+  }
+  switch (style) {
+    case "simple":
+      return value.join(",");
+    case "label":
+      return "." + value.join(".");
+    case "matrix":
+      return ";" + value.join(";");
+    case "form":
+      return value.join(",");
+    case "space_delimited":
+      return value.join(" ");
+    case "pipe_delimited":
+      return value.join("|");
+    default:
+      return value.join(",");
+  }
+}
+function serializeObject(value, style, explode) {
+  const entries = Object.entries(value).filter(([_, v]) => v !== void 0);
+  if (style === "deep_object") {
+    return Object.fromEntries(entries.map(([k, v]) => [k, String(v)]));
+  }
+  if (explode) {
+    return Object.fromEntries(entries.map(([k, v]) => [k, String(v)]));
+  }
+  const pairs = entries.flatMap(([k, v]) => [k, String(v)]);
+  switch (style) {
+    case "simple":
+      return pairs.join(",");
+    case "label":
+      return "." + pairs.join(".");
+    case "matrix":
+      return ";" + pairs.join(";");
+    case "form":
+      return pairs.join(",");
+    default:
+      return pairs.join(",");
+  }
+}
+
+// src/http/request-builder.ts
+var Request = class {
+  baseUrl;
+  method;
+  path;
+  config;
+  headers;
+  queryParams;
+  pathParams;
+  body;
+  responses;
+  errors;
+  requestSchema;
+  requestContentType;
+  validation;
+  retry;
+  constructor(params) {
+    this.baseUrl = params.baseUrl;
+    this.method = params.method;
+    this.path = params.path;
+    this.config = params.config;
+    this.headers = params.headers || /* @__PURE__ */ new Map();
+    this.queryParams = params.queryParams || /* @__PURE__ */ new Map();
+    this.pathParams = params.pathParams || /* @__PURE__ */ new Map();
+    this.body = params.body;
+    this.responses = params.responses || [];
+    this.errors = params.errors || [];
+    this.requestSchema = params.requestSchema;
+    this.requestContentType = params.requestContentType;
+    this.validation = params.validation || {};
+    this.retry = params.retry || { attempts: 1 };
+  }
+  /**
+   * Add a header parameter
+   */
+  addHeaderParam(key, param) {
+    this.headers.set(key, param);
+  }
+  /**
+   * Add a query parameter
+   */
+  addQueryParam(key, param) {
+    this.queryParams.set(key, param);
+  }
+  /**
+   * Add a path parameter
+   */
+  addPathParam(key, param) {
+    this.pathParams.set(key, param);
+  }
+  /**
+   * Set the request body
+   */
+  addBody(body) {
+    this.body = body;
+  }
+  /**
+   * Construct the full URL with path and query parameters
+   */
+  constructFullUrl() {
+    let url = this.path;
+    for (const [key, param] of this.pathParams) {
+      const value = serializeParameter(param);
+      url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
+    }
+    const queryString = this.buildQueryString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    return `${this.baseUrl}${url}`;
+  }
+  /**
+   * Get serialized headers
+   */
+  getHeaders() {
+    const headers = {};
+    for (const [key, param] of this.headers) {
+      const value = serializeParameter(param);
+      if (value !== void 0 && value !== null) {
+        headers[key] = String(value);
+      }
+    }
+    return headers;
+  }
+  /**
+   * Build query string from parameters
+   */
+  buildQueryString() {
+    const parts = [];
+    for (const [key, param] of this.queryParams) {
+      const serialized = serializeQueryParam(key, param);
+      if (serialized) {
+        parts.push(serialized);
+      }
+    }
+    return parts.join("&");
+  }
+};
+function serializeQueryParam(key, param) {
+  const value = param.value;
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    if (param.explode) {
+      return value.map((v) => `${encodeURIComponent(key)}=${encodeURIComponent(String(v))}`).join("&");
+    }
+    return `${encodeURIComponent(key)}=${value.map((v) => encodeURIComponent(String(v))).join(",")}`;
+  }
+  if (typeof value === "object") {
+    if (param.style === "deep_object") {
+      return Object.entries(value).map(([k, v]) => `${encodeURIComponent(key)}[${encodeURIComponent(k)}]=${encodeURIComponent(String(v))}`).join("&");
+    }
+    return Object.entries(value).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+  }
+  return `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`;
+}
+
+// src/services/api-keys-service.ts
+var ApiKeysService = class extends BaseService {
+  /**
+   * Get user information for current API key
+   * Debug endpoint to retrieve user ID and authentication method from the current API key
+   */
+  async debugUser() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/apikeys/debug-user",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * List API keys
+   * List all API keys for the authenticated user
+   */
+  async listApiKeys() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/apikeys",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Create API key
+   * Create a new API key for the authenticated user
+   * @param body - Request body
+   */
+  async createApiKey(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/apikeys",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Delete API key
+   * Delete (revoke) an API key by its ID
+   * @param id - The API key ID
+   */
+  async deleteApiKey(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/apikeys/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+};
+
+// src/services/artifacts-service.ts
+var ArtifactsService = class extends BaseService {
+  /**
+   * List artifacts
+   * List all artifacts for the authenticated user with optional filters
+   * @param limit - Maximum number of artifacts to return
+   * @param offset - Number of artifacts to skip
+   * @param memoryId - Filter by memory ID
+   * @param conversationId - Filter by conversation ID
+   * @param type - Filter by artifact type
+   */
+  async listArtifacts(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/artifacts",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    if (options?.memoryId !== void 0) {
+      request.addQueryParam("memoryId", {
+        key: "memoryId",
+        value: options.memoryId,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.conversationId !== void 0) {
+      request.addQueryParam("conversationId", {
+        key: "conversationId",
+        value: options.conversationId,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.type !== void 0) {
+      request.addQueryParam("type", {
+        key: "type",
+        value: options.type,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Create artifact
+   * Create a new artifact for the authenticated user
+   * @param body - Request body
+   */
+  async createArtifact(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/artifacts",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get artifact by ID
+   * Retrieve a specific artifact by its ID
+   * @param id - The artifact ID
+   */
+  async getArtifactById(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/artifacts/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Delete artifact
+   * Delete an artifact by its ID
+   * @param id - The artifact ID
+   */
+  async deleteArtifact(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/artifacts/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Update artifact
+   * Update an existing artifact with partial data
+   * @param id - The artifact ID
+   * @param body - Request body
+   */
+  async updateArtifact(id, body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PATCH",
+      path: "/api/artifacts/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/conversations-service.ts
+var ConversationsService = class extends BaseService {
+  /**
+   * List conversations
+   * List all conversations for the authenticated user with pagination
+   * @param limit - Maximum number of conversations to return
+   * @param offset - Number of conversations to skip
+   */
+  async listConversations(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/conversations",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Create conversation
+   * Create a new conversation for the authenticated user
+   * @param body - Request body
+   */
+  async createConversation(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/conversations",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get conversation summary
+   * Retrieve a conversation summary by its ID
+   * @param conversationId - The conversation ID
+   */
+  async getConversationSummary(conversationId) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/conversations/{conversationId}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("conversationId", {
+      key: "conversationId",
+      value: conversationId,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Delete conversation
+   * Delete a conversation and soft-delete all associated memories
+   * @param conversationId - The conversation ID
+   */
+  async deleteConversation(conversationId) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/conversations/{conversationId}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("conversationId", {
+      key: "conversationId",
+      value: conversationId,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Get conversation timeline
+   * Get all memories in a conversation in chronological order
+   * @param conversationId - The conversation ID
+   */
+  async getConversationTimeline(conversationId) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/conversations/{conversationId}/timeline",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("conversationId", {
+      key: "conversationId",
+      value: conversationId,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Search conversations
+   * Search conversations by query string
+   * @param body - Request body
+   */
+  async searchConversations(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/conversations/search",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Find conversations by topic
+   * Find conversations that contain a specific topic
+   * @param body - Request body
+   */
+  async findConversationsByTopic(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/conversations/by-topic",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/facts-service.ts
+var FactsService = class extends BaseService {
+  /**
+   * List facts
+   * List all facts for the authenticated user
+   * @param limit - Maximum number of facts to return
+   * @param offset - Number of facts to skip
+   */
+  async listFacts(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/facts",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Create fact
+   * Create a new semantic fact
+   * @param body - Request body
+   */
+  async createFact(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/facts",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get fact by ID
+   * Retrieve a specific fact by its ID
+   * @param id - The fact ID
+   */
+  async getFactById(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/facts/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Update fact
+   * Update an existing fact completely
+   * @param id - The fact ID
+   * @param body - Request body
+   */
+  async updateFact(id, body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PUT",
+      path: "/api/facts/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Delete fact
+   * Delete a fact by its ID
+   * @param id - The fact ID
+   */
+  async deleteFact(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/facts/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Search facts
+   * Search semantic facts by query string
+   * @param body - Request body
+   */
+  async searchFacts(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/facts/search",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/graphrag-service.ts
+var GraphragService = class extends BaseService {
+  /**
+   * Explain a GraphRAG query
+   * Get explanation for a previously executed GraphRAG query result
+   * @param queryId - The query ID to explain
+   */
+  async explainGraphRAGQuery(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/graphrag/explain",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.queryId !== void 0) {
+      request.addQueryParam("queryId", {
+        key: "queryId",
+        value: options.queryId,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Query communities
+   * Query communities for relevant information using semantic search
+   * @param body - Request body
+   */
+  async queryCommunities(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/graphrag/query-communities",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Execute a GraphRAG query
+   * Execute a graph-based retrieval augmented generation query
+   * @param body - Request body
+   */
+  async executeGraphRAGQuery(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/graphrag/query",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/health-service.ts
+var HealthService = class extends BaseService {
+  /**
+     * 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.
+  
+     */
+  async healthCheck() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/health",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+};
+
+// src/services/memories-service.ts
+var MemoriesService = class extends BaseService {
+  /**
+   * Get memory by ID
+   * Retrieve a specific memory by its ID
+   * @param id - The memory ID
+   */
+  async getMemoryById(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Update a memory
+   * Update an existing memory for the authenticated user
+   * @param id - Memory ID
+   * @param body - Request body
+   */
+  async updateMemory(id, body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PUT",
+      path: "/api/memories/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Delete memory
+   * Delete a memory by its ID
+   * @param id - The memory ID
+   */
+  async deleteMemory(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/memories/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+     * 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 idPrefix - Filter memories by ID prefix (git-style short ID lookup). Minimum 6 characters.
+     * @param limit - Maximum number of memories to return
+     * @param offset - Number of memories to skip
+     * @param page - Page number (alternative to offset)
+     */
+  async listMemories(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.idPrefix !== void 0) {
+      request.addQueryParam("idPrefix", {
+        key: "idPrefix",
+        value: options.idPrefix,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    if (options?.page !== void 0) {
+      request.addQueryParam("page", {
+        key: "page",
+        value: options.page,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 q - Search query string
+     * @param searchMethod - Search algorithm to use
+     * @param limit - Maximum number of results to return
+     * @param offset - Number of results to skip for pagination
+     * @param threshold - Minimum similarity threshold for semantic search
+     * @param mode - Content filtering mode
+     * @param vectorWeight - Weight for vector similarity in hybrid search
+     * @param fulltextWeight - Weight for fulltext matching in hybrid search
+     * @param topics - Comma-separated list of topics to filter by
+     * @param memoryType - Filter by memory type
+     * @param conversationId - Filter by conversation ID
+     * @param explain - Include detailed match explanations in results
+     * @param includeTopics - Include associated topics in results
+     * @param includeEntities - Include mentioned entities in results
+     * @param asOfTime - Point-in-time query (ISO 8601 datetime)
+     * @param validAtTime - Filter by validity time (ISO 8601 datetime)
+     * @param eventTimeFrom - Event time range start (ISO 8601 datetime)
+     * @param eventTimeTo - Event time range end (ISO 8601 datetime)
+     * @param ingestionTimeFrom - Ingestion time range start (ISO 8601 datetime)
+     * @param ingestionTimeTo - Ingestion time range end (ISO 8601 datetime)
+     * @param includeExpired - Include expired memories in results
+     * @param temporalMode - Temporal query mode
+     */
+  async searchMemoriesGet(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/search",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.q !== void 0) {
+      request.addQueryParam("q", {
+        key: "q",
+        value: options.q,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.searchMethod !== void 0) {
+      request.addQueryParam("searchMethod", {
+        key: "searchMethod",
+        value: options.searchMethod,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    if (options?.threshold !== void 0) {
+      request.addQueryParam("threshold", {
+        key: "threshold",
+        value: options.threshold,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.mode !== void 0) {
+      request.addQueryParam("mode", {
+        key: "mode",
+        value: options.mode,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.vectorWeight !== void 0) {
+      request.addQueryParam("vectorWeight", {
+        key: "vectorWeight",
+        value: options.vectorWeight,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.fulltextWeight !== void 0) {
+      request.addQueryParam("fulltextWeight", {
+        key: "fulltextWeight",
+        value: options.fulltextWeight,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.topics !== void 0) {
+      request.addQueryParam("topics", {
+        key: "topics",
+        value: options.topics,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.memoryType !== void 0) {
+      request.addQueryParam("memoryType", {
+        key: "memoryType",
+        value: options.memoryType,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.conversationId !== void 0) {
+      request.addQueryParam("conversationId", {
+        key: "conversationId",
+        value: options.conversationId,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.explain !== void 0) {
+      request.addQueryParam("explain", {
+        key: "explain",
+        value: options.explain,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.includeTopics !== void 0) {
+      request.addQueryParam("includeTopics", {
+        key: "includeTopics",
+        value: options.includeTopics,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.includeEntities !== void 0) {
+      request.addQueryParam("includeEntities", {
+        key: "includeEntities",
+        value: options.includeEntities,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.asOfTime !== void 0) {
+      request.addQueryParam("asOfTime", {
+        key: "asOfTime",
+        value: options.asOfTime,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.validAtTime !== void 0) {
+      request.addQueryParam("validAtTime", {
+        key: "validAtTime",
+        value: options.validAtTime,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.eventTimeFrom !== void 0) {
+      request.addQueryParam("eventTimeFrom", {
+        key: "eventTimeFrom",
+        value: options.eventTimeFrom,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.eventTimeTo !== void 0) {
+      request.addQueryParam("eventTimeTo", {
+        key: "eventTimeTo",
+        value: options.eventTimeTo,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.ingestionTimeFrom !== void 0) {
+      request.addQueryParam("ingestionTimeFrom", {
+        key: "ingestionTimeFrom",
+        value: options.ingestionTimeFrom,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.ingestionTimeTo !== void 0) {
+      request.addQueryParam("ingestionTimeTo", {
+        key: "ingestionTimeTo",
+        value: options.ingestionTimeTo,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.includeExpired !== void 0) {
+      request.addQueryParam("includeExpired", {
+        key: "includeExpired",
+        value: options.includeExpired,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.temporalMode !== void 0) {
+      request.addQueryParam("temporalMode", {
+        key: "temporalMode",
+        value: options.temporalMode,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/search",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 limit - Maximum number of similar memories to return
+     */
+  async getSimilarMemories(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/{id}/similar",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 limit - Maximum number of conversation memories to return
+     */
+  async getConversationMemories(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/{id}/conversation-memories",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 limit - Maximum number of related memories to return
+     */
+  async getRelatedMemories(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/{id}/related",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 direction - Direction of relationships to retrieve
+     */
+  async getMemoryRelationships(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/{id}/relationships",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.direction !== void 0) {
+      request.addQueryParam("direction", {
+        key: "direction",
+        value: options.direction,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/{id}/relationships",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/memories/{id}/relationships/{relationshipId}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    request.addPathParam("relationshipId", {
+      key: "relationshipId",
+      value: relationshipId,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+     * 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 before - Number of preceding memories to return
+     * @param after - Number of following memories to return
+     */
+  async getMemoryTimeline(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/{id}/timeline",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.before !== void 0) {
+      request.addQueryParam("before", {
+        key: "before",
+        value: options.before,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.after !== void 0) {
+      request.addQueryParam("after", {
+        key: "after",
+        value: options.after,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 body - Request body
+     */
+  async detectMemoryRelationships(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/{id}/detect-relationships",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/narratives-service.ts
+var NarrativesService = class extends BaseService {
+  /**
+     * List narrative threads
+     * List all narrative threads for the authenticated user.
+  Narratives group related memories into coherent storylines.
+  
+     * @param limit - Maximum number of narratives to return
+     * @param offset - Number of narratives to skip
+     * @param state - Filter by narrative state
+     * @param topics - Comma-separated list of topics to filter by
+     */
+  async listNarratives(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/narratives",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    if (options?.state !== void 0) {
+      request.addQueryParam("state", {
+        key: "state",
+        value: options.state,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.topics !== void 0) {
+      request.addQueryParam("topics", {
+        key: "topics",
+        value: options.topics,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/narratives",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get a narrative thread
+   * Retrieve a specific narrative thread by ID
+   * @param id - The narrative ID
+   */
+  async getNarrative(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/narratives/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+     * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/narratives/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+     * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PATCH",
+      path: "/api/narratives/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 limit - Maximum number of memories to return
+     * @param offset - Number of memories to skip
+     */
+  async getNarrativeTimeline(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/narratives/{id}/timeline",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/narratives/{id}/memories",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * 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 request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/narratives/{id}/memories/{memoryId}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    request.addPathParam("memoryId", {
+      key: "memoryId",
+      value: memoryId,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+};
+
+// src/services/system-service.ts
+var SystemService = class extends BaseService {
+  /**
+   * 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 noCache - Bypass cache and regenerate specification
+   */
+  async getOpenApiSpec(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/openapi.json",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.noCache !== void 0) {
+      request.addQueryParam("noCache", {
+        key: "noCache",
+        value: options.noCache,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get system health status
+   * Get the current health status of the system including database connectivity
+   */
+  async getSystemHealth() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/system/health",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Get context status
+   * Get database statistics and context information
+   */
+  async getContextStatus() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/system/context/status",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Get feature flags
+   * Get all feature flags for the authenticated user
+   */
+  async getFeatureFlags() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/system/feature-flags",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Evaluate feature flag
+   * Evaluate a specific feature flag for the authenticated user
+   * @param body - Request body
+   */
+  async evaluateFeatureFlag(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/system/feature-flags/evaluate",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Analyze memory quality distribution
+   * Analyze the quality distribution of memories for the authenticated user
+   * @param includeDetails - Include detailed pruning candidate information
+   * @param minQualityThreshold - Minimum quality threshold for pruning candidates (default 0.4)
+   */
+  async analyzeMemoryQuality(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/system/memory/quality",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.includeDetails !== void 0) {
+      request.addQueryParam("includeDetails", {
+        key: "includeDetails",
+        value: options.includeDetails,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.minQualityThreshold !== void 0) {
+      request.addQueryParam("minQualityThreshold", {
+        key: "minQualityThreshold",
+        value: options.minQualityThreshold,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Prune low-quality memories
+   * Prune (soft delete) low-quality memories for the authenticated user
+   * @param body - Request body
+   */
+  async pruneMemories(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/system/memory/prune",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/patterns-service.ts
+var PatternsService = class extends BaseService {
+  /**
+   * List patterns
+   * List all patterns for the authenticated user
+   * @param limit - Maximum number of patterns to return
+   * @param offset - Number of patterns to skip
+   */
+  async listPatterns(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/patterns",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Compile patterns
+   * Compile patterns from user's memories
+   * @param body - Request body
+   */
+  async compilePatterns(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/patterns/compile",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Detect behavioral patterns
+   * Run pattern detection algorithms to identify recurring behavioral patterns
+   * @param body - Request body
+   */
+  async detectPatterns(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/patterns/detect",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Analyze pattern trends
+   * Analyze pattern trends, correlations, and generate insights
+   * @param body - Request body
+   */
+  async analyzePatterns(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/patterns/analyze",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Update pattern
+   * Update an existing pattern with partial data
+   * @param id - The pattern ID
+   * @param body - Request body
+   */
+  async updatePattern(id, body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PATCH",
+      path: "/api/patterns/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Record pattern feedback
+   * Record feedback on a pattern
+   * @param body - Request body
+   */
+  async recordPatternFeedback(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/patterns/feedback",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/behavior-service.ts
+var BehaviorService = class extends BaseService {
+  /**
+   * Get behavioral state
+   * Get current behavioral state for the authenticated user
+   */
+  async getBehavioralState() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/patterns/behavior/state",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Update behavioral state
+   * Update or mutate behavioral state
+   * @param body - Request body
+   */
+  async updateBehavioralState(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/patterns/behavior/state",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/topics-service.ts
+var TopicsService = class extends BaseService {
+  /**
+   * List topics
+   * List all topics with pagination
+   * @param limit - Maximum number of topics to return
+   * @param offset - Number of topics to skip
+   */
+  async listTopics(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/topics",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get topic by ID
+   * Retrieve a specific topic by its ID
+   * @param id - The topic ID
+   */
+  async getTopicById(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/topics/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Merge topics
+   * Merge two topics into one
+   * @param body - Request body
+   */
+  async mergeTopics(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/topics/merge",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Discover related topics
+   * Discover topics related to a given topic
+   * @param body - Request body
+   */
+  async discoverRelatedTopics(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/topics/discover-related",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Calculate topic similarity
+   * Calculate similarity score between two topics
+   * @param body - Request body
+   */
+  async calculateTopicSimilarity(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/topics/similarity",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Find similar topics
+   * Find topics similar to a given topic
+   * @param body - Request body
+   */
+  async findSimilarTopics(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/topics/similar",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Cluster topics
+   * Cluster topics using community detection algorithms
+   * @param body - Request body
+   */
+  async clusterTopics(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/topics/cluster",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Detect communities
+   * Detect communities in the topic graph using specified algorithm
+   * @param body - Request body
+   */
+  async detectCommunities(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/topics/detect-communities",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Search topics
+   * Search topics by query string using fulltext search
+   * @param body - Request body
+   */
+  async searchTopics(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/topics/search",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/communities-service.ts
+var CommunitiesService = class extends BaseService {
+  /**
+   * List communities
+   * List all communities with pagination
+   * @param limit - Maximum number of communities to return
+   * @param offset - Number of communities to skip
+   */
+  async listCommunities(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/topics/communities",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get community by ID
+   * Retrieve a specific community by its ID
+   * @param id - The community ID
+   */
+  async getCommunityById(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/topics/communities/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Merge communities
+   * Merge two communities into one
+   * @param body - Request body
+   */
+  async mergeCommunities(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/topics/communities/merge",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/users-service.ts
+var UsersService = class extends BaseService {
+  /**
+     * 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.
+  
+     * @param body - Request body
+     */
+  async syncUser(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/users/sync",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get current user
+   * Get the currently authenticated user's profile and usage information
+   */
+  async getCurrentUser() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/users/me",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Update current user
+   * Update the currently authenticated user's profile
+   * @param body - Request body
+   */
+  async updateCurrentUser(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PATCH",
+      path: "/api/users/me",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get current user's usage
+   * Get the currently authenticated user's memory usage statistics
+   */
+  async getCurrentUserUsage() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/users/me/usage",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Get user by ID
+   * Get a user by their internal ID (admin only)
+   * @param id - 
+   */
+  async getUserById(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/users/{id}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+};
+
+// src/http/http-types.ts
+var SerializationStyle = /* @__PURE__ */ ((SerializationStyle2) => {
+  SerializationStyle2["SIMPLE"] = "simple";
+  SerializationStyle2["LABEL"] = "label";
+  SerializationStyle2["MATRIX"] = "matrix";
+  SerializationStyle2["FORM"] = "form";
+  SerializationStyle2["SPACE_DELIMITED"] = "space_delimited";
+  SerializationStyle2["PIPE_DELIMITED"] = "pipe_delimited";
+  SerializationStyle2["DEEP_OBJECT"] = "deep_object";
+  SerializationStyle2["NONE"] = "none";
+  return SerializationStyle2;
+})(SerializationStyle || {});
+var ContentType = /* @__PURE__ */ ((ContentType2) => {
+  ContentType2["Json"] = "json";
+  ContentType2["Xml"] = "xml";
+  ContentType2["Pdf"] = "pdf";
+  ContentType2["Image"] = "image";
+  ContentType2["File"] = "file";
+  ContentType2["Binary"] = "binary";
+  ContentType2["FormUrlEncoded"] = "form";
+  ContentType2["Text"] = "text";
+  ContentType2["MultipartFormData"] = "multipartFormData";
+  ContentType2["EventStream"] = "eventStream";
+  ContentType2["NoContent"] = "noContent";
+  return ContentType2;
+})(ContentType || {});
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["DEFAULT"] = "http://localhost:3000";
+  return Environment2;
+})(Environment || {});
+
+// src/models/schemas.ts
+var import_zod = require("zod");
+var error = import_zod.z.object({
+  /** Error message */
+  error: import_zod.z.string()
+});
+var pagination = import_zod.z.object({
+  /** Maximum number of items per page */
+  limit: import_zod.z.number().min(1),
+  /** Number of items to skip */
+  offset: import_zod.z.number().min(0),
+  /** Total number of items */
+  count: import_zod.z.number().min(0)
+});
+var memory = import_zod.z.object({
+  /** Unique memory identifier */
+  id: import_zod.z.string(),
+  /** Memory content */
+  content: import_zod.z.string(),
+  /** Type of memory */
+  memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]),
+  /** Context or domain of the memory */
+  context: import_zod.z.string().optional(),
+  /** Associated topics */
+  topics: import_zod.z.array(import_zod.z.string()).optional(),
+  /** System ingestion timestamp (when the system learned about this) */
+  timestamp: import_zod.z.string().datetime().optional(),
+  /** Event time (when the event actually occurred in reality) */
+  eventTime: import_zod.z.string().datetime().optional(),
+  /** Validity start time (when this fact becomes valid) */
+  validFrom: import_zod.z.string().datetime().optional(),
+  /** Validity end time (when this fact expires, null means never expires) */
+  validTo: import_zod.z.string().datetime().nullable().optional(),
+  /** Creation timestamp */
+  createdAt: import_zod.z.string().datetime(),
+  /** Last update timestamp */
+  updatedAt: import_zod.z.string().datetime(),
+  /** Confidence score (0-1) for this memory's accuracy */
+  confidenceScore: import_zod.z.number().min(0).max(1).optional(),
+  /** Basis for the confidence score */
+  confidenceBasis: import_zod.z.enum(["direct-statement", "repeated-mention", "single-mention", "hedged", "inference", "external-source", "contradicted"]).optional(),
+  /** Effective state of the memory in the narrative */
+  effectiveState: import_zod.z.enum(["current", "superseded", "contradicted"]).optional()
+});
+var createMemoryRequest = import_zod.z.object({
+  /** Conversation ID - use "NEW" to create a new conversation or provide existing conversation ID */
+  conversationId: import_zod.z.string().min(1),
+  /** Memory content */
+  content: import_zod.z.string().min(1),
+  /** Type of memory */
+  memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]).optional(),
+  /** Role (MCP protocol compatibility) */
+  role: import_zod.z.enum(["user", "assistant", "system"]).optional(),
+  /** Context or domain */
+  context: import_zod.z.string().optional(),
+  /** Associated topics */
+  topics: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Event time (when the event actually occurred in reality, ISO 8601 format) */
+  eventTime: import_zod.z.string().datetime().optional(),
+  /** Validity start time (when this fact becomes valid, ISO 8601 format) */
+  validFrom: import_zod.z.string().datetime().optional(),
+  /** Validity end time (when this fact expires, ISO 8601 format, omit for never expires) */
+  validTo: import_zod.z.string().datetime().optional()
+});
+var updateMemoryRequest = import_zod.z.object({
+  /** Updated memory content */
+  content: import_zod.z.string().min(1).optional(),
+  /** Updated memory type */
+  memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]).optional(),
+  /** Updated context or domain */
+  context: import_zod.z.string().optional(),
+  /** Updated topics */
+  topics: import_zod.z.array(import_zod.z.string()).optional()
+});
+var createMemoryResponseMeta = import_zod.z.object({
+  /** Conversation ID (actual ID if "NEW" was provided) */
+  conversationId: import_zod.z.string(),
+  /** Auto-assigned session ID based on 90-minute gap detection */
+  sessionId: import_zod.z.string(),
+  /** Whether a new session was created (true) or existing session was reused (false) */
+  sessionCreated: import_zod.z.boolean(),
+  /** Whether a new conversation was created (true if conversationId was "NEW") */
+  conversationCreated: import_zod.z.boolean()
+});
+var createMemoryResponse = import_zod.z.lazy(() => import_zod.z.object({
+  data: memory,
+  meta: createMemoryResponseMeta
+}));
+var relatedMemoryResult = import_zod.z.object({
+  memory: import_zod.z.object({
+    /** Unique memory identifier */
+    id: import_zod.z.string(),
+    /** Memory content */
+    content: import_zod.z.string(),
+    /** Type of memory */
+    memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]),
+    /** Context or domain of the memory */
+    context: import_zod.z.string().optional(),
+    /** Associated topics */
+    topics: import_zod.z.array(import_zod.z.string()).optional(),
+    /** System ingestion timestamp (when the system learned about this) */
+    timestamp: import_zod.z.string().datetime().optional(),
+    /** Event time (when the event actually occurred in reality) */
+    eventTime: import_zod.z.string().datetime().optional(),
+    /** Validity start time (when this fact becomes valid) */
+    validFrom: import_zod.z.string().datetime().optional(),
+    /** Validity end time (when this fact expires, null means never expires) */
+    validTo: import_zod.z.string().datetime().nullable().optional(),
+    /** Creation timestamp */
+    createdAt: import_zod.z.string().datetime(),
+    /** Last update timestamp */
+    updatedAt: import_zod.z.string().datetime(),
+    /** Confidence score (0-1) for this memory's accuracy */
+    confidenceScore: import_zod.z.number().min(0).max(1).optional(),
+    /** Basis for the confidence score */
+    confidenceBasis: import_zod.z.enum(["direct-statement", "repeated-mention", "single-mention", "hedged", "inference", "external-source", "contradicted"]).optional(),
+    /** Effective state of the memory in the narrative */
+    effectiveState: import_zod.z.enum(["current", "superseded", "contradicted"]).optional()
+  }),
+  /** Relevance score (0-1). For similar: semantic similarity. For related: topic overlap ratio. For conversation: position score. */
+  score: import_zod.z.number().min(0).max(1),
+  /** Type of relationship: similar, similar-by-topic, conversation, or topic */
+  relationship: import_zod.z.string(),
+  /** Topics shared with the source memory (only for topic relationship) */
+  sharedTopics: import_zod.z.array(import_zod.z.string()).optional()
+});
+var getMemoryResponse = import_zod.z.lazy(() => import_zod.z.object({
+  data: memory
+}));
+var graphRAGQueryRequest = import_zod.z.object({
+  /** GraphRAG query string */
+  query: import_zod.z.string().min(1),
+  /** Maximum graph traversal depth (alias: depth) */
+  maxDepth: import_zod.z.number().min(1).max(5).optional(),
+  /** Graph traversal depth (deprecated, use maxDepth) */
+  depth: import_zod.z.number().min(1).max(5).optional(),
+  /** Maximum number of results to return */
+  limit: import_zod.z.number().min(1).max(100).optional(),
+  /** Include relationship data in response */
+  includeRelationships: import_zod.z.boolean().optional()
+});
+var graphRAGQueryResponse = import_zod.z.lazy(() => import_zod.z.object({
+  /** Unique identifier for this query execution */
+  queryId: import_zod.z.string(),
+  /** Array of query results with graph context */
+  results: import_zod.z.array(import_zod.z.object({
+    memory,
+    /** Relevance score from full-text search */
+    score: import_zod.z.number(),
+    /** Topics associated with this memory */
+    topics: import_zod.z.array(import_zod.z.object({}).catchall(import_zod.z.unknown().nullable())),
+    /** Entities mentioned in this memory */
+    entities: import_zod.z.array(import_zod.z.object({}).catchall(import_zod.z.unknown().nullable())),
+    /** Related memories through shared topics */
+    relatedMemories: import_zod.z.array(import_zod.z.object({}).catchall(import_zod.z.unknown().nullable()))
+  })),
+  /** Query execution metadata */
+  metadata: import_zod.z.object({
+    /** Original query string */
+    query: import_zod.z.string(),
+    /** Graph traversal depth used */
+    depth: import_zod.z.number(),
+    /** Maximum number of results returned */
+    limit: import_zod.z.number(),
+    /** Query execution timestamp */
+    timestamp: import_zod.z.string().datetime()
+  })
+}));
+var conversation = import_zod.z.object({
+  /** Unique conversation identifier */
+  id: import_zod.z.string(),
+  /** Conversation title */
+  title: import_zod.z.string(),
+  /** Conversation summary */
+  summary: import_zod.z.string().nullable(),
+  /** Creation timestamp */
+  createdAt: import_zod.z.string().datetime(),
+  /** Last update timestamp */
+  updatedAt: import_zod.z.string().datetime()
+});
+var createConversationRequest = import_zod.z.object({
+  /** Conversation title */
+  title: import_zod.z.string().min(1),
+  /** Optional conversation summary */
+  summary: import_zod.z.string().optional()
+});
+var apiKey = import_zod.z.object({
+  /** Unique API key identifier */
+  id: import_zod.z.string(),
+  /** Human-readable label for the API key */
+  label: import_zod.z.string(),
+  /** API key prefix for identification */
+  prefix: import_zod.z.string(),
+  /** Creation timestamp */
+  createdAt: import_zod.z.string().datetime(),
+  /** Expiration timestamp (null if never expires) */
+  expiresAt: import_zod.z.string().datetime().nullable(),
+  /** Last usage timestamp (null if never used) */
+  lastUsedAt: import_zod.z.string().datetime().nullable()
+});
+var topic = import_zod.z.object({
+  /** Topic name */
+  name: import_zod.z.string(),
+  /** Number of memories associated with this topic */
+  count: import_zod.z.number().min(0)
+});
+var pattern = import_zod.z.object({
+  /** Unique pattern identifier */
+  id: import_zod.z.string(),
+  /** Pattern type */
+  type: import_zod.z.string(),
+  /** Pattern description */
+  description: import_zod.z.string(),
+  /** Confidence score (0-1) */
+  confidence: import_zod.z.number().min(0).max(1)
+});
+var serviceCheck = import_zod.z.object({
+  /** Service status */
+  status: import_zod.z.enum(["up", "down"]),
+  /** Response time in milliseconds */
+  responseTime: import_zod.z.number().optional()
+});
+var healthCheck = import_zod.z.object({
+  /** Overall system health status */
+  status: import_zod.z.enum(["healthy", "degraded", "unhealthy"]),
+  /** Health check timestamp */
+  timestamp: import_zod.z.string().datetime(),
+  /** API version */
+  version: import_zod.z.string(),
+  /** System uptime in seconds */
+  uptime: import_zod.z.number(),
+  /** Individual service health checks */
+  checks: import_zod.z.object({}).catchall(serviceCheck)
+});
+var searchRequest = import_zod.z.object({
+  /** Search query */
+  query: import_zod.z.string().min(1),
+  /** Content filtering mode (defaults to unified) */
+  mode: import_zod.z.enum(["unified", "content", "facts"]).optional(),
+  /** Search algorithm: hybrid (combined, default), semantic (vector), or keyword (fulltext). */
+  searchMethod: import_zod.z.enum(["keyword", "semantic", "hybrid"]).optional(),
+  /** Maximum number of results (defaults to 20) */
+  limit: import_zod.z.number().min(1).max(100).optional(),
+  /** Offset for pagination (defaults to 0) */
+  offset: import_zod.z.number().min(0).optional(),
+  /** Weight for vector (semantic) results in hybrid search (0-1, defaults to 0.7) */
+  vectorWeight: import_zod.z.number().min(0).max(1).optional(),
+  /** Weight for fulltext (keyword) results in hybrid search (0-1, defaults to 0.3) */
+  fulltextWeight: import_zod.z.number().min(0).max(1).optional(),
+  /** Minimum similarity threshold for semantic search (0-1, defaults to 0.5) */
+  threshold: import_zod.z.number().min(0).max(1).optional(),
+  /** If true, include detailed explanation of how each result was matched */
+  explain: import_zod.z.boolean().optional(),
+  /** Point-in-time query: show what the system knew at this time (ISO 8601 format) */
+  asOfTime: import_zod.z.string().datetime().optional(),
+  /** Validity query: show facts that were valid at this time (ISO 8601 format) */
+  validAtTime: import_zod.z.string().datetime().optional(),
+  /** Event time range start (ISO 8601 format) */
+  eventTimeFrom: import_zod.z.string().datetime().optional(),
+  /** Event time range end (ISO 8601 format) */
+  eventTimeTo: import_zod.z.string().datetime().optional(),
+  /** Ingestion time range start (ISO 8601 format) */
+  ingestionTimeFrom: import_zod.z.string().datetime().optional(),
+  /** Ingestion time range end (ISO 8601 format) */
+  ingestionTimeTo: import_zod.z.string().datetime().optional(),
+  /** Include expired facts (defaults to false) */
+  includeExpired: import_zod.z.boolean().optional(),
+  /** Temporal query mode: 'current' (only valid now), 'historical' (as of a point in time), 'evolution' (chronological) */
+  temporalMode: import_zod.z.enum(["current", "historical", "evolution"]).optional(),
+  /** Filter by topics - returns memories that have ANY of the specified topics */
+  topics: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Filter by memory type */
+  memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]).optional(),
+  /** Filter by conversation ID */
+  conversationId: import_zod.z.string().optional(),
+  /** Include topics associated with matched memories (defaults to false for performance) */
+  includeTopics: import_zod.z.boolean().optional(),
+  /** Include entities mentioned in matched memories (defaults to false for performance) */
+  includeEntities: import_zod.z.boolean().optional()
+});
+var entity = import_zod.z.object({
+  /** Entity name */
+  name: import_zod.z.string().optional(),
+  /** Entity type */
+  type: import_zod.z.string().optional()
+});
+var topicReference = import_zod.z.object({
+  /** Topic unique identifier */
+  id: import_zod.z.string().uuid(),
+  /** Topic name */
+  name: import_zod.z.string(),
+  /** When the topic was created */
+  createdAt: import_zod.z.string().datetime().optional()
+});
+var searchResult = import_zod.z.lazy(() => import_zod.z.object({
+  memory: import_zod.z.object({
+    /** Unique memory identifier */
+    id: import_zod.z.string(),
+    /** Memory content */
+    content: import_zod.z.string(),
+    /** Type of memory */
+    memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]),
+    /** Context or domain of the memory */
+    context: import_zod.z.string().optional(),
+    /** Associated topics */
+    topics: import_zod.z.array(import_zod.z.string()).optional(),
+    /** System ingestion timestamp (when the system learned about this) */
+    timestamp: import_zod.z.string().datetime().optional(),
+    /** Event time (when the event actually occurred in reality) */
+    eventTime: import_zod.z.string().datetime().optional(),
+    /** Validity start time (when this fact becomes valid) */
+    validFrom: import_zod.z.string().datetime().optional(),
+    /** Validity end time (when this fact expires, null means never expires) */
+    validTo: import_zod.z.string().datetime().nullable().optional(),
+    /** Creation timestamp */
+    createdAt: import_zod.z.string().datetime(),
+    /** Last update timestamp */
+    updatedAt: import_zod.z.string().datetime(),
+    /** Confidence score (0-1) for this memory's accuracy */
+    confidenceScore: import_zod.z.number().min(0).max(1).optional(),
+    /** Basis for the confidence score */
+    confidenceBasis: import_zod.z.enum(["direct-statement", "repeated-mention", "single-mention", "hedged", "inference", "external-source", "contradicted"]).optional(),
+    /** Effective state of the memory in the narrative */
+    effectiveState: import_zod.z.enum(["current", "superseded", "contradicted"]).optional()
+  }),
+  /** Relevance score for this result */
+  score: import_zod.z.number(),
+  /** Entities mentioned in this memory */
+  entities: import_zod.z.array(entity).optional(),
+  /** Topics associated with this memory */
+  topics: import_zod.z.array(topicReference).optional(),
+  /** Search method used to find this result */
+  searchMethod: import_zod.z.string().optional(),
+  /** Combined RRF score for hybrid search */
+  hybridScore: import_zod.z.number().optional(),
+  /** Vector similarity score (0-1) */
+  vectorScore: import_zod.z.number().optional(),
+  /** Rank in vector search results */
+  vectorRank: import_zod.z.number().nullable().optional(),
+  /** Fulltext search score */
+  fulltextScore: import_zod.z.number().optional(),
+  /** Rank in fulltext search results */
+  fulltextRank: import_zod.z.number().nullable().optional(),
+  /** Detailed explanation of the match (only when explain=true) */
+  explanation: import_zod.z.object({
+    /** Human-readable explanation of why this result matched */
+    matchReason: import_zod.z.string(),
+    /** Terms from the query that matched (for keyword search) */
+    matchedTerms: import_zod.z.array(import_zod.z.string()).optional(),
+    /** Cosine similarity score for semantic match (0-1) */
+    semanticSimilarity: import_zod.z.number().optional(),
+    /** Factors that contributed to the match */
+    contributingFactors: import_zod.z.array(import_zod.z.string()).optional()
+  }).optional()
+}));
+var temporalMetadata = import_zod.z.object({
+  /** Temporal query mode used */
+  temporalMode: import_zod.z.string(),
+  /** Point-in-time timestamp */
+  asOfTime: import_zod.z.string().datetime().nullable(),
+  /** Validity timestamp */
+  validAtTime: import_zod.z.string().datetime().nullable(),
+  /** Event time range filter */
+  eventTimeRange: import_zod.z.object({
+    from: import_zod.z.string().datetime().nullable(),
+    to: import_zod.z.string().datetime().nullable()
+  }).nullable(),
+  /** Ingestion time range filter */
+  ingestionTimeRange: import_zod.z.object({
+    from: import_zod.z.string().datetime().nullable(),
+    to: import_zod.z.string().datetime().nullable()
+  }).nullable(),
+  /** Whether expired facts are included */
+  includeExpired: import_zod.z.boolean(),
+  /** Whether temporal fields are included in results */
+  temporalFieldsIncluded: import_zod.z.boolean()
+}).nullable();
+var searchResponse = import_zod.z.lazy(() => import_zod.z.object({
+  /** Search results with metadata */
+  data: import_zod.z.array(searchResult),
+  /** Search method used for this query */
+  searchMethod: import_zod.z.string().optional(),
+  pagination: import_zod.z.object({
+    /** Maximum number of items per page */
+    limit: import_zod.z.number().min(1),
+    /** Number of items to skip */
+    offset: import_zod.z.number().min(0),
+    /** Total number of items */
+    count: import_zod.z.number().min(0)
+  }),
+  /** Temporal query metadata (null for semantic/hybrid search) */
+  temporalMetadata
+}));
+var fact = import_zod.z.object({
+  /** Unique identifier for the fact */
+  id: import_zod.z.string(),
+  /** User ID who owns this fact */
+  userId: import_zod.z.string(),
+  /** Fact name/label */
+  name: import_zod.z.string(),
+  /** Entity type */
+  type: import_zod.z.string(),
+  /** Fact description */
+  description: import_zod.z.string().nullable().optional(),
+  /** Confidence score (0-1) */
+  confidence: import_zod.z.number().min(0).max(1).optional(),
+  /** Creation timestamp */
+  createdAt: import_zod.z.string().datetime(),
+  /** Last update timestamp */
+  updatedAt: import_zod.z.string().datetime()
+});
+var createFactRequest = import_zod.z.object({
+  /** Fact subject (entity name) */
+  subject: import_zod.z.string().min(1),
+  /** Relationship type */
+  predicate: import_zod.z.string().min(1),
+  /** Fact object (related entity) */
+  object: import_zod.z.string().min(1)
+});
+var updateFactRequest = import_zod.z.object({
+  /** Fact subject (entity name) */
+  subject: import_zod.z.string().min(1).optional(),
+  /** Relationship type */
+  predicate: import_zod.z.string().min(1).optional(),
+  /** Fact object (related entity) */
+  object: import_zod.z.string().min(1).optional(),
+  /** Confidence score (0-1) */
+  confidence: import_zod.z.number().min(0).max(1).optional()
+});
+var factSearchRequest = import_zod.z.object({
+  /** Search query string */
+  query: import_zod.z.string().min(1),
+  /** Maximum number of results to return */
+  limit: import_zod.z.number().min(1).max(100).optional()
+});
+var artifact = import_zod.z.object({
+  /** Unique identifier for the artifact */
+  id: import_zod.z.string(),
+  /** User ID who owns this artifact */
+  userId: import_zod.z.string(),
+  /** Artifact content */
+  content: import_zod.z.string(),
+  /** Artifact type (e.g., note, document, code) */
+  type: import_zod.z.string(),
+  /** Artifact name */
+  name: import_zod.z.string().nullable().optional(),
+  /** Artifact description */
+  description: import_zod.z.string().nullable().optional(),
+  /** Associated memory ID */
+  memoryId: import_zod.z.string().nullable().optional(),
+  /** Associated conversation ID */
+  conversationId: import_zod.z.string().nullable().optional(),
+  /** Additional metadata */
+  metadata: import_zod.z.object({}).optional(),
+  /** Creation timestamp */
+  createdAt: import_zod.z.string().datetime(),
+  /** Last update timestamp */
+  updatedAt: import_zod.z.string().datetime()
+});
+var createArtifactRequest = import_zod.z.object({
+  /** Artifact content */
+  content: import_zod.z.string().min(1),
+  /** Artifact type (e.g., note, document, code) */
+  type: import_zod.z.string().min(1),
+  /** Artifact name */
+  name: import_zod.z.string().optional(),
+  /** Artifact description */
+  description: import_zod.z.string().optional(),
+  /** Associated memory ID */
+  memoryId: import_zod.z.string().optional(),
+  /** Associated conversation ID */
+  conversationId: import_zod.z.string().optional(),
+  /** Additional metadata */
+  metadata: import_zod.z.object({}).optional()
+});
+var updateArtifactRequest = import_zod.z.object({
+  /** Artifact content */
+  content: import_zod.z.string().min(1).optional(),
+  /** Artifact type (e.g., note, document, code) */
+  type: import_zod.z.string().min(1).optional(),
+  /** Artifact name */
+  name: import_zod.z.string().optional(),
+  /** Artifact description */
+  description: import_zod.z.string().optional(),
+  /** Additional metadata */
+  metadata: import_zod.z.object({}).optional()
+});
+var community = import_zod.z.object({
+  /** Unique identifier for the community */
+  id: import_zod.z.string(),
+  /** Community name */
+  name: import_zod.z.string(),
+  /** Community description */
+  description: import_zod.z.string().nullable().optional(),
+  /** Number of topics in this community */
+  topicCount: import_zod.z.number().min(0).optional(),
+  /** Creation timestamp */
+  createdAt: import_zod.z.string().datetime(),
+  /** Last update timestamp */
+  updatedAt: import_zod.z.string().datetime()
+});
+var mergeCommunitiesRequest = import_zod.z.object({
+  /** Source community ID to merge from */
+  sourceCommunityId: import_zod.z.string().min(1),
+  /** Target community ID to merge into */
+  targetCommunityId: import_zod.z.string().min(1)
+});
+var memoryRelationship = import_zod.z.object({
+  /** Unique relationship identifier */
+  id: import_zod.z.string(),
+  /** ID of the source memory (the memory that has the relationship) */
+  sourceMemoryId: import_zod.z.string(),
+  /** ID of the target memory (the memory being related to) */
+  targetMemoryId: import_zod.z.string(),
+  /** Type of relationship between memories */
+  type: import_zod.z.enum(["SUPERSEDES", "FOLLOWS", "RESOLVES", "CONTRADICTS", "REFERENCES"]),
+  /** Confidence score for the relationship (0-1) */
+  confidence: import_zod.z.number().min(0).max(1),
+  /** How the relationship was created */
+  creationMethod: import_zod.z.enum(["manual", "auto-semantic", "auto-temporal"]),
+  /** Human-readable explanation for why this relationship exists */
+  reason: import_zod.z.string().optional(),
+  /** When the relationship was created */
+  createdAt: import_zod.z.string().datetime()
+});
+var createMemoryRelationshipRequest = import_zod.z.object({
+  /** ID of the target memory to create a relationship with */
+  targetMemoryId: import_zod.z.string().min(1),
+  /** Type of relationship between memories */
+  type: import_zod.z.enum(["SUPERSEDES", "FOLLOWS", "RESOLVES", "CONTRADICTS", "REFERENCES"]),
+  /** Confidence score for the relationship (0-1, defaults to 1.0 for manual) */
+  confidence: import_zod.z.number().min(0).max(1).optional(),
+  /** Optional explanation for the relationship */
+  reason: import_zod.z.string().optional()
+});
+var memoryRelationshipsResponse = import_zod.z.lazy(() => import_zod.z.object({
+  data: import_zod.z.array(memoryRelationship),
+  /** The source memory ID these relationships are for */
+  sourceMemoryId: import_zod.z.string(),
+  /** Direction of relationships returned */
+  direction: import_zod.z.enum(["outgoing", "incoming", "both"])
+}));
+var narrativeThread = import_zod.z.object({
+  /** Unique narrative thread identifier */
+  id: import_zod.z.string(),
+  /** User ID who owns this narrative */
+  userId: import_zod.z.string(),
+  /** Title describing the narrative thread */
+  title: import_zod.z.string(),
+  /** Current state of the narrative thread */
+  state: import_zod.z.enum(["open", "resolved", "reopened", "superseded"]),
+  /** ID of the first memory in this narrative */
+  rootMemoryId: import_zod.z.string(),
+  /** ID of the most recent memory in this narrative */
+  currentMemoryId: import_zod.z.string().optional(),
+  /** ID of the memory that resolved this narrative (if resolved) */
+  resolutionMemoryId: import_zod.z.string().optional(),
+  /** Topics associated with this narrative */
+  topics: import_zod.z.array(import_zod.z.string()),
+  /** Number of memories in this narrative */
+  memoryCount: import_zod.z.number().min(0),
+  /** When the narrative was created */
+  createdAt: import_zod.z.string().datetime(),
+  /** When the narrative was last updated */
+  updatedAt: import_zod.z.string().datetime()
+});
+var createNarrativeRequest = import_zod.z.object({
+  /** Title for the narrative thread */
+  title: import_zod.z.string().min(1),
+  /** ID of the first memory in this narrative */
+  rootMemoryId: import_zod.z.string().min(1),
+  /** Topics to associate with this narrative */
+  topics: import_zod.z.array(import_zod.z.string()).optional()
+});
+var updateNarrativeRequest = import_zod.z.object({
+  /** Updated title for the narrative */
+  title: import_zod.z.string().min(1).optional(),
+  /** Current state of the narrative thread */
+  state: import_zod.z.enum(["open", "resolved", "reopened", "superseded"]).optional(),
+  /** ID of the memory that resolves this narrative */
+  resolutionMemoryId: import_zod.z.string().optional(),
+  /** Updated topics for the narrative */
+  topics: import_zod.z.array(import_zod.z.string()).optional()
+});
+var addMemoryToNarrativeRequest = import_zod.z.object({
+  /** ID of the memory to add to the narrative */
+  memoryId: import_zod.z.string().min(1),
+  /** Position in the narrative (0-indexed, omit for append) */
+  position: import_zod.z.number().min(0).optional()
+});
+var narrativeMemory = import_zod.z.object({
+  memory: import_zod.z.object({
+    /** Unique memory identifier */
+    id: import_zod.z.string(),
+    /** Memory content */
+    content: import_zod.z.string(),
+    /** Type of memory */
+    memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]),
+    /** Context or domain of the memory */
+    context: import_zod.z.string().optional(),
+    /** Associated topics */
+    topics: import_zod.z.array(import_zod.z.string()).optional(),
+    /** System ingestion timestamp (when the system learned about this) */
+    timestamp: import_zod.z.string().datetime().optional(),
+    /** Event time (when the event actually occurred in reality) */
+    eventTime: import_zod.z.string().datetime().optional(),
+    /** Validity start time (when this fact becomes valid) */
+    validFrom: import_zod.z.string().datetime().optional(),
+    /** Validity end time (when this fact expires, null means never expires) */
+    validTo: import_zod.z.string().datetime().nullable().optional(),
+    /** Creation timestamp */
+    createdAt: import_zod.z.string().datetime(),
+    /** Last update timestamp */
+    updatedAt: import_zod.z.string().datetime(),
+    /** Confidence score (0-1) for this memory's accuracy */
+    confidenceScore: import_zod.z.number().min(0).max(1).optional(),
+    /** Basis for the confidence score */
+    confidenceBasis: import_zod.z.enum(["direct-statement", "repeated-mention", "single-mention", "hedged", "inference", "external-source", "contradicted"]).optional(),
+    /** Effective state of the memory in the narrative */
+    effectiveState: import_zod.z.enum(["current", "superseded", "contradicted"]).optional()
+  }),
+  /** Position of this memory in the narrative (0-indexed) */
+  position: import_zod.z.number().min(0),
+  /** Effective state of this memory in the narrative context */
+  effectiveState: import_zod.z.enum(["current", "superseded", "contradicted"]).optional()
+});
+var narrativeTimelineResponse = import_zod.z.lazy(() => import_zod.z.object({
+  data: import_zod.z.array(narrativeMemory),
+  narrative: narrativeThread,
+  pagination: import_zod.z.object({
+    limit: import_zod.z.number(),
+    offset: import_zod.z.number(),
+    total: import_zod.z.number()
+  })
+}));
+var getNarrativeResponse = import_zod.z.lazy(() => import_zod.z.object({
+  data: narrativeThread
+}));
+var listNarrativesResponse = import_zod.z.lazy(() => import_zod.z.object({
+  data: import_zod.z.array(narrativeThread),
+  pagination: import_zod.z.object({
+    limit: import_zod.z.number(),
+    offset: import_zod.z.number(),
+    count: import_zod.z.number()
+  })
+}));
+var user = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  email: import_zod.z.string().email(),
+  firstName: import_zod.z.string().nullable(),
+  lastName: import_zod.z.string().nullable(),
+  profilePictureUrl: import_zod.z.string().url().nullable(),
+  plan: import_zod.z.enum(["free", "pro", "enterprise"]),
+  memoryLimit: import_zod.z.number(),
+  retentionDays: import_zod.z.number().nullable(),
+  createdAt: import_zod.z.string().datetime(),
+  updatedAt: import_zod.z.string().datetime()
+});
+var userUsage = import_zod.z.object({
+  memoriesUsed: import_zod.z.number(),
+  memoryLimit: import_zod.z.number(),
+  memoriesRemaining: import_zod.z.number(),
+  percentUsed: import_zod.z.number(),
+  plan: import_zod.z.enum(["free", "pro", "enterprise"]),
+  periodStart: import_zod.z.string().datetime(),
+  periodEnd: import_zod.z.string().datetime()
+});
+
+// src/index.ts
+var Memnexus = class {
+  config;
+  /** API key management endpoints operations */
+  apiKeys;
+  /** Artifact storage and retrieval endpoints operations */
+  artifacts;
+  /** Conversation tracking and analysis endpoints operations */
+  conversations;
+  /** Fact extraction and management endpoints operations */
+  facts;
+  /** Graph-based retrieval augmented generation endpoints operations */
+  graphrag;
+  /** Health check endpoints operations */
+  health;
+  /** Memory management and retrieval endpoints operations */
+  memories;
+  /** Narrative thread management endpoints operations */
+  narratives;
+  /** System health, monitoring, and configuration endpoints operations */
+  system;
+  /** Pattern detection and behavioral analysis endpoints operations */
+  patterns;
+  /** Behavioral pattern tracking and state management endpoints operations */
+  behavior;
+  /** Topic detection, clustering, and management endpoints operations */
+  topics;
+  /** Topic community detection and management endpoints operations */
+  communities;
+  /** User management and profile endpoints operations */
+  users;
+  /**
+   * Create a new SDK client.
+   * @param config - SDK configuration
+   */
+  constructor(config = {}) {
+    this.config = {
+      baseUrl: config.baseUrl || "http://localhost:3000",
+      ...config
+    };
+    this.apiKeys = new ApiKeysService(this.config);
+    this.artifacts = new ArtifactsService(this.config);
+    this.conversations = new ConversationsService(this.config);
+    this.facts = new FactsService(this.config);
+    this.graphrag = new GraphragService(this.config);
+    this.health = new HealthService(this.config);
+    this.memories = new MemoriesService(this.config);
+    this.narratives = new NarrativesService(this.config);
+    this.system = new SystemService(this.config);
+    this.patterns = new PatternsService(this.config);
+    this.behavior = new BehaviorService(this.config);
+    this.topics = new TopicsService(this.config);
+    this.communities = new CommunitiesService(this.config);
+    this.users = new UsersService(this.config);
+  }
+  /**
+   * Set the API token for authentication.
+   * @param token - Bearer token
+   */
+  setToken(token) {
+    this.config.token = token;
+    this.apiKeys.token = token;
+    this.artifacts.token = token;
+    this.conversations.token = token;
+    this.facts.token = token;
+    this.graphrag.token = token;
+    this.health.token = token;
+    this.memories.token = token;
+    this.narratives.token = token;
+    this.system.token = token;
+    this.patterns.token = token;
+    this.behavior.token = token;
+    this.topics.token = token;
+    this.communities.token = token;
+    this.users.token = token;
+  }
+  /**
+   * Set the base URL for API requests.
+   * @param baseUrl - API base URL
+   */
+  setBaseUrl(baseUrl) {
+    this.config.baseUrl = baseUrl;
+    this.apiKeys.baseUrl = baseUrl;
+    this.artifacts.baseUrl = baseUrl;
+    this.conversations.baseUrl = baseUrl;
+    this.facts.baseUrl = baseUrl;
+    this.graphrag.baseUrl = baseUrl;
+    this.health.baseUrl = baseUrl;
+    this.memories.baseUrl = baseUrl;
+    this.narratives.baseUrl = baseUrl;
+    this.system.baseUrl = baseUrl;
+    this.patterns.baseUrl = baseUrl;
+    this.behavior.baseUrl = baseUrl;
+    this.topics.baseUrl = baseUrl;
+    this.communities.baseUrl = baseUrl;
+    this.users.baseUrl = baseUrl;
+  }
+  /**
+   * Set the environment.
+   * @param environment - API environment
+   */
+  setEnvironment(environment) {
+    this.config.environment = environment;
+    this.apiKeys.environment = environment;
+    this.artifacts.environment = environment;
+    this.conversations.environment = environment;
+    this.facts.environment = environment;
+    this.graphrag.environment = environment;
+    this.health.environment = environment;
+    this.memories.environment = environment;
+    this.narratives.environment = environment;
+    this.system.environment = environment;
+    this.patterns.environment = environment;
+    this.behavior.environment = environment;
+    this.topics.environment = environment;
+    this.communities.environment = environment;
+    this.users.environment = environment;
+  }
+};
+var index_default = Memnexus;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiKeysService,
+  ArtifactsService,
+  BehaviorService,
+  CommunitiesService,
+  ContentType,
+  ConversationsService,
+  Environment,
+  FactsService,
+  GraphragService,
+  HealthService,
+  Memnexus,
+  MemoriesService,
+  NarrativesService,
+  PatternsService,
+  SerializationStyle,
+  SystemService,
+  TopicsService,
+  UsersService,
+  addMemoryToNarrativeRequest,
+  apiKey,
+  artifact,
+  community,
+  conversation,
+  createArtifactRequest,
+  createConversationRequest,
+  createFactRequest,
+  createMemoryRelationshipRequest,
+  createMemoryRequest,
+  createMemoryResponse,
+  createMemoryResponseMeta,
+  createNarrativeRequest,
+  entity,
+  error,
+  fact,
+  factSearchRequest,
+  getMemoryResponse,
+  getNarrativeResponse,
+  graphRAGQueryRequest,
+  graphRAGQueryResponse,
+  healthCheck,
+  listNarrativesResponse,
+  memory,
+  memoryRelationship,
+  memoryRelationshipsResponse,
+  mergeCommunitiesRequest,
+  narrativeMemory,
+  narrativeThread,
+  narrativeTimelineResponse,
+  pagination,
+  pattern,
+  relatedMemoryResult,
+  searchRequest,
+  searchResponse,
+  searchResult,
+  serviceCheck,
+  temporalMetadata,
+  topic,
+  topicReference,
+  updateArtifactRequest,
+  updateFactRequest,
+  updateMemoryRequest,
+  updateNarrativeRequest,
+  user,
+  userUsage
+});
+//# sourceMappingURL=index.cjs.map