@magemetrics/ai 0.4.1-RC1 → 0.4.1

package/dist/web-component/index.d.ts

@@ -1,15 +1,19 @@
 import { AuthState } from '@magemetrics/core';
 import { CreateFlowParam } from '@magemetrics/core';
 import { default as default_2 } from 'react';
+import { Dispatch } from 'react';
 import { FetchNextPageOptions } from '@tanstack/react-query';
+import { ForwardRefExoticComponent } from 'react';
 import { GenerateInsightParam } from '@magemetrics/core';
 import { InfiniteData } from '@tanstack/react-query';
 import { InfiniteQueryObserverResult } from '@tanstack/react-query';
-import { JSX } from 'react/jsx-runtime';
 import { MageMetricsClient } from '@magemetrics/core';
 import { MageMetricsClientConfig } from '@magemetrics/core';
+import { OnChangeFn } from '@tanstack/react-table';
 import { PropsWithChildren } from 'react';
-import { SortingState } from '@tanstack/react-table';
+import { RefAttributes } from 'react';
+import { SetStateAction } from 'react';
+import { SortingState as SortingState_2 } from '@tanstack/react-table';
 import { UseMutateAsyncFunction } from '@tanstack/react-query';
 import { UseMutateFunction } from '@tanstack/react-query';
 import { UseMutationOptions } from '@tanstack/react-query';
@@ -41,9 +45,7 @@ export declare interface Components {
             [key: string]: (props: CellContentProps) => default_2.ReactNode;
         };
     };
-    dataReportTable?: (props: {
-        report: FrontendReport;
-    }) => default_2.ReactNode;
+    dataReportTable?: (props: DataReportMessageProps) => default_2.ReactNode;
     dataReportMessageActions?: (props: {
         report: FrontendReport;
         isSelected: boolean;
@@ -67,6 +69,8 @@ declare type ControlledModalProps = {
     onClose: () => void;
 };
 
+export declare const ConversationContent: React.FC<ConversationContentProps>;
+
 declare interface ConversationContentProps {
     flowId?: string;
     className?: string;
@@ -77,7 +81,45 @@ declare interface ConversationContentProps {
 
 export { CreateFlowParam }
 
-export declare const DataTable: () => JSX.Element;
+/**
+ * This component is not bounded in height and must be wrapped in a container to properly work
+ * @param props - props
+ * @param props.reportId - The ID of the report to display
+ * @param props.initialState - The initial state of data table
+ * @param props.onStateChange - Callback function to handle state changes
+ * @returns JSX.Element
+ */
+export declare const DataReport: React.FC<{
+    reportId: number;
+    initialState?: DataTableState;
+    onStateChange?: (state: DataTableState) => void;
+}>;
+
+export declare interface DataReportMessageProps {
+    report: FrontendReport;
+    explainability: FrontendReportExplainability | null | undefined;
+    infiniteData: {
+        data?: {
+            pages: Record<string, unknown>[][];
+        };
+        isPending: boolean;
+        fetchNextPage: () => Promise<unknown>;
+        isFetching: boolean;
+        isFetchingNextPage: boolean;
+        hasNextPage: boolean | undefined;
+    };
+    columns: FrontendReportColumns;
+    totalRows: number;
+}
+
+export declare const DataTable: React.FC<DataReportMessageProps>;
+
+declare type DataTableState = {
+    pageIndex: number;
+    pageSize: number;
+    sorting: SortingState;
+    filters: TableFilters;
+};
 
 declare type DisplayControlProps = {
     /** Whether to display the recommendations section when the input is active */
@@ -94,6 +136,10 @@ declare type DomWrapperProps = {
     display?: string;
 };
 
+export declare const DownloadDataReportButton: React.FC<{
+    reportId: number;
+}>;
+
 declare type ExportReportDataParams = {
     reportId: number;
     filename?: string;
@@ -143,6 +189,69 @@ declare type FormattedData = {
 
 declare type FrontendReport = z.infer<typeof FrontendReportSchema>;
 
+declare type FrontendReportColumns = z.infer<typeof FrontendReportColumnsSchema>;
+
+declare const FrontendReportColumnsSchema: z.ZodArray<z.ZodObject<{
+    dataType: z.ZodString;
+    renderType: z.ZodOptional<z.ZodString>;
+    unit: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    data_type: z.ZodString;
+}, z.core.$strip>>;
+
+declare type FrontendReportExplainability = z.infer<typeof FrontendReportExplainabilitySchema>;
+
+declare const FrontendReportExplainabilitySchema: z.ZodObject<{
+    flow_data_id: z.ZodNumber;
+    sql_explanation: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        chunk_title: z.ZodString;
+        chunk_explanation: z.ZodString;
+        lines: z.ZodArray<z.ZodObject<{
+            sql: z.ZodString;
+            explanation: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>>;
+    business_explanation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        summary: z.ZodString;
+        implementation: z.ZodArray<z.ZodString>;
+        assumptions: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                grain: "grain";
+                completeness: "completeness";
+                transformation: "transformation";
+                relationship: "relationship";
+                other: "other";
+            }>;
+            details: z.ZodString;
+            explanation: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    columns_lineage: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                result: "result";
+                filter: "filter";
+                entity: "entity";
+                attribute: "attribute";
+                process: "process";
+                combine: "combine";
+            }>;
+            explanation: z.ZodString;
+        }, z.core.$strip>>;
+        edges: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            target: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>>;
+    confidence_score: z.ZodNumber;
+    confidence_score_reason: z.ZodString;
+    assumptions_score: z.ZodOptional<z.ZodNumber>;
+    assumptions_score_reason: z.ZodOptional<z.ZodString>;
+    friendliness_score: z.ZodOptional<z.ZodNumber>;
+    friendliness_score_reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
 declare const FrontendReportSchema: z.ZodObject<{
     status: z.ZodNullable<z.ZodString>;
     title: z.ZodString;
@@ -214,6 +323,20 @@ declare const FrontendVisualizationSchema: z.ZodObject<{
 
 export { GenerateInsightParam }
 
+export declare const InfiniteDataTableUI: React.FC<InfiniteDataTableUIProps>;
+
+declare type InfiniteDataTableUIProps = {
+    flowDataId: number;
+    data: Record<string, unknown>[];
+    columns: FrontendReportColumns;
+    explainability: FrontendReportExplainability | null | undefined;
+    hasNextPage: boolean | undefined;
+    fetchNextPage: () => Promise<unknown>;
+    isFetchingNextPage: boolean;
+    isFetching: boolean;
+    totalRows: number;
+};
+
 export declare const logout: () => void;
 
 export { MageMetricsClient }
@@ -271,6 +394,37 @@ declare interface ModalProps {
     startOptions?: StartOptions;
 }
 
+export declare const PaginatedDataTableUI: React.FC<PaginatedDataTableUIProps>;
+
+declare type PaginatedDataTableUIProps = {
+    reportId: number;
+    data: Record<string, unknown>[];
+    columns: FrontendReportColumns;
+    explainability: FrontendReportExplainability | null | undefined;
+    isFetching: boolean;
+    totalRows?: number;
+    pageIndex: number;
+    pageSize: number;
+    totalPages?: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    onNextPage: () => void;
+    onPreviousPage: () => void;
+    goToPage: (page: number) => void;
+    sorting: SortingState;
+    onSortingChange: OnChangeFn<SortingState>;
+    filters: TableFilters;
+    onFiltersChange: (filters: TableFilters) => void;
+    onCalculatedPageSize?: (pageSize: number) => void;
+    onStateChange?: (state: {
+        pageIndex: number;
+        pageSize: number;
+        sorting: SortingState;
+        filters: TableFilters;
+    }) => void;
+    emptyState?: React.ReactNode;
+};
+
 declare type PersistenceOptions = "queryParam" | "none";
 
 export declare const PublicCanvas: React.FC<React.ComponentProps<typeof PublicCanvasPanel>>;
@@ -279,15 +433,31 @@ declare const PublicCanvasPanel: default_2.FC<{
     canvasId: string;
 }>;
 
+/**
+ * This component is not bounded in height and must be wrapped in a container to properly work
+ * @param props - props
+ * @param props.canvasId - The ID of the canvas to display
+ * @param props.reportId - The ID of the report to display
+ * @param props.initialState - The initial state of data table
+ * @param props.onStateChange - Callback function to handle state changes
+ * @returns JSX.Element
+ */
+export declare const PublicDataReport: React.FC<{
+    canvasId: string;
+    reportId: number;
+    initialState?: DataTableState;
+    onStateChange?: (state: DataTableState) => void;
+}>;
+
 declare type ReportDataFilters = {
     columns?: string[];
     limit: number;
-    sorting: SortingState_2;
+    sorting: SortingState;
     filters: TableFilters;
     cursor?: number;
 };
 
-declare type SortingState_2 = ColumnSort[];
+declare type SortingState = ColumnSort[];
 
 export declare const StandaloneConversationModal: React.FC<StandaloneConversationModalProps>;
 
@@ -428,34 +598,7 @@ export declare const useCreateFlow: (options?: UseMutationOptions<{
     }, Error, CreateFlowParam, unknown>;
 };
 
-export declare const useCustomReportData: () => {
-    report: {
-        status: string | null;
-        title: string;
-        id: number;
-        request: string | null;
-        created_at: string;
-        is_removed: boolean;
-        flow_id: string;
-        bookmarked: boolean;
-        data_summary: {
-            [x: string]: unknown;
-            columns: Record<string, {
-                [x: string]: unknown;
-                data_type: string;
-                null_count: number | null;
-                unique_count: number | null;
-                unique_percentage: number | null;
-                position?: number | undefined;
-            }>;
-        };
-    };
-    fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<InfiniteData<    {
-        [key: string]: unknown;
-    }[], unknown>, Error>>;
-    pages: {
-        [key: string]: unknown;
-    }[][] | undefined;
+export declare const useDataReport: (reportId: FrontendReport["id"]) => {
     columns: {
         name: string;
         data_type: string;
@@ -464,13 +607,59 @@ export declare const useCustomReportData: () => {
         unit?: string;
     }[] | undefined;
     isPendingColumns: boolean;
-    hasMoreData: boolean;
-    isFetching: boolean;
     isPendingData: boolean;
-    totalRows: number | undefined;
-    totalPages: number | undefined;
-    sorting: SortingState;
-    filters: TableFilters;
+    fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<InfiniteData<    {
+        [key: string]: unknown;
+    }[], unknown>, Error>>;
+    isFetching: boolean;
+    isFetchingNextPage: boolean;
+    hasNextPage: boolean;
+    allData: {
+        [key: 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<    {
+        [key: string]: unknown;
+    }[], unknown> | undefined;
 };
 
 export declare const useDataReportColumnValue: (reportId: number, filters: ReportDataFilters) => UseQueryResult<    {
@@ -720,6 +909,79 @@ export declare const useMageMetricsClient: () => MageMetricsClient;
 
 export declare const useMageMetricsReady: () => false | MageMetricsClient;
 
+export declare const usePaginatedDataReport: (reportId: FrontendReport["id"], options?: {
+    pageSize?: number;
+    initialPageIndex?: number;
+    initialSorting?: SortingState_2;
+    initialFilters?: TableFilters;
+}) => {
+    columns: {
+        name: string;
+        data_type: string;
+        dataType: string;
+        renderType?: string;
+        unit?: string;
+    }[] | undefined;
+    isPendingColumns: boolean;
+    isPendingData: boolean;
+    isFetching: boolean;
+    data: {
+        [key: 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 | undefined;
+    pageIndex: number;
+    pageSize: number;
+    totalPages: number | undefined;
+    nextPage: () => void;
+    previousPage: () => void;
+    goToPage: (page: number) => void;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    sorting: SortingState_2;
+    setSorting: Dispatch<SetStateAction<SortingState_2>>;
+    filters: TableFilters;
+    setFilters: (newFilters: TableFilters) => void;
+};
+
 export declare const useRecentFlows: (limit?: number) => UseQueryResult<    {
     id: string;
     request: string;
@@ -769,4 +1031,10 @@ declare const V1FrontendVisualizationSchema: z.ZodObject<{
     }, z.core.$strip>], "type">;
 }, z.core.$strip>;
 
+export declare const Visualization: ForwardRefExoticComponent<    {
+    visualizationId: number;
+    withTitle: boolean;
+    exportingEnabled?: boolean;
+} & RefAttributes<HTMLDivElement>>;
+
 export { }