@reminix/cli 0.1.22 → 0.1.24

package/dist/lib/api-types.d.ts

@@ -125,7 +125,7 @@ export interface paths {
          *
          *     **Supported Agents:** Custom agents only. Managed agents should use the /chat endpoint.
          *
-         *     **Input:** Pass structured input data matching the agent's parameter schema.
+         *     **Input:** Pass structured input data matching the agent's input schema.
          *
          *     **Timeout:** Agent invocations have a 60-second timeout. If the agent takes longer to respond,
          *     you will receive a 504 Gateway Timeout error. For long-running tasks, consider using streaming
@@ -225,7 +225,7 @@ export interface paths {
         put?: never;
         /**
          * Call a tool
-         * @description Call a tool with the provided input parameters.
+         * @description Call a tool with the provided input.
          *
          *     **Timeout:** Tool calls have a 60-second timeout. If the tool takes longer to respond,
          *     you will receive a 504 Gateway Timeout error.
@@ -452,7 +452,7 @@ export interface paths {
          *     Use filters to narrow down results by type, source, name, or status.
          *
          *     **Filters:**
-         *     - `type`: Filter by execution type (agent_execute, tool_execute)
+         *     - `type`: Filter by execution type (agent_invoke, agent_chat, tool_call)
          *     - `source`: Filter by request source (api, cli, dashboard, widget, sdk)
          *     - `name`: Filter by agent or tool name
          *     - `status`: Filter by result status (success, error, timeout)
@@ -537,6 +537,218 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/memories": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List memories
+         * @description List all memory keys for a specific identity.
+         *
+         *     Identity is specified via query parameters with the `identity.` prefix.
+         *     For example: `?identity.user_id=user_123&identity.tenant_id=acme`
+         *
+         *     Returns memory keys and metadata (not full values for efficiency).
+         */
+        get: operations["listMemories"];
+        put?: never;
+        /**
+         * Store a memory
+         * @description Store a key-value memory for a specific identity.
+         *
+         *     If a memory with the same key already exists, it will be updated.
+         */
+        post: operations["storeMemory"];
+        /**
+         * Delete all memories
+         * @description Delete all memories for a specific identity.
+         */
+        delete: operations["deleteAllMemories"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/memories/{key}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a memory
+         * @description Get a memory value by key for a specific identity.
+         *
+         *     Identity is specified via query parameters with the `identity.` prefix.
+         */
+        get: operations["getMemory"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a memory
+         * @description Delete a memory by key for a specific identity.
+         */
+        delete: operations["deleteMemory"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/knowledge/collections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List knowledge collections
+         * @description List all knowledge collections for the project.
+         */
+        get: operations["listCollections"];
+        put?: never;
+        /**
+         * Create a knowledge collection
+         * @description Create a new knowledge collection for storing documents.
+         */
+        post: operations["createCollection"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/knowledge/collections/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a knowledge collection
+         * @description Get details of a knowledge collection including document stats.
+         */
+        get: operations["getCollection"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a knowledge collection
+         * @description Delete a knowledge collection and all its documents.
+         */
+        delete: operations["deleteCollection"];
+        options?: never;
+        head?: never;
+        /**
+         * Update a knowledge collection
+         * @description Update a knowledge collection name or description.
+         */
+        patch: operations["updateCollection"];
+        trace?: never;
+    };
+    "/knowledge/collections/{id}/documents": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List documents in a collection
+         * @description List all documents in a knowledge collection.
+         */
+        get: operations["listDocuments"];
+        put?: never;
+        /**
+         * Upload a document
+         * @description Create a document record and get a presigned URL for upload.
+         *
+         *     After receiving the response, upload the file to the presigned URL using a PUT request.
+         *     The document will be processed automatically after upload.
+         */
+        post: operations["createDocument"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/knowledge/collections/{collectionId}/documents/{documentId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a document
+         * @description Get details of a document.
+         */
+        get: operations["getDocument"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a document
+         * @description Delete a document and its associated data.
+         */
+        delete: operations["deleteDocument"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/knowledge/collections/{collectionId}/documents/{documentId}/process": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Process a document
+         * @description Trigger processing for a document after upload.
+         *
+         *     This extracts text from the document, splits it into chunks,
+         *     generates embeddings, and stores them for search.
+         *
+         *     The document status will transition: pending → processing → ready (or failed).
+         */
+        post: operations["processDocument"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/knowledge/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Search knowledge base
+         * @description Search across one or more knowledge collections using semantic similarity.
+         *
+         *     The search uses vector embeddings to find the most relevant content.
+         *     Results are ordered by relevance score (0-1, higher is more similar).
+         */
+        post: operations["searchKnowledge"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -580,6 +792,18 @@ export interface components {
             /** @description Error message describing what went wrong */
             error: string;
         };
+        /** @description Memory feature configuration */
+        AgentMemoryConfig: {
+            /** @description Whether memory is enabled for this agent */
+            enabled: boolean;
+        };
+        /** @description Knowledge base feature configuration */
+        AgentKnowledgeBaseConfig: {
+            /** @description Whether knowledge base is enabled for this agent */
+            enabled: boolean;
+            /** @description Collection IDs to search */
+            collectionIds: string[];
+        };
         /**
          * @description Agent configuration (for managed agents)
          * @example {
@@ -589,7 +813,16 @@ export interface components {
          *       "tools": [
          *         "search-web"
          *       ],
-         *       "maxIterations": 10
+         *       "maxIterations": 10,
+         *       "memory": {
+         *         "enabled": true
+         *       },
+         *       "knowledgeBase": {
+         *         "enabled": true,
+         *         "collectionIds": [
+         *           "coll_abc123"
+         *         ]
+         *       }
          *     }
          */
         AgentConfig: {
@@ -608,14 +841,29 @@ export interface components {
             maxIterations?: number;
             /** @description Whether to require approval for tool calls */
             requireApproval?: boolean;
+            memory?: components["schemas"]["AgentMemoryConfig"];
+            knowledgeBase?: components["schemas"]["AgentKnowledgeBaseConfig"];
         } | null;
-        /** @description JSON Schema for agent input parameters */
+        /** @description JSON Schema for agent input */
         JsonSchema: ({
-            type: string;
+            /** @description JSON Schema type (e.g., "object", "string", "array") */
+            type?: string;
+            /** @description Human-readable title */
+            title?: string;
+            /** @description Description of the schema */
+            description?: string;
+            /** @description Default value for the property */
+            default?: unknown;
+            /** @description Enumeration of allowed values */
+            enum?: unknown[];
+            /** @description Property definitions for object types */
             properties?: {
                 [key: string]: unknown;
             };
+            /** @description List of required property names */
             required?: string[];
+            /** @description Schema for array items */
+            items?: unknown;
         } & {
             [key: string]: unknown;
         }) | null;
@@ -636,12 +884,8 @@ export interface components {
             config: components["schemas"]["AgentConfig"];
             /** @description Agent description */
             description: string | null;
-            parameters: components["schemas"]["JsonSchema"];
+            input: components["schemas"]["JsonSchema"];
             output: components["schemas"]["JsonSchema"] & unknown;
-            /** @description Top-level keys expected in request body */
-            requestKeys: string[] | null;
-            /** @description Top-level keys returned in response body */
-            responseKeys: string[] | null;
             /** @description Whether agent supports streaming */
             canStream: boolean | null;
             /** @description Whether agent supports chat interface */
@@ -707,11 +951,16 @@ export interface components {
                 maxIterations?: number;
                 /** @description Whether to require approval for tool calls */
                 requireApproval?: boolean;
+                memory?: components["schemas"]["AgentMemoryConfig"];
+                knowledgeBase?: components["schemas"]["AgentKnowledgeBaseConfig"];
             };
         };
-        /** @description Response with dynamic keys based on agent configuration. Regular agents return { output: ... }, chat agents return { messages: [...] }. */
-        ExecuteResponse: {
-            [key: string]: unknown;
+        /** @description Response with output from the agent and optional execution ID. */
+        AgentInvokeResponse: {
+            /** @description Output from the agent */
+            output?: unknown;
+            /** @description Execution ID for tracking */
+            execution_id?: string;
         };
         StreamChunk: {
             /** @description Text chunk from the stream */
@@ -729,13 +978,15 @@ export interface components {
         } & {
             [key: string]: unknown;
         };
-        /** @description Request body with dynamic keys based on agent configuration. Always includes optional `stream` and `context` fields. */
-        ExecuteRequest: {
+        /** @description Request body with input object and optional stream/context fields. */
+        AgentInvokeRequest: {
+            /** @description Input data for the agent */
+            input?: {
+                [key: string]: unknown;
+            };
             /** @description Enable streaming response (SSE) */
             stream?: boolean;
             context?: components["schemas"]["Context"];
-        } & {
-            [key: string]: unknown;
         };
         /**
          * @description Message role
@@ -809,7 +1060,7 @@ export interface components {
             status: "active" | "inactive";
             /** @description Tool description */
             description: string | null;
-            parameters: components["schemas"]["JsonSchema"] & unknown;
+            input: components["schemas"]["JsonSchema"] & unknown;
             output: components["schemas"]["JsonSchema"] & unknown;
             /** @description When the tool was discovered */
             discoveredAt: string | null;
@@ -820,12 +1071,12 @@ export interface components {
             /** @description Last update timestamp */
             updatedAt: string;
         };
-        ExecuteToolResponse: {
+        ToolCallResponse: {
             /** @description Output from the tool execution. */
             output?: unknown;
         };
-        ExecuteToolRequest: {
-            /** @description Input parameters for the tool. Structure depends on tool definition. */
+        ToolCallRequest: {
+            /** @description Input data for the tool. Structure depends on tool definition. */
             input: {
                 [key: string]: unknown;
             };
@@ -972,7 +1223,7 @@ export interface components {
             status: "success" | "error" | "timeout";
             /** @description Execution duration in milliseconds */
             durationMs: number | null;
-            /** @description Input parameters */
+            /** @description Request input */
             input?: unknown;
             /** @description Output from execution (null for errors) */
             output?: unknown;
@@ -1023,6 +1274,78 @@ export interface components {
             /** @description Conversation messages */
             messages: components["schemas"]["ConversationMessage"][];
         };
+        MemoryListItem: {
+            /** @description Memory key */
+            key: string;
+            /** @description When the memory was last updated */
+            updatedAt: string;
+            /** @description When the memory expires (if set) */
+            expiresAt: string | null;
+        };
+        /** @description Identity fields for memory scoping (e.g., user_id, tenant_id) */
+        MemoryIdentity: {
+            [key: string]: unknown;
+        };
+        Memory: {
+            /** @description Unique memory ID */
+            id: string;
+            /** @description Project ID */
+            projectId: string;
+            identity: components["schemas"]["MemoryIdentity"];
+            /** @description Memory key */
+            key: string;
+            /** @description Memory value */
+            value?: unknown;
+            /** @description When the memory was created */
+            createdAt: string;
+            /** @description When the memory was last updated */
+            updatedAt: string;
+            /** @description When the memory expires */
+            expiresAt: string | null;
+        };
+        KnowledgeCollection: {
+            /** @description Unique collection ID */
+            id: string;
+            /** @description Project ID */
+            projectId: string;
+            /** @description Collection name */
+            name: string;
+            /** @description Collection description */
+            description: string | null;
+            /** @description Embedding model used */
+            embeddingModel: string;
+            /** @description Total number of documents */
+            documentCount?: number;
+            /** @description Number of processed documents */
+            readyDocumentCount?: number;
+            /** @description When the collection was created */
+            createdAt: string;
+            /** @description When the collection was last updated */
+            updatedAt: string;
+        };
+        KnowledgeDocument: {
+            /** @description Unique document ID */
+            id: string;
+            /** @description Collection ID */
+            collectionId: string;
+            /** @description Document name */
+            name: string;
+            /** @description S3 URL of the document */
+            sourceUrl: string;
+            /** @description MIME type */
+            mimeType: string;
+            /**
+             * @description Processing status
+             * @enum {string}
+             */
+            status: "pending" | "processing" | "ready" | "failed";
+            /** @description Document metadata */
+            metadata?: unknown;
+            /** @description When the document was created */
+            createdAt: string;
+            /** @description When the document was last updated */
+            updatedAt: string;
+        };
     };
     responses: never;
     parameters: never;
@@ -1358,7 +1681,7 @@ export interface operations {
         };
         requestBody?: {
             content: {
-                "application/json": components["schemas"]["ExecuteRequest"];
+                "application/json": components["schemas"]["AgentInvokeRequest"];
             };
         };
         responses: {
@@ -1368,7 +1691,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ExecuteResponse"];
+                    "application/json": components["schemas"]["AgentInvokeResponse"];
                     "text/event-stream": components["schemas"]["StreamChunk"];
                 };
             };
@@ -1596,7 +1919,7 @@ export interface operations {
         };
         requestBody?: {
             content: {
-                "application/json": components["schemas"]["ExecuteToolRequest"];
+                "application/json": components["schemas"]["ToolCallRequest"];
             };
         };
         responses: {
@@ -1606,7 +1929,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ExecuteToolResponse"];
+                    "application/json": components["schemas"]["ToolCallResponse"];
                 };
             };
             /** @description Bad Request - Invalid input */
@@ -2094,7 +2417,7 @@ export interface operations {
                 /** @description Cursor for pagination */
                 cursor?: string;
                 /** @description Filter by execution type */
-                type?: "agent_execute" | "agent_chat" | "tool_execute";
+                type?: "agent_invoke" | "agent_chat" | "tool_call";
                 /** @description Filter by request source */
                 source?: "api" | "cli" | "dashboard" | "widget" | "sdk";
                 /** @description Filter by agent or tool name */
@@ -2293,5 +2616,695 @@ export interface operations {
             };
         };
     };
+    listMemories: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of memory keys */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["MemoryListItem"][];
+                    };
+                };
+            };
+            /** @description Bad request - identity required */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    storeMemory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    identity: components["schemas"]["MemoryIdentity"] & unknown;
+                    /** @description Memory key */
+                    key: string;
+                    /** @description Value to store */
+                    value?: unknown;
+                    /**
+                     * Format: date-time
+                     * @description Optional expiration time (ISO 8601)
+                     */
+                    expiresAt?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Memory stored successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Memory"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteAllMemories: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Memories deleted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Number of memories deleted */
+                        deleted: number;
+                    };
+                };
+            };
+            /** @description Bad request - identity required */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getMemory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Memory key */
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Memory value */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Memory"];
+                };
+            };
+            /** @description Bad request - identity required */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Memory not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteMemory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Memory key */
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Memory deleted successfully */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Bad request - identity required */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Memory not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    listCollections: {
+        parameters: {
+            query?: {
+                limit?: number;
+                cursor?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of collections */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["KnowledgeCollection"][];
+                        nextCursor: string | null;
+                        hasMore: boolean;
+                    };
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    createCollection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Collection name */
+                    name: string;
+                    /** @description Collection description */
+                    description?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Collection created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["KnowledgeCollection"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getCollection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Collection details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["KnowledgeCollection"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Collection not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteCollection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Collection deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Collection not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    updateCollection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    name?: string;
+                    description?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Collection updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["KnowledgeCollection"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Collection not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    listDocuments: {
+        parameters: {
+            query?: {
+                limit?: number;
+                cursor?: string;
+                status?: "pending" | "processing" | "ready" | "failed";
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of documents */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["KnowledgeDocument"][];
+                        nextCursor: string | null;
+                        hasMore: boolean;
+                    };
+                };
+            };
+            /** @description Collection not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    createDocument: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Document name (filename) */
+                    name: string;
+                    /** @description MIME type of the document */
+                    mimeType: string;
+                    /** @description File size in bytes */
+                    size?: number;
+                };
+            };
+        };
+        responses: {
+            /** @description Document created with upload URL */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        document: components["schemas"]["KnowledgeDocument"];
+                        /** @description Presigned URL for uploading the file */
+                        uploadUrl: string;
+                    };
+                };
+            };
+            /** @description Collection not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getDocument: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                collectionId: string;
+                documentId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Document details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["KnowledgeDocument"];
+                };
+            };
+            /** @description Document not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    deleteDocument: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                collectionId: string;
+                documentId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Document deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Document not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    processDocument: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                collectionId: string;
+                documentId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Use Unstructured.io for extraction if available */
+                    preferUnstructured?: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Processing started */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        message: string;
+                        document: components["schemas"]["KnowledgeDocument"];
+                    };
+                };
+            };
+            /** @description Bad request - Document already processed or processing */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Document not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    searchKnowledge: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @description Natural language search query */
+                    query: string;
+                    /** @description Collection IDs to search */
+                    collectionIds: string[];
+                    /**
+                     * @description Maximum number of results
+                     * @default 5
+                     */
+                    limit?: number;
+                    /**
+                     * @description Minimum similarity score (0-1)
+                     * @default 0.7
+                     */
+                    threshold?: number;
+                };
+            };
+        };
+        responses: {
+            /** @description Search results */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Number of results found */
+                        count: number;
+                        chunks: {
+                            /** @description Chunk text content */
+                            content: string;
+                            /** @description Similarity score (0-1) */
+                            score: number;
+                            /** @description Source document ID */
+                            documentId: string;
+                            /** @description Position in document */
+                            chunkIndex: number;
+                        }[];
+                    };
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
 }
 //# sourceMappingURL=api-types.d.ts.map