drizzle-cube 0.2.26 → 0.2.27

package/dist/client/components/PortletAnalysisModal.d.ts

@@ -1,4 +1,4 @@
-import { PortletConfig, ColorPalette } from '../types';
+import { PortletConfig, ColorPalette, DashboardFilter } from '../types';
 interface PortletAnalysisModalProps {
     isOpen: boolean;
     onClose: () => void;
@@ -9,6 +9,8 @@ interface PortletAnalysisModalProps {
     title: string;
     submitText: string;
     colorPalette?: ColorPalette;
+    /** Dashboard filters to apply to preview (when editing portlet in dashboard context) */
+    dashboardFilters?: DashboardFilter[];
 }
 /**
  * PortletAnalysisModal - A modal wrapper around AnalysisBuilder for portlet editing
@@ -21,5 +23,5 @@ interface PortletAnalysisModalProps {
  * - Title input in header
  * - Initial data support (no re-fetch when editing)
  */
-export default function PortletAnalysisModal({ isOpen, onClose, onSave, portlet, initialData, title: modalTitle, submitText, colorPalette }: PortletAnalysisModalProps): import("react/jsx-runtime").JSX.Element;
+export default function PortletAnalysisModal({ isOpen, onClose, onSave, portlet, initialData, title: modalTitle, submitText, colorPalette, dashboardFilters }: PortletAnalysisModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/client/components/QueryBuilder/types.d.ts

@@ -40,23 +40,6 @@ export interface QueryBuilderRef {
     };
     getValidationResult: () => ValidationResult | null;
 }
-export interface CubeMetaExplorerProps {
-    schema: MetaResponse | null;
-    schemaStatus: SchemaStatus;
-    schemaError: string | null;
-    selectedFields: {
-        measures: string[];
-        dimensions: string[];
-        timeDimensions: string[];
-    };
-    onFieldSelect: (fieldName: string, fieldType: 'measures' | 'dimensions' | 'timeDimensions') => void;
-    onFieldDeselect: (fieldName: string, fieldType: 'measures' | 'dimensions' | 'timeDimensions') => void;
-    onRetrySchema?: () => void;
-    onOpenSettings?: () => void;
-    onExpandSchema?: (expanded: boolean) => void;
-    onViewTypeChange?: (viewType: 'tree' | 'diagram') => void;
-    isExpanded?: boolean;
-}
 export type ShareButtonState = 'idle' | 'copied' | 'copied-no-chart';
 export interface QueryPanelProps {
     query: CubeQuery;

package/dist/client/components/shared/utils.d.ts

@@ -1,5 +1,6 @@
-import { CubeQuery, Filter, SimpleFilter, GroupFilter } from '../../types';
+import { CubeQuery, Filter, SimpleFilter } from '../../types';
 import { MetaField, MetaResponse } from '../QueryBuilder/types';
+export { isSimpleFilter, isGroupFilter, isAndFilter, isOrFilter, flattenFilters, countFilters, createSimpleFilter, createAndFilter, createOrFilter, cleanupFilters, transformFiltersForServer, transformFiltersFromServer, hasQueryContent, cleanQuery, cleanQueryForServer, transformQueryForUI, getCubeNameFromField, getFieldType, getFieldTitle, getAvailableOperators, getAllFilterableFields, convertDateRangeTypeToValue, requiresNumberInput, formatDateForCube, } from '../../shared/utils';
 /**
  * Check if a field is selected in the current query
  */
@@ -16,67 +17,23 @@ export declare function getRegularDimensionFields(schema: MetaResponse): MetaFie
  * Get all measure fields from schema
  */
 export declare function getMeasureFields(schema: MetaResponse): MetaField[];
-/**
- * Check if query has any content (measures, dimensions, or timeDimensions)
- */
-export declare function hasQueryContent(query: CubeQuery): boolean;
 /**
  * Get count of selected fields across all types
  */
 export declare function getSelectedFieldsCount(query: CubeQuery): number;
-/**
- * Get cube name from field name (e.g., "Employees.count" -> "Employees")
- */
-export declare function getCubeNameFromField(fieldName: string): string;
 /**
  * Group fields by cube name
  */
 export declare function groupFieldsByCube(fields: MetaField[]): Record<string, MetaField[]>;
-/**
- * Clean query object by removing empty arrays
- */
-export declare function cleanQuery(query: CubeQuery): CubeQuery;
-/**
- * Clean a query and transform filters for server compatibility
- * This version transforms GroupFilter to legacy and/or format
- */
-export declare function cleanQueryForServer(query: CubeQuery): CubeQuery;
 /**
  * Create an empty query object
  */
 export declare function createEmptyQuery(): CubeQuery;
-/**
- * Filter utility functions
- */
-/**
- * Check if a filter is a simple filter
- */
-export declare function isSimpleFilter(filter: Filter): filter is SimpleFilter;
-/**
- * Check if a filter is a group filter
- */
-export declare function isGroupFilter(filter: Filter): filter is GroupFilter;
-/**
- * Check if a filter is an AND filter
- */
-export declare function isAndFilter(filter: Filter): filter is GroupFilter;
-/**
- * Check if a filter is an OR filter
- */
-export declare function isOrFilter(filter: Filter): filter is GroupFilter;
-/**
- * Flatten all simple filters from a hierarchical filter structure
- */
-export declare function flattenFilters(filters: Filter[]): SimpleFilter[];
 /**
  * Get all filterable fields from schema (measures, dimensions, and time dimensions)
  * Returns ALL fields if no query provided, or only query fields if query provided
  */
 export declare function getFilterableFields(schema: MetaResponse, query?: CubeQuery): MetaField[];
-/**
- * Get ALL filterable fields from schema, regardless of query selection
- */
-export declare function getAllFilterableFields(schema: MetaResponse): MetaField[];
 /**
  * Get organized filter field options with query fields prioritized at top
  */
@@ -84,17 +41,6 @@ export declare function getOrganizedFilterFields(schema: MetaResponse, query?: C
     queryFields: MetaField[];
     allFields: MetaField[];
 };
-/**
- * Get available operators for a field type
- */
-export declare function getAvailableOperators(fieldType: string): Array<{
-    operator: string;
-    label: string;
-}>;
-/**
- * Get field type from schema
- */
-export declare function getFieldType(fieldName: string, schema: MetaResponse): string;
 /**
  * Validate a filter
  */
@@ -102,52 +48,11 @@ export declare function validateFilter(filter: SimpleFilter, schema: MetaRespons
     isValid: boolean;
     errors: string[];
 };
-/**
- * Count total filters in hierarchical structure
- */
-export declare function countFilters(filters: Filter[]): number;
-/**
- * Create a new simple filter
- */
-export declare function createSimpleFilter(member: string, operator?: string, values?: any[]): SimpleFilter;
-/**
- * Create a new AND filter group
- */
-export declare function createAndFilter(filters?: Filter[]): GroupFilter;
-/**
- * Create a new OR filter group
- */
-export declare function createOrFilter(filters?: Filter[]): GroupFilter;
-/**
- * Clean up filters by removing any that reference fields not in the current query
- * @deprecated This function is no longer used as we now support filtering on any schema field
- */
-export declare function cleanupFilters(filters: Filter[], _query?: CubeQuery): Filter[];
 /**
  * Clean up filters by removing any that reference fields not in the current query (legacy)
  * Only used for backward compatibility - filters on non-query fields are now supported
  */
 export declare function cleanupFiltersLegacy(filters: Filter[], query: CubeQuery): Filter[];
-/**
- * Transform filters from new GroupFilter format to legacy server format
- * Server expects { and: [...] } and { or: [...] } instead of { type: 'and', filters: [...] }
- */
-export declare function transformFiltersForServer(filters: Filter[]): any[];
-/**
- * Date range utility functions
- */
-/**
- * Convert DateRangeType to Cube.js compatible date range format
- */
-export declare function convertDateRangeTypeToValue(rangeType: string, number?: number): string;
-/**
- * Check if a date range type requires a number input
- */
-export declare function requiresNumberInput(rangeType: string): boolean;
-/**
- * Format date for Cube.js (YYYY-MM-DD)
- */
-export declare function formatDateForCube(date: Date): string;
 /**
  * Get the time dimensions that have date ranges applied
  */
@@ -156,18 +61,6 @@ export declare function getTimeDimensionsWithDateRanges(query: CubeQuery): Recor
  * Check if a query has any time dimensions
  */
 export declare function hasTimeDimensions(query: CubeQuery): boolean;
-/**
- * Transform a Cube.js query from external format to UI internal format
- * This handles format differences between server/API queries and QueryBuilder state
- */
-export declare function transformQueryForUI(query: any): CubeQuery;
-/**
- * Sorting utility functions
- */
-/**
- * Get field title from schema metadata, falling back to field name
- */
-export declare function getFieldTitle(fieldName: string, schema: MetaResponse | null): string;
 /**
  * Clean up order object by removing fields that are no longer in the query
  */
@@ -184,9 +77,6 @@ export declare function getSortTooltip(direction: 'asc' | 'desc' | null): string
  * Get next sort direction in the cycle: null -> asc -> desc -> null
  */
 export declare function getNextSortDirection(current: 'asc' | 'desc' | null): 'asc' | 'desc' | null;
-/**
- * Compact filter bar date utilities
- */
 /**
  * Date preset configuration for compact filter bar
  */

package/dist/client/components.d.ts

@@ -8,7 +8,6 @@ export { default as AnalyticsPortlet } from './components/AnalyticsPortlet';
 export { default as AnalyticsDashboard } from './components/AnalyticsDashboard';
 export { default as DashboardGrid } from './components/DashboardGrid';
 export { default as PortletContainer } from './components/PortletContainer';
-export { default as PortletEditModal } from './components/PortletEditModal';
 export { default as DashboardEditModal } from './components/DashboardEditModal';
 export { default as Modal } from './components/Modal';
 export { default as QueryBuilder } from './components/QueryBuilderShim';

package/dist/client/components.js

@@ -1,19 +1,18 @@
-import { a as t, A as s, d as o, D as r, M as d, P as l, b as i, Q as n } from "./chunks/components-BGWiuXqQ.js";
-import { c as b, j as u, h as y, e as c, d as h, v as D } from "./chunks/charts-BsXrHSCm.js";
+import { a as s, A as t, c as r, D as o, M as d, P as i, Q as l } from "./chunks/components-CWMeA5e-.js";
+import { c, j as u, h as y, e as P, d as b, v as h } from "./chunks/charts-BfXEKIrq.js";
 export {
-  t as AnalyticsDashboard,
-  s as AnalyticsPortlet,
-  o as DashboardEditModal,
-  r as DashboardGrid,
+  s as AnalyticsDashboard,
+  t as AnalyticsPortlet,
+  r as DashboardEditModal,
+  o as DashboardGrid,
   d as Modal,
-  l as PortletContainer,
-  i as PortletEditModal,
-  n as QueryBuilder,
-  b as createDashboardLayout,
+  i as PortletContainer,
+  l as QueryBuilder,
+  c as createDashboardLayout,
   u as createSamplePortlet,
   y as findNextPosition,
-  c as generatePortletId,
-  h as generateResponsiveLayouts,
-  D as validateCubeQuery
+  P as generatePortletId,
+  b as generateResponsiveLayouts,
+  h as validateCubeQuery
 };
 //# sourceMappingURL=components.js.map

package/dist/client/hooks/queries/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * TanStack Query Hooks - Barrel Export
+ *
+ * These hooks provide TanStack Query-based data fetching for:
+ * - Cube metadata (useCubeMetaQuery)
+ * - Single cube data loading (useCubeLoadQuery)
+ * - Multi-cube data loading (useMultiCubeLoadQuery)
+ * - Dry-run/debug data (useDryRunQuery, useMultiDryRunQueries)
+ *
+ * All hooks include built-in debouncing, caching, and error handling.
+ */
+export { useCubeMetaQuery, prefetchCubeMeta, CUBE_META_QUERY_KEY, type UseCubeMetaQueryOptions, type UseCubeMetaQueryResult, } from './useCubeMetaQuery';
+export { useCubeLoadQuery, createQueryKey, type UseCubeLoadQueryOptions, type UseCubeLoadQueryResult, } from './useCubeLoadQuery';
+export { useMultiCubeLoadQuery, createMultiQueryKey, type UseMultiCubeLoadQueryOptions, type UseMultiCubeLoadQueryResult, } from './useMultiCubeLoadQuery';
+export { useDryRunQuery, useMultiDryRunQueries, useDryRunQueries, createDryRunQueryKey, type DebugDataEntry, type UseDryRunQueryOptions, type UseDryRunQueryResult, type UseMultiDryRunQueriesOptions, type UseMultiDryRunQueriesResult, } from './useDryRunQuery';

package/dist/client/hooks/queries/useCubeLoadQuery.d.ts

@@ -0,0 +1,67 @@
+import { CubeQuery, CubeResultSet } from '../../types';
+/**
+ * Create a stable query key from a CubeQuery
+ * The key includes all query parameters to ensure proper caching
+ */
+export declare function createQueryKey(query: CubeQuery | null): readonly unknown[];
+export interface UseCubeLoadQueryOptions {
+    /**
+     * Whether to skip the query
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Debounce delay in milliseconds
+     * @default 300
+     */
+    debounceMs?: number;
+    /**
+     * Whether to reset result set when query changes
+     * @default true
+     */
+    resetResultSetOnChange?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 60 * 1000 (1 minute)
+     */
+    staleTime?: number;
+    /**
+     * Whether to keep previous data while loading new data
+     * @default true
+     */
+    keepPreviousData?: boolean;
+}
+export interface UseCubeLoadQueryResult {
+    /** The result set from the query */
+    resultSet: CubeResultSet | null;
+    /** Raw data from the result set */
+    rawData: unknown[] | null;
+    /** Whether the query is loading (initial load) */
+    isLoading: boolean;
+    /** Whether the query is fetching (includes refetch) */
+    isFetching: boolean;
+    /** Whether query is debouncing (waiting for user to stop typing) */
+    isDebouncing: boolean;
+    /** Error if the query failed */
+    error: Error | null;
+    /** The debounced query that was executed */
+    debouncedQuery: CubeQuery | null;
+    /** Whether the current query is valid */
+    isValidQuery: boolean;
+    /** Manually refetch the data */
+    refetch: () => void;
+    /** Clear the query cache */
+    clearCache: () => void;
+}
+/**
+ * TanStack Query hook for loading cube data with debouncing
+ *
+ * Usage:
+ * ```tsx
+ * const { resultSet, rawData, isLoading, error } = useCubeLoadQuery(query, {
+ *   debounceMs: 300,
+ *   skip: !isReady
+ * })
+ * ```
+ */
+export declare function useCubeLoadQuery(query: CubeQuery | null, options?: UseCubeLoadQueryOptions): UseCubeLoadQueryResult;

package/dist/client/hooks/queries/useCubeMetaQuery.d.ts

@@ -0,0 +1,51 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { useCubeApi } from '../../providers/CubeApiProvider';
+import { CubeMeta, FieldLabelMap } from '../../types';
+export declare const CUBE_META_QUERY_KEY: readonly ["cube", "meta"];
+export interface UseCubeMetaQueryOptions {
+    /**
+     * Whether to skip the query (useful for conditional fetching)
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Stale time in milliseconds (how long before data is considered stale)
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseCubeMetaQueryResult {
+    /** Cube metadata */
+    meta: CubeMeta | null;
+    /** Field label map for quick lookups */
+    labelMap: FieldLabelMap;
+    /** Whether the query is loading */
+    isLoading: boolean;
+    /** Whether the query is fetching (includes background refetch) */
+    isFetching: boolean;
+    /** Error if the query failed */
+    error: Error | null;
+    /** Manually refetch the metadata */
+    refetch: () => void;
+    /** Get a field's display label */
+    getFieldLabel: (fieldName: string) => string;
+}
+/**
+ * TanStack Query hook for fetching cube metadata
+ *
+ * Usage:
+ * ```tsx
+ * const { meta, labelMap, isLoading, error, refetch } = useCubeMetaQuery()
+ * ```
+ */
+export declare function useCubeMetaQuery(options?: UseCubeMetaQueryOptions): UseCubeMetaQueryResult;
+/**
+ * Prefetch cube metadata - useful for eager loading
+ *
+ * Usage:
+ * ```tsx
+ * const queryClient = useQueryClient()
+ * await prefetchCubeMeta(queryClient, cubeApi)
+ * ```
+ */
+export declare function prefetchCubeMeta(queryClient: ReturnType<typeof useQueryClient>, cubeApi: ReturnType<typeof useCubeApi>['cubeApi']): Promise<void>;

package/dist/client/hooks/queries/useDryRunQuery.d.ts

@@ -0,0 +1,103 @@
+import { CubeQuery } from '../../types';
+import { QueryAnalysis } from '../../components/AnalysisBuilder/types';
+/**
+ * Debug data entry for a single query
+ */
+export interface DebugDataEntry {
+    /** Generated SQL and parameters */
+    sql: {
+        sql: string;
+        params: unknown[];
+    } | null;
+    /** Query analysis (dimensions, measures, complexity, etc.) */
+    analysis: QueryAnalysis | null;
+    /** Whether this entry is loading */
+    loading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+}
+/**
+ * Create a stable query key for dry-run
+ */
+export declare function createDryRunQueryKey(query: CubeQuery | null): readonly unknown[];
+export interface UseDryRunQueryOptions {
+    /**
+     * Whether to skip the query
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseDryRunQueryResult {
+    /** Debug data for the query */
+    debugData: DebugDataEntry;
+    /** Manually refetch */
+    refetch: () => void;
+}
+/**
+ * TanStack Query hook for single query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useDryRunQuery(query, { skip: !isValidQuery })
+ * ```
+ */
+export declare function useDryRunQuery(query: CubeQuery | null, options?: UseDryRunQueryOptions): UseDryRunQueryResult;
+export interface UseMultiDryRunQueriesOptions {
+    /**
+     * Whether to skip all queries
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseMultiDryRunQueriesResult {
+    /** Debug data for each query */
+    debugDataPerQuery: DebugDataEntry[];
+    /** Whether any query is loading */
+    isLoading: boolean;
+    /** Manually refetch all */
+    refetchAll: () => void;
+}
+/**
+ * TanStack Query hook for multiple query dry-runs (debug) data
+ *
+ * Fetches debug data for multiple queries in parallel.
+ *
+ * Usage:
+ * ```tsx
+ * const { debugDataPerQuery, isLoading } = useMultiDryRunQueries(queries, {
+ *   skip: !isMultiQueryMode
+ * })
+ * ```
+ */
+export declare function useMultiDryRunQueries(queries: CubeQuery[], options?: UseMultiDryRunQueriesOptions): UseMultiDryRunQueriesResult;
+/**
+ * Combined hook for single or multi-query dry-run based on mode
+ *
+ * This is a convenience wrapper that automatically chooses between
+ * single and multi-query dry-run based on the number of queries.
+ *
+ * Usage:
+ * ```tsx
+ * const { debugDataPerQuery } = useDryRunQueries({
+ *   queries: isMultiQueryMode ? allQueries : [currentQuery],
+ *   isMultiQueryMode,
+ *   skip: !isValidQuery
+ * })
+ * ```
+ */
+export declare function useDryRunQueries(options: {
+    queries: CubeQuery[];
+    isMultiQueryMode: boolean;
+    skip?: boolean;
+    staleTime?: number;
+}): UseMultiDryRunQueriesResult;

package/dist/client/hooks/queries/useMultiCubeLoadQuery.d.ts

@@ -0,0 +1,68 @@
+import { MultiQueryConfig, CubeResultSet } from '../../types';
+/**
+ * Create a stable query key for multi-query
+ */
+export declare function createMultiQueryKey(config: MultiQueryConfig | null): readonly unknown[];
+export interface UseMultiCubeLoadQueryOptions {
+    /**
+     * Whether to skip the query
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Debounce delay in milliseconds
+     * @default 300
+     */
+    debounceMs?: number;
+    /**
+     * Whether to reset result set when query changes
+     * @default true
+     */
+    resetResultSetOnChange?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 60 * 1000 (1 minute)
+     */
+    staleTime?: number;
+    /**
+     * Whether to keep previous data while loading new data
+     * @default true
+     */
+    keepPreviousData?: boolean;
+}
+export interface UseMultiCubeLoadQueryResult {
+    /** Merged data from all queries */
+    data: unknown[] | null;
+    /** Individual result sets from each query */
+    resultSets: (CubeResultSet | null)[] | null;
+    /** Per-query raw data */
+    perQueryData: (unknown[] | null)[] | null;
+    /** Whether any query is still loading (initial load) */
+    isLoading: boolean;
+    /** Whether any query is fetching (includes refetch) */
+    isFetching: boolean;
+    /** Whether query is debouncing (waiting for user to stop typing) */
+    isDebouncing: boolean;
+    /** First error encountered */
+    error: Error | null;
+    /** Per-query errors */
+    errors: (Error | null)[];
+    /** The debounced config that was executed */
+    debouncedConfig: MultiQueryConfig | null;
+    /** Whether the current config is valid */
+    isValidConfig: boolean;
+    /** Manually refetch the data */
+    refetch: () => void;
+}
+/**
+ * TanStack Query hook for loading multi-cube data with debouncing
+ *
+ * Usage:
+ * ```tsx
+ * const { data, isLoading, error } = useMultiCubeLoadQuery(config, {
+ *   debounceMs: 300,
+ *   skip: !isMultiQueryMode
+ * })
+ * ```
+ */
+export declare function useMultiCubeLoadQuery(config: MultiQueryConfig | null, options?: UseMultiCubeLoadQueryOptions): UseMultiCubeLoadQueryResult;

package/dist/client/hooks/useAnalysisAI.d.ts

@@ -0,0 +1,44 @@
+import { AnalysisBuilderState, AIState } from '../components/AnalysisBuilder/types';
+import { ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types';
+interface UseAnalysisAIOptions {
+    /** Current state for snapshotting */
+    state: AnalysisBuilderState;
+    /** Set state function for applying AI-generated queries */
+    setState: (updater: (prev: AnalysisBuilderState) => AnalysisBuilderState) => void;
+    /** Current chart type */
+    chartType: ChartType;
+    /** Set chart type */
+    setChartType: (type: ChartType) => void;
+    /** Current chart config */
+    chartConfig: ChartAxisConfig;
+    /** Set chart config */
+    setChartConfig: (config: ChartAxisConfig) => void;
+    /** Current display config */
+    displayConfig: ChartDisplayConfig;
+    /** Set display config */
+    setDisplayConfig: (config: ChartDisplayConfig) => void;
+    /** Set whether user manually selected chart */
+    setUserManuallySelectedChart: (value: boolean) => void;
+    /** Set active view */
+    setActiveView: (view: 'table' | 'chart') => void;
+    /** AI endpoint URL */
+    aiEndpoint?: string;
+}
+interface UseAnalysisAIResult {
+    /** Current AI state */
+    aiState: AIState;
+    /** Open the AI panel */
+    handleOpenAI: () => void;
+    /** Close the AI panel */
+    handleCloseAI: () => void;
+    /** Update the AI prompt */
+    handleAIPromptChange: (prompt: string) => void;
+    /** Generate query from AI */
+    handleGenerateAI: () => Promise<void>;
+    /** Accept the AI-generated query */
+    handleAcceptAI: () => void;
+    /** Cancel and restore previous state */
+    handleCancelAI: () => void;
+}
+export declare function useAnalysisAI({ state, setState, chartType, setChartType, chartConfig, setChartConfig, displayConfig, setDisplayConfig, setUserManuallySelectedChart, setActiveView, aiEndpoint }: UseAnalysisAIOptions): UseAnalysisAIResult;
+export {};