@magemetrics/ai 0.0.49 → 0.0.54-RC1

package/dist/react/index.d.ts

@@ -1,23 +1,26 @@
+import type { Client } from 'openapi-fetch';
 import { default as default_2 } from 'react';
+import { FetchNextPageOptions } from '@tanstack/react-query';
+import { ForwardRefExoticComponent } from 'react';
+import { InfiniteData } from '@tanstack/react-query';
+import { InfiniteQueryObserverResult } from '@tanstack/react-query';
 import { JSX } from 'react/jsx-runtime';
+import { objectOutputType } from 'zod';
+import { PropsWithChildren } from 'react';
+import { RefAttributes } from 'react';
+import type { Simplify } from 'type-fest';
 import { UseMutateAsyncFunction } from '@tanstack/react-query';
 import { UseMutateFunction } from '@tanstack/react-query';
 import { UseMutationOptions } from '@tanstack/react-query';
+import { UseQueryResult } from '@tanstack/react-query';
 import { z } from 'zod';
+import { ZodNullable } from 'zod';
+import { ZodNumber } from 'zod';
+import { ZodOptional } from 'zod';
+import { ZodString } from 'zod';
+import { ZodTypeAny } from 'zod';
 
-export declare class ApiService {
-    private client;
-    constructor(baseUrl: string);
-    getRecentFlows: (params: {
-        limit?: number;
-    }) => Promise<{
-        created_at: string;
-        id: string;
-        request: string;
-        user_id: string | null;
-    }[]>;
-    startFlow: (request: StartFlowParam) => Promise<string>;
-}
+export declare type AuthState = "initializing" | "ready" | "error";
 
 export declare type CellContentProps = {
     formattedValue: FormattedData | undefined;
@@ -62,6 +65,40 @@ export declare interface Components {
         };
     };
     dataReportTable?: (props: DataReportMessageProps) => default_2.ReactNode;
+    messageActions?: (props: {
+        type: "data-report";
+        report: FrontendReport;
+    } | {
+        type: "visualization";
+        visualization: FrontendVisualization;
+    }) => default_2.ReactNode;
+}
+
+declare interface components {
+    schemas: {
+        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;
+        };
+        VisualizationData: {
+            [key: string]: string | (number | null) | unknown | null;
+        }[];
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
 }
 
 declare type ControlledModalProps = {
@@ -69,11 +106,21 @@ declare type ControlledModalProps = {
     onClose: () => void;
 };
 
+export declare const Dashboard: React.FC<React.ComponentProps<typeof Dashboard_2>>;
+
+declare const Dashboard_2: React.FC<{
+    dashboardId: string;
+}>;
+
+export declare const DataReport: React.FC<{
+    reportId: number;
+}>;
+
 export declare interface DataReportMessageProps {
-    report: FrontendFlowData;
+    report: FrontendReport;
     isOpened: boolean;
     setIsOpened: (opened: boolean) => void;
-    explainability: FrontendFlowDataExplainability | null | undefined;
+    explainability: FrontendReportExplainability | null | undefined;
     infiniteData: {
         data?: {
             pages: Record<string, unknown>[][];
@@ -84,11 +131,11 @@ export declare interface DataReportMessageProps {
         isFetchingNextPage: boolean;
         hasNextPage: boolean | undefined;
     };
-    columns: FrontendFlowColumns;
+    columns: FrontendReportColumns;
     totalRows: number;
 }
 
-export declare const DataTable: (props: DataReportMessageProps) => JSX.Element;
+export declare const DataTable: React.FC<DataReportMessageProps>;
 
 declare type DisplayControlProps = {
     showRecommendations?: boolean;
@@ -96,6 +143,23 @@ declare type DisplayControlProps = {
     showBackdrop?: boolean;
 };
 
+export declare const DomWrapper: React.FC<PropsWithChildren<DomWrapperProps>>;
+
+declare type DomWrapperProps = {
+    display?: string;
+};
+
+declare type ExportReportDataParams = {
+    reportId: number;
+    filename?: string;
+    format?: "text" | "blob";
+};
+
+declare type ExportReportDataResult = {
+    filename: string;
+    data: Blob | string;
+};
+
 /**
  * This module handles the formatting and normalization of table cell values for display and sorting.
  *
@@ -123,9 +187,11 @@ declare type FormattedData = {
     sortValue: string | number | Date | null;
 };
 
-declare type FrontendFlowColumns = z.infer<typeof FrontendFlowColumnsSchema>;
+declare type FrontendReport = z.infer<typeof FrontendReportSchema>;
 
-declare const FrontendFlowColumnsSchema: z.ZodArray<z.ZodObject<{
+declare type FrontendReportColumns = z.infer<typeof FrontendReportColumnsSchema>;
+
+declare const FrontendReportColumnsSchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     data_type: z.ZodString;
 } & {
@@ -146,11 +212,9 @@ declare const FrontendFlowColumnsSchema: z.ZodArray<z.ZodObject<{
     renderType?: string | undefined;
 }>, "many">;
 
-declare type FrontendFlowData = z.infer<typeof FrontendFlowDataSchema>;
-
-declare type FrontendFlowDataExplainability = z.infer<typeof FrontendFlowDataExplainabilitySchema>;
+declare type FrontendReportExplainability = z.infer<typeof FrontendReportExplainabilitySchema>;
 
-declare const FrontendFlowDataExplainabilitySchema: z.ZodObject<Omit<{
+declare const FrontendReportExplainabilitySchema: z.ZodObject<Omit<{
     sql_explanation: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
         chunk_title: z.ZodString;
         chunk_explanation: z.ZodString;
@@ -340,7 +404,7 @@ declare const FrontendFlowDataExplainabilitySchema: z.ZodObject<Omit<{
     friendliness_score_reason?: string | undefined;
 }>;
 
-declare const FrontendFlowDataSchema: z.ZodObject<Omit<{
+declare const FrontendReportSchema: z.ZodObject<Omit<{
     created_at: z.ZodString;
     flow_id: z.ZodString;
     id: z.ZodNumber;
@@ -413,10 +477,11 @@ declare const FrontendFlowDataSchema: z.ZodObject<Omit<{
     }, z.ZodTypeAny, "passthrough">>;
     bookmarked: z.ZodBoolean;
     status: z.ZodNullable<z.ZodString>;
-}, "schema" | "sql" | "table" | "created_at" | "is_sample" | "data_sample">, "strip", z.ZodTypeAny, {
+}, "schema" | "sql" | "table" | "is_sample" | "data_sample">, "strip", z.ZodTypeAny, {
     status: string | null;
     title: string;
     id: number;
+    created_at: string;
     bookmarked: boolean;
     flow_id: string;
     data_summary: {
@@ -434,6 +499,7 @@ declare const FrontendFlowDataSchema: z.ZodObject<Omit<{
     status: string | null;
     title: string;
     id: number;
+    created_at: string;
     bookmarked: boolean;
     flow_id: string;
     data_summary: {
@@ -449,13 +515,372 @@ declare const FrontendFlowDataSchema: z.ZodObject<Omit<{
     };
 }>;
 
+declare type FrontendVisualization = z.output<typeof FrontendVisualizationSchema>;
+
+declare const FrontendVisualizationSchema: z.ZodObject<Omit<{
+    id: z.ZodNumber;
+    flow_data_id: z.ZodNumber;
+    created_at: z.ZodString;
+    configuration: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        xAxisLabel: z.ZodString;
+        yAxisLabel: z.ZodString;
+        xAxisDataKey: z.ZodOptional<z.ZodString>;
+        yAxisDataKey: z.ZodOptional<z.ZodString>;
+        dimensionDataKey: z.ZodOptional<z.ZodString>;
+        valueColumns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        title: z.ZodString;
+        type: z.ZodLiteral<"bar">;
+    }, "strip", z.ZodTypeAny, {
+        type: "bar";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    }, {
+        type: "bar";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    }>, z.ZodObject<{
+        xAxisLabel: z.ZodString;
+        yAxisLabel: z.ZodString;
+        xAxisDataKey: z.ZodOptional<z.ZodString>;
+        yAxisDataKey: z.ZodOptional<z.ZodString>;
+        dimensionDataKey: z.ZodOptional<z.ZodString>;
+        valueColumns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        title: z.ZodString;
+        type: z.ZodLiteral<"line/area">;
+    }, "strip", z.ZodTypeAny, {
+        type: "line/area";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    }, {
+        type: "line/area";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    }>, z.ZodObject<{
+        xAxisLabel: z.ZodString;
+        yAxisLabel: z.ZodString;
+        xAxisDataKey: z.ZodOptional<z.ZodString>;
+        yAxisDataKey: z.ZodOptional<z.ZodString>;
+        dimensionDataKey: z.ZodOptional<z.ZodString>;
+        valueColumns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        title: z.ZodString;
+        type: z.ZodLiteral<"scatter">;
+    }, "strip", z.ZodTypeAny, {
+        type: "scatter";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    }, {
+        type: "scatter";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    }>, z.ZodObject<{
+        nameKey: z.ZodString;
+        dataKey: z.ZodString;
+        title: z.ZodString;
+        type: z.ZodLiteral<"pie">;
+    }, "strip", z.ZodTypeAny, {
+        type: "pie";
+        title: string;
+        nameKey: string;
+        dataKey: string;
+    }, {
+        type: "pie";
+        title: string;
+        nameKey: string;
+        dataKey: string;
+    }>]>;
+    sql: z.ZodString;
+    bookmarked: z.ZodBoolean;
+}, "sql">, "strip", z.ZodTypeAny, {
+    id: number;
+    flow_data_id: number;
+    created_at: string;
+    configuration: {
+        type: "bar";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    } | {
+        type: "line/area";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    } | {
+        type: "scatter";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    } | {
+        type: "pie";
+        title: string;
+        nameKey: string;
+        dataKey: string;
+    };
+    bookmarked: boolean;
+}, {
+    id: number;
+    flow_data_id: number;
+    created_at: string;
+    configuration: {
+        type: "bar";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    } | {
+        type: "line/area";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    } | {
+        type: "scatter";
+        title: string;
+        xAxisLabel: string;
+        yAxisLabel: string;
+        valueColumns?: string[] | undefined;
+        xAxisDataKey?: string | undefined;
+        yAxisDataKey?: string | undefined;
+        dimensionDataKey?: string | undefined;
+    } | {
+        type: "pie";
+        title: string;
+        nameKey: string;
+        dataKey: string;
+    };
+    bookmarked: boolean;
+}>;
+
+export declare const InfiniteDataTableUI: React.FC<InfiniteDataTableUIProps>;
+
+declare type InfiniteDataTableUIProps = {
+    flowDataId: number;
+    data: Record<string, unknown>[];
+    columns: FrontendReportColumns;
+    explainability: FrontendReportExplainability | null | undefined;
+    isOpened: boolean;
+    setIsOpened: (opened: boolean) => void;
+    hasNextPage?: boolean;
+    fetchNextPage: () => Promise<unknown>;
+    isFetchingNextPage: boolean;
+    isFetching: boolean;
+    totalRows: number;
+};
+
+declare type InternalApiClient = Simplify<Client<NoAuthPaths, `${string}/${string}`>>;
+
 export declare const logout: () => Promise<void>;
 
+/**
+ * Core MageMetrics client that handles authentication lifecycle and provides
+ * a promise-based API that automatically waits for authentication to complete.
+ */
+export declare class MageMetricsClient extends EventTarget {
+    private config;
+    private authState;
+    private supabaseClient;
+    private internalApiClient;
+    private noAuthApiClient;
+    private authApiResponse;
+    private authPromise;
+    private processedJwt;
+    constructor(config: MageMetricsClientConfig);
+    waitForAuth(): Promise<void>;
+    updateExternalJwt(jwt: string): Promise<void>;
+    get state(): AuthState;
+    getAuthHeaders(): Promise<Record<string, string>>;
+    logout(): Promise<void>;
+    /**
+     * Public API methods that automatically wait for authentication
+     */
+    api: {
+        getRecentFlows: (params?: {
+            limit?: number;
+        }) => Promise<{
+            created_at: string;
+            id: string;
+            request: string;
+            user_id: string | null;
+        }[]>;
+        getFlowDataInsights: (flowId: string, { count }: {
+            count: boolean;
+        }) => Promise<{
+            count: false;
+            data_reports: {
+                status: string | null;
+                title: string;
+                id: number;
+                created_at: string;
+                bookmarked: boolean;
+                flow_id: string;
+                data_summary: {
+                    columns: Record<string, objectOutputType<    {
+                    position: ZodOptional<ZodNumber>;
+                    data_type: ZodString;
+                    null_count: ZodNullable<ZodNumber>;
+                    unique_count: ZodNullable<ZodNumber>;
+                    unique_percentage: ZodNullable<ZodNumber>;
+                    }, ZodTypeAny, "passthrough">>;
+                } & {
+                    [k: string]: unknown;
+                };
+            }[];
+            visualizations: {
+                id: number;
+                flow_data_id: number;
+                created_at: string;
+                configuration: {
+                    type: "bar";
+                    title: string;
+                    xAxisLabel: string;
+                    yAxisLabel: string;
+                    valueColumns?: string[] | undefined;
+                    xAxisDataKey?: string | undefined;
+                    yAxisDataKey?: string | undefined;
+                    dimensionDataKey?: string | undefined;
+                } | {
+                    type: "line/area";
+                    title: string;
+                    xAxisLabel: string;
+                    yAxisLabel: string;
+                    valueColumns?: string[] | undefined;
+                    xAxisDataKey?: string | undefined;
+                    yAxisDataKey?: string | undefined;
+                    dimensionDataKey?: string | undefined;
+                } | {
+                    type: "scatter";
+                    title: string;
+                    xAxisLabel: string;
+                    yAxisLabel: string;
+                    valueColumns?: string[] | undefined;
+                    xAxisDataKey?: string | undefined;
+                    yAxisDataKey?: string | undefined;
+                    dimensionDataKey?: string | undefined;
+                } | {
+                    type: "pie";
+                    title: string;
+                    nameKey: string;
+                    dataKey: string;
+                };
+                bookmarked: boolean;
+            }[];
+        } | {
+            count: true;
+            data_reports: number;
+            visualizations: number;
+        }>;
+        startFlow: (request: StartFlowParam) => Promise<string>;
+        getDashboard: (dashboardId: string) => Promise<{
+            description: string | null;
+            id: string;
+            name: string;
+            positions: ({
+                type: "data-report";
+                flowId: string;
+                flowDataId: number;
+                title: string;
+                col: number;
+                colSpan: number;
+                rowSpan: number;
+            } | {
+                type: "visualization";
+                visualizationId: number;
+                title: string;
+                col: number;
+                colSpan: number;
+                rowSpan: number;
+            })[];
+        }>;
+        exportReportData: (reportId: number, format?: "text" | "blob") => Promise<{
+            filename: string;
+            data: string | Blob;
+        }>;
+    };
+    /**
+     * 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;
+}
+
+export declare interface MageMetricsClientConfig {
+    apiUrl: string;
+    apiKey: string;
+    externalJwt?: string;
+}
+
 export declare const MageMetricsContextProvider: default_2.FC<MageMetricsContextProviderProps>;
 
 export declare interface MageMetricsContextProviderProps {
     children: default_2.ReactNode;
-    apiKey?: string;
+    apiKey: string;
     externalJwt?: string;
     apiUrl: string;
     experimental_components?: Components;
@@ -477,8 +902,2466 @@ declare interface ModalProps {
     startOptions?: StartOptions;
 }
 
+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;
+                    };
+                };
+            };
+        };
+    };
+    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;
+                    };
+                };
+            };
+        };
+    };
+    runEnd2EndFlow: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                    };
+                };
+            };
+        };
+    };
+    retrieveFlowDataInsights: {
+        parameters: {
+            query?: {
+                count?: boolean;
+            };
+            header: {
+                "sp-access-token": string;
+                "sp-refresh-token"?: string;
+            };
+            path: {
+                flowId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Flow data insights (data reports and visualizations) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        count: false;
+                        data_reports: {
+                            created_at: string;
+                            flow_id: string;
+                            id: number;
+                            title: string;
+                            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;
+                        }[];
+                        visualizations: {
+                            id: number;
+                            flow_data_id: number;
+                            created_at: string;
+                            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;
+                            };
+                            bookmarked: boolean;
+                        }[];
+                    } | {
+                        /** @enum {boolean} */
+                        count: true;
+                        data_reports: number;
+                        visualizations: number;
+                    };
+                };
+            };
+            /** @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;
+                    };
+                };
+            };
+        };
+    };
+    retrieveFlowDataReports: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+                "sp-refresh-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;
+                        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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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?: {
+                limit?: number;
+                /** @example name:asc,date:desc */
+                order?: string;
+                cursor?: number;
+                /** @example status:active,name:John%20Doe */
+                filter?: string;
+            };
+            header: {
+                "sp-access-token": string;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                    };
+                };
+            };
+        };
+    };
+    getDataReportVisualizations: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+                "sp-refresh-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;
+                        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;
+                        visualizations: {
+                            id: number;
+                            flow_data_id: number;
+                            created_at: string;
+                            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;
+                            };
+                            bookmarked: boolean;
+                        }[];
+                    };
+                };
+            };
+            /** @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;
+                    };
+                };
+            };
+        };
+    };
+    retrieveChatTimeline: {
+        parameters: {
+            query?: never;
+            header: {
+                "sp-access-token": string;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-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;
+                "sp-refresh-token"?: string;
+            };
+            path: {
+                flowDataVisualizationId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The content of the visualization */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        id: number;
+                        flow_data_id: number;
+                        created_at: string;
+                        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;
+                        };
+                        bookmarked: boolean;
+                        data: components["schemas"]["VisualizationData"];
+                        _metadata?: {
+                            wasSampled: boolean;
+                            originalCount: number;
+                            sampledCount: number;
+                        };
+                    };
+                };
+            };
+            /** @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;
+                "sp-refresh-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;
+                        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;
+                        };
+                        bookmarked: boolean;
+                    }[];
+                };
+            };
+            /** @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;
+                "sp-refresh-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;
+                "sp-refresh-token"?: string;
+            };
+            path: {
+                dashboardId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The dashboard with the given id */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        description: string | null;
+                        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;
+                        })[];
+                    };
+                };
+            };
+            /** @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;
+                    };
+                };
+            };
+        };
+    };
+    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;
+                    };
+                };
+            };
+        };
+    };
+    getSankeyData: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Sankey data retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        metadata: {
+                            embedding_type: string;
+                            approach: string;
+                            total_clusters: number;
+                            total_noise_points: number;
+                            total_requests: number;
+                            generation_timestamp: string;
+                        };
+                        clusters: {
+                            cluster_id: number;
+                            cluster_name: string;
+                            representative_questions: {
+                                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;
+                        }[];
+                    };
+                };
+            };
+            /** @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/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/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-insights": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["retrieveFlowDataInsights"];
+        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}/visualizations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["getDataReportVisualizations"];
+        put?: never;
+        post?: never;
+        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/chat/{flowId}/quick-actions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: {
+            parameters: {
+                query?: never;
+                header: {
+                    "sp-access-token": string;
+                    "sp-refresh-token"?: string;
+                };
+                path: {
+                    flowId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        content: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description The quick actions for the given message */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            label: string;
+                            explanation: string;
+                        }[];
+                    };
+                };
+                /** @description The provided content is invalid */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: 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;
+                        };
+                    };
+                };
+            };
+        };
+        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/{flowDataVisualizationId}": {
+        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/{dashboardId}": {
+        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/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/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;
+    };
+}
+
 declare type PersistenceOptions = "queryParam" | "none";
 
+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;
+}>;
+
 export declare const StandaloneConversationModal: React.FC<StandaloneConversationModalProps>;
 
 declare type StandaloneConversationModalProps = {
@@ -487,7 +3370,7 @@ declare type StandaloneConversationModalProps = {
     onOpenChange?: (open: boolean) => void;
 };
 
-declare type StartFlowParam = {
+export declare type StartFlowParam = {
     query: string;
 } | {
     triggerId: string;
@@ -500,6 +3383,223 @@ declare type StartOptions = DisplayControlProps & {
     placeholders?: string[];
 };
 
+declare type ToRemove = Simplify<{
+    header: "sp-access-token" | "sp-refresh-token";
+}>;
+
+export declare const useDataReport: (flowDataId: FrontendReport["id"]) => {
+    dataColumns: {
+        name: string;
+        data_type: string;
+        dataType: string;
+        renderType?: string;
+        unit?: string;
+    }[] | undefined;
+    isPendingColumns: boolean;
+    isPendingData: boolean;
+    fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<InfiniteData<Record<string, unknown>[], unknown>, Error>>;
+    isFetching: boolean;
+    isFetchingNextPage: boolean;
+    hasNextPage: boolean;
+    allData: Record<string, unknown>[];
+    explainability: {
+        sql_explanation?: {
+            chunk_title: string;
+            chunk_explanation: string;
+            lines: {
+                sql: string;
+                explanation: string;
+            }[];
+        }[] | null;
+        business_explanation?: {
+            summary: string;
+            implementation: string[];
+            assumptions: {
+                type: "grain" | "completeness" | "transformation" | "relationship" | "other";
+                details: string;
+                explanation: string;
+            }[];
+        } | null;
+        columns_lineage?: {
+            [key: string]: {
+                nodes: {
+                    id: 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;
+    } | null | undefined;
+    totalRows: number;
+    infiniteData: InfiniteData<Record<string, unknown>[], unknown> | undefined;
+};
+
+export declare const useDownloadReportData: (options?: UseMutationOptions<ExportReportDataResult, Error, ExportReportDataParams>) => {
+    download: UseMutateFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: UseMutateFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: UseMutateAsyncFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+} | {
+    download: UseMutateFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+    data: undefined;
+    variables: ExportReportDataParams;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: UseMutateFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: UseMutateAsyncFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+} | {
+    download: UseMutateFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+    data: undefined;
+    error: Error;
+    variables: ExportReportDataParams;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: UseMutateFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: UseMutateAsyncFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+} | {
+    download: UseMutateFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+    data: ExportReportDataResult;
+    error: null;
+    variables: ExportReportDataParams;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: UseMutateFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: UseMutateAsyncFunction<ExportReportDataResult, Error, ExportReportDataParams, unknown>;
+};
+
+export declare const useFlowDataInsights: (flowId: string, enabled?: boolean) => UseQueryResult<    {
+count: false;
+data_reports: {
+status: string | null;
+title: string;
+id: number;
+created_at: string;
+bookmarked: boolean;
+flow_id: string;
+data_summary: {
+columns: Record<string, objectOutputType<    {
+position: ZodOptional<ZodNumber>;
+data_type: ZodString;
+null_count: ZodNullable<ZodNumber>;
+unique_count: ZodNullable<ZodNumber>;
+unique_percentage: ZodNullable<ZodNumber>;
+}, ZodTypeAny, "passthrough">>;
+} & {
+[k: string]: unknown;
+};
+}[];
+visualizations: {
+id: number;
+flow_data_id: number;
+created_at: string;
+configuration: {
+type: "bar";
+title: string;
+xAxisLabel: string;
+yAxisLabel: string;
+valueColumns?: string[] | undefined;
+xAxisDataKey?: string | undefined;
+yAxisDataKey?: string | undefined;
+dimensionDataKey?: string | undefined;
+} | {
+type: "line/area";
+title: string;
+xAxisLabel: string;
+yAxisLabel: string;
+valueColumns?: string[] | undefined;
+xAxisDataKey?: string | undefined;
+yAxisDataKey?: string | undefined;
+dimensionDataKey?: string | undefined;
+} | {
+type: "scatter";
+title: string;
+xAxisLabel: string;
+yAxisLabel: string;
+valueColumns?: string[] | undefined;
+xAxisDataKey?: string | undefined;
+yAxisDataKey?: string | undefined;
+dimensionDataKey?: string | undefined;
+} | {
+type: "pie";
+title: string;
+nameKey: string;
+dataKey: string;
+};
+bookmarked: boolean;
+}[];
+}, Error>;
+
+export declare const useFlowDataInsightsCount: (flowId: string) => UseQueryResult<    {
+count: true;
+data_reports: number;
+visualizations: number;
+}, Error>;
+
+export declare const useMageMetricsApiUrl: () => string;
+
+export declare const useMageMetricsClient: () => MageMetricsClient | undefined;
+
+export declare const useMageMetricsReady: () => false | MageMetricsClient | undefined;
+
+export declare const useRecentFlows: (limit?: number) => UseQueryResult<    {
+created_at: string;
+id: string;
+request: string;
+user_id: string | null;
+}[], Error>;
+
 export declare const useStartFlow: (options?: UseMutationOptions<string, Error, StartFlowParam>) => {
     startFlow: UseMutateFunction<string, Error, StartFlowParam, unknown>;
     startFlowAsync: UseMutateAsyncFunction<string, Error, StartFlowParam, unknown>;
@@ -578,6 +3678,12 @@ export declare const useStartFlow: (options?: UseMutationOptions<string, Error,
     mutateAsync: UseMutateAsyncFunction<string, Error, StartFlowParam, unknown>;
 };
 
+export declare const Visualization: ForwardRefExoticComponent<    {
+visualizationId: number;
+isFullWidth: boolean;
+withTitle: boolean;
+} & RefAttributes<HTMLDivElement>>;
+
 export { }