
import { At as SubmitRunTrackProps, C as Run, an as NodeColumnData, l as Check } from "./instanceInfo-D9Pe6gIo.js";
import { c as LineageGraphNode, n as ActionState } from "./types-O5C1mYdz.js";
import { M as CheckEvent } from "./api-CHRBUwIf.js";
import { i as RegistryEntry } from "./types-LBo5v16M.js";
import { r as DataGridHandle } from "./ScreenshotDataGrid-BFA3jIej.js";
import * as _tanstack_react_query0 from "@tanstack/react-query";
import { AxiosInstance } from "axios";
import React, { JSX, ReactNode } from "react";
import * as react_jsx_runtime48 from "react/jsx-runtime";

//#region src/components/ui/mui-provider.d.ts
interface MuiProviderProps {
  children: ReactNode;
  /**
   * Force a specific theme mode. If not provided, follows system/user preference.
   */
  forcedTheme?: "light" | "dark";
  /**
   * Whether to include MUI's CssBaseline for consistent baseline styles.
   * Disabled by default to avoid conflicts with Chakra/Tailwind during migration.
   */
  enableCssBaseline?: boolean;
}
/**
 * MUI Theme Provider for Recce
 *
 * This provider integrates MUI theming with the existing next-themes
 * color mode system used by Chakra UI. MUI 7 CSS Variables mode is used,
 * which responds to the `.dark` class on document.documentElement.
 *
 * Usage:
 * ```tsx
 * <MuiProvider>
 *   <MuiButton>Click me</MuiButton>
 * </MuiProvider>
 * ```
 */
declare function MuiProvider({
  children,
  forcedTheme,
  enableCssBaseline
}: MuiProviderProps): react_jsx_runtime48.JSX.Element;
//#endregion
//#region src/hooks/CheckContextAdapter.d.ts
interface CheckContextAdapterProps {
  children: ReactNode;
}
/**
 * OSS-compatible CheckContext type with required fields.
 * The @datarecce/ui CheckContextType has optional OSS fields,
 * but OSS components expect them to be defined.
 */
interface OSSCheckContext {
  latestSelectedCheckId: string;
  setLatestSelectedCheckId: (checkId: string) => void;
}
/**
 * CheckContextAdapter bridges OSS with @datarecce/ui's CheckProvider.
 *
 * The OSS RecceCheckContext was very simple - just selection state:
 * - latestSelectedCheckId: string
 * - setLatestSelectedCheckId: (checkId: string) => void
 *
 * This adapter manages internal state and provides the OSS interface
 * through the @datarecce/ui CheckProvider.
 */
declare function CheckContextAdapter({
  children
}: CheckContextAdapterProps): react_jsx_runtime48.JSX.Element;
/**
 * OSS-compatible hook that returns the check context with guaranteed non-optional fields.
 * This wraps @datarecce/ui's useCheckContext and provides type safety for OSS components.
 */
declare function useRecceCheckContext(): OSSCheckContext;
//#endregion
//#region src/hooks/LineageGraphAdapter.d.ts
interface LineageGraphAdapterProps {
  children: React.ReactNode;
}
/**
 * LineageGraphAdapter - Bridges OSS data fetching with @datarecce/ui's LineageGraphProvider
 *
 * This adapter:
 * 1. Does data fetching (useQuery for lineage data)
 * 2. Handles WebSocket connection for real-time updates
 * 3. Renders disconnect/relaunch modals
 * 4. Wraps @datarecce/ui's LineageGraphProvider, passing fetched data as props
 *
 * The separation allows @datarecce/ui to be reusable (props-driven, no fetching)
 * while OSS app handles its own data fetching needs.
 */
declare function LineageGraphAdapter({
  children
}: LineageGraphAdapterProps): react_jsx_runtime48.JSX.Element;
//#endregion
//#region src/hooks/QueryContextAdapter.d.ts
interface QueryContextAdapterProps {
  children: ReactNode;
}
declare const defaultSqlQuery = "select * from {{ ref(\"mymodel\") }}";
/**
 * OSS-compatible QueryContext type with required fields.
 * The @datarecce/ui QueryContextType has optional OSS fields,
 * but OSS components expect them to be defined.
 */
interface OSSQueryContext {
  sqlQuery: string;
  setSqlQuery: (sql: string) => void;
  primaryKeys: string[] | undefined;
  setPrimaryKeys: (pks: string[] | undefined) => void;
  isCustomQueries: boolean;
  setCustomQueries: (isCustom: boolean) => void;
  baseSqlQuery: string;
  setBaseSqlQuery: (sql: string) => void;
}
/**
 * QueryContextAdapter bridges OSS with @datarecce/ui's QueryProvider.
 *
 * Unlike CheckContextAdapter, this adapter manages internal state because
 * OSS's RecceQueryContext manages input state (sqlQuery, primaryKeys, etc.)
 * via useState, while @datarecce/ui's QueryProvider is props-driven.
 *
 * This adapter:
 * 1. Creates internal state matching OSS's interface
 * 2. Passes state and setters to QueryProvider as props
 * 3. Allows consumers to use the same hooks as before
 */
declare function QueryContextAdapter({
  children
}: QueryContextAdapterProps): react_jsx_runtime48.JSX.Element;
/**
 * OSS-compatible hook that returns the query context with guaranteed non-optional fields.
 * This wraps @datarecce/ui's useQueryContext and provides type safety for OSS components.
 */
declare function useRecceQueryContext(): OSSQueryContext;
//#endregion
//#region src/hooks/RecceActionAdapter.d.ts
/**
 * Extended options for OSS that include registry-specific features
 */
interface RecceActionOptions {
  showForm: boolean;
  showLast?: boolean;
  trackProps?: SubmitRunTrackProps;
}
interface RecceActionAdapterProps {
  children: React.ReactNode;
}
/**
 * RecceActionAdapter - Bridges OSS action handling with @datarecce/ui's RecceActionProvider
 *
 * This adapter:
 * 1. Keeps submitRun API logic (OSS-specific)
 * 2. Keeps RunModal UI rendering (OSS-specific)
 * 3. Keeps cache invalidation via useQueryClient (OSS-specific)
 * 4. Uses findByRunType registry lookup (OSS-specific)
 * 5. Wraps @datarecce/ui's RecceActionProvider, passing callbacks as props
 *
 * The separation allows @datarecce/ui to be reusable (props-driven, no API calls)
 * while OSS app handles its own API calls, modals, and cache management.
 */
declare function RecceActionAdapter({
  children
}: RecceActionAdapterProps): react_jsx_runtime48.JSX.Element;
//#endregion
//#region src/hooks/RecceContextProvider.d.ts
interface RecceContextProps {
  children: React.ReactNode;
}
/**
 * Main context provider for Recce application.
 *
 * For custom API configuration (e.g., recce-cloud), wrap this provider
 * with ApiConfigProvider:
 *
 * ```tsx
 * <ApiConfigProvider
 *   apiPrefix="/api/v2/sessions/abc123"
 *   authToken="eyJ..."
 * >
 *   <RecceContextProvider>
 *     {children}
 *   </RecceContextProvider>
 * </ApiConfigProvider>
 * ```
 *
 * When used without ApiConfigProvider (OSS mode), hooks will use
 * the default axios client with standard /api/* endpoints.
 */
declare function RecceContextProvider({
  children
}: RecceContextProps): react_jsx_runtime48.JSX.Element;
//#endregion
//#region src/hooks/RecceShareStateContext.d.ts
interface ShareStateProps {
  shareUrl?: string;
  isLoading: boolean;
  error?: string;
  handleShareClick: () => Promise<void>;
}
declare function RecceShareStateContextProvider({
  children
}: {
  children: React.ReactNode;
}): react_jsx_runtime48.JSX.Element;
declare const useRecceShareStateContext: () => ShareStateProps;
//#endregion
//#region src/hooks/ScreenShot.d.ts
type DataGridRefType = DataGridHandle & {
  element?: HTMLElement;
};
declare const IGNORE_SCREENSHOT_CLASS = "ignore-screenshot";
interface HookOptions {
  renderLibrary?: "html2canvas" | "html-to-image";
  imageType?: "png" | "jpeg";
  backgroundColor?: string | null;
  boardEffect?: boolean;
  shadowEffect?: boolean;
  borderStyle?: string;
  borderRadius?: string;
  onSuccess?: () => void;
  onError?: (error: unknown) => void;
  onClipboardNotDefined?: (blob: Blob) => void;
  ignoreElements?: (element: Element) => boolean;
}
declare function useCopyToClipboard({
  renderLibrary,
  imageType,
  backgroundColor,
  boardEffect,
  shadowEffect,
  borderStyle,
  borderRadius,
  onSuccess,
  onError,
  ignoreElements
}: HookOptions): {
  status: "success" | "error" | "loading" | "idle";
  isLoading: boolean;
  isErrored: boolean;
  isSuccess: boolean;
  copyToClipboard: () => Promise<void>;
  ImageDownloadModal: () => react_jsx_runtime48.JSX.Element;
  ref: React.RefObject<DataGridRefType | null>;
};
declare function useCopyToClipboardButton(options?: HookOptions): {
  ref: React.RefObject<DataGridRefType | null>;
  CopyToClipboardButton: ({
    imageType,
    ...props
  }: {
    imageType?: "png" | "jpeg";
  }) => react_jsx_runtime48.JSX.Element;
  onMouseEnter: () => void;
  onMouseLeave: () => void;
  onCopyToClipboard: () => Promise<void>;
};
declare function useImageDownloadModal(): {
  onOpen: () => void;
  setImgBlob: React.Dispatch<React.SetStateAction<Blob | undefined>>;
  ImageDownloadModal: () => react_jsx_runtime48.JSX.Element;
};
//#endregion
//#region src/hooks/useApiConfig.d.ts
/**
 * API configuration adapter for OSS and cloud hosts.
 *
 * @remarks
 * Fallback chain:
 * 1. RecceProvider (via useApiConfigOptional)
 * 2. Default config using PUBLIC_API_URL
 */
interface ApiConfigContextType {
  /**
   * API endpoint prefix to replace `/api` in all requests.
   * For OSS: "" (empty string, uses default /api/* paths)
   * For Cloud: "/api/v2/sessions/<session_id>" (replaces /api with this)
   */
  apiPrefix: string;
  /**
   * Optional authentication token for API requests.
   * When provided, adds "Authorization: Bearer <token>" header.
   */
  authToken?: string;
  /**
   * Optional base URL override.
   * When provided, overrides the PUBLIC_API_URL for this context.
   */
  baseUrl?: string;
  /**
   * Pre-configured axios instance with interceptors for
   * API prefix replacement and auth token injection.
   */
  apiClient: AxiosInstance;
}
/**
 * Access the API configuration and configured axios client.
 *
 * @remarks
 * Priority order:
 * 1. RecceProvider (via useApiConfigOptional)
 * 2. Default config (for backward compatibility)
 */
declare function useApiConfig(): ApiConfigContextType;
//#endregion
//#region src/hooks/useAvatar.d.ts
/**
 * useAvatar - Hook for fetching user avatars with proper fallback handling.
 *
 * Solves the issue where email-only login users (non-GitHub) were showing
 * incorrect GitHub avatars because their Recce Cloud user_id was being
 * passed to the GitHub API.
 *
 * Logic:
 * 1. Fetch current user data to get login_type
 * 2. If actor's user_id matches current user AND login_type is "github":
 *    - Fetch and return GitHub avatar URL
 * 3. Otherwise:
 *    - Return null (component should show initials fallback)
 */
interface UseAvatarOptions {
  /** The user ID from the event actor */
  userId: string | number | null | undefined;
  /** Whether to enable the query */
  enabled?: boolean;
}
interface UseAvatarResult {
  /** The avatar URL if available, null otherwise */
  avatarUrl: string | null;
  /** Whether the avatar is loading */
  isLoading: boolean;
  /** Whether this user is a GitHub user */
  isGitHubUser: boolean;
}
/**
 * Hook to fetch a user's avatar with proper fallback handling.
 *
 * Only fetches GitHub avatars for users who authenticated via GitHub.
 * For email-only users, returns null so the component can show initials.
 *
 * @example
 * ```tsx
 * function UserAvatar({ userId, displayName }: Props) {
 *   const { avatarUrl } = useAvatar({ userId });
 *
 *   return (
 *     <MuiAvatar src={avatarUrl || undefined}>
 *       {displayName.charAt(0).toUpperCase()}
 *     </MuiAvatar>
 *   );
 * }
 * ```
 */
declare function useAvatar({
  userId,
  enabled
}: UseAvatarOptions): UseAvatarResult;
//#endregion
//#region src/hooks/useCheckEvents.d.ts
/**
 * Custom hook for managing check events (timeline/conversation).
 *
 * Provides data fetching with polling for real-time updates,
 * and mutation functions for CRUD operations.
 */
interface UseCheckEventsOptions {
  enabled?: boolean;
}
declare function useCheckEvents(checkId: string, options?: UseCheckEventsOptions): {
  events: CheckEvent[];
  isLoading: boolean;
  error: Error | null;
  refetch: (options?: _tanstack_react_query0.RefetchOptions) => Promise<_tanstack_react_query0.QueryObserverResult<CheckEvent[], Error>>;
  createComment: _tanstack_react_query0.UseMutateFunction<CheckEvent, Error, string, unknown>;
  isCreatingComment: boolean;
  createCommentError: Error | null;
  updateComment: _tanstack_react_query0.UseMutateAsyncFunction<CheckEvent, Error, {
    eventId: string;
    content: string;
  }, unknown>;
  isUpdatingComment: boolean;
  updateCommentError: Error | null;
  deleteComment: _tanstack_react_query0.UseMutateAsyncFunction<void, Error, string, unknown>;
  isDeletingComment: boolean;
  deleteCommentError: Error | null;
};
//#endregion
//#region src/hooks/useClipBoardToast.d.ts
declare function useClipBoardToast(): {
  successToast: (message: string) => void;
  failToast: (title: string, error: unknown) => void;
};
//#endregion
//#region src/hooks/useCountdownToast.d.ts
/**
 * @recce-migration NOT_APPLICABLE
 *
 * This hook is specific to Recce OSS and should not be migrated to @datarecce/ui.
 *
 * Reason: Server lifetime countdown is an OSS-specific feature for local
 * development servers. It shows remaining time before auto-shutdown.
 * Cloud deployments do not have this concept.
 *
 * If this changes in the future, consider:
 * - This is unlikely to be needed in cloud/shared contexts
 */
/**
 * Hook to manage countdown toast notifications for server lifetime
 * @param lifetimeExpiredAt - Date when the server will expire
 */
declare function useCountdownToast(lifetimeExpiredAt: Date | undefined): void;
//#endregion
//#region src/hooks/useCSVExport.d.ts
interface UseCSVExportOptions {
  run?: Run;
  /** View options - displayMode is extracted if present (for query_diff views) */
  viewOptions?: Record<string, unknown>;
}
interface UseCSVExportResult {
  /** Whether CSV export is available for this run type */
  canExportCSV: boolean;
  /** Copy result data as CSV to clipboard */
  copyAsCSV: () => Promise<void>;
  /** Copy result data as TSV to clipboard (pastes into spreadsheets) */
  copyAsTSV: () => Promise<void>;
  /** Download result data as CSV file */
  downloadAsCSV: () => void;
  /** Download result data as TSV file */
  downloadAsTSV: () => void;
  /** Download result data as Excel file */
  downloadAsExcel: () => void;
}
declare function useCSVExport({
  run,
  viewOptions
}: UseCSVExportOptions): UseCSVExportResult;
//#endregion
//#region src/hooks/useFeedbackCollectionToast.d.ts
declare function useFeedbackCollectionToast(options: {
  feedbackId: string;
  description: string;
  onFeedbackSubmit: (feedback: string) => void;
  externalLink?: string;
  externalLinkText?: string;
}): {
  feedbackToast: (skipBypassFeedback?: boolean) => void;
  closeToast: () => void;
};
//#endregion
//#region src/hooks/useGuideToast.d.ts
/**
 * @recce-migration NOT_APPLICABLE
 *
 * This hook is specific to Recce OSS and should not be migrated to @datarecce/ui.
 *
 * Reason: Onboarding guide toasts are tied to OSS-specific feature flags and
 * user onboarding flows. Cloud has different onboarding patterns.
 *
 * If this changes in the future, consider:
 * - Creating a generic toast system in @datarecce/ui
 * - Keeping onboarding logic in host applications
 */
declare function useGuideToast(options: {
  guideId: string;
  description: string;
  externalLink?: string;
  externalLinkText?: string;
  onExternalLinkClick?: () => void;
}): {
  guideToast: () => void;
  closeGuideToast: () => void;
};
//#endregion
//#region src/hooks/useIsDark.d.ts
/**
 * Simple dark mode detection hook
 *
 * Uses RecceTheme context when available for reliable dark mode detection.
 * Falls back to DOM class detection when not within RecceProvider,
 * allowing components to work in both contexts (e.g., OSS app with next-themes
 * and Recce Cloud with RecceProvider).
 *
 * For more theme colors, use useThemeColors() instead.
 *
 * @returns true if dark mode is active, false otherwise
 *
 * @example
 * ```tsx
 * function MyComponent() {
 *   const isDark = useIsDark();
 *   return <Box bgcolor={isDark ? "grey.900" : "grey.100"}>Content</Box>;
 * }
 * ```
 */
declare function useIsDark(): boolean;
//#endregion
//#region src/hooks/useModelColumns.d.ts
/**
 * Extract columns from a lineage graph node.
 * Combines base and current columns using union logic.
 */
declare function extractColumns(node: LineageGraphNode): NodeColumnData[];
/**
 * Create a union of base and current columns by name.
 * Columns from current take precedence if both exist.
 */
declare function unionColumns(baseColumns: NodeColumnData[], currentColumns: NodeColumnData[]): NodeColumnData[];
/**
 * Return type for the useModelColumns hook
 */
interface UseModelColumnsReturn {
  columns: NodeColumnData[];
  primaryKey: string | undefined;
  isLoading: boolean;
  error: Error | null;
}
/**
 * Hook to fetch model column information.
 *
 * This hook combines data from the lineage graph context (if available)
 * with API calls to get detailed column information for a model.
 *
 * @param model - The model name to fetch columns for
 * @param client - Axios instance for API calls (optional - will use context if not provided)
 * @returns Object with columns, primaryKey, isLoading, and error states
 *
 * @example
 * ```tsx
 * const { columns, primaryKey, isLoading, error } = useModelColumns(modelName);
 *
 * if (isLoading) return <Loading />;
 * if (error) return <Error message={error.message} />;
 *
 * return <ColumnList columns={columns} primaryKey={primaryKey} />;
 * ```
 */
declare function useModelColumns(model: string | undefined, client?: AxiosInstance): UseModelColumnsReturn;
//#endregion
//#region src/hooks/useMultiNodesAction.d.ts
/**
 * Action types that can be tracked.
 * Maps to common data validation operations.
 */
type MultiNodesActionType = "row_count" | "row_count_diff" | "value_diff";
/**
 * Properties passed to the tracking callback when an action is executed.
 */
interface MultiNodesActionTrackProps {
  /** The type of action being executed */
  action: MultiNodesActionType;
  /** Source/location where the action was triggered */
  source: string;
  /** Number of nodes included in the action */
  node_count: number;
}
/**
 * Callbacks for tracking analytics events during action execution.
 * This is intentionally optional to allow the base hook to be used
 * in environments without analytics (e.g., embedded or library usage).
 */
interface MultiNodesActionTracking {
  /**
   * Called when an action is executed.
   * Implementations can use this to send analytics events.
   * @param props - Properties describing the action
   */
  onTrackAction?: (props: MultiNodesActionTrackProps) => void;
}
/**
 * Lifecycle callbacks for action execution.
 * These are called at key points during action execution to allow
 * the UI to respond to state changes.
 */
interface MultiNodesActionCallbacks {
  /** Called when any action starts executing */
  onActionStarted: () => void;
  /** Called when a node's action state is updated (status change, completion, etc.) */
  onActionNodeUpdated: (node: LineageGraphNode) => void;
  /** Called when all actions in the batch complete (success, failure, or cancellation) */
  onActionCompleted: () => void;
}
/**
 * Configuration options for the useMultiNodesAction hook.
 */
interface UseMultiNodesActionOptions extends MultiNodesActionCallbacks, MultiNodesActionTracking {
  /**
   * Source identifier for tracking where actions are triggered from.
   * Used in analytics events.
   * @default "lineage_view_top_bar"
   */
  trackingSource?: string;
}
/**
 * Return type for the useMultiNodesAction hook.
 */
interface UseMultiNodesActionReturn {
  /** Current action state (mutable ref for performance) */
  actionState: ActionState;
  /** Execute row count on selected nodes (multi_nodes mode) */
  runRowCount: () => Promise<void>;
  /** Execute row count diff on selected nodes (multi_nodes mode) */
  runRowCountDiff: () => Promise<void>;
  /** Execute value diff on selected nodes (per_node mode) */
  runValueDiff: () => Promise<void>;
  /** Create a lineage diff check for selected nodes */
  addLineageDiffCheck: () => Promise<Check>;
  /** Create a schema diff check for selected nodes */
  addSchemaDiffCheck: () => Promise<Check>;
  /** Cancel the current running action */
  cancel: () => Promise<void>;
  /** Reset action state to initial values */
  reset: () => void;
}
/**
 * Hook for executing batch operations on multiple lineage graph nodes.
 *
 * Provides methods to run data validation operations (row count, row count diff,
 * value diff) on selected nodes, with support for action tracking, cancellation,
 * and progress monitoring.
 *
 * @param nodes - Array of lineage graph nodes to operate on
 * @param options - Configuration options including callbacks and tracking
 * @returns Object containing action state and operation methods
 *
 * @example
 * ```tsx
 * function ActionBar({ selectedNodes }) {
 *   const {
 *     actionState,
 *     runRowCount,
 *     runRowCountDiff,
 *     runValueDiff,
 *     cancel,
 *     reset
 *   } = useMultiNodesAction(selectedNodes, {
 *     onActionStarted: () => console.log('Started'),
 *     onActionNodeUpdated: (node) => console.log('Updated:', node.id),
 *     onActionCompleted: () => console.log('Completed'),
 *     onTrackAction: (props) => analytics.track(props),
 *   });
 *
 *   return (
 *     <div>
 *       <button onClick={runRowCount}>Row Count</button>
 *       <button onClick={cancel}>Cancel</button>
 *       <span>{actionState.status}</span>
 *     </div>
 *   );
 * }
 * ```
 */
declare const useMultiNodesAction: (nodes: LineageGraphNode[], options: UseMultiNodesActionOptions) => UseMultiNodesActionReturn;
//#endregion
//#region src/hooks/useRun.d.ts
interface UseRunResult {
  run?: Run;
  aborting: boolean;
  isRunning: boolean;
  error: Error | null;
  onCancel: () => Promise<void>;
  RunResultView?: RegistryEntry["RunResultView"] | undefined;
}
declare const useRun: (runId?: string) => UseRunResult;
//#endregion
//#region src/hooks/useValueDiffAlertDialog.d.ts
/**
 * Options for useValueDiffAlertDialog hook
 */
interface UseValueDiffAlertDialogOptions {
  /** Callback invoked when user confirms the value diff operation */
  onConfirm?: (nodeCount: number) => void;
  /** Callback invoked when user cancels the value diff operation */
  onCancel?: (nodeCount: number) => void;
}
/**
 * Return type for useValueDiffAlertDialog hook
 */
interface UseValueDiffAlertDialogReturn {
  /** Function to trigger the confirmation dialog. Returns a promise that resolves to true if confirmed, false if cancelled. */
  confirm: (nodeCount: number) => Promise<boolean>;
  /** The dialog component to render in your component tree */
  AlertDialog: JSX.Element;
}
/**
 * Hook for displaying a confirmation dialog before executing value diff on multiple nodes.
 *
 * @param options - Optional callbacks for tracking/analytics
 * @returns Object containing `confirm` function and `AlertDialog` component
 *
 * @example Basic usage without tracking
 * ```tsx
 * import { useValueDiffAlertDialog } from '@datarecce/ui/hooks';
 *
 * function MyComponent() {
 *   const { confirm, AlertDialog } = useValueDiffAlertDialog();
 *
 *   const handleValueDiff = async () => {
 *     const confirmed = await confirm(5); // 5 nodes
 *     if (confirmed) {
 *       // Execute value diff
 *     }
 *   };
 *
 *   return (
 *     <>
 *       <button onClick={handleValueDiff}>Run Value Diff</button>
 *       {AlertDialog}
 *     </>
 *   );
 * }
 * ```
 *
 * @example With tracking callbacks
 * ```tsx
 * import { useValueDiffAlertDialog } from '@datarecce/ui/hooks';
 *
 * function MyComponent() {
 *   const { confirm, AlertDialog } = useValueDiffAlertDialog({
 *     onConfirm: (nodeCount) => {
 *       analytics.track('value_diff_confirmed', { nodeCount });
 *     },
 *     onCancel: (nodeCount) => {
 *       analytics.track('value_diff_cancelled', { nodeCount });
 *     },
 *   });
 *
 *   return (
 *     <>
 *       <button onClick={() => confirm(10)}>Run Value Diff</button>
 *       {AlertDialog}
 *     </>
 *   );
 * }
 * ```
 */
declare function useValueDiffAlertDialog(options?: UseValueDiffAlertDialogOptions): UseValueDiffAlertDialogReturn;
//#endregion
export { useCopyToClipboard as A, defaultSqlQuery as B, useCheckEvents as C, ApiConfigContextType as D, useAvatar as E, RecceContextProvider as F, useRecceCheckContext as G, LineageGraphAdapter as H, RecceActionAdapter as I, MuiProvider as K, RecceActionOptions as L, useImageDownloadModal as M, RecceShareStateContextProvider as N, useApiConfig as O, useRecceShareStateContext as P, OSSQueryContext as R, useClipBoardToast as S, UseAvatarResult as T, CheckContextAdapter as U, useRecceQueryContext as V, OSSCheckContext as W, useIsDark as _, useRun as a, useCSVExport as b, MultiNodesActionTracking as c, UseMultiNodesActionReturn as d, useMultiNodesAction as f, useModelColumns as g, unionColumns as h, UseRunResult as i, useCopyToClipboardButton as j, IGNORE_SCREENSHOT_CLASS as k, MultiNodesActionType as l, extractColumns as m, UseValueDiffAlertDialogReturn as n, MultiNodesActionCallbacks as o, UseModelColumnsReturn as p, useValueDiffAlertDialog as r, MultiNodesActionTrackProps as s, UseValueDiffAlertDialogOptions as t, UseMultiNodesActionOptions as u, useGuideToast as v, UseAvatarOptions as w, useCountdownToast as x, useFeedbackCollectionToast as y, QueryContextAdapter as z };
//# sourceMappingURL=index-CUNBonki.d.ts.map