@magemetrics/core 0.9.0 → 0.10.0-rc1

package/dist/index.d.ts

@@ -142,6 +142,8 @@ declare interface components {
             dataType: string;
             renderType?: string;
             unit?: string;
+            /** @enum {string} */
+            canonicalDataType?: "numeric" | "boolean" | "datetime" | "text" | "array" | "json" | "other";
         }[];
         /** Format: uuid */
         CanvasId: string;
@@ -288,6 +290,75 @@ declare interface components {
             explanation: string;
             type: string;
         };
+        AgentRunResponse: {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            agent_id: string;
+            /** @enum {string} */
+            status: "pending" | "running" | "completed" | "failed" | "cancelled";
+            created_at: string;
+            started_at: string | null;
+            completed_at: string | null;
+            output_data: {
+                [key: string]: unknown;
+            } | null;
+            error_message: string | null;
+        };
+        StartAgentRunRequest: {
+            /** Format: uuid */
+            agent_id: string;
+            /** @default {} */
+            inputs: {
+                [key: string]: unknown;
+            };
+        };
+        Agent: {
+            /** Format: uuid */
+            id: string;
+            company_id: number;
+            name: string;
+            objective: string | null;
+            generated_inputs_fragment: string | null;
+            generated_outputs_fragment: string | null;
+            generated_objective_fragment: string | null;
+            active_tools: string[] | null;
+            input_schema: ({
+                id: string;
+                name: string;
+                description?: string;
+                /** @enum {string} */
+                type: "enum";
+                options: {
+                    value: string;
+                    fragment?: string;
+                }[];
+                /** @default false */
+                useFragmentMapping: boolean;
+                /** @default false */
+                required: boolean;
+            } | {
+                id: string;
+                name: string;
+                description?: string;
+                /** @enum {string} */
+                type: "text";
+                /**
+                 * @default false
+                 * @enum {boolean}
+                 */
+                useFragmentMapping: false;
+                /** @default false */
+                required: boolean;
+            })[] | null;
+            output_schema: {
+                [key: string]: unknown;
+            } | null;
+            master_prompt_name: string | null;
+            master_prompt_version: number | null;
+            created_at: string;
+            updated_at: string;
+        };
     };
     responses: never;
     parameters: never;
@@ -418,8 +489,8 @@ export declare interface ExternalAuthProviderConfig {
 declare type FrontendRecentFlows = z.infer<typeof FrontendRecentFlowsSchema>;
 
 declare const FrontendRecentFlowsSchema: z.ZodObject<{
-    title: z.ZodNullable<z.ZodString>;
     id: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
     request: z.ZodString;
     created_at: z.ZodString;
     user_id: z.ZodNullable<z.ZodString>;
@@ -436,8 +507,8 @@ declare const inputSchema: z.ZodObject<{
     isNewAnalysisGoal: z.ZodBoolean;
     responseType: z.ZodEnum<{
         text: "text";
-        table: "table";
         visualization: "visualization";
+        table: "table";
     }>;
     difficultyLevel: z.ZodEnum<{
         simple: "simple";
@@ -686,8 +757,8 @@ export declare class MageMetricsClient {
             }>;
             delete: (canvasId: string) => Promise<void>;
             getForFlow: (flowId: string) => Promise<{
-                title: string | null;
                 id: string;
+                title: string | null;
                 nodes: any[];
                 edges: any[];
                 is_public: boolean;
@@ -713,6 +784,7 @@ export declare class MageMetricsClient {
                 dataType: string;
                 renderType?: string;
                 unit?: string;
+                canonicalDataType?: "numeric" | "boolean" | "datetime" | "text" | "array" | "json" | "other";
             }[];
             rowCount: {
                 count: number;
@@ -949,7 +1021,7 @@ declare interface operations {
                 /** @example name:asc,date:desc */
                 order?: string;
                 cursor?: number;
-                /** @example status:active,name:John%20Doe */
+                /** @example status:eq:active,name:contains:John%20Doe */
                 filter?: string;
             };
             header?: never;
@@ -1890,7 +1962,7 @@ declare interface operations {
                 /** @example name:asc,date:desc */
                 order?: string;
                 cursor?: number;
-                /** @example status:active,name:John%20Doe */
+                /** @example status:eq:active,name:contains:John%20Doe */
                 filter?: string;
             };
             header: {
@@ -2948,6 +3020,148 @@ declare interface operations {
             };
         };
     };
+    listAgentRuns: {
+        parameters: {
+            query?: {
+                status?: "pending" | "running" | "completed" | "failed" | "cancelled";
+                agent_id?: string;
+                limit?: number;
+            };
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of agent runs */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentRunResponse"][];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    startAgentRun: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["StartAgentRunRequest"];
+            };
+        };
+        responses: {
+            /** @description The agent run was started */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentRunResponse"];
+                };
+            };
+            /** @description Invalid request or input validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Agent definition not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getAgentRun: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The agent run */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentRunResponse"];
+                };
+            };
+            /** @description Agent run not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
     createQueryExample: {
         parameters: {
             query?: never;
@@ -3506,94 +3720,631 @@ declare interface operations {
             };
         };
     };
-}
-
-declare type PatchParam<T, Config extends RemoveParamsConfig, P extends keyof Config> = Simplify<T extends {
-    [key in P]: infer H;
-} ? H extends Partial<Record<string, unknown>> ? Config[P] extends string ? Omit<H, Config[P]> : H : never : never>;
-
-/**
- * This file was auto-generated by openapi-typescript.
- * Do not make direct changes to the file.
- */
-
-declare interface paths {
-    "/api/v1/auth/exchangeExternalToken": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        post: operations["exchangeExternalToken"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/v1/auth/apiInformation": {
+    generateSuggestedInputs: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get: operations["getApiInformation"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/v1/public/canvas/{canvas_id}/data-reports/{report_id}/columns": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
+        requestBody?: {
+            content: {
+                "application/json": {
+                    objective: string;
+                    guidelines: string;
+                };
+            };
         };
-        get: operations["getPublicCanvasDataReportColumns"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/v1/public/canvas/{canvas_id}/data-reports/{report_id}/data": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
+        responses: {
+            /** @description Suggested input fields generated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        inputFields: {
+                            id: string;
+                            name: string;
+                            description: string;
+                            /** @enum {string} */
+                            type: "text" | "enum";
+                            options?: {
+                                value: string;
+                                fragment?: string;
+                            }[];
+                            /** @default false */
+                            useFragmentMapping: boolean;
+                            /** @default true */
+                            required: boolean;
+                        }[];
+                    };
+                };
+            };
+            /** @description Generation failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
         };
-        get: operations["getPublicCanvasDataReportData"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
     };
-    "/api/v1/public/canvas/{canvas_id}/data-reports/{report_id}/count": {
+    generateOutputStructure: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get: operations["getPublicCanvasDataReportRowCount"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
+        requestBody?: {
+            content: {
+                "application/json": {
+                    objective: string;
+                    guidelines: string;
+                    inputFields: {
+                        id: string;
+                        name: string;
+                        description: string;
+                        /** @enum {string} */
+                        type: "text" | "enum";
+                        options?: {
+                            value: string;
+                            fragment?: string;
+                        }[];
+                        /** @default false */
+                        useFragmentMapping?: boolean;
+                        /** @default true */
+                        required?: boolean;
+                    }[];
+                };
+            };
+        };
+        responses: {
+            /** @description Output structure generated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        outputStructure: {
+                            key: string;
+                            /** @enum {string} */
+                            type: "text" | "number" | "boolean" | "enum" | "array" | "object";
+                            description: string;
+                            /** @default false */
+                            attachEvidences: boolean;
+                            enumValues?: string[];
+                            children?: {
+                                key: string;
+                                /** @enum {string} */
+                                type: "text" | "number" | "boolean" | "enum" | "array" | "object";
+                                description: string;
+                                /** @default false */
+                                attachEvidences: boolean;
+                                enumValues?: string[];
+                                children?: {
+                                    key: string;
+                                    /** @enum {string} */
+                                    type: "text" | "number" | "boolean" | "enum" | "array" | "object";
+                                    description: string;
+                                    /** @default false */
+                                    attachEvidences: boolean;
+                                    enumValues?: string[];
+                                }[];
+                            }[];
+                        }[];
+                    };
+                };
+            };
+            /** @description Generation failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    generateFragments: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    objective: string;
+                    guidelines: string;
+                    inputFields: {
+                        id: string;
+                        name: string;
+                        description: string;
+                        /** @enum {string} */
+                        type: "text" | "enum";
+                        options?: {
+                            value: string;
+                            fragment?: string;
+                        }[];
+                        /** @default false */
+                        useFragmentMapping?: boolean;
+                        /** @default true */
+                        required?: boolean;
+                    }[];
+                    outputStructure: {
+                        key: string;
+                        /** @enum {string} */
+                        type: "text" | "number" | "boolean" | "enum" | "array" | "object";
+                        description: string;
+                        /** @default false */
+                        attachEvidences?: boolean;
+                        enumValues?: string[];
+                        children?: {
+                            key: string;
+                            /** @enum {string} */
+                            type: "text" | "number" | "boolean" | "enum" | "array" | "object";
+                            description: string;
+                            /** @default false */
+                            attachEvidences?: boolean;
+                            enumValues?: string[];
+                            children?: {
+                                key: string;
+                                /** @enum {string} */
+                                type: "text" | "number" | "boolean" | "enum" | "array" | "object";
+                                description: string;
+                                /** @default false */
+                                attachEvidences?: boolean;
+                                enumValues?: string[];
+                            }[];
+                        }[];
+                    }[];
+                };
+            };
+        };
+        responses: {
+            /** @description Prompt fragments generated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        objectiveFragment: string;
+                        inputsFragment: string;
+                        outputFragment: string;
+                    };
+                };
+            };
+            /** @description Generation failed */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    listAgents: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of agents for the company */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Agent"][];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    createAgent: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    name: string;
+                    objective?: string;
+                    generated_inputs_fragment?: string;
+                    generated_outputs_fragment?: string;
+                    generated_objective_fragment?: string;
+                    /** @default [] */
+                    active_tools?: string[];
+                    input_schema?: ({
+                        id: string;
+                        name: string;
+                        description?: string;
+                        /** @enum {string} */
+                        type: "enum";
+                        options: {
+                            value: string;
+                            fragment?: string;
+                        }[];
+                        /** @default false */
+                        useFragmentMapping?: boolean;
+                        /** @default false */
+                        required?: boolean;
+                    } | {
+                        id: string;
+                        name: string;
+                        description?: string;
+                        /** @enum {string} */
+                        type: "text";
+                        /**
+                         * @default false
+                         * @enum {boolean}
+                         */
+                        useFragmentMapping?: false;
+                        /** @default false */
+                        required?: boolean;
+                    })[];
+                    output_schema: {
+                        [key: string]: unknown;
+                    };
+                    master_prompt_name?: string;
+                    master_prompt_version?: number;
+                };
+            };
+        };
+        responses: {
+            /** @description The created agent */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Agent"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getAgent: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The agent */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Agent"];
+                };
+            };
+            /** @description Agent not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    updateAgent: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    name?: string;
+                    objective?: string | null;
+                    generated_inputs_fragment?: string | null;
+                    generated_outputs_fragment?: string | null;
+                    generated_objective_fragment?: string | null;
+                    active_tools?: string[];
+                    input_schema?: ({
+                        id: string;
+                        name: string;
+                        description?: string;
+                        /** @enum {string} */
+                        type: "enum";
+                        options: {
+                            value: string;
+                            fragment?: string;
+                        }[];
+                        /** @default false */
+                        useFragmentMapping?: boolean;
+                        /** @default false */
+                        required?: boolean;
+                    } | {
+                        id: string;
+                        name: string;
+                        description?: string;
+                        /** @enum {string} */
+                        type: "text";
+                        /**
+                         * @default false
+                         * @enum {boolean}
+                         */
+                        useFragmentMapping?: false;
+                        /** @default false */
+                        required?: boolean;
+                    })[] | null;
+                    output_schema?: {
+                        [key: string]: unknown;
+                    } | null;
+                    master_prompt_name?: string | null;
+                    master_prompt_version?: number | null;
+                };
+            };
+        };
+        responses: {
+            /** @description The updated agent */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Agent"];
+                };
+            };
+            /** @description Invalid request (e.g., invalid tools) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Agent not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    deleteAgent: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Agent deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        success: true;
+                    };
+                };
+            };
+            /** @description Agent not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+}
+
+declare type PatchParam<T, Config extends RemoveParamsConfig, P extends keyof Config> = Simplify<T extends {
+    [key in P]: infer H;
+} ? H extends Partial<Record<string, unknown>> ? Config[P] extends string ? Omit<H, Config[P]> : H : never : never>;
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+declare interface paths {
+    "/api/v1/auth/exchangeExternalToken": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["exchangeExternalToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/auth/apiInformation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getApiInformation"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/public/canvas/{canvas_id}/data-reports/{report_id}/columns": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getPublicCanvasDataReportColumns"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/public/canvas/{canvas_id}/data-reports/{report_id}/data": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getPublicCanvasDataReportData"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/public/canvas/{canvas_id}/data-reports/{report_id}/count": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getPublicCanvasDataReportRowCount"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
         head?: never;
         patch?: never;
         trace?: never;
@@ -4078,6 +4829,38 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/agent-runs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listAgentRuns"];
+        put?: never;
+        post: operations["startAgentRun"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/agent-runs/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getAgentRun"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/admin-console/query-examples": {
         parameters: {
             query?: never;
@@ -4206,6 +4989,86 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/admin-console/agents/generate-inputs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["generateSuggestedInputs"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/agents/generate-output": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["generateOutputStructure"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/agents/generate-fragments": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["generateFragments"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/agents": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listAgents"];
+        put?: never;
+        post: operations["createAgent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/agents/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getAgent"];
+        put: operations["updateAgent"];
+        post?: never;
+        delete: operations["deleteAgent"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 
 declare type QuickActions = z.infer<typeof QuickActionsSchema>;
@@ -4237,7 +5100,26 @@ declare const redactedOutputSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         status: z.ZodLiteral<"error">;
-        message: z.ZodString;
+        category: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            timeout: "timeout";
+            connection_error: "connection_error";
+            auth_error: "auth_error";
+            resource_exhausted: "resource_exhausted";
+            table_not_found: "table_not_found";
+            column_not_found: "column_not_found";
+            schema_not_found: "schema_not_found";
+            view_not_found: "view_not_found";
+            function_not_found: "function_not_found";
+            syntax_error: "syntax_error";
+            ambiguous_column: "ambiguous_column";
+            type_mismatch: "type_mismatch";
+            invalid_cast: "invalid_cast";
+            invalid_argument: "invalid_argument";
+            division_by_zero: "division_by_zero";
+            constraint_violation: "constraint_violation";
+            permission_denied: "permission_denied";
+        }>>;
     }, z.core.$strip>], "status">>;
 }, z.core.$strip>;
 
@@ -4374,7 +5256,26 @@ declare const SignalWithReportIdSchema: z.ZodObject<{
 
 declare type SortingState = ColumnSort[];
 
-declare type TableFilters = Record<string, string | number>;
+declare type TableFilters = Record<string, TableFilterValue>;
+
+declare type TableFilterValue = z.infer<typeof TableFilterValueSchema>;
+
+declare const TableFilterValueSchema: z.ZodObject<{
+    operator: z.ZodEnum<{
+        contains: "contains";
+        eq: "eq";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        endsWith: "endsWith";
+        startsWith: "startsWith";
+        neq: "neq";
+        regex: "regex";
+        between: "between";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+}, z.core.$strip>;
 
 /**
  * Token storage keys