@memnexus-ai/typescript-sdk 1.6.1 → 1.6.2

package/dist/index.d.ts

@@ -1,68 +1,178 @@
 import { ZodType, z } from 'zod';
 
+/**
+ * Available API environments with their base URLs.
+ * Use these constants to configure the SDK for different environments (production, staging, etc.).
+ */
 declare enum Environment {
+    /** DEFAULT environment base URL */
     DEFAULT = "http://localhost:3000"
 }
 
+/**
+ * Standard HTTP methods supported by the SDK.
+ */
 type HttpMethod$1 = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+/**
+ * Represents an HTTP request with all its components.
+ */
 interface HttpRequest {
+    /** Base URL of the API endpoint */
     baseUrl: string;
+    /** HTTP method for the request */
     method: HttpMethod$1;
+    /** Request path (relative to base URL) */
     path: string;
+    /** Request headers as key-value pairs */
     headers: Map<string, unknown>;
+    /** Request body payload (optional) */
     body?: BodyInit;
+    /** Signal to abort the request (optional) */
     abortSignal?: AbortSignal;
+    /** Query string parameters */
     queryParams: Map<string, unknown>;
+    /** Path parameters for URL templating */
     pathParams: Map<string, unknown>;
 }
+/**
+ * Metadata about an HTTP response.
+ */
 interface HttpMetadata$1 {
+    /** HTTP status code */
     status: number;
+    /** HTTP status text message */
     statusText: string;
+    /** Response headers as key-value pairs */
     headers: Record<string, string>;
 }
+/**
+ * Represents an HTTP response with typed data.
+ * @template T - The type of the response data
+ */
 interface HttpResponse$1<T> {
+    /** Parsed response data (optional) */
     data?: T;
+    /** Response metadata (status, headers, etc.) */
     metadata: HttpMetadata$1;
+    /** Raw response object from the HTTP client */
     raw: ArrayBuffer;
 }
+/**
+ * Represents an HTTP error response.
+ */
 interface HttpError$1 {
+    /** Error message or description */
     error: string;
+    /** Response metadata (status, headers, etc.) */
     metadata: HttpMetadata$1;
 }
+/**
+ * Hook interface for intercepting and modifying HTTP requests and responses.
+ * Allows custom logic to be executed at different stages of the request lifecycle.
+ */
 interface Hook {
+    /**
+     * Called before an HTTP request is sent.
+     * Allows modification of the request before execution.
+     * @param request - The HTTP request to be sent
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to the potentially modified request
+     */
     beforeRequest(request: HttpRequest, params: Map<string, string>): Promise<HttpRequest>;
+    /**
+     * Called after a successful HTTP response is received.
+     * Allows processing or modification of the response.
+     * @param request - The original HTTP request
+     * @param response - The HTTP response received
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to the potentially modified response
+     */
     afterResponse(request: HttpRequest, response: HttpResponse$1<any>, params: Map<string, string>): Promise<HttpResponse$1<any>>;
+    /**
+     * Called when an HTTP request results in an error.
+     * Allows custom error handling and transformation.
+     * @param request - The original HTTP request
+     * @param response - The error response received
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to an error object
+     */
     onError(request: HttpRequest, response: HttpResponse$1<any>, params: Map<string, string>): Promise<HttpError$1>;
 }
 
+/**
+ * OpenAPI parameter serialization styles.
+ * Defines how parameters should be formatted in the request.
+ */
 declare enum SerializationStyle {
+    /** Simple comma-separated values (e.g., "3,4,5") */
     SIMPLE = "simple",
+    /** Label prefix with dot notation (e.g., ".3.4.5") */
     LABEL = "label",
+    /** Matrix semicolon-prefixed (e.g., ";id=3;id=4") */
     MATRIX = "matrix",
+    /** Form-style ampersand-separated (e.g., "id=3&id=4") */
     FORM = "form",
+    /** Space-delimited values (e.g., "id=3 4 5") */
     SPACE_DELIMITED = "space_delimited",
+    /** Pipe-delimited values (e.g., "id=3|4|5") */
     PIPE_DELIMITED = "pipe_delimited",
+    /** Deep object notation (e.g., "id[role]=admin") */
     DEEP_OBJECT = "deep_object",
+    /** No specific style applied */
     NONE = "none"
 }
 
+/**
+ * Error class that can be thrown explicitly via a throw() method.
+ * Extends the built-in Error class with a convenience method for throwing.
+ */
 declare class ThrowableError extends Error {
     message: string;
     protected response?: unknown;
+    /**
+     * Creates a new throwable error.
+     * @param message - The error message
+     * @param response - Optional response data associated with the error
+     */
     constructor(message: string, response?: unknown);
+    /**
+     * Throws this error instance.
+     * Convenience method for explicitly throwing the error.
+     * @throws This error instance
+     */
     throw(): void;
 }
 
+/**
+ * Defines an expected response format with schema validation.
+ * Used to match and validate responses based on content type and status code.
+ */
 interface ResponseDefinition {
+    /** Zod schema for validating the response body */
     schema: ZodType;
+    /** The content type of this response (e.g., 'application/json') */
     contentType: ContentType;
+    /** The HTTP status code this definition applies to */
     status: number;
 }
+/**
+ * Defines an error response format with custom error class.
+ * Used to throw typed errors based on content type and status code.
+ */
 interface ErrorDefinition {
+    /** Constructor for the error class to instantiate */
     error: new (...args: any[]) => ThrowableError;
+    /** The content type of this error response */
     contentType: ContentType;
+    /** The HTTP status code this error applies to */
     status: number;
 }
+/**
+ * Parameters required to create a Request instance.
+ * Contains all configuration needed for HTTP execution, validation, and error handling.
+ *
+ * @template Page - The type of paginated data items
+ */
 interface CreateRequestParameters<Page = unknown[]> {
     baseUrl: string;
     method: HttpMethod;
@@ -70,6 +180,7 @@ interface CreateRequestParameters<Page = unknown[]> {
     headers: Map<string, RequestParameter>;
     queryParams: Map<string, RequestParameter>;
     pathParams: Map<string, RequestParameter>;
+    cookies: Map<string, RequestParameter>;
     path: string;
     config: SdkConfig;
     responses: ResponseDefinition[];
@@ -82,33 +193,72 @@ interface CreateRequestParameters<Page = unknown[]> {
     filename?: string;
     filenames?: string[];
 }
+/**
+ * Represents a request parameter with serialization metadata.
+ * Wraps a value with OpenAPI serialization instructions for proper encoding.
+ */
 interface RequestParameter {
+    /** The parameter name (may be undefined for path substitution) */
     key: string | undefined;
+    /** The actual parameter value */
     value: unknown;
+    /** Whether to explode arrays/objects into multiple parameters */
     explode: boolean;
+    /** Whether to URL-encode the value */
     encode: boolean;
+    /** The OpenAPI serialization style (e.g., SIMPLE, FORM, MATRIX) */
     style: SerializationStyle;
+    /** Whether this parameter is a pagination limit */
     isLimit: boolean;
+    /** Whether this parameter is a pagination offset */
     isOffset: boolean;
+    /** Whether this parameter is a pagination cursor */
     isCursor: boolean;
 }
+/**
+ * Configuration for limit-offset pagination.
+ * Used for traditional page-based pagination with size and offset.
+ *
+ * @template Page - The type of page data
+ */
 interface RequestPagination<Page> {
+    /** The number of items per page */
     pageSize?: number;
+    /** JSON path to extract page data from response */
     pagePath: string[];
+    /** Zod schema for validating page data */
     pageSchema?: ZodType<Page, any, any>;
 }
+/**
+ * Configuration for cursor-based pagination.
+ * Used for stateless pagination with cursor tokens.
+ *
+ * @template Page - The type of page data
+ */
 interface RequestCursorPagination<Page> {
+    /** JSON path to extract page data from response */
     pagePath: string[];
+    /** Zod schema for validating page data */
     pageSchema?: ZodType<Page, any, any>;
+    /** JSON path to extract next cursor from response */
     cursorPath: string[];
+    /** Zod schema for validating cursor value */
     cursorSchema?: ZodType<string | null | undefined>;
 }
 
+/**
+ * Represents an HTTP request with all necessary configuration and parameters.
+ * Handles path/query/header/cookie serialization, pagination, validation, and retry logic.
+ * This is the core request object passed through the handler chain for execution.
+ *
+ * @template PageSchema - The type of paginated data returned by this request
+ */
 declare class Request<PageSchema = unknown[]> {
     baseUrl: string;
     headers: Map<string, RequestParameter>;
     queryParams: Map<string, RequestParameter>;
     pathParams: Map<string, RequestParameter>;
+    cookies: Map<string, RequestParameter>;
     body?: any;
     method: HttpMethod;
     path: string;
@@ -124,14 +274,73 @@ declare class Request<PageSchema = unknown[]> {
     filenames?: string[];
     private readonly pathPattern;
     constructor(params: CreateRequestParameters<PageSchema>);
+    /**
+     * Adds a header parameter to the request with OpenAPI serialization rules.
+     *
+     * @param key - The header name
+     * @param param - The parameter configuration including value, style, and encoding options
+     */
     addHeaderParam(key: string, param: RequestParameter): void;
+    /**
+     * Adds a query parameter to the request with OpenAPI serialization rules.
+     *
+     * @param key - The query parameter name
+     * @param param - The parameter configuration including value, style, and encoding options
+     */
     addQueryParam(key: string, param: RequestParameter): void;
+    /**
+     * Adds a path parameter to the request with OpenAPI serialization rules.
+     *
+     * @param key - The path parameter name (matches template variable in path pattern)
+     * @param param - The parameter configuration including value, style, and encoding options
+     */
     addPathParam(key: string, param: RequestParameter): void;
+    /**
+     * Sets the request body if the value is defined.
+     *
+     * @param body - The request body to send
+     */
     addBody(body: any): void;
+    /**
+     * Updates this request from a modified hook request.
+     * Used after hooks modify the request to sync changes back to the internal Request object.
+     *
+     * @param hookRequest - The modified request from hook processing
+     */
     updateFromHookRequest(hookRequest: HttpRequest): void;
+    /**
+     * Constructs the complete URL by combining base URL, path with substituted parameters,
+     * and serialized query string.
+     *
+     * @returns The fully constructed URL ready for HTTP execution
+     */
     constructFullUrl(): string;
+    /**
+     * Creates a copy of this request with optional parameter overrides.
+     * Useful for pagination where you need to modify parameters while keeping the rest intact.
+     *
+     * @param overrides - Optional parameters to override in the copied request
+     * @returns A new Request instance with the specified overrides
+     */
     copy(overrides?: Partial<CreateRequestParameters>): Request<unknown[]>;
+    /**
+     * Serializes headers to a format suitable for HTTP execution.
+     *
+     * @returns Serialized headers as HeadersInit, or undefined if no headers
+     */
     getHeaders(): HeadersInit | undefined;
+    /**
+     * Serializes cookies to a format suitable for HTTP execution.
+     *
+     * @returns Serialized cookies as a record, or undefined if no cookies
+     */
+    getCookies(): Record<string, string> | undefined;
+    /**
+     * Advances pagination parameters to fetch the next page.
+     * Handles both cursor-based and limit-offset pagination strategies.
+     *
+     * @param cursor - The cursor value for cursor-based pagination (optional for limit-offset)
+     */
     nextPage(cursor?: string): void;
     private constructPath;
     private getOffsetParam;
@@ -139,7 +348,14 @@ declare class Request<PageSchema = unknown[]> {
     private getAllParams;
 }
 
+/**
+ * Standard HTTP methods supported by the SDK.
+ */
 type HttpMethod = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+/**
+ * SDK configuration interface.
+ * Contains all settings required to initialize and configure the SDK.
+ */
 interface SdkConfig {
     baseUrl?: string;
     environment?: Environment;
@@ -148,32 +364,72 @@ interface SdkConfig {
     retry?: RetryOptions;
     validation?: ValidationOptions;
 }
+/**
+ * Metadata about an HTTP response.
+ * Contains status information and headers from the server response.
+ */
 interface HttpMetadata {
+    /** HTTP status code (e.g., 200, 404, 500) */
     status: number;
+    /** HTTP status text message (e.g., "OK", "Not Found") */
     statusText: string;
+    /** Response headers as key-value pairs */
     headers: Record<string, string>;
 }
+/**
+ * Standard HTTP response with typed data.
+ * @template T - The type of the response data
+ */
 interface HttpResponse<T = unknown> {
+    /** Parsed response data (optional) */
     data?: T;
+    /** Response metadata (status, headers, etc.) */
     metadata: HttpMetadata;
+    /** Raw response object from the HTTP client */
     raw: ArrayBuffer;
 }
+/**
+ * HTTP response for paginated API endpoints.
+ * Marker interface extending HttpResponse for type safety with pagination.
+ * @template T - The type of a single page of data
+ */
 interface PaginatedHttpResponse<T = unknown> extends HttpResponse<T> {
 }
+/**
+ * HTTP response for cursor-paginated API endpoints.
+ * Includes a cursor for fetching the next page of results.
+ * @template T - The type of a single page of data
+ */
 interface CursorPaginatedHttpResponse<T = unknown> extends HttpResponse<T> {
+    /** Cursor string for fetching the next page, null if no more pages, undefined if not applicable */
     nextCursor?: string | null;
 }
+/**
+ * Supported content types for HTTP requests and responses.
+ * Determines how the SDK serializes requests and parses responses.
+ */
 declare enum ContentType {
+    /** JSON format (application/json) */
     Json = "json",
+    /** XML format (application/xml, text/xml) */
     Xml = "xml",
+    /** PDF document (application/pdf) */
     Pdf = "pdf",
+    /** Image file (image/*) */
     Image = "image",
+    /** Generic file */
     File = "file",
+    /** Binary data (application/octet-stream) */
     Binary = "binary",
+    /** URL-encoded form data (application/x-www-form-urlencoded) */
     FormUrlEncoded = "form",
+    /** Plain text (text/plain) */
     Text = "text",
+    /** Multipart form data for file uploads (multipart/form-data) */
     MultipartFormData = "multipartFormData",
+    /** Server-sent events stream (text/event-stream) */
     EventStream = "eventStream",
+    /** No content (HTTP 204) */
     NoContent = "noContent"
 }
 interface RequestConfig {
@@ -189,35 +445,143 @@ interface ValidationOptions {
     responseValidation?: boolean;
 }
 
+/**
+ * Error class for HTTP request failures.
+ * Captures error details including status, metadata, and the raw response.
+ */
 declare class HttpError extends Error {
+    /** Error message or status text */
     readonly error: string;
+    /** HTTP response metadata (status, headers, etc.) */
     readonly metadata: HttpMetadata;
+    /** Raw response object from the HTTP client */
     readonly raw?: ArrayBuffer;
+    /**
+     * Creates a new HTTP error.
+     * @param metadata - HTTP response metadata
+     * @param raw - Raw response object (optional)
+     * @param error - Custom error message (optional, defaults to status text)
+     */
     constructor(metadata: HttpMetadata, raw?: ArrayBuffer, error?: string);
 }
 
+/**
+ * Default implementation of the Hook interface that provides pass-through behavior.
+ * This hook can be extended to add custom logic for request/response interception.
+ */
 declare class CustomHook implements Hook {
+    /**
+     * Called before an HTTP request is sent.
+     * Default implementation returns the request unchanged.
+     * @param request - The HTTP request to be sent
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to the unmodified request
+     */
     beforeRequest(request: HttpRequest, params: Map<string, string>): Promise<HttpRequest>;
+    /**
+     * Called after a successful HTTP response is received.
+     * Default implementation returns the response unchanged.
+     * @param request - The original HTTP request
+     * @param response - The HTTP response received
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to the unmodified response
+     */
     afterResponse(request: HttpRequest, response: HttpResponse$1<any>, params: Map<string, string>): Promise<HttpResponse$1<any>>;
+    /**
+     * Called when an HTTP request results in an error.
+     * Default implementation wraps the error response in an HttpError object.
+     * @param request - The original HTTP request
+     * @param response - The error response received
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to an HttpError object
+     */
     onError(request: HttpRequest, response: HttpResponse$1<any>, params: Map<string, string>): Promise<HttpError>;
 }
 
+/**
+ * Core HTTP client for making API requests.
+ * Manages request/response handling through a chain of handlers for validation, retry, hooks, and more.
+ */
 declare class HttpClient {
     private config;
+    /** Chain of request handlers that process requests in sequence */
     private readonly requestHandlerChain;
+    /**
+     * Creates a new HTTP client with configured request handlers.
+     * @param config - SDK configuration including base URL and authentication
+     * @param hook - Optional custom hook for request/response interception
+     */
     constructor(config: SdkConfig, hook?: CustomHook);
+    /**
+     * Executes a standard HTTP request.
+     * @template T - The expected response data type
+     * @param request - The HTTP request to execute
+     * @returns A promise that resolves to the HTTP response
+     */
     call<T>(request: Request): Promise<HttpResponse<T>>;
+    /**
+     * Executes a streaming HTTP request that yields responses incrementally.
+     * @template T - The expected response data type for each chunk
+     * @param request - The HTTP request to execute
+     * @returns An async generator that yields HTTP responses
+     */
     stream<T>(request: Request): AsyncGenerator<HttpResponse<T>>;
+    /**
+     * Executes a paginated HTTP request and extracts the page data from the response.
+     * @template FullResponse - The complete response type from the API
+     * @template Page - The type of a single page of data
+     * @param request - The paginated HTTP request to execute
+     * @returns A promise that resolves to the paginated HTTP response
+     * @throws Error if the response contains no data to paginate through
+     */
     callPaginated<FullResponse, Page>(request: Request<Page>): Promise<PaginatedHttpResponse<Page>>;
+    /**
+     * Executes a cursor-paginated HTTP request and extracts both page data and the next cursor.
+     * @template FullResponse - The complete response type from the API
+     * @template Page - The type of a single page of data
+     * @param request - The cursor-paginated HTTP request to execute
+     * @returns A promise that resolves to the cursor-paginated HTTP response with next cursor
+     * @throws Error if the response contains no data to paginate through
+     */
     callCursorPaginated<FullResponse, Page>(request: Request<Page>): Promise<CursorPaginatedHttpResponse<Page>>;
+    /**
+     * Updates the base URL for all subsequent requests.
+     * @param url - The new base URL to use
+     */
     setBaseUrl(url: string): void;
+    /**
+     * Updates the SDK configuration.
+     * @param config - The new SDK configuration
+     */
     setConfig(config: SdkConfig): void;
+    /**
+     * Extracts page data from a full API response using the configured pagination path.
+     * @template FullResponse - The complete response type from the API
+     * @template Page - The type of a single page of data
+     * @param request - The request containing pagination configuration
+     * @param data - The full response data to extract the page from
+     * @returns The extracted and parsed page data
+     * @throws Error if pagination is not configured or page extraction fails
+     */
     private getPage;
+    /**
+     * Extracts the next cursor from a full API response for cursor-based pagination.
+     * @template FullResponse - The complete response type from the API
+     * @template Page - The type of a single page of data
+     * @param request - The request containing cursor pagination configuration
+     * @param data - The full response data to extract the cursor from
+     * @returns The next cursor string, null if no more pages, or undefined if not cursor pagination
+     */
     private getNextCursor;
 }
 
+/**
+ * Base service class that all API service classes extend.
+ * Provides common functionality including HTTP client management and configuration.
+ */
 declare class BaseService {
     config: SdkConfig;
+    /** The HTTP client instance used to make API requests */
     client: HttpClient;
     constructor(config: SdkConfig);
     set baseUrl(baseUrl: string);
@@ -227,7 +591,43 @@ declare class BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the DebugUserOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const debugUserOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        userId: z.ZodOptional<z.ZodString>;
+        authMethod: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        userId?: string | undefined;
+        authMethod?: string | undefined;
+    }, {
+        userId?: string | undefined;
+        authMethod?: string | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        userId?: string | undefined;
+        authMethod?: string | undefined;
+    } | undefined;
+}, {
+    data?: {
+        userId?: string | undefined;
+        authMethod?: string | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {DebugUserOkResponse} debugUserOkResponse
+ * @property {DebugUserOkResponseData}
+ */
+type DebugUserOkResponse = z.infer<typeof debugUserOkResponse>;
+
+/**
+ * Zod schema for the ListApiKeysOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listApiKeysOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -279,7 +679,9 @@ declare const listApiKeysOkResponse: z.ZodLazy<z.ZodObject<{
 type ListApiKeysOkResponse = z.infer<typeof listApiKeysOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateApiKeyRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createApiKeyRequest: z.ZodLazy<z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
@@ -300,7 +702,9 @@ declare const createApiKeyRequest: z.ZodLazy<z.ZodObject<{
 type CreateApiKeyRequest = z.infer<typeof createApiKeyRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateApiKeyCreatedResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createApiKeyCreatedResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -380,13 +784,18 @@ declare const createApiKeyCreatedResponse: z.ZodLazy<z.ZodObject<{
  */
 type CreateApiKeyCreatedResponse = z.infer<typeof createApiKeyCreatedResponse>;
 
+/**
+ * Service class for ApiKeysService operations.
+ * Provides methods to interact with ApiKeysService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class ApiKeysService extends BaseService {
     /**
      * Debug endpoint to retrieve user ID and authentication method from the current API key
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<DebugUserOkResponse>>} - User information retrieved successfully
      */
-    debugUser(requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    debugUser(requestConfig?: RequestConfig): Promise<HttpResponse<DebugUserOkResponse>>;
     /**
      * List all API keys for the authenticated user
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
@@ -409,7 +818,32 @@ declare class ApiKeysService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the DebugUserOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const debugUserOkResponseData: z.ZodLazy<z.ZodObject<{
+    userId: z.ZodOptional<z.ZodString>;
+    authMethod: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    userId?: string | undefined;
+    authMethod?: string | undefined;
+}, {
+    userId?: string | undefined;
+    authMethod?: string | undefined;
+}>>;
+/**
+ *
+ * @typedef  {DebugUserOkResponseData} debugUserOkResponseData
+ * @property {string}
+ * @property {string}
+ */
+type DebugUserOkResponseData = z.infer<typeof debugUserOkResponseData>;
+
+/**
+ * Zod schema for the ApiKey model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const apiKey: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -446,7 +880,9 @@ declare const apiKey: z.ZodLazy<z.ZodObject<{
 type ApiKey = z.infer<typeof apiKey>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateApiKeyCreatedResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createApiKeyCreatedResponseData: z.ZodLazy<z.ZodObject<{
     apiKey: z.ZodOptional<z.ZodString>;
@@ -502,7 +938,9 @@ declare const createApiKeyCreatedResponseData: z.ZodLazy<z.ZodObject<{
 type CreateApiKeyCreatedResponseData = z.infer<typeof createApiKeyCreatedResponseData>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListArtifactsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listArtifactsOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -511,12 +949,7 @@ declare const listArtifactsOkResponse: z.ZodLazy<z.ZodObject<{
         content: z.ZodString;
         type: z.ZodString;
         name: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        description: z.ZodNullable<z.ZodOptional<z.ZodString>>; /**
-         *
-         * @typedef  {ListArtifactsOkResponse} listArtifactsOkResponse
-         * @property {Artifact[]}
-         * @property {number}
-         */
+        description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         memoryId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         conversationId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         metadata: z.ZodOptional<z.ZodAny>;
@@ -524,9 +957,9 @@ declare const listArtifactsOkResponse: z.ZodLazy<z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -536,9 +969,9 @@ declare const listArtifactsOkResponse: z.ZodLazy<z.ZodObject<{
         metadata?: any;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -551,9 +984,9 @@ declare const listArtifactsOkResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -566,9 +999,9 @@ declare const listArtifactsOkResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -596,7 +1029,9 @@ interface ListArtifactsParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateArtifactRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createArtifactRequest: z.ZodLazy<z.ZodObject<{
     content: z.ZodString;
@@ -637,7 +1072,9 @@ declare const createArtifactRequest: z.ZodLazy<z.ZodObject<{
 type CreateArtifactRequest = z.infer<typeof createArtifactRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateArtifactCreatedResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createArtifactCreatedResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -651,16 +1088,12 @@ declare const createArtifactCreatedResponse: z.ZodLazy<z.ZodObject<{
         conversationId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         metadata: z.ZodOptional<z.ZodAny>;
         createdAt: z.ZodString;
-        /**
-         * The shape of the model mapping from the api schema into the application shape.
-         * Is equal to application shape if all property names match the api schema
-         */
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -670,9 +1103,9 @@ declare const createArtifactCreatedResponse: z.ZodLazy<z.ZodObject<{
         metadata?: any;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -684,9 +1117,9 @@ declare const createArtifactCreatedResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -698,9 +1131,9 @@ declare const createArtifactCreatedResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -718,7 +1151,9 @@ declare const createArtifactCreatedResponse: z.ZodLazy<z.ZodObject<{
 type CreateArtifactCreatedResponse = z.infer<typeof createArtifactCreatedResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetArtifactByIdOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getArtifactByIdOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -735,9 +1170,9 @@ declare const getArtifactByIdOkResponse: z.ZodLazy<z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -747,9 +1182,9 @@ declare const getArtifactByIdOkResponse: z.ZodLazy<z.ZodObject<{
         metadata?: any;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -761,9 +1196,9 @@ declare const getArtifactByIdOkResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -775,9 +1210,9 @@ declare const getArtifactByIdOkResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -795,7 +1230,9 @@ declare const getArtifactByIdOkResponse: z.ZodLazy<z.ZodObject<{
 type GetArtifactByIdOkResponse = z.infer<typeof getArtifactByIdOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the UpdateArtifactRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const updateArtifactRequest: z.ZodLazy<z.ZodObject<{
     content: z.ZodOptional<z.ZodString>;
@@ -828,7 +1265,9 @@ declare const updateArtifactRequest: z.ZodLazy<z.ZodObject<{
 type UpdateArtifactRequest = z.infer<typeof updateArtifactRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the UpdateArtifactOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const updateArtifactOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -845,9 +1284,9 @@ declare const updateArtifactOkResponse: z.ZodLazy<z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -857,9 +1296,9 @@ declare const updateArtifactOkResponse: z.ZodLazy<z.ZodObject<{
         metadata?: any;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -871,9 +1310,9 @@ declare const updateArtifactOkResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -885,9 +1324,9 @@ declare const updateArtifactOkResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         content: string;
         updatedAt: string;
         name?: string | null | undefined;
@@ -904,6 +1343,11 @@ declare const updateArtifactOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type UpdateArtifactOkResponse = z.infer<typeof updateArtifactOkResponse>;
 
+/**
+ * Service class for ArtifactsService operations.
+ * Provides methods to interact with ArtifactsService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class ArtifactsService extends BaseService {
     /**
      * List all artifacts for the authenticated user with optional filters
@@ -946,7 +1390,9 @@ declare class ArtifactsService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Artifact model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const artifact: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -962,9 +1408,9 @@ declare const artifact: z.ZodLazy<z.ZodObject<{
     updatedAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: string;
+    userId: string;
     id: string;
     createdAt: string;
-    userId: string;
     content: string;
     updatedAt: string;
     name?: string | null | undefined;
@@ -974,9 +1420,9 @@ declare const artifact: z.ZodLazy<z.ZodObject<{
     metadata?: any;
 }, {
     type: string;
+    userId: string;
     id: string;
     createdAt: string;
-    userId: string;
     content: string;
     updatedAt: string;
     name?: string | null | undefined;
@@ -1003,7 +1449,9 @@ declare const artifact: z.ZodLazy<z.ZodObject<{
 type Artifact = z.infer<typeof artifact>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListConversationsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listConversationsOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -1079,7 +1527,9 @@ interface ListConversationsParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateConversationRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createConversationRequest: z.ZodLazy<z.ZodObject<{
     title: z.ZodString;
@@ -1100,7 +1550,9 @@ declare const createConversationRequest: z.ZodLazy<z.ZodObject<{
 type CreateConversationRequest = z.infer<typeof createConversationRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateConversationCreatedResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createConversationCreatedResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -1147,7 +1599,9 @@ declare const createConversationCreatedResponse: z.ZodLazy<z.ZodObject<{
 type CreateConversationCreatedResponse = z.infer<typeof createConversationCreatedResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetConversationSummaryOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getConversationSummaryOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -1194,7 +1648,9 @@ declare const getConversationSummaryOkResponse: z.ZodLazy<z.ZodObject<{
 type GetConversationSummaryOkResponse = z.infer<typeof getConversationSummaryOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetConversationTimelineOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getConversationTimelineOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -1275,7 +1731,9 @@ declare const getConversationTimelineOkResponse: z.ZodLazy<z.ZodObject<{
 type GetConversationTimelineOkResponse = z.infer<typeof getConversationTimelineOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchConversationsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchConversationsRequest: z.ZodLazy<z.ZodObject<{
     query: z.ZodString;
@@ -1296,7 +1754,9 @@ declare const searchConversationsRequest: z.ZodLazy<z.ZodObject<{
 type SearchConversationsRequest = z.infer<typeof searchConversationsRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchConversationsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchConversationsOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -1347,7 +1807,9 @@ declare const searchConversationsOkResponse: z.ZodLazy<z.ZodObject<{
 type SearchConversationsOkResponse = z.infer<typeof searchConversationsOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the FindConversationsByTopicRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const findConversationsByTopicRequest: z.ZodLazy<z.ZodObject<{
     topicId: z.ZodString;
@@ -1368,7 +1830,9 @@ declare const findConversationsByTopicRequest: z.ZodLazy<z.ZodObject<{
 type FindConversationsByTopicRequest = z.infer<typeof findConversationsByTopicRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the FindConversationsByTopicOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const findConversationsByTopicOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -1432,6 +1896,11 @@ declare const findConversationsByTopicOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type FindConversationsByTopicOkResponse = z.infer<typeof findConversationsByTopicOkResponse>;
 
+/**
+ * Service class for ConversationsService operations.
+ * Provides methods to interact with ConversationsService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class ConversationsService extends BaseService {
     /**
      * List all conversations for the authenticated user with pagination
@@ -1476,7 +1945,9 @@ declare class ConversationsService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Conversation model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const conversation: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -1509,7 +1980,9 @@ declare const conversation: z.ZodLazy<z.ZodObject<{
 type Conversation = z.infer<typeof conversation>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListConversationsOkResponsePagination model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listConversationsOkResponsePagination: z.ZodLazy<z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
@@ -1540,7 +2013,9 @@ declare enum MemoryMemoryType1 {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the FindConversationsByTopicOkResponseMetadata model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const findConversationsByTopicOkResponseMetadata: z.ZodLazy<z.ZodObject<{
     topicId: z.ZodOptional<z.ZodString>;
@@ -1557,7 +2032,9 @@ declare const findConversationsByTopicOkResponseMetadata: z.ZodLazy<z.ZodObject<
 type FindConversationsByTopicOkResponseMetadata = z.infer<typeof findConversationsByTopicOkResponseMetadata>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListFactsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listFactsOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -1571,18 +2048,18 @@ declare const listFactsOkResponse: z.ZodLazy<z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
         confidence?: number | undefined;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1592,9 +2069,9 @@ declare const listFactsOkResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1604,9 +2081,9 @@ declare const listFactsOkResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1628,7 +2105,9 @@ interface ListFactsParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateFactRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createFactRequest: z.ZodLazy<z.ZodObject<{
     subject: z.ZodString;
@@ -1653,7 +2132,9 @@ declare const createFactRequest: z.ZodLazy<z.ZodObject<{
 type CreateFactRequest = z.infer<typeof createFactRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateFactCreatedResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createFactCreatedResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -1667,18 +2148,18 @@ declare const createFactCreatedResponse: z.ZodLazy<z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
         confidence?: number | undefined;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1687,9 +2168,9 @@ declare const createFactCreatedResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1698,9 +2179,9 @@ declare const createFactCreatedResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1715,7 +2196,9 @@ declare const createFactCreatedResponse: z.ZodLazy<z.ZodObject<{
 type CreateFactCreatedResponse = z.infer<typeof createFactCreatedResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetFactByIdOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getFactByIdOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -1729,18 +2212,18 @@ declare const getFactByIdOkResponse: z.ZodLazy<z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
         confidence?: number | undefined;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1749,9 +2232,9 @@ declare const getFactByIdOkResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1760,9 +2243,9 @@ declare const getFactByIdOkResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1777,7 +2260,9 @@ declare const getFactByIdOkResponse: z.ZodLazy<z.ZodObject<{
 type GetFactByIdOkResponse = z.infer<typeof getFactByIdOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the UpdateFactRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const updateFactRequest: z.ZodLazy<z.ZodObject<{
     subject: z.ZodOptional<z.ZodString>;
@@ -1806,7 +2291,9 @@ declare const updateFactRequest: z.ZodLazy<z.ZodObject<{
 type UpdateFactRequest = z.infer<typeof updateFactRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the UpdateFactOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const updateFactOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -1820,18 +2307,18 @@ declare const updateFactOkResponse: z.ZodLazy<z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
         confidence?: number | undefined;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1840,9 +2327,9 @@ declare const updateFactOkResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1851,9 +2338,9 @@ declare const updateFactOkResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1868,7 +2355,9 @@ declare const updateFactOkResponse: z.ZodLazy<z.ZodObject<{
 type UpdateFactOkResponse = z.infer<typeof updateFactOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the FactSearchRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const factSearchRequest: z.ZodLazy<z.ZodObject<{
     query: z.ZodString;
@@ -1889,7 +2378,9 @@ declare const factSearchRequest: z.ZodLazy<z.ZodObject<{
 type FactSearchRequest = z.infer<typeof factSearchRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchFactsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchFactsOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -1903,18 +2394,18 @@ declare const searchFactsOkResponse: z.ZodLazy<z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
         confidence?: number | undefined;
     }, {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1931,9 +2422,9 @@ declare const searchFactsOkResponse: z.ZodLazy<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1946,9 +2437,9 @@ declare const searchFactsOkResponse: z.ZodLazy<z.ZodObject<{
 }, {
     data?: {
         type: string;
+        userId: string;
         id: string;
         createdAt: string;
-        userId: string;
         name: string;
         updatedAt: string;
         description?: string | null | undefined;
@@ -1968,6 +2459,11 @@ declare const searchFactsOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type SearchFactsOkResponse = z.infer<typeof searchFactsOkResponse>;
 
+/**
+ * Service class for FactsService operations.
+ * Provides methods to interact with FactsService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class FactsService extends BaseService {
     /**
      * List all facts for the authenticated user
@@ -2013,7 +2509,9 @@ declare class FactsService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Fact model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const fact: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -2026,18 +2524,18 @@ declare const fact: z.ZodLazy<z.ZodObject<{
     updatedAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: string;
+    userId: string;
     id: string;
     createdAt: string;
-    userId: string;
     name: string;
     updatedAt: string;
     description?: string | null | undefined;
     confidence?: number | undefined;
 }, {
     type: string;
+    userId: string;
     id: string;
     createdAt: string;
-    userId: string;
     name: string;
     updatedAt: string;
     description?: string | null | undefined;
@@ -2058,7 +2556,9 @@ declare const fact: z.ZodLazy<z.ZodObject<{
 type Fact = z.infer<typeof fact>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchFactsOkResponseMetadata model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchFactsOkResponseMetadata: z.ZodLazy<z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
@@ -2074,12 +2574,33 @@ declare const searchFactsOkResponseMetadata: z.ZodLazy<z.ZodObject<{
  */
 type SearchFactsOkResponseMetadata = z.infer<typeof searchFactsOkResponseMetadata>;
 
+/**
+ * Zod schema for the ExplainGraphRagQueryOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const explainGraphRagQueryOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    data?: any;
+}, {
+    data?: any;
+}>>;
+/**
+ *
+ * @typedef  {ExplainGraphRagQueryOkResponse} explainGraphRagQueryOkResponse
+ * @property {any} - Query explanation details
+ */
+type ExplainGraphRagQueryOkResponse = z.infer<typeof explainGraphRagQueryOkResponse>;
+
 interface ExplainGraphRagQueryParams {
     queryId: string;
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the QueryCommunitiesRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const queryCommunitiesRequest: z.ZodLazy<z.ZodObject<{
     query: z.ZodString;
@@ -2100,7 +2621,28 @@ declare const queryCommunitiesRequest: z.ZodLazy<z.ZodObject<{
 type QueryCommunitiesRequest = z.infer<typeof queryCommunitiesRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the QueryCommunitiesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const queryCommunitiesOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strip", z.ZodTypeAny, {
+    data?: any[] | undefined;
+}, {
+    data?: any[] | undefined;
+}>>;
+/**
+ *
+ * @typedef  {QueryCommunitiesOkResponse} queryCommunitiesOkResponse
+ * @property {any[]}
+ */
+type QueryCommunitiesOkResponse = z.infer<typeof queryCommunitiesOkResponse>;
+
+/**
+ * Zod schema for the GraphRagQueryRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const graphRagQueryRequest: z.ZodLazy<z.ZodObject<{
     query: z.ZodString;
@@ -2133,7 +2675,9 @@ declare const graphRagQueryRequest: z.ZodLazy<z.ZodObject<{
 type GraphRagQueryRequest = z.infer<typeof graphRagQueryRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ExecuteGraphRagQueryOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const executeGraphRagQueryOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -2141,9 +2685,6 @@ declare const executeGraphRagQueryOkResponse: z.ZodLazy<z.ZodObject<{
         results: z.ZodArray<z.ZodLazy<z.ZodObject<{
             memory: z.ZodLazy<z.ZodObject<{
                 id: z.ZodString;
-                /**
-                 * The shape of the model inside the application code - what the users use
-                 */
                 content: z.ZodString;
                 memoryType: z.ZodString;
                 context: z.ZodOptional<z.ZodString>;
@@ -2357,20 +2898,25 @@ declare const executeGraphRagQueryOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type ExecuteGraphRagQueryOkResponse = z.infer<typeof executeGraphRagQueryOkResponse>;
 
+/**
+ * Service class for GraphRagService operations.
+ * Provides methods to interact with GraphRagService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class GraphRagService extends BaseService {
     /**
      * Get explanation for a previously executed GraphRAG query result
      * @param {string} params.queryId - The query ID to explain
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<ExplainGraphRagQueryOkResponse>>} - Query explanation retrieved successfully
      */
-    explainGraphRagQuery(params: ExplainGraphRagQueryParams, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    explainGraphRagQuery(params: ExplainGraphRagQueryParams, requestConfig?: RequestConfig): Promise<HttpResponse<ExplainGraphRagQueryOkResponse>>;
     /**
      * Query communities for relevant information using semantic search
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<QueryCommunitiesOkResponse>>} - Community query results
      */
-    queryCommunities(body: QueryCommunitiesRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    queryCommunities(body: QueryCommunitiesRequest, requestConfig?: RequestConfig): Promise<HttpResponse<QueryCommunitiesOkResponse>>;
     /**
      * Execute a graph-based retrieval augmented generation query
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
@@ -2380,7 +2926,9 @@ declare class GraphRagService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GraphRagQueryResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const graphRagQueryResponse: z.ZodLazy<z.ZodObject<{
     queryId: z.ZodString;
@@ -2544,7 +3092,9 @@ declare const graphRagQueryResponse: z.ZodLazy<z.ZodObject<{
 type GraphRagQueryResponse = z.infer<typeof graphRagQueryResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Results model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const results: z.ZodLazy<z.ZodObject<{
     memory: z.ZodLazy<z.ZodObject<{
@@ -2637,7 +3187,9 @@ declare const results: z.ZodLazy<z.ZodObject<{
 type Results = z.infer<typeof results>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GraphRagQueryResponseMetadata model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const graphRagQueryResponseMetadata: z.ZodLazy<z.ZodObject<{
     query: z.ZodString;
@@ -2666,7 +3218,9 @@ declare const graphRagQueryResponseMetadata: z.ZodLazy<z.ZodObject<{
 type GraphRagQueryResponseMetadata = z.infer<typeof graphRagQueryResponseMetadata>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the HealthCheck model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const healthCheck: z.ZodLazy<z.ZodObject<{
     status: z.ZodString;
@@ -2698,7 +3252,12 @@ declare const healthCheck: z.ZodLazy<z.ZodObject<{
  */
 type HealthCheck = z.infer<typeof healthCheck>;
 
-declare class HealthService extends BaseService {
+/**
+ * Service class for HealthService operations.
+ * Provides methods to interact with HealthService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
+declare class HealthService extends BaseService {
     /**
    * 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 availability verification.
@@ -2716,7 +3275,9 @@ declare enum HealthCheckStatus {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ServiceCheck model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const serviceCheck: z.ZodLazy<z.ZodObject<{
     status: z.ZodString;
@@ -2742,7 +3303,9 @@ declare enum ServiceCheckStatus {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetMemoryResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getMemoryResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodLazy<z.ZodObject<{
@@ -2819,7 +3382,9 @@ declare const getMemoryResponse: z.ZodLazy<z.ZodObject<{
 type GetMemoryResponse = z.infer<typeof getMemoryResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the UpdateMemoryRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const updateMemoryRequest: z.ZodLazy<z.ZodObject<{
     content: z.ZodOptional<z.ZodString>;
@@ -2848,7 +3413,9 @@ declare const updateMemoryRequest: z.ZodLazy<z.ZodObject<{
 type UpdateMemoryRequest = z.infer<typeof updateMemoryRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the UpdateMemoryOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const updateMemoryOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -2925,7 +3492,9 @@ declare const updateMemoryOkResponse: z.ZodLazy<z.ZodObject<{
 type UpdateMemoryOkResponse = z.infer<typeof updateMemoryOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListMemoriesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -3041,7 +3610,9 @@ interface GetRelatedMemoriesParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateMemoryRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createMemoryRequest: z.ZodLazy<z.ZodObject<{
     conversationId: z.ZodString;
@@ -3090,7 +3661,9 @@ declare const createMemoryRequest: z.ZodLazy<z.ZodObject<{
 type CreateMemoryRequest = z.infer<typeof createMemoryRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateMemoryResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createMemoryResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodLazy<z.ZodObject<{
@@ -3196,7 +3769,9 @@ declare const createMemoryResponse: z.ZodLazy<z.ZodObject<{
 type CreateMemoryResponse = z.infer<typeof createMemoryResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchRequest: z.ZodLazy<z.ZodObject<{
     query: z.ZodString;
@@ -3289,7 +3864,9 @@ declare const searchRequest: z.ZodLazy<z.ZodObject<{
 type SearchRequest = z.infer<typeof searchRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -3641,7 +4218,9 @@ declare const searchResponse: z.ZodLazy<z.ZodObject<{
 type SearchResponse = z.infer<typeof searchResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetSimilarMemoriesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getSimilarMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -3831,7 +4410,9 @@ declare const getSimilarMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
 type GetSimilarMemoriesOkResponse = z.infer<typeof getSimilarMemoriesOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetConversationMemoriesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getConversationMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -4025,7 +4606,9 @@ declare const getConversationMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
 type GetConversationMemoriesOkResponse = z.infer<typeof getConversationMemoriesOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetRelatedMemoriesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getRelatedMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -4214,6 +4797,11 @@ declare const getRelatedMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type GetRelatedMemoriesOkResponse = z.infer<typeof getRelatedMemoriesOkResponse>;
 
+/**
+ * Service class for MemoriesService operations.
+ * Provides methods to interact with MemoriesService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class MemoriesService extends BaseService {
     /**
      * Retrieve a specific memory by its ID
@@ -4324,7 +4912,9 @@ declare enum UpdateMemoryRequestMemoryType {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Pagination model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const pagination: z.ZodLazy<z.ZodObject<{
     limit: z.ZodNumber;
@@ -4348,20 +4938,10 @@ declare const pagination: z.ZodLazy<z.ZodObject<{
  */
 type Pagination = z.infer<typeof pagination>;
 
-declare enum CreateMemoryRequestMemoryType {
-    EPISODIC = "episodic",
-    SEMANTIC = "semantic",
-    PROCEDURAL = "procedural"
-}
-
-declare enum Role {
-    USER = "user",
-    ASSISTANT = "assistant",
-    SYSTEM = "system"
-}
-
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreateMemoryResponseMeta model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createMemoryResponseMeta: z.ZodLazy<z.ZodObject<{
     conversationId: z.ZodString;
@@ -4389,32 +4969,22 @@ declare const createMemoryResponseMeta: z.ZodLazy<z.ZodObject<{
  */
 type CreateMemoryResponseMeta = z.infer<typeof createMemoryResponseMeta>;
 
-declare enum Mode {
-    UNIFIED = "unified",
-    CONTENT = "content",
-    FACTS = "facts"
-}
-
-declare enum SearchMethod {
-    KEYWORD = "keyword",
-    SEMANTIC = "semantic",
-    HYBRID = "hybrid"
-}
-
-declare enum TemporalMode {
-    CURRENT = "current",
-    HISTORICAL = "historical",
-    EVOLUTION = "evolution"
-}
-
-declare enum SearchRequestMemoryType {
+declare enum CreateMemoryRequestMemoryType {
     EPISODIC = "episodic",
     SEMANTIC = "semantic",
     PROCEDURAL = "procedural"
 }
 
+declare enum Role {
+    USER = "user",
+    ASSISTANT = "assistant",
+    SYSTEM = "system"
+}
+
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchResult model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchResult: z.ZodLazy<z.ZodObject<{
     memory: z.ZodLazy<z.ZodObject<{
@@ -4586,7 +5156,9 @@ declare const searchResult: z.ZodLazy<z.ZodObject<{
 type SearchResult = z.infer<typeof searchResult>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchResultMemory model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchResultMemory: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -4649,7 +5221,9 @@ declare enum MemoryMemoryType2 {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Entity model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const entity: z.ZodLazy<z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -4670,7 +5244,9 @@ declare const entity: z.ZodLazy<z.ZodObject<{
 type Entity = z.infer<typeof entity>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Explanation model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const explanation: z.ZodLazy<z.ZodObject<{
     matchReason: z.ZodString;
@@ -4699,7 +5275,9 @@ declare const explanation: z.ZodLazy<z.ZodObject<{
 type Explanation = z.infer<typeof explanation>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchResponsePagination model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchResponsePagination: z.ZodLazy<z.ZodObject<{
     limit: z.ZodNumber;
@@ -4724,7 +5302,9 @@ declare const searchResponsePagination: z.ZodLazy<z.ZodObject<{
 type SearchResponsePagination = z.infer<typeof searchResponsePagination>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the TemporalMetadata model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const temporalMetadata: z.ZodLazy<z.ZodObject<{
     temporalMode: z.ZodString;
@@ -4795,7 +5375,9 @@ declare const temporalMetadata: z.ZodLazy<z.ZodObject<{
 type TemporalMetadata = z.infer<typeof temporalMetadata>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the EventTimeRange model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const eventTimeRange: z.ZodLazy<z.ZodObject<{
     from: z.ZodNullable<z.ZodString>;
@@ -4816,7 +5398,9 @@ declare const eventTimeRange: z.ZodLazy<z.ZodObject<{
 type EventTimeRange = z.infer<typeof eventTimeRange>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the IngestionTimeRange model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const ingestionTimeRange: z.ZodLazy<z.ZodObject<{
     from: z.ZodNullable<z.ZodString>;
@@ -4836,8 +5420,34 @@ declare const ingestionTimeRange: z.ZodLazy<z.ZodObject<{
  */
 type IngestionTimeRange = z.infer<typeof ingestionTimeRange>;
 
+declare enum Mode {
+    UNIFIED = "unified",
+    CONTENT = "content",
+    FACTS = "facts"
+}
+
+declare enum SearchMethod {
+    KEYWORD = "keyword",
+    SEMANTIC = "semantic",
+    HYBRID = "hybrid"
+}
+
+declare enum TemporalMode {
+    CURRENT = "current",
+    HISTORICAL = "historical",
+    EVOLUTION = "evolution"
+}
+
+declare enum SearchRequestMemoryType {
+    EPISODIC = "episodic",
+    SEMANTIC = "semantic",
+    PROCEDURAL = "procedural"
+}
+
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the RelatedMemoryResult model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const relatedMemoryResult: z.ZodLazy<z.ZodObject<{
     memory: z.ZodLazy<z.ZodObject<{
@@ -4851,14 +5461,6 @@ declare const relatedMemoryResult: z.ZodLazy<z.ZodObject<{
         validFrom: z.ZodOptional<z.ZodString>;
         validTo: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         createdAt: z.ZodString;
-        /**
-         *
-         * @typedef  {RelatedMemoryResult} relatedMemoryResult
-         * @property {RelatedMemoryResultMemory} - The related memory object
-         * @property {number} - Relevance score (0-1). For similar: semantic similarity. For related: topic overlap ratio. For conversation: position score.
-         * @property {string} - Type of relationship: similar, similar-by-topic, conversation, or topic
-         * @property {string[]} - Topics shared with the source memory (only for topic relationship)
-         */
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         id: string;
@@ -4934,7 +5536,9 @@ declare const relatedMemoryResult: z.ZodLazy<z.ZodObject<{
 type RelatedMemoryResult = z.infer<typeof relatedMemoryResult>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the RelatedMemoryResultMemory model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const relatedMemoryResultMemory: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -4997,7 +5601,9 @@ declare enum MemoryMemoryType3 {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetRelatedMemoriesOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getRelatedMemoriesOkResponseData: z.ZodLazy<z.ZodObject<{
     memory: z.ZodLazy<z.ZodObject<{
@@ -5086,7 +5692,9 @@ declare const getRelatedMemoriesOkResponseData: z.ZodLazy<z.ZodObject<{
 type GetRelatedMemoriesOkResponseData = z.infer<typeof getRelatedMemoriesOkResponseData>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the DataMemory model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const dataMemory: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -5162,7 +5770,86 @@ interface AnalyzeMemoryQualityParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetSystemHealthOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const getSystemHealthOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        status: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodAny>;
+        uptime: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status?: string | undefined;
+        database?: any;
+        uptime?: number | undefined;
+    }, {
+        status?: string | undefined;
+        database?: any;
+        uptime?: number | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        status?: string | undefined;
+        database?: any;
+        uptime?: number | undefined;
+    } | undefined;
+}, {
+    data?: {
+        status?: string | undefined;
+        database?: any;
+        uptime?: number | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {GetSystemHealthOkResponse} getSystemHealthOkResponse
+ * @property {GetSystemHealthOkResponseData}
+ */
+type GetSystemHealthOkResponse = z.infer<typeof getSystemHealthOkResponse>;
+
+/**
+ * Zod schema for the GetContextStatusOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const getContextStatusOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    data?: any;
+}, {
+    data?: any;
+}>>;
+/**
+ *
+ * @typedef  {GetContextStatusOkResponse} getContextStatusOkResponse
+ * @property {any} - Database statistics and context information
+ */
+type GetContextStatusOkResponse = z.infer<typeof getContextStatusOkResponse>;
+
+/**
+ * Zod schema for the GetFeatureFlagsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const getFeatureFlagsOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    data?: any;
+}, {
+    data?: any;
+}>>;
+/**
+ *
+ * @typedef  {GetFeatureFlagsOkResponse} getFeatureFlagsOkResponse
+ * @property {any} - Map of feature flag names to their values
+ */
+type GetFeatureFlagsOkResponse = z.infer<typeof getFeatureFlagsOkResponse>;
+
+/**
+ * Zod schema for the EvaluateFeatureFlagRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const evaluateFeatureFlagRequest: z.ZodLazy<z.ZodObject<{
     flagName: z.ZodString;
@@ -5183,7 +5870,43 @@ declare const evaluateFeatureFlagRequest: z.ZodLazy<z.ZodObject<{
 type EvaluateFeatureFlagRequest = z.infer<typeof evaluateFeatureFlagRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the EvaluateFeatureFlagOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const evaluateFeatureFlagOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        flagName: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        flagName?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        flagName?: string | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        enabled?: boolean | undefined;
+        flagName?: string | undefined;
+    } | undefined;
+}, {
+    data?: {
+        enabled?: boolean | undefined;
+        flagName?: string | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {EvaluateFeatureFlagOkResponse} evaluateFeatureFlagOkResponse
+ * @property {EvaluateFeatureFlagOkResponseData}
+ */
+type EvaluateFeatureFlagOkResponse = z.infer<typeof evaluateFeatureFlagOkResponse>;
+
+/**
+ * Zod schema for the AnalyzeMemoryQualityOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const analyzeMemoryQualityOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -5202,11 +5925,6 @@ declare const analyzeMemoryQualityOkResponse: z.ZodLazy<z.ZodObject<{
             low?: number | undefined;
         }>>>;
         averageQuality: z.ZodOptional<z.ZodNumber>;
-        /**
-         *
-         * @typedef  {AnalyzeMemoryQualityOkResponse} analyzeMemoryQualityOkResponse
-         * @property {AnalyzeMemoryQualityOkResponseData}
-         */
         pruningCandidates: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         totalMemories?: number | undefined;
@@ -5258,7 +5976,9 @@ declare const analyzeMemoryQualityOkResponse: z.ZodLazy<z.ZodObject<{
 type AnalyzeMemoryQualityOkResponse = z.infer<typeof analyzeMemoryQualityOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the PruneMemoriesRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const pruneMemoriesRequest: z.ZodLazy<z.ZodObject<{
     targetReduction: z.ZodOptional<z.ZodNumber>;
@@ -5291,7 +6011,9 @@ declare const pruneMemoriesRequest: z.ZodLazy<z.ZodObject<{
 type PruneMemoriesRequest = z.infer<typeof pruneMemoriesRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the PruneMemoriesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const pruneMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -5327,6 +6049,11 @@ declare const pruneMemoriesOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type PruneMemoriesOkResponse = z.infer<typeof pruneMemoriesOkResponse>;
 
+/**
+ * Service class for SystemService operations.
+ * Provides methods to interact with SystemService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class SystemService extends BaseService {
     /**
      * Returns the OpenAPI 3.x specification for the entire API. This endpoint is used by CI/CD to sync the API Gateway.
@@ -5338,27 +6065,27 @@ declare class SystemService extends BaseService {
     /**
      * Get the current health status of the system including database connectivity
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<GetSystemHealthOkResponse>>} - System is healthy
      */
-    getSystemHealth(requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    getSystemHealth(requestConfig?: RequestConfig): Promise<HttpResponse<GetSystemHealthOkResponse>>;
     /**
      * Get database statistics and context information
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<GetContextStatusOkResponse>>} - Context status retrieved successfully
      */
-    getContextStatus(requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    getContextStatus(requestConfig?: RequestConfig): Promise<HttpResponse<GetContextStatusOkResponse>>;
     /**
      * Get all feature flags for the authenticated user
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<GetFeatureFlagsOkResponse>>} - Feature flags retrieved successfully
      */
-    getFeatureFlags(requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    getFeatureFlags(requestConfig?: RequestConfig): Promise<HttpResponse<GetFeatureFlagsOkResponse>>;
     /**
      * Evaluate a specific feature flag for the authenticated user
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<EvaluateFeatureFlagOkResponse>>} - Feature flag evaluation result
      */
-    evaluateFeatureFlag(body: EvaluateFeatureFlagRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    evaluateFeatureFlag(body: EvaluateFeatureFlagRequest, requestConfig?: RequestConfig): Promise<HttpResponse<EvaluateFeatureFlagOkResponse>>;
     /**
      * Analyze the quality distribution of memories for the authenticated user
      * @param {boolean} [params.includeDetails] - Include detailed pruning candidate information
@@ -5376,7 +6103,64 @@ declare class SystemService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetSystemHealthOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const getSystemHealthOkResponseData: z.ZodLazy<z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodAny>;
+    uptime: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status?: string | undefined;
+    database?: any;
+    uptime?: number | undefined;
+}, {
+    status?: string | undefined;
+    database?: any;
+    uptime?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {GetSystemHealthOkResponseData} getSystemHealthOkResponseData
+ * @property {DataStatus}
+ * @property {any}
+ * @property {number}
+ */
+type GetSystemHealthOkResponseData = z.infer<typeof getSystemHealthOkResponseData>;
+
+declare enum DataStatus {
+    HEALTHY = "healthy",
+    UNHEALTHY = "unhealthy"
+}
+
+/**
+ * Zod schema for the EvaluateFeatureFlagOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const evaluateFeatureFlagOkResponseData: z.ZodLazy<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    flagName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+    flagName?: string | undefined;
+}, {
+    enabled?: boolean | undefined;
+    flagName?: string | undefined;
+}>>;
+/**
+ *
+ * @typedef  {EvaluateFeatureFlagOkResponseData} evaluateFeatureFlagOkResponseData
+ * @property {boolean}
+ * @property {string}
+ */
+type EvaluateFeatureFlagOkResponseData = z.infer<typeof evaluateFeatureFlagOkResponseData>;
+
+/**
+ * Zod schema for the AnalyzeMemoryQualityOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const analyzeMemoryQualityOkResponseData: z.ZodLazy<z.ZodObject<{
     totalMemories: z.ZodOptional<z.ZodNumber>;
@@ -5425,7 +6209,9 @@ declare const analyzeMemoryQualityOkResponseData: z.ZodLazy<z.ZodObject<{
 type AnalyzeMemoryQualityOkResponseData = z.infer<typeof analyzeMemoryQualityOkResponseData>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the QualityDistribution model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const qualityDistribution: z.ZodLazy<z.ZodObject<{
     high: z.ZodOptional<z.ZodNumber>;
@@ -5450,7 +6236,9 @@ declare const qualityDistribution: z.ZodLazy<z.ZodObject<{
 type QualityDistribution = z.infer<typeof qualityDistribution>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the PruneMemoriesOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const pruneMemoriesOkResponseData: z.ZodLazy<z.ZodObject<{
     prunedCount: z.ZodOptional<z.ZodNumber>;
@@ -5475,7 +6263,9 @@ declare const pruneMemoriesOkResponseData: z.ZodLazy<z.ZodObject<{
 type PruneMemoriesOkResponseData = z.infer<typeof pruneMemoriesOkResponseData>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListPatternsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listPatternsOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -5546,7 +6336,9 @@ interface ListPatternsParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CompilePatternsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const compilePatternsRequest: z.ZodLazy<z.ZodObject<{
     minOccurrences: z.ZodOptional<z.ZodNumber>;
@@ -5567,7 +6359,57 @@ declare const compilePatternsRequest: z.ZodLazy<z.ZodObject<{
 type CompilePatternsRequest = z.infer<typeof compilePatternsRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CompilePatternsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const compilePatternsOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }, {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }>>, "many">>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }[] | undefined;
+    count?: number | undefined;
+}, {
+    data?: {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }[] | undefined;
+    count?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {CompilePatternsOkResponse} compilePatternsOkResponse
+ * @property {Pattern[]}
+ * @property {number}
+ */
+type CompilePatternsOkResponse = z.infer<typeof compilePatternsOkResponse>;
+
+/**
+ * Zod schema for the DetectPatternsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const detectPatternsRequest: z.ZodLazy<z.ZodObject<{
     contextFilter: z.ZodOptional<z.ZodString>;
@@ -5604,7 +6446,109 @@ declare const detectPatternsRequest: z.ZodLazy<z.ZodObject<{
 type DetectPatternsRequest = z.infer<typeof detectPatternsRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the DetectPatternsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const detectPatternsOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        detectedPatterns: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            description: z.ZodString;
+            confidence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            id: string;
+            description: string;
+            confidence: number;
+        }, {
+            type: string;
+            id: string;
+            description: string;
+            confidence: number;
+        }>>, "many">>;
+        count: z.ZodOptional<z.ZodNumber>;
+        stored: z.ZodOptional<z.ZodNumber>;
+        confidence: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+            average: z.ZodOptional<z.ZodNumber>;
+            highest: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            average?: number | undefined;
+            highest?: number | undefined;
+        }, {
+            average?: number | undefined;
+            highest?: number | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        detectedPatterns?: {
+            type: string;
+            id: string;
+            description: string;
+            confidence: number;
+        }[] | undefined;
+        count?: number | undefined;
+        stored?: number | undefined;
+        confidence?: {
+            average?: number | undefined;
+            highest?: number | undefined;
+        } | undefined;
+    }, {
+        detectedPatterns?: {
+            type: string;
+            id: string;
+            description: string;
+            confidence: number;
+        }[] | undefined;
+        count?: number | undefined;
+        stored?: number | undefined;
+        confidence?: {
+            average?: number | undefined;
+            highest?: number | undefined;
+        } | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        detectedPatterns?: {
+            type: string;
+            id: string;
+            description: string;
+            confidence: number;
+        }[] | undefined;
+        count?: number | undefined;
+        stored?: number | undefined;
+        confidence?: {
+            average?: number | undefined;
+            highest?: number | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    data?: {
+        detectedPatterns?: {
+            type: string;
+            id: string;
+            description: string;
+            confidence: number;
+        }[] | undefined;
+        count?: number | undefined;
+        stored?: number | undefined;
+        confidence?: {
+            average?: number | undefined;
+            highest?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {DetectPatternsOkResponse} detectPatternsOkResponse
+ * @property {DetectPatternsOkResponseData}
+ */
+type DetectPatternsOkResponse = z.infer<typeof detectPatternsOkResponse>;
+
+/**
+ * Zod schema for the AnalyzePatternsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const analyzePatternsRequest: z.ZodLazy<z.ZodObject<{
     timeRange: z.ZodOptional<z.ZodNumber>;
@@ -5629,7 +6573,90 @@ declare const analyzePatternsRequest: z.ZodLazy<z.ZodObject<{
 type AnalyzePatternsRequest = z.infer<typeof analyzePatternsRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the AnalyzePatternsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const analyzePatternsOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        analysis: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+            totalPatterns: z.ZodOptional<z.ZodNumber>;
+            recentPatterns: z.ZodOptional<z.ZodNumber>;
+            trends: z.ZodOptional<z.ZodAny>;
+            insights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            recommendations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            totalPatterns?: number | undefined;
+            recentPatterns?: number | undefined;
+            trends?: any;
+            insights?: string[] | undefined;
+            recommendations?: string[] | undefined;
+        }, {
+            totalPatterns?: number | undefined;
+            recentPatterns?: number | undefined;
+            trends?: any;
+            insights?: string[] | undefined;
+            recommendations?: string[] | undefined;
+        }>>>;
+        timeRange: z.ZodOptional<z.ZodNumber>;
+        analyzedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        analysis?: {
+            totalPatterns?: number | undefined;
+            recentPatterns?: number | undefined;
+            trends?: any;
+            insights?: string[] | undefined;
+            recommendations?: string[] | undefined;
+        } | undefined;
+        timeRange?: number | undefined;
+        analyzedAt?: string | undefined;
+    }, {
+        analysis?: {
+            totalPatterns?: number | undefined;
+            recentPatterns?: number | undefined;
+            trends?: any;
+            insights?: string[] | undefined;
+            recommendations?: string[] | undefined;
+        } | undefined;
+        timeRange?: number | undefined;
+        analyzedAt?: string | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        analysis?: {
+            totalPatterns?: number | undefined;
+            recentPatterns?: number | undefined;
+            trends?: any;
+            insights?: string[] | undefined;
+            recommendations?: string[] | undefined;
+        } | undefined;
+        timeRange?: number | undefined;
+        analyzedAt?: string | undefined;
+    } | undefined;
+}, {
+    data?: {
+        analysis?: {
+            totalPatterns?: number | undefined;
+            recentPatterns?: number | undefined;
+            trends?: any;
+            insights?: string[] | undefined;
+            recommendations?: string[] | undefined;
+        } | undefined;
+        timeRange?: number | undefined;
+        analyzedAt?: string | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {AnalyzePatternsOkResponse} analyzePatternsOkResponse
+ * @property {AnalyzePatternsOkResponseData}
+ */
+type AnalyzePatternsOkResponse = z.infer<typeof analyzePatternsOkResponse>;
+
+/**
+ * Zod schema for the UpdatePatternRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const updatePatternRequest: z.ZodLazy<z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -5658,7 +6685,53 @@ declare const updatePatternRequest: z.ZodLazy<z.ZodObject<{
 type UpdatePatternRequest = z.infer<typeof updatePatternRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the UpdatePatternOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const updatePatternOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }, {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    } | undefined;
+}, {
+    data?: {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {UpdatePatternOkResponse} updatePatternOkResponse
+ * @property {Pattern}
+ */
+type UpdatePatternOkResponse = z.infer<typeof updatePatternOkResponse>;
+
+/**
+ * Zod schema for the RecordPatternFeedbackRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const recordPatternFeedbackRequest: z.ZodLazy<z.ZodObject<{
     patternId: z.ZodString;
@@ -5678,6 +6751,55 @@ declare const recordPatternFeedbackRequest: z.ZodLazy<z.ZodObject<{
  */
 type RecordPatternFeedbackRequest = z.infer<typeof recordPatternFeedbackRequest>;
 
+/**
+ * Zod schema for the RecordPatternFeedbackOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const recordPatternFeedbackOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }, {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    } | undefined;
+}, {
+    data?: {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {RecordPatternFeedbackOkResponse} recordPatternFeedbackOkResponse
+ * @property {Pattern}
+ */
+type RecordPatternFeedbackOkResponse = z.infer<typeof recordPatternFeedbackOkResponse>;
+
+/**
+ * Service class for PatternsService operations.
+ * Provides methods to interact with PatternsService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class PatternsService extends BaseService {
     /**
      * List all patterns for the authenticated user
@@ -5690,38 +6812,40 @@ declare class PatternsService extends BaseService {
     /**
      * Compile patterns from user's memories
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<CompilePatternsOkResponse>>} - Patterns compiled successfully
      */
-    compilePatterns(body: CompilePatternsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    compilePatterns(body: CompilePatternsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<CompilePatternsOkResponse>>;
     /**
      * Run pattern detection algorithms to identify recurring behavioral patterns
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - Patterns detected successfully
+     * @returns {Promise<HttpResponse<DetectPatternsOkResponse>>} - Patterns detected successfully
      */
-    detectPatterns(body: DetectPatternsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    detectPatterns(body: DetectPatternsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<DetectPatternsOkResponse>>;
     /**
      * Analyze pattern trends, correlations, and generate insights
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - Analysis completed successfully
+     * @returns {Promise<HttpResponse<AnalyzePatternsOkResponse>>} - Analysis completed successfully
      */
-    analyzePatterns(body: AnalyzePatternsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    analyzePatterns(body: AnalyzePatternsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<AnalyzePatternsOkResponse>>;
     /**
      * Update an existing pattern with partial data
      * @param {string} id - The pattern ID
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<UpdatePatternOkResponse>>} - Pattern updated successfully
      */
-    updatePattern(id: string, body: UpdatePatternRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    updatePattern(id: string, body: UpdatePatternRequest, requestConfig?: RequestConfig): Promise<HttpResponse<UpdatePatternOkResponse>>;
     /**
      * Record feedback on a pattern
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<RecordPatternFeedbackOkResponse>>} - Feedback recorded successfully
      */
-    recordPatternFeedback(body: RecordPatternFeedbackRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    recordPatternFeedback(body: RecordPatternFeedbackRequest, requestConfig?: RequestConfig): Promise<HttpResponse<RecordPatternFeedbackOkResponse>>;
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Pattern model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const pattern: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -5750,7 +6874,9 @@ declare const pattern: z.ZodLazy<z.ZodObject<{
 type Pattern = z.infer<typeof pattern>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListPatternsOkResponsePagination model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listPatternsOkResponsePagination: z.ZodLazy<z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
@@ -5774,6 +6900,192 @@ declare const listPatternsOkResponsePagination: z.ZodLazy<z.ZodObject<{
  */
 type ListPatternsOkResponsePagination = z.infer<typeof listPatternsOkResponsePagination>;
 
+/**
+ * Zod schema for the DetectPatternsOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const detectPatternsOkResponseData: z.ZodLazy<z.ZodObject<{
+    detectedPatterns: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }, {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }>>, "many">>;
+    count: z.ZodOptional<z.ZodNumber>;
+    stored: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        average: z.ZodOptional<z.ZodNumber>;
+        highest: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        average?: number | undefined;
+        highest?: number | undefined;
+    }, {
+        average?: number | undefined;
+        highest?: number | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    detectedPatterns?: {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }[] | undefined;
+    count?: number | undefined;
+    stored?: number | undefined;
+    confidence?: {
+        average?: number | undefined;
+        highest?: number | undefined;
+    } | undefined;
+}, {
+    detectedPatterns?: {
+        type: string;
+        id: string;
+        description: string;
+        confidence: number;
+    }[] | undefined;
+    count?: number | undefined;
+    stored?: number | undefined;
+    confidence?: {
+        average?: number | undefined;
+        highest?: number | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {DetectPatternsOkResponseData} detectPatternsOkResponseData
+ * @property {Pattern[]}
+ * @property {number}
+ * @property {number}
+ * @property {Confidence}
+ */
+type DetectPatternsOkResponseData = z.infer<typeof detectPatternsOkResponseData>;
+
+/**
+ * Zod schema for the Confidence model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const confidence: z.ZodLazy<z.ZodObject<{
+    average: z.ZodOptional<z.ZodNumber>;
+    highest: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    average?: number | undefined;
+    highest?: number | undefined;
+}, {
+    average?: number | undefined;
+    highest?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {Confidence} confidence
+ * @property {number}
+ * @property {number}
+ */
+type Confidence = z.infer<typeof confidence>;
+
+/**
+ * Zod schema for the AnalyzePatternsOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const analyzePatternsOkResponseData: z.ZodLazy<z.ZodObject<{
+    analysis: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        totalPatterns: z.ZodOptional<z.ZodNumber>;
+        recentPatterns: z.ZodOptional<z.ZodNumber>;
+        trends: z.ZodOptional<z.ZodAny>;
+        insights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        recommendations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        totalPatterns?: number | undefined;
+        recentPatterns?: number | undefined;
+        trends?: any;
+        insights?: string[] | undefined;
+        recommendations?: string[] | undefined;
+    }, {
+        totalPatterns?: number | undefined;
+        recentPatterns?: number | undefined;
+        trends?: any;
+        insights?: string[] | undefined;
+        recommendations?: string[] | undefined;
+    }>>>;
+    timeRange: z.ZodOptional<z.ZodNumber>;
+    analyzedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    analysis?: {
+        totalPatterns?: number | undefined;
+        recentPatterns?: number | undefined;
+        trends?: any;
+        insights?: string[] | undefined;
+        recommendations?: string[] | undefined;
+    } | undefined;
+    timeRange?: number | undefined;
+    analyzedAt?: string | undefined;
+}, {
+    analysis?: {
+        totalPatterns?: number | undefined;
+        recentPatterns?: number | undefined;
+        trends?: any;
+        insights?: string[] | undefined;
+        recommendations?: string[] | undefined;
+    } | undefined;
+    timeRange?: number | undefined;
+    analyzedAt?: string | undefined;
+}>>;
+/**
+ *
+ * @typedef  {AnalyzePatternsOkResponseData} analyzePatternsOkResponseData
+ * @property {Analysis}
+ * @property {number}
+ * @property {string}
+ */
+type AnalyzePatternsOkResponseData = z.infer<typeof analyzePatternsOkResponseData>;
+
+/**
+ * Zod schema for the Analysis model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const analysis: z.ZodLazy<z.ZodObject<{
+    totalPatterns: z.ZodOptional<z.ZodNumber>;
+    recentPatterns: z.ZodOptional<z.ZodNumber>;
+    trends: z.ZodOptional<z.ZodAny>;
+    insights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    recommendations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    totalPatterns?: number | undefined;
+    recentPatterns?: number | undefined;
+    trends?: any;
+    insights?: string[] | undefined;
+    recommendations?: string[] | undefined;
+}, {
+    totalPatterns?: number | undefined;
+    recentPatterns?: number | undefined;
+    trends?: any;
+    insights?: string[] | undefined;
+    recommendations?: string[] | undefined;
+}>>;
+/**
+ *
+ * @typedef  {Analysis} analysis
+ * @property {number}
+ * @property {number}
+ * @property {any}
+ * @property {string[]}
+ * @property {string[]}
+ */
+type Analysis = z.infer<typeof analysis>;
+
 declare enum GroupBy {
     TYPE_ = "type",
     CONTEXT = "context",
@@ -5781,7 +7093,28 @@ declare enum GroupBy {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetBehavioralStateOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const getBehavioralStateOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    data?: any;
+}, {
+    data?: any;
+}>>;
+/**
+ *
+ * @typedef  {GetBehavioralStateOkResponse} getBehavioralStateOkResponse
+ * @property {any} - Behavioral state object
+ */
+type GetBehavioralStateOkResponse = z.infer<typeof getBehavioralStateOkResponse>;
+
+/**
+ * Zod schema for the UpdateBehavioralStateRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const updateBehavioralStateRequest: z.ZodLazy<z.ZodObject<{
     state: z.ZodOptional<z.ZodAny>;
@@ -5801,23 +7134,49 @@ declare const updateBehavioralStateRequest: z.ZodLazy<z.ZodObject<{
  */
 type UpdateBehavioralStateRequest = z.infer<typeof updateBehavioralStateRequest>;
 
+/**
+ * Zod schema for the UpdateBehavioralStateOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const updateBehavioralStateOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    data?: any;
+}, {
+    data?: any;
+}>>;
+/**
+ *
+ * @typedef  {UpdateBehavioralStateOkResponse} updateBehavioralStateOkResponse
+ * @property {any} - Updated behavioral state object
+ */
+type UpdateBehavioralStateOkResponse = z.infer<typeof updateBehavioralStateOkResponse>;
+
+/**
+ * Service class for BehaviorService operations.
+ * Provides methods to interact with BehaviorService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class BehaviorService extends BaseService {
     /**
      * Get current behavioral state for the authenticated user
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<GetBehavioralStateOkResponse>>} - Behavioral state retrieved successfully
      */
-    getBehavioralState(requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    getBehavioralState(requestConfig?: RequestConfig): Promise<HttpResponse<GetBehavioralStateOkResponse>>;
     /**
      * Update or mutate behavioral state
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<UpdateBehavioralStateOkResponse>>} - Behavioral state updated successfully
      */
-    updateBehavioralState(body: UpdateBehavioralStateRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    updateBehavioralState(body: UpdateBehavioralStateRequest, requestConfig?: RequestConfig): Promise<HttpResponse<UpdateBehavioralStateOkResponse>>;
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListTopicsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listTopicsOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -5878,7 +7237,9 @@ interface ListTopicsParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetTopicByIdOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getTopicByIdOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -5910,7 +7271,9 @@ declare const getTopicByIdOkResponse: z.ZodLazy<z.ZodObject<{
 type GetTopicByIdOkResponse = z.infer<typeof getTopicByIdOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the MergeTopicsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const mergeTopicsRequest: z.ZodLazy<z.ZodObject<{
     sourceTopicId: z.ZodString;
@@ -5931,7 +7294,43 @@ declare const mergeTopicsRequest: z.ZodLazy<z.ZodObject<{
 type MergeTopicsRequest = z.infer<typeof mergeTopicsRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the MergeTopicsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const mergeTopicsOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        name: z.ZodString;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        count: number;
+    }, {
+        name: string;
+        count: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        name: string;
+        count: number;
+    } | undefined;
+}, {
+    data?: {
+        name: string;
+        count: number;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {MergeTopicsOkResponse} mergeTopicsOkResponse
+ * @property {Topic}
+ */
+type MergeTopicsOkResponse = z.infer<typeof mergeTopicsOkResponse>;
+
+/**
+ * Zod schema for the DiscoverRelatedTopicsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const discoverRelatedTopicsRequest: z.ZodLazy<z.ZodObject<{
     topicId: z.ZodString;
@@ -5952,7 +7351,43 @@ declare const discoverRelatedTopicsRequest: z.ZodLazy<z.ZodObject<{
 type DiscoverRelatedTopicsRequest = z.infer<typeof discoverRelatedTopicsRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the DiscoverRelatedTopicsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const discoverRelatedTopicsOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
+        name: z.ZodString;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        count: number;
+    }, {
+        name: string;
+        count: number;
+    }>>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        name: string;
+        count: number;
+    }[] | undefined;
+}, {
+    data?: {
+        name: string;
+        count: number;
+    }[] | undefined;
+}>>;
+/**
+ *
+ * @typedef  {DiscoverRelatedTopicsOkResponse} discoverRelatedTopicsOkResponse
+ * @property {Topic[]}
+ */
+type DiscoverRelatedTopicsOkResponse = z.infer<typeof discoverRelatedTopicsOkResponse>;
+
+/**
+ * Zod schema for the CalculateTopicSimilarityRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const calculateTopicSimilarityRequest: z.ZodLazy<z.ZodObject<{
     topicId1: z.ZodString;
@@ -5973,7 +7408,38 @@ declare const calculateTopicSimilarityRequest: z.ZodLazy<z.ZodObject<{
 type CalculateTopicSimilarityRequest = z.infer<typeof calculateTopicSimilarityRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CalculateTopicSimilarityOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const calculateTopicSimilarityOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        similarity: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        similarity?: number | undefined;
+    }, {
+        similarity?: number | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        similarity?: number | undefined;
+    } | undefined;
+}, {
+    data?: {
+        similarity?: number | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {CalculateTopicSimilarityOkResponse} calculateTopicSimilarityOkResponse
+ * @property {CalculateTopicSimilarityOkResponseData}
+ */
+type CalculateTopicSimilarityOkResponse = z.infer<typeof calculateTopicSimilarityOkResponse>;
+
+/**
+ * Zod schema for the FindSimilarTopicsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const findSimilarTopicsRequest: z.ZodLazy<z.ZodObject<{
     topicId: z.ZodString;
@@ -5984,21 +7450,78 @@ declare const findSimilarTopicsRequest: z.ZodLazy<z.ZodObject<{
     threshold?: number | undefined;
     limit?: number | undefined;
 }, {
-    topicId: string;
-    threshold?: number | undefined;
-    limit?: number | undefined;
+    topicId: string;
+    threshold?: number | undefined;
+    limit?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {FindSimilarTopicsRequest} findSimilarTopicsRequest
+ * @property {string}
+ * @property {number}
+ * @property {number}
+ */
+type FindSimilarTopicsRequest = z.infer<typeof findSimilarTopicsRequest>;
+
+/**
+ * Zod schema for the FindSimilarTopicsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const findSimilarTopicsOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
+        topic: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+            name: z.ZodString;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            count: number;
+        }, {
+            name: string;
+            count: number;
+        }>>>;
+        similarity: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        topic?: {
+            name: string;
+            count: number;
+        } | undefined;
+        similarity?: number | undefined;
+    }, {
+        topic?: {
+            name: string;
+            count: number;
+        } | undefined;
+        similarity?: number | undefined;
+    }>>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        topic?: {
+            name: string;
+            count: number;
+        } | undefined;
+        similarity?: number | undefined;
+    }[] | undefined;
+}, {
+    data?: {
+        topic?: {
+            name: string;
+            count: number;
+        } | undefined;
+        similarity?: number | undefined;
+    }[] | undefined;
 }>>;
 /**
  *
- * @typedef  {FindSimilarTopicsRequest} findSimilarTopicsRequest
- * @property {string}
- * @property {number}
- * @property {number}
+ * @typedef  {FindSimilarTopicsOkResponse} findSimilarTopicsOkResponse
+ * @property {FindSimilarTopicsOkResponseData[]}
  */
-type FindSimilarTopicsRequest = z.infer<typeof findSimilarTopicsRequest>;
+type FindSimilarTopicsOkResponse = z.infer<typeof findSimilarTopicsOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ClusterTopicsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const clusterTopicsRequest: z.ZodLazy<z.ZodObject<{
     minClusterSize: z.ZodOptional<z.ZodNumber>;
@@ -6015,7 +7538,43 @@ declare const clusterTopicsRequest: z.ZodLazy<z.ZodObject<{
 type ClusterTopicsRequest = z.infer<typeof clusterTopicsRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ClusterTopicsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const clusterTopicsOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        clusters: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+        clusterCount: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        clusters?: any[] | undefined;
+        clusterCount?: number | undefined;
+    }, {
+        clusters?: any[] | undefined;
+        clusterCount?: number | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        clusters?: any[] | undefined;
+        clusterCount?: number | undefined;
+    } | undefined;
+}, {
+    data?: {
+        clusters?: any[] | undefined;
+        clusterCount?: number | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {ClusterTopicsOkResponse} clusterTopicsOkResponse
+ * @property {ClusterTopicsOkResponseData}
+ */
+type ClusterTopicsOkResponse = z.infer<typeof clusterTopicsOkResponse>;
+
+/**
+ * Zod schema for the DetectCommunitiesRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const detectCommunitiesRequest: z.ZodLazy<z.ZodObject<{
     algorithm: z.ZodOptional<z.ZodString>;
@@ -6032,7 +7591,92 @@ declare const detectCommunitiesRequest: z.ZodLazy<z.ZodObject<{
 type DetectCommunitiesRequest = z.infer<typeof detectCommunitiesRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the DetectCommunitiesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const detectCommunitiesOkResponse: z.ZodLazy<z.ZodObject<{
+    data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        communities: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            topicCount: z.ZodOptional<z.ZodNumber>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            createdAt: string;
+            name: string;
+            updatedAt: string;
+            description?: string | null | undefined;
+            topicCount?: number | undefined;
+        }, {
+            id: string;
+            createdAt: string;
+            name: string;
+            updatedAt: string;
+            description?: string | null | undefined;
+            topicCount?: number | undefined;
+        }>>, "many">>;
+        communityCount: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        communities?: {
+            id: string;
+            createdAt: string;
+            name: string;
+            updatedAt: string;
+            description?: string | null | undefined;
+            topicCount?: number | undefined;
+        }[] | undefined;
+        communityCount?: number | undefined;
+    }, {
+        communities?: {
+            id: string;
+            createdAt: string;
+            name: string;
+            updatedAt: string;
+            description?: string | null | undefined;
+            topicCount?: number | undefined;
+        }[] | undefined;
+        communityCount?: number | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    data?: {
+        communities?: {
+            id: string;
+            createdAt: string;
+            name: string;
+            updatedAt: string;
+            description?: string | null | undefined;
+            topicCount?: number | undefined;
+        }[] | undefined;
+        communityCount?: number | undefined;
+    } | undefined;
+}, {
+    data?: {
+        communities?: {
+            id: string;
+            createdAt: string;
+            name: string;
+            updatedAt: string;
+            description?: string | null | undefined;
+            topicCount?: number | undefined;
+        }[] | undefined;
+        communityCount?: number | undefined;
+    } | undefined;
+}>>;
+/**
+ *
+ * @typedef  {DetectCommunitiesOkResponse} detectCommunitiesOkResponse
+ * @property {DetectCommunitiesOkResponseData}
+ */
+type DetectCommunitiesOkResponse = z.infer<typeof detectCommunitiesOkResponse>;
+
+/**
+ * Zod schema for the SearchTopicsRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchTopicsRequest: z.ZodLazy<z.ZodObject<{
     query: z.ZodString;
@@ -6057,7 +7701,9 @@ declare const searchTopicsRequest: z.ZodLazy<z.ZodObject<{
 type SearchTopicsRequest = z.infer<typeof searchTopicsRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the SearchTopicsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const searchTopicsOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
@@ -6085,6 +7731,11 @@ declare const searchTopicsOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type SearchTopicsOkResponse = z.infer<typeof searchTopicsOkResponse>;
 
+/**
+ * Service class for TopicsService operations.
+ * Provides methods to interact with TopicsService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class TopicsService extends BaseService {
     /**
      * List all topics with pagination
@@ -6104,39 +7755,39 @@ declare class TopicsService extends BaseService {
     /**
      * Merge two topics into one
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<MergeTopicsOkResponse>>} - Topics merged successfully
      */
-    mergeTopics(body: MergeTopicsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    mergeTopics(body: MergeTopicsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<MergeTopicsOkResponse>>;
     /**
      * Discover topics related to a given topic
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<DiscoverRelatedTopicsOkResponse>>} - Related topics discovered successfully
      */
-    discoverRelatedTopics(body: DiscoverRelatedTopicsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    discoverRelatedTopics(body: DiscoverRelatedTopicsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<DiscoverRelatedTopicsOkResponse>>;
     /**
      * Calculate similarity score between two topics
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<CalculateTopicSimilarityOkResponse>>} - Similarity calculated successfully
      */
-    calculateTopicSimilarity(body: CalculateTopicSimilarityRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    calculateTopicSimilarity(body: CalculateTopicSimilarityRequest, requestConfig?: RequestConfig): Promise<HttpResponse<CalculateTopicSimilarityOkResponse>>;
     /**
      * Find topics similar to a given topic
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<FindSimilarTopicsOkResponse>>} - Similar topics found successfully
      */
-    findSimilarTopics(body: FindSimilarTopicsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    findSimilarTopics(body: FindSimilarTopicsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<FindSimilarTopicsOkResponse>>;
     /**
      * Cluster topics using community detection algorithms
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<ClusterTopicsOkResponse>>} - Topics clustered successfully
      */
-    clusterTopics(body: ClusterTopicsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    clusterTopics(body: ClusterTopicsRequest, requestConfig?: RequestConfig): Promise<HttpResponse<ClusterTopicsOkResponse>>;
     /**
      * Detect communities in the topic graph using specified algorithm
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
-     * @returns {Promise<HttpResponse<any>>} - OK
+     * @returns {Promise<HttpResponse<DetectCommunitiesOkResponse>>} - Communities detected successfully
      */
-    detectCommunities(body: DetectCommunitiesRequest, requestConfig?: RequestConfig): Promise<HttpResponse<void>>;
+    detectCommunities(body: DetectCommunitiesRequest, requestConfig?: RequestConfig): Promise<HttpResponse<DetectCommunitiesOkResponse>>;
     /**
      * Search topics by query string using fulltext search
      * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
@@ -6146,7 +7797,9 @@ declare class TopicsService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListTopicsOkResponsePagination model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listTopicsOkResponsePagination: z.ZodLazy<z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
@@ -6171,7 +7824,147 @@ declare const listTopicsOkResponsePagination: z.ZodLazy<z.ZodObject<{
 type ListTopicsOkResponsePagination = z.infer<typeof listTopicsOkResponsePagination>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CalculateTopicSimilarityOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const calculateTopicSimilarityOkResponseData: z.ZodLazy<z.ZodObject<{
+    similarity: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    similarity?: number | undefined;
+}, {
+    similarity?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {CalculateTopicSimilarityOkResponseData} calculateTopicSimilarityOkResponseData
+ * @property {number}
+ */
+type CalculateTopicSimilarityOkResponseData = z.infer<typeof calculateTopicSimilarityOkResponseData>;
+
+/**
+ * Zod schema for the FindSimilarTopicsOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const findSimilarTopicsOkResponseData: z.ZodLazy<z.ZodObject<{
+    topic: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        name: z.ZodString;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        count: number;
+    }, {
+        name: string;
+        count: number;
+    }>>>;
+    similarity: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    topic?: {
+        name: string;
+        count: number;
+    } | undefined;
+    similarity?: number | undefined;
+}, {
+    topic?: {
+        name: string;
+        count: number;
+    } | undefined;
+    similarity?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {FindSimilarTopicsOkResponseData} findSimilarTopicsOkResponseData
+ * @property {Topic}
+ * @property {number}
+ */
+type FindSimilarTopicsOkResponseData = z.infer<typeof findSimilarTopicsOkResponseData>;
+
+/**
+ * Zod schema for the ClusterTopicsOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const clusterTopicsOkResponseData: z.ZodLazy<z.ZodObject<{
+    clusters: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    clusterCount: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    clusters?: any[] | undefined;
+    clusterCount?: number | undefined;
+}, {
+    clusters?: any[] | undefined;
+    clusterCount?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {ClusterTopicsOkResponseData} clusterTopicsOkResponseData
+ * @property {any[]}
+ * @property {number}
+ */
+type ClusterTopicsOkResponseData = z.infer<typeof clusterTopicsOkResponseData>;
+
+/**
+ * Zod schema for the DetectCommunitiesOkResponseData model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const detectCommunitiesOkResponseData: z.ZodLazy<z.ZodObject<{
+    communities: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        topicCount: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        createdAt: string;
+        name: string;
+        updatedAt: string;
+        description?: string | null | undefined;
+        topicCount?: number | undefined;
+    }, {
+        id: string;
+        createdAt: string;
+        name: string;
+        updatedAt: string;
+        description?: string | null | undefined;
+        topicCount?: number | undefined;
+    }>>, "many">>;
+    communityCount: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    communities?: {
+        id: string;
+        createdAt: string;
+        name: string;
+        updatedAt: string;
+        description?: string | null | undefined;
+        topicCount?: number | undefined;
+    }[] | undefined;
+    communityCount?: number | undefined;
+}, {
+    communities?: {
+        id: string;
+        createdAt: string;
+        name: string;
+        updatedAt: string;
+        description?: string | null | undefined;
+        topicCount?: number | undefined;
+    }[] | undefined;
+    communityCount?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {DetectCommunitiesOkResponseData} detectCommunitiesOkResponseData
+ * @property {Community[]}
+ * @property {number}
+ */
+type DetectCommunitiesOkResponseData = z.infer<typeof detectCommunitiesOkResponseData>;
+
+/**
+ * Zod schema for the ListCommunitiesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listCommunitiesOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -6252,7 +8045,9 @@ interface ListCommunitiesParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetCommunityByIdOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getCommunityByIdOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -6304,7 +8099,9 @@ declare const getCommunityByIdOkResponse: z.ZodLazy<z.ZodObject<{
 type GetCommunityByIdOkResponse = z.infer<typeof getCommunityByIdOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the MergeCommunitiesRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const mergeCommunitiesRequest: z.ZodLazy<z.ZodObject<{
     sourceCommunityId: z.ZodString;
@@ -6325,7 +8122,9 @@ declare const mergeCommunitiesRequest: z.ZodLazy<z.ZodObject<{
 type MergeCommunitiesRequest = z.infer<typeof mergeCommunitiesRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the MergeCommunitiesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const mergeCommunitiesOkResponse: z.ZodLazy<z.ZodObject<{
     data: z.ZodOptional<z.ZodLazy<z.ZodObject<{
@@ -6376,6 +8175,11 @@ declare const mergeCommunitiesOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type MergeCommunitiesOkResponse = z.infer<typeof mergeCommunitiesOkResponse>;
 
+/**
+ * Service class for CommunitiesService operations.
+ * Provides methods to interact with CommunitiesService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class CommunitiesService extends BaseService {
     /**
      * List all communities with pagination
@@ -6401,44 +8205,9 @@ declare class CommunitiesService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
- */
-declare const community: z.ZodLazy<z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    topicCount: z.ZodOptional<z.ZodNumber>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    createdAt: string;
-    name: string;
-    updatedAt: string;
-    description?: string | null | undefined;
-    topicCount?: number | undefined;
-}, {
-    id: string;
-    createdAt: string;
-    name: string;
-    updatedAt: string;
-    description?: string | null | undefined;
-    topicCount?: number | undefined;
-}>>;
-/**
- *
- * @typedef  {Community} community
- * @property {string} - Unique identifier for the community
- * @property {string} - Community name
- * @property {string} - Community description
- * @property {number} - Number of topics in this community
- * @property {string} - Creation timestamp
- * @property {string} - Last update timestamp
- */
-type Community = z.infer<typeof community>;
-
-/**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListCommunitiesOkResponsePagination model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listCommunitiesOkResponsePagination: z.ZodLazy<z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
@@ -6463,7 +8232,9 @@ declare const listCommunitiesOkResponsePagination: z.ZodLazy<z.ZodObject<{
 type ListCommunitiesOkResponsePagination = z.infer<typeof listCommunitiesOkResponsePagination>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Memory model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const memory: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -6520,7 +8291,9 @@ declare const memory: z.ZodLazy<z.ZodObject<{
 type Memory = z.infer<typeof memory>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Topic model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const topic: z.ZodLazy<z.ZodObject<{
     name: z.ZodString;
@@ -6540,6 +8313,45 @@ declare const topic: z.ZodLazy<z.ZodObject<{
  */
 type Topic = z.infer<typeof topic>;
 
+/**
+ * Zod schema for the Community model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
+ */
+declare const community: z.ZodLazy<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    topicCount: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: string;
+    name: string;
+    updatedAt: string;
+    description?: string | null | undefined;
+    topicCount?: number | undefined;
+}, {
+    id: string;
+    createdAt: string;
+    name: string;
+    updatedAt: string;
+    description?: string | null | undefined;
+    topicCount?: number | undefined;
+}>>;
+/**
+ *
+ * @typedef  {Community} community
+ * @property {string} - Unique identifier for the community
+ * @property {string} - Community name
+ * @property {string} - Community description
+ * @property {number} - Number of topics in this community
+ * @property {string} - Creation timestamp
+ * @property {string} - Last update timestamp
+ */
+type Community = z.infer<typeof community>;
+
 declare class Error$1 extends ThrowableError {
     message: string;
     protected response?: unknown;
@@ -6569,4 +8381,4 @@ declare class Memnexus {
     set token(token: string);
 }
 
-export { AnalyzeMemoryQualityOkResponse, AnalyzeMemoryQualityOkResponseData, AnalyzePatternsRequest, ApiKey, ApiKeysService, Artifact, ArtifactsService, BehaviorService, CalculateTopicSimilarityRequest, ClusterTopicsRequest, CommunitiesService, Community, CompilePatternsRequest, Conversation, ConversationsService, CreateApiKeyCreatedResponse, CreateApiKeyCreatedResponseData, CreateApiKeyRequest, CreateArtifactCreatedResponse, CreateArtifactRequest, CreateConversationCreatedResponse, CreateConversationRequest, CreateFactCreatedResponse, CreateFactRequest, CreateMemoryRequest, CreateMemoryRequestMemoryType, CreateMemoryResponse, CreateMemoryResponseMeta, DataMemory, DetectCommunitiesRequest, DetectPatternsRequest, DiscoverRelatedTopicsRequest, Entity, Environment, Error$1 as Error, EvaluateFeatureFlagRequest, EventTimeRange, ExecuteGraphRagQueryOkResponse, Explanation, Fact, FactSearchRequest, FactsService, FindConversationsByTopicOkResponse, FindConversationsByTopicOkResponseMetadata, FindConversationsByTopicRequest, FindSimilarTopicsRequest, GetArtifactByIdOkResponse, GetCommunityByIdOkResponse, GetConversationMemoriesOkResponse, GetConversationSummaryOkResponse, GetConversationTimelineOkResponse, GetFactByIdOkResponse, GetMemoryResponse, GetRelatedMemoriesOkResponse, GetRelatedMemoriesOkResponseData, GetSimilarMemoriesOkResponse, GetTopicByIdOkResponse, GraphRagQueryRequest, GraphRagQueryResponse, GraphRagQueryResponseMetadata, GraphRagService, GroupBy, HealthCheck, HealthCheckStatus, HealthService, HttpError, HttpMetadata, HttpMethod, HttpResponse, IngestionTimeRange, ListApiKeysOkResponse, ListArtifactsOkResponse, ListCommunitiesOkResponse, ListCommunitiesOkResponsePagination, ListConversationsOkResponse, ListConversationsOkResponsePagination, ListFactsOkResponse, ListMemoriesOkResponse, ListPatternsOkResponse, ListPatternsOkResponsePagination, ListTopicsOkResponse, ListTopicsOkResponsePagination, Memnexus, MemoriesService, Memory, MemoryMemoryType1, MemoryMemoryType2, MemoryMemoryType3, MemoryMemoryType4, MergeCommunitiesOkResponse, MergeCommunitiesRequest, MergeTopicsRequest, Mode, NoCache, Pagination, Pattern, PatternsService, PruneMemoriesOkResponse, PruneMemoriesOkResponseData, PruneMemoriesRequest, QualityDistribution, QueryCommunitiesRequest, RecordPatternFeedbackRequest, RelatedMemoryResult, RelatedMemoryResultMemory, RequestConfig, Results, RetryOptions, Role, SdkConfig, SearchConversationsOkResponse, SearchConversationsRequest, SearchFactsOkResponse, SearchFactsOkResponseMetadata, SearchMethod, SearchRequest, SearchRequestMemoryType, SearchResponse, SearchResponsePagination, SearchResult, SearchResultMemory, SearchTopicsOkResponse, SearchTopicsRequest, ServiceCheck, ServiceCheckStatus, SystemService, TemporalMetadata, TemporalMode, Topic, TopicsService, UpdateArtifactOkResponse, UpdateArtifactRequest, UpdateBehavioralStateRequest, UpdateFactOkResponse, UpdateFactRequest, UpdateMemoryOkResponse, UpdateMemoryRequest, UpdateMemoryRequestMemoryType, UpdatePatternRequest, ValidationOptions };
+export { Analysis, AnalyzeMemoryQualityOkResponse, AnalyzeMemoryQualityOkResponseData, AnalyzePatternsOkResponse, AnalyzePatternsOkResponseData, AnalyzePatternsRequest, ApiKey, ApiKeysService, Artifact, ArtifactsService, BehaviorService, CalculateTopicSimilarityOkResponse, CalculateTopicSimilarityOkResponseData, CalculateTopicSimilarityRequest, ClusterTopicsOkResponse, ClusterTopicsOkResponseData, ClusterTopicsRequest, CommunitiesService, Community, CompilePatternsOkResponse, CompilePatternsRequest, Confidence, Conversation, ConversationsService, CreateApiKeyCreatedResponse, CreateApiKeyCreatedResponseData, CreateApiKeyRequest, CreateArtifactCreatedResponse, CreateArtifactRequest, CreateConversationCreatedResponse, CreateConversationRequest, CreateFactCreatedResponse, CreateFactRequest, CreateMemoryRequest, CreateMemoryRequestMemoryType, CreateMemoryResponse, CreateMemoryResponseMeta, DataMemory, DataStatus, DebugUserOkResponse, DebugUserOkResponseData, DetectCommunitiesOkResponse, DetectCommunitiesOkResponseData, DetectCommunitiesRequest, DetectPatternsOkResponse, DetectPatternsOkResponseData, DetectPatternsRequest, DiscoverRelatedTopicsOkResponse, DiscoverRelatedTopicsRequest, Entity, Environment, Error$1 as Error, EvaluateFeatureFlagOkResponse, EvaluateFeatureFlagOkResponseData, EvaluateFeatureFlagRequest, EventTimeRange, ExecuteGraphRagQueryOkResponse, ExplainGraphRagQueryOkResponse, Explanation, Fact, FactSearchRequest, FactsService, FindConversationsByTopicOkResponse, FindConversationsByTopicOkResponseMetadata, FindConversationsByTopicRequest, FindSimilarTopicsOkResponse, FindSimilarTopicsOkResponseData, FindSimilarTopicsRequest, GetArtifactByIdOkResponse, GetBehavioralStateOkResponse, GetCommunityByIdOkResponse, GetContextStatusOkResponse, GetConversationMemoriesOkResponse, GetConversationSummaryOkResponse, GetConversationTimelineOkResponse, GetFactByIdOkResponse, GetFeatureFlagsOkResponse, GetMemoryResponse, GetRelatedMemoriesOkResponse, GetRelatedMemoriesOkResponseData, GetSimilarMemoriesOkResponse, GetSystemHealthOkResponse, GetSystemHealthOkResponseData, GetTopicByIdOkResponse, GraphRagQueryRequest, GraphRagQueryResponse, GraphRagQueryResponseMetadata, GraphRagService, GroupBy, HealthCheck, HealthCheckStatus, HealthService, HttpError, HttpMetadata, HttpMethod, HttpResponse, IngestionTimeRange, ListApiKeysOkResponse, ListArtifactsOkResponse, ListCommunitiesOkResponse, ListCommunitiesOkResponsePagination, ListConversationsOkResponse, ListConversationsOkResponsePagination, ListFactsOkResponse, ListMemoriesOkResponse, ListPatternsOkResponse, ListPatternsOkResponsePagination, ListTopicsOkResponse, ListTopicsOkResponsePagination, Memnexus, MemoriesService, Memory, MemoryMemoryType1, MemoryMemoryType2, MemoryMemoryType3, MemoryMemoryType4, MergeCommunitiesOkResponse, MergeCommunitiesRequest, MergeTopicsOkResponse, MergeTopicsRequest, Mode, NoCache, Pagination, Pattern, PatternsService, PruneMemoriesOkResponse, PruneMemoriesOkResponseData, PruneMemoriesRequest, QualityDistribution, QueryCommunitiesOkResponse, QueryCommunitiesRequest, RecordPatternFeedbackOkResponse, RecordPatternFeedbackRequest, RelatedMemoryResult, RelatedMemoryResultMemory, RequestConfig, Results, RetryOptions, Role, SdkConfig, SearchConversationsOkResponse, SearchConversationsRequest, SearchFactsOkResponse, SearchFactsOkResponseMetadata, SearchMethod, SearchRequest, SearchRequestMemoryType, SearchResponse, SearchResponsePagination, SearchResult, SearchResultMemory, SearchTopicsOkResponse, SearchTopicsRequest, ServiceCheck, ServiceCheckStatus, SystemService, TemporalMetadata, TemporalMode, Topic, TopicsService, UpdateArtifactOkResponse, UpdateArtifactRequest, UpdateBehavioralStateOkResponse, UpdateBehavioralStateRequest, UpdateFactOkResponse, UpdateFactRequest, UpdateMemoryOkResponse, UpdateMemoryRequest, UpdateMemoryRequestMemoryType, UpdatePatternOkResponse, UpdatePatternRequest, ValidationOptions };