@magemetrics/core 0.0.59 → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4279 @@
+import { Client } from 'openapi-fetch';
+import { DefaultChatTransport } from 'ai';
+import { HttpChatTransportInitOptions } from 'ai';
+import type { InferUITool } from 'ai';
+import type { Simplify } from 'type-fest';
+import type { Tool } from 'ai';
+import type { UIMessage } from 'ai';
+import { z } from 'zod';
+
+/**
+ * Universal storage adapter interface for cross-platform compatibility.
+ * All operations are async to accommodate different storage mechanisms.
+ */
+export declare interface AsyncStorage {
+    /**
+     * Retrieve an item from storage
+     * @param key - The storage key
+     * @returns Promise resolving to the stored value or null if not found
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * Store an item in storage
+     * @param key - The storage key
+     * @param value - The value to store (must be a string)
+     * @returns Promise resolving when storage is complete
+     */
+    setItem(key: string, value: string): Promise<void>;
+    /**
+     * Remove an item from storage
+     * @param key - The storage key
+     * @returns Promise resolving when removal is complete
+     */
+    removeItem(key: string): Promise<void>;
+}
+
+/**
+ * Universal storage adapter interface for cross-platform compatibility.
+ * All operations are async to accommodate different storage mechanisms.
+ */
+declare interface AsyncStorage_2 {
+    /**
+     * Retrieve an item from storage
+     * @param key - The storage key
+     * @returns Promise resolving to the stored value or null if not found
+     */
+    getItem(key: string): Promise<string | null>;
+
+    /**
+     * Store an item in storage
+     * @param key - The storage key
+     * @param value - The value to store (must be a string)
+     * @returns Promise resolving when storage is complete
+     */
+    setItem(key: string, value: string): Promise<void>;
+
+    /**
+     * Remove an item from storage
+     * @param key - The storage key
+     * @returns Promise resolving when removal is complete
+     */
+    removeItem(key: string): Promise<void>;
+}
+
+/**
+ * Authentication states
+ */
+export declare type AuthState = "initializing" | "ready" | "error";
+
+/**
+ * Browser localStorage adapter with async interface.
+ * Wraps the synchronous localStorage API with async methods for consistency.
+ */
+export declare class BrowserStorageAdapter implements AsyncStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+
+export declare const CHECK_KEY = "mm-ai-check-key";
+
+declare interface components {
+    schemas: {
+        VisualizationData: {
+            [key: string]: string | (number | null) | unknown | null;
+        }[];
+        VisualizationWithData: {
+            id: number;
+            flow_data_id: number;
+            created_at: string;
+            bookmarked: boolean;
+            configuration: {
+                /** @enum {string} */
+                type: "bar";
+                title: string;
+                /** @enum {number} */
+                config_version: 2;
+                xAxisLabel: string;
+                yAxisLabel: string;
+                categoryColumn: string;
+                secondaryCategoryColumn?: string;
+                valueColumn: string;
+            } | {
+                /** @enum {string} */
+                type: "line/area";
+                /** @enum {number} */
+                config_version: 2;
+                title: string;
+                xAxisColumn: string;
+                valueColumns: string[];
+                yAxisLabels: string[];
+            } | {
+                /** @enum {string} */
+                type: "line/area-categorical";
+                title: string;
+                /** @enum {number} */
+                config_version: 2;
+                valueColumn: string;
+                xAxisColumn: string;
+                xAxisLabel: string;
+                yAxisLabel: string;
+                categoryColumn: string;
+            } | {
+                /** @enum {string} */
+                type: "scatter";
+                title: string;
+                /** @enum {number} */
+                config_version: 2;
+                xAxisLabel: string;
+                yAxisLabel: string;
+                xAxisValueColumn: string;
+                yAxisValueColumn: string;
+            } | {
+                /** @enum {string} */
+                type: "pie";
+                title: string;
+                /** @enum {number} */
+                config_version: 2;
+                categoryColumn: string;
+                valueColumn: string;
+            };
+            data: components["schemas"]["VisualizationData"];
+            _metadata?: {
+                wasSampled: boolean;
+                originalCount: number;
+                sampledCount: number;
+            };
+        } | {
+            id: number;
+            flow_data_id: number;
+            created_at: string;
+            bookmarked: boolean;
+            configuration: {
+                /** @enum {string} */
+                type: "bar";
+                title: string;
+                xAxisLabel: string;
+                yAxisLabel: string;
+                xAxisDataKey?: string;
+                yAxisDataKey?: string;
+                dimensionDataKey?: string;
+                valueColumns?: string[];
+            } | {
+                /** @enum {string} */
+                type: "line/area";
+                title: string;
+                xAxisLabel: string;
+                yAxisLabel: string;
+                xAxisDataKey?: string;
+                yAxisDataKey?: string;
+                dimensionDataKey?: string;
+                valueColumns?: string[];
+            } | {
+                /** @enum {string} */
+                type: "scatter";
+                title: string;
+                xAxisLabel: string;
+                yAxisLabel: string;
+                xAxisDataKey?: string;
+                yAxisDataKey?: string;
+                dimensionDataKey?: string;
+                valueColumns?: string[];
+            } | {
+                /** @enum {string} */
+                type: "pie";
+                title: string;
+                nameKey: string;
+                dataKey: string;
+            };
+            data: components["schemas"]["VisualizationData"];
+            _metadata?: {
+                wasSampled: boolean;
+                originalCount: number;
+                sampledCount: number;
+            };
+        };
+        /** Format: uuid */
+        DashboardId: string;
+        ReportColumns: {
+            name: string;
+            data_type: string;
+            dataType: string;
+            renderType?: string;
+            unit?: string;
+        }[];
+        ReportData: Record<string, unknown>[];
+        /** @description Starter recommendations */
+        StarterRecommendation: {
+            starter: string;
+            explanation: string;
+            type: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+
+/**
+ * Parameters for starting a flow
+ */
+export declare type CreateFlowParam = {
+    query: string;
+} | {
+    triggerId: string;
+    variables: Record<string, string>;
+};
+
+declare type CustomDataParts = {
+    "quick-actions": z.infer<typeof QuickActionsSchema>;
+    signal: z.infer<typeof SignalWithReportIdSchema>;
+};
+
+declare type ExtractInsightResponse = z.infer<typeof ExtractInsightResponseSchema>;
+
+declare const ExtractInsightResponseSchema: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    insight: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    insight: string;
+}, {
+    type: "text";
+    insight: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"missing">;
+}, "strip", z.ZodTypeAny, {
+    type: "missing";
+}, {
+    type: "missing";
+}>]>;
+
+declare type FrontendDashboard = z.infer<typeof FrontendDashboardSchema>;
+
+declare const FrontendDashboardSchema: z.ZodObject<Omit<{
+    company_id: z.ZodNumber;
+    created_at: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    name: z.ZodString;
+    positions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"data-report">;
+        flowId: z.ZodString;
+        flowDataId: z.ZodNumber;
+        title: z.ZodString;
+        col: z.ZodNumber;
+        colSpan: z.ZodNumber;
+        rowSpan: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "data-report";
+        title: string;
+        flowDataId: number;
+        flowId: string;
+        col: number;
+        colSpan: number;
+        rowSpan: number;
+    }, {
+        type: "data-report";
+        title: string;
+        flowDataId: number;
+        flowId: string;
+        col: number;
+        colSpan: number;
+        rowSpan: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"visualization">;
+        visualizationId: z.ZodNumber;
+        title: z.ZodString;
+        col: z.ZodNumber;
+        colSpan: z.ZodNumber;
+        rowSpan: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "visualization";
+        title: string;
+        col: number;
+        colSpan: number;
+        rowSpan: number;
+        visualizationId: number;
+    }, {
+        type: "visualization";
+        title: string;
+        col: number;
+        colSpan: number;
+        rowSpan: number;
+        visualizationId: number;
+    }>]>, "many">;
+    updated_at: z.ZodString;
+    is_removed: z.ZodBoolean;
+    is_public: z.ZodBoolean;
+}, "created_at" | "is_removed" | "company_id" | "updated_at">, "strip", z.ZodTypeAny, {
+    description: string | null;
+    name: string;
+    id: string;
+    positions: ({
+        type: "data-report";
+        title: string;
+        flowDataId: number;
+        flowId: string;
+        col: number;
+        colSpan: number;
+        rowSpan: number;
+    } | {
+        type: "visualization";
+        title: string;
+        col: number;
+        colSpan: number;
+        rowSpan: number;
+        visualizationId: number;
+    })[];
+    is_public: boolean;
+}, {
+    description: string | null;
+    name: string;
+    id: string;
+    positions: ({
+        type: "data-report";
+        title: string;
+        flowDataId: number;
+        flowId: string;
+        col: number;
+        colSpan: number;
+        rowSpan: number;
+    } | {
+        type: "visualization";
+        title: string;
+        col: number;
+        colSpan: number;
+        rowSpan: number;
+        visualizationId: number;
+    })[];
+    is_public: boolean;
+}>;
+
+declare type FrontendRecentFlows = z.infer<typeof FrontendRecentFlowsSchema>;
+
+declare const FrontendRecentFlowsSchema: z.ZodObject<Omit<{
+    created_at: z.ZodString;
+    id: z.ZodString;
+    request: z.ZodString;
+    user_id: z.ZodNullable<z.ZodString>;
+    flow_steps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<["running", "completed", "failed", "awaiting_input"]>;
+        output: z.ZodNullable<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodArray<z.ZodUnknown, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "running" | "completed" | "failed" | "awaiting_input";
+        name: string;
+        output: unknown[] | z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null;
+    }, {
+        status: "running" | "completed" | "failed" | "awaiting_input";
+        name: string;
+        output: unknown[] | z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null;
+    }>, "many">;
+    flow_chat_messages: z.ZodArray<z.ZodObject<{
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        count: number;
+    }, {
+        count: number;
+    }>, "many">;
+}, "flow_steps" | "flow_chat_messages">, "strip", z.ZodTypeAny, {
+    id: string;
+    request: string;
+    created_at: string;
+    user_id: string | null;
+}, {
+    id: string;
+    request: string;
+    created_at: string;
+    user_id: string | null;
+}>;
+
+/**
+ * Parameters for generating contextual insights
+ */
+export declare type GenerateInsightParam = {
+    selectedFilterValue: string;
+    customId: string;
+};
+
+export declare const getPublicApiClient: (apiUrl: string, apiKey: string) => Client<NoAuthPaths>;
+
+declare const inputSchema: z.ZodObject<{
+    userRequest: z.ZodString;
+    isNewAnalysisGoal: z.ZodBoolean;
+    responseType: z.ZodEnum<["text", "table", "visualization"]>;
+    difficultyLevel: z.ZodEnum<["simple", "moderate", "complex"]>;
+}, "strip", z.ZodTypeAny, {
+    userRequest: string;
+    isNewAnalysisGoal: boolean;
+    responseType: "text" | "table" | "visualization";
+    difficultyLevel: "simple" | "moderate" | "complex";
+}, {
+    userRequest: string;
+    isNewAnalysisGoal: boolean;
+    responseType: "text" | "table" | "visualization";
+    difficultyLevel: "simple" | "moderate" | "complex";
+}>;
+
+declare const inputSchema_2: z.ZodObject<{
+    chartType: z.ZodEnum<["bar", "line/area", "scatter", "pie"]>;
+    columnConfiguration: z.ZodObject<{
+        dimensionColumn: z.ZodString;
+        valueColumns: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        dimensionColumn: string;
+        valueColumns: string[];
+    }, {
+        dimensionColumn: string;
+        valueColumns: string[];
+    }>;
+    explanations: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    chartType: "bar" | "line/area" | "scatter" | "pie";
+    columnConfiguration: {
+        dimensionColumn: string;
+        valueColumns: string[];
+    };
+    explanations: string;
+}, {
+    chartType: "bar" | "line/area" | "scatter" | "pie";
+    columnConfiguration: {
+        dimensionColumn: string;
+        valueColumns: string[];
+    };
+    explanations: string;
+}>;
+
+declare const inputSchema_3: z.ZodObject<{
+    thought: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    thought: string;
+}, {
+    thought: string;
+}>;
+
+declare const inputSchema_4: z.ZodObject<{
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+}, {
+    value: string;
+}>;
+
+declare const inputSchema_5: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+
+declare const inputSchema_6: z.ZodObject<{
+    table_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    table_name: string;
+}, {
+    table_name: string;
+}>;
+
+declare const inputSchema_7: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+
+declare type InternalApiClient = Simplify<Client<NoAuthPaths, `${string}/${string}`>>;
+
+export declare class MageMetricsChatTransport extends DefaultChatTransport<MMChatUIMessage> {
+    constructor(apiUrl: string, flowId: string, options?: Omit<HttpChatTransportInitOptions<MMChatUIMessage>, "api" | "headers" | "prepareSendMessagesRequest">);
+}
+
+/**
+ * Core MageMetrics client that handles authentication lifecycle and provides
+ * a promise-based API that automatically waits for authentication to complete.
+ *
+ * This version uses composition instead of inheritance and pluggable storage adapters
+ * for cross-platform compatibility.
+ */
+export declare class MageMetricsClient {
+    private config;
+    private authState;
+    private supabaseClient;
+    private internalApiClient;
+    private noAuthApiClient;
+    private authApiResponse;
+    private authPromise;
+    private processedJwt;
+    private storageAdapter;
+    private events;
+    constructor(config: MageMetricsClientConfig);
+    /**
+     * Add an event listener for authentication state changes
+     * @param type the type of the event
+     * @param listener the listener to add
+     * @param options options for the event listener
+     * @param options.signal an optional AbortSignal to abort the event listener
+     */
+    addEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>, options?: {
+        signal?: AbortSignal;
+    }): void;
+    /**
+     * Remove an event listener
+     * @param type the type of the event
+     * @param listener the listener to remove
+     */
+    removeEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>): void;
+    waitForAuth(): Promise<void>;
+    updateExternalJwt(jwt: string): Promise<void>;
+    get state(): AuthState;
+    getAuthHeaders(): Promise<Record<string, string>>;
+    private clearStorage;
+    logout(): Promise<void>;
+    /**
+     * Public API methods that automatically wait for authentication
+     */
+    api: {
+        getRecentFlows: (params?: {
+            limit?: number;
+        }) => Promise<FrontendRecentFlows[]>;
+        createFlow: (request: CreateFlowParam) => Promise<{
+            flowId: string;
+        }>;
+        getDashboard: (dashboardId: string) => Promise<FrontendDashboard>;
+        exportReportData: (reportId: number, format?: "text" | "blob") => Promise<{
+            filename: string;
+            data: Blob | string;
+        }>;
+        generateContextualInsight: (payload: GenerateInsightParam) => Promise<ExtractInsightResponse>;
+    };
+    /**
+     * Initialize authentication flow
+     */
+    private initializeAuth;
+    /**
+     * Perform the complete authentication flow
+     */
+    private performAuthFlow;
+    private getApiInformation;
+    private initializeSupabaseClient;
+    client(): Promise<InternalApiClient>;
+    /**
+     * Initialize the API client with Supabase headers
+     */
+    private initializeApiClient;
+    /**
+     * Handle the authentication logic (check session or exchange token)
+     */
+    private handleAuthentication;
+    /**
+     * Exchange external JWT for Supabase tokens
+     */
+    private exchangeExternalToken;
+    private createSupabaseHeaderMiddleware;
+    private setState;
+    private encodeCheckKey;
+    saveCheckKey(externalJwt: string, apiKey: string): Promise<void>;
+    compareCheckKey(externalJwt: string, apiKey: string): Promise<boolean>;
+    clearCheckKey(): Promise<void>;
+}
+
+/**
+ * Configuration options for the MageMetricsClient
+ */
+export declare interface MageMetricsClientConfig {
+    apiUrl: string;
+    apiKey: string;
+    externalJwt?: string;
+    additionalHeaders?: Record<string, string>;
+    storageAdapter?: AsyncStorage_2;
+}
+
+/**
+ * Event types using discriminated union for type safety and extensibility
+ */
+export declare type MageMetricsEvent = {
+    type: "authStateChange";
+    detail: AuthState;
+};
+
+/**
+ * Simple event emitter for MageMetrics client.
+ * Uses discriminated unions for type-safe events.
+ */
+export declare class MageMetricsEventEmitter {
+    private listeners;
+    addEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>, options?: {
+        signal?: AbortSignal;
+    }): void;
+    removeEventListener<T extends MageMetricsEvent>(type: T["type"], listener: MageMetricsEventListener<T>): void;
+    dispatch<T extends MageMetricsEvent>(type: T["type"], detail: T["detail"]): void;
+}
+
+/**
+ * Event listener function type
+ */
+export declare type MageMetricsEventListener<T extends MageMetricsEvent = MageMetricsEvent> = (event: T) => void;
+
+/**
+ * in-memory storage adapter.
+ */
+export declare class MemoryStorageAdapter implements AsyncStorage {
+    private storage;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+
+declare type MMChatUIMessage = UIMessage<unknown, CustomDataParts, MMUiTools>;
+
+declare type MMUiTools = {
+    generateDataReport: UiTool;
+    generateVisualization: UiTool_2;
+    think: UiTool_3;
+    valueBasedColumnSearch: UiTool_4;
+    getAvailableTables: UiTool_5;
+    getAvailableColumnsForTable: UiTool_6;
+    webSearch: UiTool_7;
+};
+
+declare type NoAuthPaths = Simplify<{
+    [Path in keyof paths]: RemoveAuthHeader<paths[Path]>;
+}>;
+
+declare interface operations {
+    exchangeExternalToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    apiKey: string;
+                    externalJWT: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Retrieve a JWT for an external user */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        accessToken: string;
+                        refreshToken: string;
+                    };
+                };
+            };
+            /** @description Invalid input */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Unable to retrieve a JWT for an external user */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getApiInformation: {
+        parameters: {
+            query: {
+                apiKey: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Retrieve the API URL and anon key */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        apiUrl: string;
+                        anonKey: string;
+                    };
+                };
+            };
+            /** @description Invalid input */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Unable to retrieve the API URL and anon key */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    PublicDashboardFetchVisualization: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                visualization_id: string;
+                dashboard_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The content of the visualization */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VisualizationWithData"];
+                };
+            };
+            /** @description Invalid arguments to fetch visualization */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Unable to fetch visualization with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    retrievePublicDashboard: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                dashboard_id: components["schemas"]["DashboardId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The dashboard with the given id */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        description: string | null;
+                        /** Format: uuid */
+                        id: string;
+                        name: string;
+                        positions: ({
+                            /** @enum {string} */
+                            type: "data-report";
+                            flowId: string;
+                            flowDataId: number;
+                            title: string;
+                            col: number;
+                            colSpan: number;
+                            rowSpan: number;
+                        } | {
+                            /** @enum {string} */
+                            type: "visualization";
+                            visualizationId: number;
+                            title: string;
+                            col: number;
+                            colSpan: number;
+                            rowSpan: number;
+                        })[];
+                        is_public: boolean;
+                    };
+                };
+            };
+            /** @description Unable to retrieve dashboard with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getPublicDataReportColumns: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                report_id: string;
+                dashboard_id: components["schemas"]["DashboardId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description A list containing the columns of the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ReportColumns"];
+                };
+            };
+            /** @description Unable to retrieve report with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getPublicDataReportData: {
+        parameters: {
+            query?: {
+                limit?: number;
+                /** @example name:asc,date:desc */
+                order?: string;
+                cursor?: number;
+                /** @example status:active,name:John%20Doe */
+                filter?: string;
+            };
+            header?: never;
+            path: {
+                report_id: string;
+                dashboard_id: components["schemas"]["DashboardId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The content of the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ReportData"];
+                };
+            };
+            /** @description Unable to retrieve report with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getPublicDataReportRowCount: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                report_id: string;
+                dashboard_id: components["schemas"]["DashboardId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The total count of rows in the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Total number of rows in the report */
+                        count: number;
+                    };
+                };
+            };
+            /** @description Unable to retrieve report with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    runEnd2EndFlow: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    userQuery: string;
+                    /** @default true */
+                    isNewAnalysisGoal?: boolean;
+                    /**
+                     * @default complex
+                     * @enum {string}
+                     */
+                    difficultyLevel?: "simple" | "moderate" | "complex";
+                };
+            };
+        };
+        responses: {
+            /** @description Run the end2end flow */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        status: "error";
+                        error: string;
+                    } | {
+                        /** @enum {string} */
+                        status: "success";
+                        flowId: string;
+                    };
+                };
+            };
+        };
+    };
+    retrieveFlow: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                flowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The flow with its steps */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        created_at: string;
+                        id: string;
+                        request: string;
+                        user_id: string | null;
+                        user_friendly_goal?: string;
+                        has_chat_messages: boolean;
+                    };
+                };
+            };
+            /** @description Unable to retrieve flow with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    retrieveRecentFlows: {
+        parameters: {
+            query?: {
+                limit?: number;
+            };
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description A list of recent flows */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        created_at: string;
+                        id: string;
+                        request: string;
+                        user_id: string | null;
+                    }[];
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    retrieveFlowDataReports: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                flowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The data reports associated with the flow */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        created_at: string;
+                        flow_id: string;
+                        id: number;
+                        title: string;
+                        request: string | null;
+                        data_summary: {
+                            columns: {
+                                [key: string]: {
+                                    position?: number;
+                                    data_type: string;
+                                    null_count: number | null;
+                                    unique_count: number | null;
+                                    unique_percentage: number | null;
+                                };
+                            };
+                        };
+                        bookmarked: boolean;
+                        status: string | null;
+                    }[];
+                };
+            };
+            /** @description Unable to retrieve flow with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getDataReportFeedback: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The feedback for the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        created_at: string;
+                        flow_data_id: number;
+                        /** @enum {string} */
+                        helpfulness: "helpful" | "partially helpful" | "not helpful" | "incorrect";
+                        id: number;
+                    } | null;
+                };
+            };
+            /** @description Unable to retrieve feedback */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    upsertReportFeedback: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        /** @description The feedback for the flow data */
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @enum {string} */
+                    helpfulness: "helpful" | "partially helpful" | "not helpful" | "incorrect";
+                };
+            };
+        };
+        responses: {
+            /** @description Successfully upserted feedback */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    deleteReportFeedback: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successfully deleted feedback */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Unable to retrieve feedback */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    retrieveLatestDataReportStatus: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                flowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The status of the latest flow data for a given flow */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status: string | null;
+                    };
+                };
+            };
+            /** @description Unable to retrieve status for latest flow data of flow with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getDataReportExplainability: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The explainability of the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        sql_explanation?: {
+                            chunk_title: string;
+                            chunk_explanation: string;
+                            lines: {
+                                sql: string;
+                                explanation: string;
+                            }[];
+                        }[] | null;
+                        business_explanation?: {
+                            summary: string;
+                            implementation: string[];
+                            assumptions: {
+                                /** @enum {string} */
+                                type: "grain" | "completeness" | "transformation" | "relationship" | "other";
+                                details: string;
+                                explanation: string;
+                            }[];
+                        } | null;
+                        columns_lineage?: {
+                            [key: string]: {
+                                nodes: {
+                                    id: string;
+                                    /** @enum {string} */
+                                    type: "entity" | "attribute" | "filter" | "process" | "combine" | "result";
+                                    explanation: string;
+                                }[];
+                                edges: {
+                                    source: string;
+                                    target: string;
+                                }[];
+                            };
+                        } | null;
+                        confidence_score: number;
+                        confidence_score_reason: string;
+                        assumptions_score?: number;
+                        assumptions_score_reason?: string;
+                        friendliness_score?: number;
+                        friendliness_score_reason?: string;
+                        flow_data_id: number;
+                    };
+                };
+            };
+            /** @description Unable to retrieve report with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    toggleBookmark: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Toggle bookmark for timeline item */
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @enum {string} */
+                    type: "dataReport";
+                    flowDataId: number;
+                    bookmarked: boolean;
+                } | {
+                    /** @enum {string} */
+                    type: "visualization";
+                    flowDataVisualizationId: number;
+                    bookmarked: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Successfully toggled bookmark */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                        bookmarked: boolean;
+                    };
+                };
+            };
+            /** @description Timeline item not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    retrieveLatestDataRefresh: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The latest data refresh */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        updated_at: string;
+                    };
+                };
+            };
+            /** @description Unable to retrieve latest data refresh */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    exportReportData: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The report data exported in CSV format */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/csv": string;
+                };
+            };
+            /** @description Unable to retrieve flow with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getDataReportColumns: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description A list containing the columns of the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ReportColumns"];
+                };
+            };
+            /** @description Unable to retrieve report with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getDataReportData: {
+        parameters: {
+            query?: {
+                /** @example name,date */
+                columns?: string;
+                limit?: number;
+                /** @example name:asc,date:desc */
+                order?: string;
+                cursor?: number;
+                /** @example status:active,name:John%20Doe */
+                filter?: string;
+            };
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The content of the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ReportData"];
+                };
+            };
+            /** @description Unable to retrieve report with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getDataReportRowCount: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The total count of rows in the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Total number of rows in the report */
+                        count: number;
+                    };
+                };
+            };
+            /** @description Unable to retrieve report with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getDataReport: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The visualizations for the report */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        created_at: string;
+                        flow_id: string;
+                        id: number;
+                        title: string;
+                        request: string | null;
+                        data_summary: {
+                            columns: {
+                                [key: string]: {
+                                    position?: number;
+                                    data_type: string;
+                                    null_count: number | null;
+                                    unique_count: number | null;
+                                    unique_percentage: number | null;
+                                };
+                            };
+                        };
+                        bookmarked: boolean;
+                        status: string | null;
+                    };
+                };
+            };
+            /** @description Unable to retrieve report with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    createFlow: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    userQuery: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Create a new flow */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        status: "success";
+                        flowId: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    retrieveChatTimeline: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                flowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The timeline of generated insights for the flow */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": ({
+                        /** @enum {string} */
+                        type: "dataReport";
+                        flowDataId: number;
+                        flowId: string;
+                        title: string;
+                        bookmarked: boolean;
+                        answer: string | null;
+                    } | {
+                        /** @enum {string} */
+                        type: "visualization";
+                        flowId: string;
+                        flowDataId: number;
+                        flowDataVisualizationId: number;
+                        title: string;
+                        bookmarked: boolean;
+                    } | {
+                        /** @enum {string} */
+                        type: "message";
+                    })[];
+                };
+            };
+            /** @description Unable to retrieve flow with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    retrieveChatMessages: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                flowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The messages from the given flow */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        messages: Record<string, unknown>[];
+                    };
+                };
+            };
+            /** @description Unable to retrieve flow with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getStarterRecommendations: {
+        parameters: {
+            query?: {
+                count?: number;
+            };
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Get starter recommendations */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        recommendations: components["schemas"]["StarterRecommendation"][];
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    fetchVisualization: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                visualization_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The content of the visualization */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VisualizationWithData"];
+                };
+            };
+            /** @description Invalid arguments to fetch visualization */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Unable to fetch visualization with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    listVisualizationsForFlow: {
+        parameters: {
+            query?: {
+                flowDataId?: string;
+            };
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                flowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List visualizations for a given flow. Can be filtered by flow data id as well */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: number;
+                        flow_data_id: number;
+                        created_at: string;
+                        bookmarked: boolean;
+                        configuration: {
+                            /** @enum {string} */
+                            type: "bar";
+                            title: string;
+                            /** @enum {number} */
+                            config_version: 2;
+                            xAxisLabel: string;
+                            yAxisLabel: string;
+                            categoryColumn: string;
+                            secondaryCategoryColumn?: string;
+                            valueColumn: string;
+                        } | {
+                            /** @enum {string} */
+                            type: "line/area";
+                            /** @enum {number} */
+                            config_version: 2;
+                            title: string;
+                            xAxisColumn: string;
+                            valueColumns: string[];
+                            yAxisLabels: string[];
+                        } | {
+                            /** @enum {string} */
+                            type: "line/area-categorical";
+                            title: string;
+                            /** @enum {number} */
+                            config_version: 2;
+                            valueColumn: string;
+                            xAxisColumn: string;
+                            xAxisLabel: string;
+                            yAxisLabel: string;
+                            categoryColumn: string;
+                        } | {
+                            /** @enum {string} */
+                            type: "scatter";
+                            title: string;
+                            /** @enum {number} */
+                            config_version: 2;
+                            xAxisLabel: string;
+                            yAxisLabel: string;
+                            xAxisValueColumn: string;
+                            yAxisValueColumn: string;
+                        } | {
+                            /** @enum {string} */
+                            type: "pie";
+                            title: string;
+                            /** @enum {number} */
+                            config_version: 2;
+                            categoryColumn: string;
+                            valueColumn: string;
+                        };
+                    }[];
+                };
+            };
+            /** @description Invalid arguments to fetch visualization */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Unable to list visualizations */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    triggerFlow: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Trigger flow request body */
+        requestBody: {
+            content: {
+                "application/json": {
+                    triggerId: string;
+                    variables: {
+                        [key: string]: string;
+                    };
+                };
+            };
+        };
+        responses: {
+            /** @description Flow id */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        status: "error";
+                        error: string;
+                    } | {
+                        /** @enum {string} */
+                        status: "success";
+                        flowId: string;
+                    };
+                };
+            };
+            /** @description Invalid template or variable values */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Unable to retrieve trigger with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    retrieveDashboard: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+            };
+            path: {
+                dashboard_id: components["schemas"]["DashboardId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The dashboard with the given id */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        description: string | null;
+                        /** Format: uuid */
+                        id: string;
+                        name: string;
+                        positions: ({
+                            /** @enum {string} */
+                            type: "data-report";
+                            flowId: string;
+                            flowDataId: number;
+                            title: string;
+                            col: number;
+                            colSpan: number;
+                            rowSpan: number;
+                        } | {
+                            /** @enum {string} */
+                            type: "visualization";
+                            visualizationId: number;
+                            title: string;
+                            col: number;
+                            colSpan: number;
+                            rowSpan: number;
+                        })[];
+                        is_public: boolean;
+                    };
+                };
+            };
+            /** @description Unable to retrieve dashboard with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    generateInsight: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    selected_filter_value: string;
+                    custom_id: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Insight generated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        type: "text";
+                        insight: string;
+                    } | {
+                        /** @enum {string} */
+                        type: "missing";
+                    };
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Insight not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    createQueryExample: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    request: string;
+                    sql: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Query example created successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: number;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    updateQueryExample: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    request?: string;
+                    sql?: string;
+                    is_active?: boolean;
+                    is_removed?: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Query example updated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: number;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    sqlPreview: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    sql: string;
+                };
+            };
+        };
+        responses: {
+            /** @description SQL query executed successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        columns: {
+                            id: string;
+                            accessorKey: string;
+                            header: string;
+                            cell?: unknown;
+                            meta?: {
+                                [key: string]: unknown;
+                            };
+                        }[];
+                        data: {
+                            [key: string]: unknown;
+                        }[];
+                        metadata?: {
+                            wasSampled: boolean;
+                            originalCount: number;
+                            sampledCount: number;
+                        };
+                    };
+                };
+            };
+            /** @description Invalid SQL query or 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;
+                    };
+                };
+            };
+        };
+    };
+    listSankeyUserFilters: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of available user filters */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: number;
+                        field_key: string;
+                        display_name: string;
+                        /** @default true */
+                        is_active: boolean;
+                        /** @default false */
+                        include_visualization: boolean;
+                        values: (string | {
+                            label: string;
+                            value: string;
+                        })[];
+                    }[];
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getSankeyData: {
+        parameters: {
+            query?: {
+                user_id?: string;
+                cluster_id?: number | null;
+                subcluster_id?: number | null;
+                /** @description Comma-separated list of bins: lt0.6,0.6-0.8,0.8-1 (applies to average score) */
+                score_ranges?: string;
+                /** @description JSON-encoded map of { [field_key]: string[] } to be passed to RPC */
+                external_filters?: string;
+                max_results?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Sankey data retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        metadata: {
+                            total_clusters: number;
+                            total_requests: number;
+                            generation_timestamp: string;
+                        };
+                        clusters: {
+                            cluster_id: number;
+                            subcluster_id?: number | null;
+                            cluster_name: string;
+                            representative_questions: {
+                                subcluster_id: number;
+                                question: string;
+                                count: number;
+                                sample_requests: string[];
+                                avg_confidence_score?: number | null;
+                                avg_assumptions_score?: number | null;
+                                avg_friendliness_score?: number | null;
+                            }[];
+                            count: number;
+                            avg_confidence_score?: number | null;
+                            avg_assumptions_score?: number | null;
+                            avg_friendliness_score?: number | null;
+                        }[];
+                        rows?: {
+                            flow_data_id: number;
+                            company_id: number;
+                            main_cluster_id: number;
+                            main_cluster_name: string;
+                            subcluster_id: number | null;
+                            subcluster_name: string | null;
+                            core_question: string | null;
+                            /** Format: uuid */
+                            user_id: string;
+                            initial_user_request: string | null;
+                            flow_data_request: string | null;
+                            flow_data_created_at: string | null;
+                            confidence_score: number | null;
+                            assumptions_score: number | null;
+                            friendliness_score: number | null;
+                            user_email: string | null;
+                            external: {
+                                [key: string]: unknown;
+                            } | null;
+                        }[];
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    generateInsightTemplate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    request: string;
+                    insight_type: string;
+                    additional_context?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Insight template generated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        expanded_request: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getContextualInsightPreviewData: {
+        parameters: {
+            query?: {
+                limit?: number;
+                /** @example name:asc,date:desc */
+                order?: string;
+                cursor?: number;
+                /** @example status:active,name:John%20Doe */
+                filter?: string;
+            };
+            header?: never;
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The preview data for the contextual insight */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        columns: {
+                            id: string;
+                            accessorKey: string;
+                            header: string;
+                            cell?: unknown;
+                            meta?: {
+                                [key: string]: unknown;
+                            };
+                        }[];
+                        data: {
+                            [key: string]: unknown;
+                        }[];
+                        metadata?: {
+                            wasSampled: boolean;
+                            originalCount: number;
+                            sampledCount: number;
+                        };
+                    };
+                };
+            };
+            /** @description Unable to retrieve flow data with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    getContextualInsightColumnSampleValues: {
+        parameters: {
+            query: {
+                column_name: string;
+            };
+            header?: never;
+            path: {
+                report_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Sample values for the specified column */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        options: unknown[];
+                    };
+                };
+            };
+            /** @description Unable to retrieve flow data with this id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    extractInsight: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    flow_id: string;
+                    report_id: number;
+                    topic: string;
+                    expanded_request: string;
+                    insight_type: string;
+                    selected_filter: string;
+                    selected_filter_value: string;
+                    additional_context?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Insight extracted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        type: "text";
+                        insight: string;
+                    } | {
+                        /** @enum {string} */
+                        type: "missing";
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+    suggestFilterColumn: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    report_id: number;
+                    request: string;
+                    insight_type: string;
+                    additional_context?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Filter column suggestion generated successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        recommended_column: string;
+                        reasoning: string;
+                    };
+                };
+            };
+            /** @description Report not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                    };
+                };
+            };
+            /** @description Something wrong happened */
+            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/dashboards/{dashboard_id}/visualizations/{visualization_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["PublicDashboardFetchVisualization"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/public/dashboards/{dashboard_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrievePublicDashboard"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/public/dashboards/{dashboard_id}/data-reports/{report_id}/columns": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getPublicDataReportColumns"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/public/dashboards/{dashboard_id}/data-reports/{report_id}/data": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getPublicDataReportData"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/public/dashboards/{dashboard_id}/data-reports/{report_id}/count": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getPublicDataReportRowCount"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/end2end": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["runEnd2EndFlow"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/flows/{flowId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveFlow"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/recent-flows": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveRecentFlows"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/flows/{flowId}/data-reports": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveFlowDataReports"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/data-reports/{report_id}/feedback": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getDataReportFeedback"];
+        put?: never;
+        post: operations["upsertReportFeedback"];
+        delete: operations["deleteReportFeedback"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/flows/{flowId}/data-reports/last/status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveLatestDataReportStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/data-reports/{report_id}/explainability": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getDataReportExplainability"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/timeline/bookmark": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["toggleBookmark"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/data-tables/latest-refresh": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveLatestDataRefresh"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/data-reports/{report_id}/export": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["exportReportData"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/data-reports/{report_id}/columns": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getDataReportColumns"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/data-reports/{report_id}/data": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getDataReportData"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/data-reports/{report_id}/count": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getDataReportRowCount"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/data-reports/{report_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getDataReport"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/flows": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["createFlow"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/chat/{flowId}/timeline": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveChatTimeline"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/chat/{flowId}/messages": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveChatMessages"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/recommendations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getStarterRecommendations"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/visualizations/{visualization_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["fetchVisualization"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/flows/{flowId}/visualizations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listVisualizationsForFlow"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/trigger-flow/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["triggerFlow"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/dashboard/{dashboard_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveDashboard"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/contextual-insights/generate-insight": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["generateInsight"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/query-examples": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["createQueryExample"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/query-examples/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch: operations["updateQueryExample"];
+        trace?: never;
+    };
+    "/api/v1/admin-console/sql/preview": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["sqlPreview"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/usage-insights/filters": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["listSankeyUserFilters"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/usage-insights/sankey": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getSankeyData"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/contextual-insights/generate-template": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["generateInsightTemplate"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/contextual-insights/preview/{report_id}/data": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getContextualInsightPreviewData"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/contextual-insights/preview/{report_id}/sample-values": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getContextualInsightColumnSampleValues"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/contextual-insights/extract-insight": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["extractInsight"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/admin-console/contextual-insights/suggest-filter-column": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["suggestFilterColumn"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+
+declare const QuickActionsSchema: z.ZodArray<z.ZodObject<{
+    label: z.ZodString;
+    explanation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    explanation: string;
+}, {
+    label: string;
+    explanation: string;
+}>, "many">;
+
+declare const redactedOutputSchema: z.ZodObject<{
+    tool: z.ZodLiteral<"generateDataReport">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{
+            flowDataId: z.ZodNumber;
+            answer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        }, {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        }>;
+        private: z.ZodObject<{
+            sql: z.ZodString;
+            dataReportSummary: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            sql: string;
+            dataReportSummary: string;
+        }, {
+            sql: string;
+            dataReportSummary: string;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        };
+    }, {
+        status: "success";
+        public: {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        };
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "generateDataReport";
+    result?: {
+        status: "success";
+        public: {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "generateDataReport";
+    result?: {
+        status: "success";
+        public: {
+            flowDataId: number;
+            title?: string | null | undefined;
+            answer?: string | null | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_2: z.ZodObject<{
+    tool: z.ZodLiteral<"generateVisualization">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{
+            flowDataId: z.ZodNumber;
+            flowDataVisualizationId: z.ZodNumber;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        }, {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        }>;
+        private: z.ZodObject<{
+            sql: z.ZodOptional<z.ZodString>;
+            dataReportSummary: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            sql?: string | undefined;
+            dataReportSummary?: string | undefined;
+        }, {
+            sql?: string | undefined;
+            dataReportSummary?: string | undefined;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        };
+    }, {
+        status: "success";
+        public: {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        };
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "generateVisualization";
+    result?: {
+        status: "success";
+        public: {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "generateVisualization";
+    result?: {
+        status: "success";
+        public: {
+            flowDataId: number;
+            flowDataVisualizationId: number;
+            type?: string | null | undefined;
+            title?: string | null | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_3: z.ZodObject<{
+    tool: z.ZodLiteral<"valueBasedColumnSearch">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        private: z.ZodObject<{
+            message: z.ZodOptional<z.ZodString>;
+            columns: z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                name: z.ZodString;
+                data_type: z.ZodNullable<z.ZodString>;
+                description: z.ZodNullable<z.ZodString>;
+                null_percentage: z.ZodNullable<z.ZodNumber>;
+                unique_values: z.ZodNullable<z.ZodNumber>;
+                sample_values: z.ZodNullable<z.ZodArray<z.ZodAny, "many">>;
+                table: z.ZodObject<{
+                    table_name: z.ZodString;
+                    description: z.ZodNullable<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    description: string | null;
+                    table_name: string;
+                }, {
+                    description: string | null;
+                    table_name: string;
+                }>;
+                matched_values: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                description: string | null;
+                name: string;
+                table: {
+                    description: string | null;
+                    table_name: string;
+                };
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+                matched_values: string[];
+            }, {
+                description: string | null;
+                name: string;
+                table: {
+                    description: string | null;
+                    table_name: string;
+                };
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+                matched_values: string[];
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            columns: {
+                description: string | null;
+                name: string;
+                table: {
+                    description: string | null;
+                    table_name: string;
+                };
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+                matched_values: string[];
+            }[];
+            message?: string | undefined;
+        }, {
+            columns: {
+                description: string | null;
+                name: string;
+                table: {
+                    description: string | null;
+                    table_name: string;
+                };
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+                matched_values: string[];
+            }[];
+            message?: string | undefined;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {};
+    }, {
+        status: "success";
+        public: {};
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "valueBasedColumnSearch";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "valueBasedColumnSearch";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_4: z.ZodObject<{
+    tool: z.ZodLiteral<"getAvailableTables">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        private: z.ZodObject<{
+            tables: z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                table_name: z.ZodString;
+                description: z.ZodNullable<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                description: string | null;
+                id: number;
+                table_name: string;
+            }, {
+                description: string | null;
+                id: number;
+                table_name: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            tables: {
+                description: string | null;
+                id: number;
+                table_name: string;
+            }[];
+        }, {
+            tables: {
+                description: string | null;
+                id: number;
+                table_name: string;
+            }[];
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {};
+    }, {
+        status: "success";
+        public: {};
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "getAvailableTables";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "getAvailableTables";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_5: z.ZodObject<{
+    tool: z.ZodLiteral<"getAvailableColumnsForTable">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        private: z.ZodObject<{
+            message: z.ZodOptional<z.ZodString>;
+            columns: z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                name: z.ZodString;
+                data_type: z.ZodNullable<z.ZodString>;
+                description: z.ZodNullable<z.ZodString>;
+                null_percentage: z.ZodNullable<z.ZodNumber>;
+                unique_values: z.ZodNullable<z.ZodNumber>;
+                sample_values: z.ZodNullable<z.ZodArray<z.ZodAny, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                description: string | null;
+                name: string;
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+            }, {
+                description: string | null;
+                name: string;
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            columns: {
+                description: string | null;
+                name: string;
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+            }[];
+            message?: string | undefined;
+        }, {
+            columns: {
+                description: string | null;
+                name: string;
+                id: number;
+                data_type: string | null;
+                null_percentage: number | null;
+                unique_values: number | null;
+                sample_values: any[] | null;
+            }[];
+            message?: string | undefined;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {};
+    }, {
+        status: "success";
+        public: {};
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "getAvailableColumnsForTable";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "getAvailableColumnsForTable";
+    result?: {
+        status: "success";
+        public: {};
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const redactedOutputSchema_6: z.ZodObject<{
+    tool: z.ZodLiteral<"search">;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<"status", [z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                sourceType: z.ZodLiteral<"url">;
+                id: z.ZodString;
+                url: z.ZodString;
+                title: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }, {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        }, {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        }>;
+        private: z.ZodObject<{
+            answer: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            answer?: string | undefined;
+        }, {
+            answer?: string | undefined;
+        }>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        };
+    }, {
+        status: "success";
+        public: {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        };
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        status: "error";
+    }, {
+        message: string;
+        status: "error";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "search";
+    result?: {
+        status: "success";
+        public: {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}, {
+    tool: "search";
+    result?: {
+        status: "success";
+        public: {
+            sources?: {
+                title: string;
+                id: string;
+                sourceType: "url";
+                url: string;
+            }[] | undefined;
+        };
+    } | {
+        message: string;
+        status: "error";
+    } | undefined;
+}>;
+
+declare const RedactedThinkResponse: z.ZodObject<{
+    tool: z.ZodDefault<z.ZodLiteral<"think">>;
+} & {
+    result: z.ZodOptional<z.ZodObject<Omit<{
+        status: z.ZodLiteral<"success">;
+        public: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        private: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    }, "private">, "strip", z.ZodTypeAny, {
+        status: "success";
+        public: {};
+    }, {
+        status: "success";
+        public: {};
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    tool: "think";
+    result?: {
+        status: "success";
+        public: {};
+    } | undefined;
+}, {
+    tool?: "think" | undefined;
+    result?: {
+        status: "success";
+        public: {};
+    } | undefined;
+}>;
+
+declare type RemoveAuthHeader<PathSchema> = Simplify<{
+    [Method in keyof PathSchema]: RemoveParams<PathSchema[Method], ToRemove>;
+}>;
+
+declare type RemoveParams<MethodSchema, Config extends RemoveParamsConfig> = Simplify<MethodSchema extends {
+    parameters: infer P;
+} ? Omit<MethodSchema, "parameters"> & {
+    parameters: {
+        header?: PatchParam<P, Config, "header">;
+        query?: PatchParam<P, Config, "query">;
+        path?: PatchParam<P, Config, "path">;
+        cookie?: PatchParam<P, Config, "cookie">;
+    };
+} : MethodSchema>;
+
+declare type RemoveParamsConfig = Simplify<{
+    header?: string;
+    query?: string;
+    path?: string;
+    cookie?: string;
+}>;
+
+declare const SignalWithReportIdSchema: z.ZodObject<{
+    rule: z.ZodString;
+    metric: z.ZodString;
+    trigger: z.ZodString;
+    implementation: z.ZodString;
+} & {
+    reportId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    rule: string;
+    metric: string;
+    trigger: string;
+    implementation: string;
+    reportId: number;
+}, {
+    rule: string;
+    metric: string;
+    trigger: string;
+    implementation: string;
+    reportId: number;
+}>;
+
+/**
+ * Token storage keys
+ */
+export declare const TOKEN_STORAGE_KEY = "mm-ai-sp-token";
+
+declare type ToRemove = Simplify<{
+    header: "sp-access-token";
+}>;
+
+declare type UiTool = InferUITool<Tool<z.infer<typeof inputSchema>, z.infer<typeof redactedOutputSchema>>>;
+
+declare type UiTool_2 = InferUITool<Tool<z.infer<typeof inputSchema_2>, z.infer<typeof redactedOutputSchema_2>>>;
+
+declare type UiTool_3 = InferUITool<Tool<z.infer<typeof inputSchema_3>, z.infer<typeof RedactedThinkResponse>>>;
+
+declare type UiTool_4 = InferUITool<Tool<z.infer<typeof inputSchema_4>, z.infer<typeof redactedOutputSchema_3>>>;
+
+declare type UiTool_5 = InferUITool<Tool<z.infer<typeof inputSchema_5>, z.infer<typeof redactedOutputSchema_4>>>;
+
+declare type UiTool_6 = InferUITool<Tool<z.infer<typeof inputSchema_6>, z.infer<typeof redactedOutputSchema_5>>>;
+
+declare type UiTool_7 = InferUITool<Tool<z.infer<typeof inputSchema_7>, z.infer<typeof redactedOutputSchema_6>>>;
+
+export { }