
import { Bt as ColumnRenderMode, Gt as RowObjectType, Ht as DataFrame, Vt as ColumnType, Wt as RowDataTypes, i as RecceInstanceInfo, it as RowCountResult, nt as RowCountDiffResult, on as NodeData } from "./flag-CiR2E5oz.js";
import { i as LineageGraph } from "./types-CZre3j02.js";
import { CellClassParams, ColDef, ColGroupDef, ICellRendererParams } from "ag-grid-community";

//#region src/utils/csv/browser.d.ts
/**
 * Trigger browser download of CSV file
 * @param content - CSV string content
 * @param filename - Name for the downloaded file
 */
declare function downloadCSV(content: string, filename: string): void;
/**
 * Copy CSV content to clipboard
 * Requires a secure context (HTTPS or localhost)
 * @param content - CSV string content to copy
 * @throws Error if Clipboard API is not available
 */
declare function copyCSVToClipboard(content: string): Promise<void>;
//#endregion
//#region src/utils/csv/extractors.d.ts
interface CSVData {
  columns: string[];
  rows: unknown[][];
}
interface CSVExportOptions {
  displayMode?: "inline" | "side_by_side";
  primaryKeys?: string[];
}
/**
 * Extract CSV data from a run result
 * @param runType - The type of run (query, query_diff, etc.)
 * @param result - The run result data
 * @param options - Optional export options (e.g., displayMode for query_diff)
 * @returns CSVData or null if the run type doesn't support CSV export
 */
declare function extractCSVData(runType: string, result: unknown, options?: CSVExportOptions): CSVData | null;
/**
 * Check if a run type supports CSV export
 */
declare function supportsCSVExport(runType: string): boolean;
//#endregion
//#region src/utils/csv/format.d.ts
/**
 * @file csv/format.ts
 * @description CSV formatting utilities with Excel-friendly output
 */
/**
 * Convert tabular data to CSV string
 * @param columns - Column headers
 * @param rows - Row data (array of arrays)
 * @returns CSV string with UTF-8 BOM for Excel compatibility
 */
declare function toCSV(columns: string[], rows: unknown[][]): string;
//#endregion
//#region src/utils/csv/index.d.ts
/**
 * Generate timestamp string for filenames
 * Format: YYYYMMDD-HHmmss
 */
declare function generateTimestamp(): string;
/**
 * Generate context-aware CSV filename
 */
declare function generateCSVFilename(runType: string, params?: Record<string, unknown>): string;
//#endregion
//#region src/utils/dataGrid/columnBuilders.d.ts
interface ColumnConfig {
  key: string;
  name: string;
  columnType: ColumnType;
  columnStatus?: string;
  columnRenderMode?: ColumnRenderMode;
  frozen?: boolean;
  isPrimaryKey?: boolean;
}
interface ColumnOrderConfig {
  primaryKeys: string[];
  pinnedColumns: string[];
  allColumns: string[];
  excludeColumns?: string[];
}
interface GridColumnsConfig {
  columnMap: Record<string, {
    key: string;
    colType: ColumnType;
    status?: string;
  }>;
  primaryKeys: string[];
  pinnedColumns: string[];
  columnsRenderMode: Record<string, ColumnRenderMode>;
  changedOnly?: boolean;
  rowStats?: {
    added: number;
    removed: number;
    modified: number;
  };
  excludeColumns?: string[];
  /**
   * When true, throws an error if a primary key or pinned column is not found
   * in the columnMap. When false (default), silently skips missing columns.
   *
   * - querydiff: uses false (lenient, handles schema differences)
   * - valuediff: uses true (strict, PKs must exist)
   */
  strictMode?: boolean;
}
/**
 * Determines the order of columns based on primary keys, pinned columns,
 * and remaining columns.
 *
 * @returns Array of column names in the correct display order
 */
declare function buildColumnOrder(config: ColumnOrderConfig): string[];
/**
 * Checks if a column should be included based on changedOnly filter
 */
declare function shouldIncludeColumn(columnStatus: string | undefined, changedOnly: boolean, hasModifiedRows: boolean): boolean;
/**
 * Checks if a column is a primary key (exact matching)
 */
declare function isPrimaryKeyColumn(columnName: string, primaryKeys: string[]): boolean;
/**
 * Checks if a column is pinned (exact matching)
 */
declare function isPinnedColumn(columnName: string, pinnedColumns: string[]): boolean;
/**
 * Checks if a column should be excluded from display (exact matching)
 */
declare function isExcludedColumn(columnName: string, excludeColumns: string[]): boolean;
/**
 * Gets the list of columns to display for a diff grid
 *
 * @description Builds an ordered list of column configurations:
 * 1. Primary key columns (frozen)
 * 2. Pinned columns
 * 3. Remaining columns (filtered by changedOnly if applicable)
 *
 * @throws {Error} When strictMode is true and a primary key or pinned column
 *                 is not found in the columnMap
 */
declare function getDisplayColumns(config: GridColumnsConfig): ColumnConfig[];
/**
 * Gets the list of columns for a simple (non-diff) grid
 */
declare function getSimpleDisplayColumns(config: Omit<GridColumnsConfig, "changedOnly" | "rowStats">): ColumnConfig[];
//#endregion
//#region src/utils/dataGrid/columnPrecisionOptions.d.ts
/**
 * Option for column precision menu
 */
interface ColumnPrecisionOption {
  /** Display text for the menu item */
  value: string;
  /** Callback when option is selected */
  onClick: () => void;
}
/**
 * Generates precision select options for a numeric column
 *
 * @description Returns an array of options that can be used to build
 * a menu for changing how a numeric column is rendered. Each option
 * calls the provided callback with the appropriate render mode.
 *
 * @param colName - The column name to apply the render mode to
 * @param onColumnsRenderModeChanged - Callback to update column render modes
 * @returns Array of menu options with value and onClick handler
 *
 * @example
 * ```tsx
 * const options = columnPrecisionSelectOptions(
 *   "price",
 *   (modes) => setRenderModes(prev => ({ ...prev, ...modes }))
 * );
 *
 * // Use in a menu
 * options.map(opt => (
 *   <MenuItem key={opt.value} onClick={opt.onClick}>
 *     {opt.value}
 *   </MenuItem>
 * ));
 * ```
 */
declare function columnPrecisionSelectOptions(colName: string, onColumnsRenderModeChanged: (col: Record<string, ColumnRenderMode>) => void): ColumnPrecisionOption[];
//#endregion
//#region src/utils/dataGrid/renderTypes.d.ts
/**
 * Props for the column group header component
 */
interface DataFrameColumnGroupHeaderProps {
  /** Column name to display */
  name: string;
  /** Column diff status: 'added', 'removed', 'modified', or empty string */
  columnStatus: string;
  /** Column data type for determining available options */
  columnType: ColumnType;
  /** List of current primary key column names */
  primaryKeys?: string[];
  /** Callback when primary keys change (enables PK toggle functionality) */
  onPrimaryKeyChange?: (primaryKeys: string[]) => void;
  /** List of currently pinned column names */
  pinnedColumns?: string[];
  /** Callback when pinned columns change */
  onPinnedColumnsChange?: (pinnedColumns: string[]) => void;
  /** Callback when column render mode changes */
  onColumnsRenderModeChanged?: (col: Record<string, ColumnRenderMode>) => void;
}
/**
 * Props for the simple column header component
 */
interface DataFrameColumnHeaderProps {
  /** Column name to display */
  name: string;
  /** Column data type for determining available options */
  columnType: ColumnType;
  /** List of currently pinned column names */
  pinnedColumns?: string[];
  /** Callback when pinned columns change */
  onPinnedColumnsChange?: (pinnedColumns: string[]) => void;
  /** Callback when column render mode changes */
  onColumnsRenderModeChanged?: (col: Record<string, ColumnRenderMode>) => void;
}
/**
 * Cell renderer function type (compatible with AG Grid)
 */
type CellRendererFunction = (params: ICellRendererParams) => React.ReactNode;
/**
 * Collection of render components for column builders
 *
 * @description Column builders accept this interface to decouple the column
 * building logic from specific React component implementations. This allows:
 *
 * - @datarecce/ui to contain the pure column building logic
 * - OSS packages to provide their own render component implementations
 * - Easy testing with mock components
 *
 * @example
 * ```tsx
 * // OSS passes its render components
 * const renderComponents: ColumnRenderComponents = {
 *   DataFrameColumnGroupHeader,
 *   DataFrameColumnHeader,
 *   defaultRenderCell,
 *   inlineRenderCell,
 * };
 *
 * const result = buildDiffColumnDefinitions({
 *   columns: columnConfigs,
 *   displayMode: "inline",
 *   headerProps: {...},
 *   renderComponents,
 * });
 * ```
 */
interface ColumnRenderComponents {
  /**
   * Column group header component (used for PK columns and diff grids)
   * Supports PK indicator, pin toggle, and precision menu
   */
  DataFrameColumnGroupHeader: React.ComponentType<DataFrameColumnGroupHeaderProps>;
  /**
   * Simple column header component (used for non-PK columns in simple grids)
   * Supports pin toggle and precision menu
   */
  DataFrameColumnHeader?: React.ComponentType<DataFrameColumnHeaderProps>;
  /**
   * Default cell renderer (displays single value)
   */
  defaultRenderCell: CellRendererFunction;
  /**
   * Inline diff cell renderer (displays base/current values inline)
   * Required for inline display mode in diff grids
   */
  inlineRenderCell?: CellRendererFunction;
}
/**
 * Render components required for diff column builders
 */
interface DiffColumnRenderComponents {
  DataFrameColumnGroupHeader: React.ComponentType<DataFrameColumnGroupHeaderProps>;
  defaultRenderCell: CellRendererFunction;
  inlineRenderCell: CellRendererFunction;
}
/**
 * Render components required for simple column builders
 */
interface SimpleColumnRenderComponents {
  DataFrameColumnGroupHeader: React.ComponentType<DataFrameColumnGroupHeaderProps>;
  DataFrameColumnHeader: React.ComponentType<DataFrameColumnHeaderProps>;
  defaultRenderCell: CellRendererFunction;
}
//#endregion
//#region src/utils/dataGrid/toDiffColumn.d.ts
/**
 * Custom context data for Recce columns
 * Stored in colDef.context to avoid AG Grid validation warnings
 */
interface RecceColumnContext {
  columnType?: ColumnType;
  columnRenderMode?: ColumnRenderMode;
}
/**
 * Configuration for building a diff column
 */
interface DiffColumnConfig {
  /** Column name */
  name: string;
  /** Column diff status: 'added', 'removed', 'modified', or empty */
  columnStatus: string;
  /** Column data type */
  columnType: ColumnType;
  /** How to render numeric values */
  columnRenderMode?: ColumnRenderMode;
  /** Display mode: inline shows diff in single cell, side_by_side shows two columns */
  displayMode: "inline" | "side_by_side";
  /** Title for base column in side_by_side mode */
  baseTitle?: string;
  /** Title for current column in side_by_side mode */
  currentTitle?: string;
  /** Props to pass to DataFrameColumnGroupHeader */
  headerProps?: Partial<DataFrameColumnGroupHeaderProps>;
  /** Render components for building the column */
  renderComponents: DiffColumnRenderComponents;
}
/**
 * Extended column type with context metadata
 * Uses context property for custom data per AG Grid best practices
 * Note: Distributed form allows TypeScript to narrow types correctly
 */
type DiffColumnResult = (ColDef<RowObjectType> & {
  context?: RecceColumnContext;
}) | (ColGroupDef<RowObjectType> & {
  context?: RecceColumnContext;
});
/**
 * Creates a cell class function for base column cells
 *
 * @param columnName - The column name (used for value comparison)
 * @param columnStatus - The column's diff status
 * @returns Function that returns CSS class based on row status and value diff
 */
declare function createCellClassBase(columnName: string, columnStatus: string): (params: CellClassParams<RowObjectType>) => string | undefined;
/**
 * Creates a cell class function for current column cells
 *
 * @param columnName - The column name (used for value comparison)
 * @param columnStatus - The column's diff status
 * @returns Function that returns CSS class based on row status and value diff
 */
declare function createCellClassCurrent(columnName: string, columnStatus: string): (params: CellClassParams<RowObjectType>) => string | undefined;
/**
 * Creates a diff column definition for use in data grids
 *
 * @description Builds a column configuration that supports both inline and
 * side-by-side diff display modes. In inline mode, differences are shown
 * within a single cell. In side-by-side mode, base and current values
 * appear in separate child columns.
 *
 * @param config - Column configuration options
 * @returns Column definition compatible with AG Grid
 *
 * @example
 * // Inline mode for querydiff
 * const column = toDiffColumn({
 *   name: 'price',
 *   columnStatus: 'modified',
 *   columnType: 'number',
 *   displayMode: 'inline',
 *   headerProps: {
 *     primaryKeys: ['id'],
 *     onPrimaryKeyChange: setPrimaryKeys,
 *   },
 *   renderComponents: {
 *     DataFrameColumnGroupHeader,
 *     defaultRenderCell,
 *     inlineRenderCell,
 *   },
 * });
 *
 * @example
 * // Side-by-side mode for valuediff
 * const column = toDiffColumn({
 *   name: 'Amount',
 *   columnStatus: '',
 *   columnType: 'number',
 *   displayMode: 'side_by_side',
 *   baseTitle: 'Before',
 *   currentTitle: 'After',
 *   headerProps: {
 *     primaryKeys: ['id'],
 *   },
 *   renderComponents: {
 *     DataFrameColumnGroupHeader,
 *     defaultRenderCell,
 *     inlineRenderCell,
 *   },
 * });
 */
declare function toDiffColumn(config: DiffColumnConfig): DiffColumnResult;
//#endregion
//#region src/utils/dataGrid/diffColumnBuilder.d.ts
/**
 * Extended column type with context metadata
 * Uses context property for custom data per AG Grid best practices
 * Note: Distributed form allows TypeScript to narrow types correctly
 */
type DiffColumnDefinition = (ColDef<RowObjectType> & {
  context?: RecceColumnContext;
}) | (ColGroupDef<RowObjectType> & {
  context?: RecceColumnContext;
});
/**
 * Configuration for building diff column definitions
 */
interface BuildDiffColumnDefinitionsConfig {
  /**
   * Column configurations from getDisplayColumns()
   */
  columns: ColumnConfig[];
  /**
   * Display mode for diff columns
   * - "inline": Single column with inline diff rendering
   * - "side_by_side": Column group with base/current sub-columns
   */
  displayMode: "inline" | "side_by_side";
  /**
   * Props to pass to DataFrameColumnGroupHeader for all columns
   */
  headerProps: Partial<DataFrameColumnGroupHeaderProps>;
  /**
   * Title for base column in side_by_side mode
   */
  baseTitle?: string;
  /**
   * Title for current column in side_by_side mode
   */
  currentTitle?: string;
  /**
   * Whether to add index column when no primary keys exist
   * Only applies when columns array has no isPrimaryKey entries
   * @default false
   */
  allowIndexFallback?: boolean;
  /**
   * Render components for building the columns
   */
  renderComponents: DiffColumnRenderComponents;
}
/**
 * Result from building diff column definitions
 */
interface BuildDiffColumnDefinitionsResult {
  /**
   * The generated column definitions ready for AG Grid
   */
  columns: DiffColumnDefinition[];
  /**
   * Whether an index fallback column was added
   */
  usedIndexFallback: boolean;
}
/**
 * Builds AG Grid column definitions from ColumnConfig array
 *
 * @description Transforms pure column configuration objects into actual
 * column definitions with React JSX headers. Handles:
 *
 * - Primary key columns (pinned, special cellClass)
 * - Diff columns (via toDiffColumn for inline/side_by_side modes)
 * - Index fallback (when no PKs and allowIndexFallback is true)
 *
 * @example
 * ```tsx
 * // Get column configs from shared utility
 * const columnConfigs = getDisplayColumns({
 *   columnMap,
 *   primaryKeys,
 *   pinnedColumns,
 *   columnsRenderMode,
 *   changedOnly,
 *   rowStats,
 *   excludeColumns: ["in_a", "in_b"],
 * });
 *
 * // Build actual column definitions
 * const { columns } = buildDiffColumnDefinitions({
 *   columns: columnConfigs,
 *   displayMode: "inline",
 *   headerProps: {
 *     primaryKeys,
 *     pinnedColumns,
 *     onPinnedColumnsChange,
 *   },
 *   renderComponents: {
 *     DataFrameColumnGroupHeader,
 *     defaultRenderCell,
 *     inlineRenderCell,
 *   },
 * });
 * ```
 *
 * @example
 * ```tsx
 * // With index fallback for querydiff when no PKs
 * const { columns, usedIndexFallback } = buildDiffColumnDefinitions({
 *   columns: columnConfigs,
 *   displayMode: "side_by_side",
 *   allowIndexFallback: true,
 *   headerProps: {
 *     primaryKeys: [],
 *     pinnedColumns,
 *     onPrimaryKeyChange,
 *     onPinnedColumnsChange,
 *   },
 *   renderComponents: {
 *     DataFrameColumnGroupHeader,
 *     defaultRenderCell,
 *     inlineRenderCell,
 *   },
 * });
 *
 * if (usedIndexFallback) {
 *   // Index-based matching was used
 * }
 * ```
 */
declare function buildDiffColumnDefinitions(config: BuildDiffColumnDefinitionsConfig): BuildDiffColumnDefinitionsResult;
//#endregion
//#region src/utils/dataGrid/generators/toDataDiffGrid.d.ts
/**
 * Options for generating a data diff grid
 */
interface QueryDataDiffGridOptions {
  primaryKeys?: string[];
  onPrimaryKeyChange?: (primaryKeys: string[]) => void;
  pinnedColumns?: string[];
  onPinnedColumnsChange?: (pinnedColumns: string[]) => void;
  columnsRenderMode?: Record<string, ColumnRenderMode>;
  onColumnsRenderModeChanged?: (col: Record<string, ColumnRenderMode>) => void;
  changedOnly?: boolean;
  baseTitle?: string;
  currentTitle?: string;
  displayMode?: "side_by_side" | "inline";
}
/**
 * Configuration for building the data diff grid
 */
interface ToDataDiffGridConfig {
  /**
   * Render components for column headers and cells
   */
  renderComponents: DiffColumnRenderComponents;
}
/**
 * Result of generating a data diff grid
 */
interface DataDiffGridResult {
  columns: DiffColumnDefinition[];
  rows: RowObjectType[];
  invalidPKeyBase: boolean;
  invalidPKeyCurrent: boolean;
}
/**
 * Generates grid configuration for comparing base and current DataFrames
 *
 * @param base - The base DataFrame (optional)
 * @param current - The current DataFrame (optional)
 * @param options - Grid options (primary keys, display mode, etc.)
 * @param config - Configuration with render components
 * @returns Grid columns and rows ready for AG Grid
 *
 * @example
 * ```tsx
 * const { columns, rows } = toDataDiffGrid(
 *   baseDataFrame,
 *   currentDataFrame,
 *   { primaryKeys: ['id'], displayMode: 'inline' },
 *   { renderComponents }
 * );
 * ```
 */
declare function toDataDiffGrid(_base?: DataFrame, _current?: DataFrame, options?: QueryDataDiffGridOptions, config?: ToDataDiffGridConfig): DataDiffGridResult;
//#endregion
//#region src/utils/dataGrid/simpleColumnBuilder.d.ts
/**
 * Extended column type with context metadata
 * Uses context property for custom data per AG Grid best practices
 * Note: Distributed form allows TypeScript to narrow types correctly
 */
type SimpleColumnDefinition = (ColDef<RowObjectType> & {
  context?: RecceColumnContext;
}) | (ColGroupDef<RowObjectType> & {
  context?: RecceColumnContext;
});
/**
 * Configuration for building simple column definitions
 */
interface BuildSimpleColumnDefinitionsConfig {
  /**
   * Column configurations from getSimpleDisplayColumns()
   */
  columns: ColumnConfig[];
  /**
   * Props to pass to column headers
   */
  headerProps: {
    pinnedColumns?: string[];
    onPinnedColumnsChange?: (pinnedColumns: string[]) => void;
    onColumnsRenderModeChanged?: (cols: Record<string, ColumnRenderMode>) => void;
  };
  /**
   * Whether to add index column when no primary keys exist
   * Only applies when columns array has no isPrimaryKey entries
   * @default true
   */
  allowIndexFallback?: boolean;
  /**
   * Render components for building the columns
   */
  renderComponents: SimpleColumnRenderComponents;
}
/**
 * Result from building simple column definitions
 */
interface BuildSimpleColumnDefinitionsResult {
  /**
   * The generated column definitions ready for AG Grid
   */
  columns: SimpleColumnDefinition[];
  /**
   * Whether an index fallback column was added
   */
  usedIndexFallback: boolean;
}
/**
 * Builds AG Grid column definitions from ColumnConfig array
 *
 * @description Transforms pure column configuration objects into actual
 * column definitions with React JSX headers. Handles:
 *
 * - Primary key columns (pinned, use DataFrameColumnGroupHeader)
 * - Regular columns (use DataFrameColumnHeader)
 * - Index fallback (when no PKs and allowIndexFallback is true)
 *
 * @example
 * ```tsx
 * // Get column configs from shared utility
 * const columnConfigs = getSimpleDisplayColumns({
 *   columnMap,
 *   primaryKeys,
 *   pinnedColumns,
 *   columnsRenderMode,
 * });
 *
 * // Build actual column definitions
 * const { columns } = buildSimpleColumnDefinitions({
 *   columns: columnConfigs,
 *   headerProps: {
 *     pinnedColumns,
 *     onPinnedColumnsChange,
 *     onColumnsRenderModeChanged,
 *   },
 *   renderComponents: {
 *     DataFrameColumnGroupHeader,
 *     DataFrameColumnHeader,
 *     defaultRenderCell,
 *   },
 * });
 * ```
 */
declare function buildSimpleColumnDefinitions(config: BuildSimpleColumnDefinitionsConfig): BuildSimpleColumnDefinitionsResult;
//#endregion
//#region src/utils/dataGrid/generators/toDataGrid.d.ts
/**
 * Options for generating a simple data grid
 */
interface QueryDataGridOptions {
  primaryKeys?: string[];
  onPrimaryKeyChange?: (primaryKeys: string[]) => void;
  pinnedColumns?: string[];
  onPinnedColumnsChange?: (pinnedColumns: string[]) => void;
  columnsRenderMode?: Record<string, ColumnRenderMode>;
  onColumnsRenderModeChanged?: (col: Record<string, ColumnRenderMode>) => void;
}
/**
 * Configuration for building the data grid
 */
interface ToDataGridConfig {
  /**
   * Render components for column headers and cells
   */
  renderComponents: SimpleColumnRenderComponents;
}
/**
 * Result of generating a data grid
 */
interface DataGridResult {
  columns: SimpleColumnDefinition[];
  rows: RowObjectType[];
}
/**
 * Generates grid configuration for a simple DataFrame display
 *
 * @param result - The DataFrame to display
 * @param options - Grid options (primary keys, pinning, etc.)
 * @param config - Configuration with render components
 * @returns Grid columns and rows ready for AG Grid
 *
 * @example
 * ```tsx
 * const { columns, rows } = toDataGrid(
 *   dataFrame,
 *   { primaryKeys: ['id'], pinnedColumns: [] },
 *   { renderComponents }
 * );
 * ```
 */
declare function toDataGrid(result: DataFrame, options: QueryDataGridOptions, config: ToDataGridConfig): DataGridResult;
//#endregion
//#region src/utils/dataGrid/generators/toValueDiffGrid.d.ts
/**
 * Configuration for building the value diff grid
 */
interface ToValueDiffGridConfig {
  /**
   * Render components for column headers and cells
   */
  renderComponents: DiffColumnRenderComponents;
}
/**
 * Result of generating a value diff grid
 */
interface ValueDiffGridResult {
  columns: DiffColumnDefinition[];
  rows: RowObjectType[];
}
/**
 * Generates grid configuration for value diff (joined data with in_a/in_b)
 *
 * @param df - The joined DataFrame with in_a/in_b columns
 * @param primaryKeys - Array of primary key column names
 * @param options - Grid options
 * @param config - Configuration with render components
 * @returns Grid columns and rows ready for AG Grid
 *
 * @example
 * ```tsx
 * const { columns, rows } = toValueDiffGrid(
 *   joinedDataFrame,
 *   ['id'],
 *   { displayMode: 'inline' },
 *   { renderComponents }
 * );
 * ```
 */
declare function toValueDiffGrid(df: DataFrame, primaryKeys: string[], options?: QueryDataDiffGridOptions, config?: ToValueDiffGridConfig): ValueDiffGridResult;
//#endregion
//#region src/utils/dataGrid/configured.d.ts
/**
 * Default render components used by diff column pre-configured exports.
 * These are the standard UI components from @datarecce/ui.
 */
declare const defaultRenderComponents: DiffColumnRenderComponents;
/**
 * Default render components used by simple column pre-configured exports.
 * These are the standard UI components from @datarecce/ui.
 */
declare const defaultSimpleRenderComponents: SimpleColumnRenderComponents;
/**
 * Configuration for pre-configured toDiffColumn (without renderComponents)
 */
type DiffColumnConfigConfigured = Omit<DiffColumnConfig, "renderComponents">;
/**
 * Creates a diff column definition with default render components.
 *
 * @param config - Column configuration (renderComponents automatically provided)
 * @returns Column definition compatible with AG Grid
 *
 * @example
 * ```tsx
 * const column = toDiffColumnConfigured({
 *   name: 'price',
 *   columnStatus: 'modified',
 *   columnType: 'number',
 *   displayMode: 'inline',
 * });
 * ```
 */
declare function toDiffColumnConfigured(config: DiffColumnConfigConfigured): DiffColumnResult;
/**
 * Configuration for pre-configured buildDiffColumnDefinitions (without renderComponents)
 */
type BuildDiffColumnDefinitionsConfigConfigured = Omit<BuildDiffColumnDefinitionsConfig, "renderComponents">;
/**
 * Builds AG Grid column definitions with default render components.
 *
 * @param config - Column configuration (renderComponents automatically provided)
 * @returns Column definitions and metadata
 *
 * @example
 * ```tsx
 * const { columns, usedIndexFallback } = buildDiffColumnDefinitionsConfigured({
 *   columns: columnConfigs,
 *   displayMode: "inline",
 *   headerProps: { primaryKeys },
 * });
 * ```
 */
declare function buildDiffColumnDefinitionsConfigured(config: BuildDiffColumnDefinitionsConfigConfigured): BuildDiffColumnDefinitionsResult;
/**
 * Generates grid configuration for comparing base and current DataFrames
 * with default render components.
 *
 * @param base - The base DataFrame (optional)
 * @param current - The current DataFrame (optional)
 * @param options - Grid options (primary keys, display mode, etc.)
 * @returns Grid columns and rows ready for AG Grid
 *
 * @example
 * ```tsx
 * const { columns, rows, invalidPKeyBase, invalidPKeyCurrent } = toDataDiffGridConfigured(
 *   baseDataFrame,
 *   currentDataFrame,
 *   { primaryKeys: ['id'], displayMode: 'inline' }
 * );
 * ```
 */
declare function toDataDiffGridConfigured(base?: DataFrame, current?: DataFrame, options?: QueryDataDiffGridOptions): DataDiffGridResult;
/**
 * Generates grid configuration for value diff (joined data with in_a/in_b)
 * with default render components.
 *
 * @param df - The joined DataFrame with in_a/in_b columns
 * @param primaryKeys - Array of primary key column names
 * @param options - Grid options
 * @returns Grid columns and rows ready for AG Grid
 *
 * @example
 * ```tsx
 * const { columns, rows } = toValueDiffGridConfigured(
 *   joinedDataFrame,
 *   ['id'],
 *   { displayMode: 'inline' }
 * );
 * ```
 */
declare function toValueDiffGridConfigured(df: DataFrame, primaryKeys: string[], options?: QueryDataDiffGridOptions): ValueDiffGridResult;
/**
 * Generates grid configuration for a simple DataFrame display
 * with default render components.
 *
 * @param result - The DataFrame to display
 * @param options - Grid options (primary keys, pinning, etc.)
 * @returns Grid columns and rows ready for AG Grid
 *
 * @example
 * ```tsx
 * const { columns, rows } = toDataGridConfigured(dataFrame, {
 *   primaryKeys: ['id'],
 *   pinnedColumns: [],
 * });
 * ```
 */
declare function toDataGridConfigured(result: DataFrame, options: QueryDataGridOptions): DataGridResult;
/**
 * Configuration for pre-configured buildSimpleColumnDefinitions (without renderComponents)
 */
type BuildSimpleColumnDefinitionsConfigConfigured = Omit<BuildSimpleColumnDefinitionsConfig, "renderComponents">;
/**
 * Builds AG Grid column definitions for simple grids with default render components.
 *
 * @param config - Column configuration (renderComponents automatically provided)
 * @returns Column definitions and metadata
 *
 * @example
 * ```tsx
 * const { columns } = buildSimpleColumnDefinitionsConfigured({
 *   columns: columnConfigs,
 *   headerProps: { pinnedColumns },
 * });
 * ```
 */
declare function buildSimpleColumnDefinitionsConfigured(config: BuildSimpleColumnDefinitionsConfigConfigured): BuildSimpleColumnDefinitionsResult;
//#endregion
//#region src/utils/dataGrid/generators/toRowCountDataGrid.d.ts
interface RowCountDataGridResult {
  columns: (ColDef<RowObjectType> | ColGroupDef<RowObjectType>)[];
  rows: RowObjectType[];
}
/**
 * Generates grid data for Row Count view (single environment)
 *
 * @param result - The RowCountResult from the backend
 * @returns Grid columns and rows ready for RecceDataGrid
 *
 * @example
 * ```tsx
 * const { columns, rows } = toRowCountDataGrid(run.result);
 * return <RecceDataGrid columnDefs={columns} rowData={rows} />;
 * ```
 */
declare function toRowCountDataGrid(result: RowCountResult): RowCountDataGridResult;
//#endregion
//#region src/utils/dataGrid/generators/toRowCountDiffDataGrid.d.ts
interface RowCountDiffDataGridResult {
  columns: (ColDef<RowObjectType> | ColGroupDef<RowObjectType>)[];
  rows: RowObjectType[];
}
/**
 * Generates grid data for Row Count Diff view
 *
 * @param result - The RowCountDiffResult from the backend
 * @returns Grid columns and rows ready for RecceDataGrid
 *
 * @example
 * ```tsx
 * const { columns, rows } = toRowCountDiffDataGrid(run.result);
 * return <RecceDataGrid columnDefs={columns} rowData={rows} />;
 * ```
 */
declare function toRowCountDiffDataGrid(result: RowCountDiffResult): RowCountDiffDataGridResult;
//#endregion
//#region src/utils/dataGrid/gridUtils.d.ts
interface ColumnMapEntry {
  key: string;
  colType: ColumnType;
  status?: string;
  index?: number;
}
interface MergeColumnMapEntry extends ColumnMapEntry {
  baseColumnKey: string;
  currentColumnKey: string;
}
interface RowStats {
  added: number;
  removed: number;
  modified: number;
}
/**
 * Builds a column map from a single DataFrame
 */
declare function buildColumnMap(df: DataFrame): Record<string, ColumnMapEntry>;
/**
 * Builds a column map for joined data (with in_a/in_b columns)
 *
 * NOTE: Backend now guarantees in_a/in_b are always lowercase,
 * so we only need to register them as-is.
 *
 * @throws {Error} If required in_a or in_b columns are missing
 */
declare function buildJoinedColumnMap(df: DataFrame): Record<string, ColumnMapEntry>;
/**
 * Builds a merged column map from two DataFrames
 * Tracks status (added/removed/unchanged) for each column
 */
declare function buildMergedColumnMap(base: DataFrame, current: DataFrame): Record<string, MergeColumnMapEntry>;
/**
 * Validates that all primary keys exist in the columns (exact matching)
 */
declare function validatePrimaryKeys(columns: DataFrame["columns"], primaryKeys: string[]): string[];
/**
 * Generates a unique key string from primary key values in a row (exact matching)
 */
declare function getPrimaryKeyValue(columns: DataFrame["columns"], primaryKeys: string[], row: RowObjectType): string;
/**
 * Determines the status of a row (added/removed/modified/unchanged)
 *
 * Supports two modes:
 * 1. Separate rows: baseRow and currentRow are different objects
 * 2. Merged rows: baseRow === currentRow, with values stored as base__key and current__key
 */
declare function determineRowStatus(baseRow: RowObjectType | undefined, currentRow: RowObjectType | undefined, columnMap: Record<string, ColumnMapEntry>, primaryKeys: string[]): "added" | "removed" | "modified" | undefined;
/**
 * Formats a numeric value based on render mode
 *
 * Handles special values:
 * - NaN: Returns "NaN" (no formatting applied)
 * - Infinity: Returns "∞" or "-∞" (no formatting applied)
 */
/**
 * Formats a number with up to maxDecimals decimal places, without trailing zeros
 * Uses banker's rounding (round half to even) for unbiased rounding.
 *
 * e.g., formatSmartDecimal(123, 2) => "123"
 *       formatSmartDecimal(123.4, 2) => "123.4"
 *       formatSmartDecimal(123.456, 2) => "123.46"
 *       formatSmartDecimal(123.445, 2) => "123.44" (banker's rounding)
 */
declare function formatSmartDecimal(value: number, maxDecimals?: number): string;
declare function columnRenderedValue(value: number, renderMode?: ColumnRenderMode): string;
/**
 * Converts a row value to a rendered string with gray-out indicator
 */
declare function toRenderedValue(row: RowObjectType, key: string, columnType?: ColumnType, columnRenderMode?: ColumnRenderMode): [string, boolean];
/**
 * Gets the CSS class for a cell based on row and column status
 */
declare function getCellClass(row: RowObjectType, columnStatus: string | undefined, columnKey: string, isBase: boolean): string | undefined;
/**
 * Gets the CSS class for a header cell based on column status
 */
declare function getHeaderCellClass(columnStatus: string | undefined): string | undefined;
//#endregion
//#region src/utils/dataGrid/rowBuilders.d.ts
/**
 * Union type for column map entries (supports both querydiff and valuediff)
 */
type DiffColumnMapEntry = ColumnMapEntry | MergeColumnMapEntry;
/**
 * Configuration for building diff rows
 */
interface BuildDiffRowsConfig {
  /**
   * Map of primary key values to base row data
   * Keys should already be normalized (e.g., lowercased if case-insensitive)
   */
  baseMap: Record<string, RowObjectType | undefined>;
  /**
   * Map of primary key values to current row data
   * Keys should already be normalized (e.g., lowercased if case-insensitive)
   */
  currentMap: Record<string, RowObjectType | undefined>;
  /**
   * Column definitions for base data
   * Used to iterate and extract values from base rows
   */
  baseColumns: DataFrame["columns"];
  /**
   * Column definitions for current data
   * Used to iterate and extract values from current rows
   * For joined data (valuediff), this is the same as baseColumns
   */
  currentColumns: DataFrame["columns"];
  /**
   * Column map for tracking column metadata and status
   * This object WILL BE MUTATED to update column.status when modifications are detected
   */
  columnMap: Record<string, DiffColumnMapEntry>;
  /**
   * List of primary key column names
   * These columns are stored directly on the row (not prefixed with base__/current__)
   */
  primaryKeys: string[];
  /**
   * Whether to filter out unchanged rows
   * When true, only rows with status "added", "removed", or "modified" are returned
   */
  changedOnly?: boolean;
}
/**
 * Result from building diff rows
 */
interface BuildDiffRowsResult {
  /** The generated rows with __status and prefixed column values */
  rows: RowObjectType[];
  /** Statistics about row changes */
  rowStats: RowStats;
}
/**
 * Builds diff rows from base and current row maps
 *
 * @description This function unifies the row generation logic from both
 * `toDataDiffGrid` (querydiff) and `toValueDiffGrid` (valuediff).
 *
 * Key behaviors:
 * - Merges base and current row keys to determine all unique rows
 * - Creates row objects with `_index` and `__status` fields
 * - Prefixes non-PK columns with `base__` or `current__` (lowercased)
 * - Stores PK columns directly without prefix
 * - Detects added/removed/modified status
 * - Mutates columnMap to mark modified columns
 * - Optionally filters to changed rows only
 *
 * @example
 * ```typescript
 * // For querydiff (two separate DataFrames)
 * const result = buildDiffRows({
 *   baseMap,
 *   currentMap,
 *   baseColumns: base.columns,
 *   currentColumns: current.columns,
 *   columnMap: mergedColumnMap,
 *   primaryKeys: ["id"],
 *   changedOnly: false,
 * });
 *
 * // For valuediff (joined DataFrame)
 * const result = buildDiffRows({
 *   baseMap,
 *   currentMap,
 *   baseColumns: df.columns,
 *   currentColumns: df.columns, // Same columns for both
 *   columnMap: joinedColumnMap,
 *   primaryKeys: ["id"],
 *   changedOnly: true,
 * });
 * ```
 */
declare function buildDiffRows(config: BuildDiffRowsConfig): BuildDiffRowsResult;
//#endregion
//#region src/utils/dataGrid/rowCountUtils.d.ts
/**
 * Extended row data for row count diff grid
 */
interface RowCountDiffRowData {
  name: string;
  base: number | null;
  current: number | null;
  delta: string;
}
/**
 * Extended row data for row count grid (single env)
 */
interface RowCountRowData {
  name: string;
  current: number | null;
}
/**
 * Calculates the delta string for row count comparison
 */
declare function calculateDelta(base: number | null, current: number | null): string;
/**
 * Converts RowCountDiffResult to DataFrame format
 *
 * @param result - The row count diff result from the backend
 * @returns DataFrame with name, base, current, and delta columns
 */
declare function rowCountDiffResultToDataFrame(result: RowCountDiffResult): DataFrame;
/**
 * Converts RowCountResult to DataFrame format
 *
 * @param result - The row count result from the backend
 * @returns DataFrame with name and current columns
 */
declare function rowCountResultToDataFrame(result: RowCountResult): DataFrame;
/**
 * Determines the diff status for a row count entry
 *
 * @param base - Base row count (null if not present)
 * @param current - Current row count (null if not present)
 * @returns Status string: "added" | "removed" | "modified" | undefined
 */
declare function getRowCountDiffStatus(base: number | null, current: number | null): "added" | "removed" | "modified" | undefined;
//#endregion
//#region src/utils/dataGrid/validation.d.ts
/**
 * Custom error class for data grid validation failures.
 * Provides structured error information for debugging.
 */
declare class DataGridValidationError extends Error {
  readonly context?: string | undefined;
  readonly details?: Record<string, unknown> | undefined;
  constructor(message: string, context?: string | undefined, details?: Record<string, unknown> | undefined);
}
/**
 * Validates that a DataFrame has the required structure.
 * Does NOT throw for undefined/null - those are valid (represent empty data).
 *
 * @param df - The DataFrame to validate
 * @param name - Name for error messages (e.g., "base", "current")
 * @throws DataGridValidationError if structure is invalid
 */
declare function validateDataFrame(df: DataFrame | undefined | null, name?: string): void;
/**
 * Validates that columns have required properties.
 *
 * @param columns - Array of column definitions
 * @param context - Context for error messages
 * @throws DataGridValidationError if any column is malformed
 */
declare function validateColumns(columns: DataFrame["columns"], context?: string): void;
/**
 * Validates that data rows match column count.
 *
 * @param df - The DataFrame to validate
 * @param context - Context for error messages
 * @throws DataGridValidationError if misalignment detected
 */
declare function validateColumnDataAlignment(df: DataFrame, context?: string): void;
/**
 * Validates primary key configuration.
 *
 * @param primaryKeys - Array of primary key column names
 * @param columns - Available columns to check against
 * @param options - Validation options
 * @throws DataGridValidationError if validation fails
 */
declare function validatePrimaryKeyConfig(primaryKeys: string[] | undefined, columns: DataFrame["columns"], options?: {
  required?: boolean;
  caseInsensitive?: boolean;
  context?: string;
}): void;
/**
 * Validates inputs for toDataGrid (single DataFrame).
 */
declare function validateToDataGridInputs(df: DataFrame | undefined, options?: {
  primaryKeys?: string[];
}): void;
/**
 * Validates inputs for toDataDiffGrid (base + current DataFrames).
 */
declare function validateToDataDiffGridInputs(base: DataFrame | undefined, current: DataFrame | undefined, options?: {
  primaryKeys?: string[];
}): void;
/**
 * Validates inputs for toValueDiffGrid
 *
 * @throws {DataGridValidationError} If validation fails
 */
declare function validateToValueDiffGridInputs(df: DataFrame | undefined, primaryKeys: string[]): void;
//#endregion
//#region src/utils/delta.d.ts
/**
 * @file delta.ts
 * @description Utility functions for calculating and formatting delta percentages
 *
 * These utilities are used to display percentage changes between base and current values
 * in data comparison views (row counts, value diffs, etc.)
 */
/**
 * Calculate and format the percentage change between two values.
 *
 * @param base - The baseline value (denominator for percentage calculation)
 * @param current - The current value to compare against baseline
 * @returns Formatted percentage string with sign (+/-) or special values for edge cases
 *
 * @example
 * deltaPercentageString(100, 110) // "+10.0%"
 * deltaPercentageString(100, 90)  // "-10.0%"
 * deltaPercentageString(100, 100) // "0"
 * deltaPercentageString(0, 100)   // "N/A" (division by zero)
 * deltaPercentageString(1000, 1000.5) // "+ <0.1 %" (very small change)
 */
declare function deltaPercentageString(base: number, current: number): string;
//#endregion
//#region src/utils/envUtils.d.ts
/**
 * Extract unique schema names from the lineage graph.
 *
 * Iterates through all nodes in the lineage graph and collects
 * unique schema names from both base and current environments.
 *
 * @param lineageGraph - The lineage graph data
 * @returns Tuple of [baseSchemas, currentSchemas] as Sets
 *
 * @example
 * ```ts
 * const { lineageGraph } = useLineageGraphContext();
 * const [baseSchemas, currentSchemas] = extractSchemas(lineageGraph);
 *
 * console.log(baseSchemas);    // Set { "schema_v1", "public" }
 * console.log(currentSchemas); // Set { "schema_v2", "public" }
 * ```
 */
declare function extractSchemas(lineageGraph: LineageGraph | undefined): [Set<string>, Set<string>];
//#endregion
//#region src/utils/formatSelect.d.ts
/**
 * @file formatSelect.ts
 * @description Column format selection utilities for SQL SELECT statements
 */
/**
 * Formats merged columns with (Added)/(Removed) annotations for SQL SELECT.
 * Adds trailing commas except for the last actual column.
 *
 * @param baseColumns - Columns from the base environment
 * @param currentColumns - Columns from the current environment
 * @returns Array of formatted column strings with annotations and commas
 */
declare function formatSelectColumns(baseColumns: string[], currentColumns: string[]): string[];
//#endregion
//#region src/utils/formatTime.d.ts
/**
 * @file formatTime.ts
 * @description Time formatting utilities for duration and timestamp display
 */
type TimeFormatStyle = "compact" | "verbose";
/**
 * Format seconds into human-readable time string
 *
 * @param totalSeconds - Total seconds to format
 * @param style - "compact" for MM:SS, "verbose" for human-readable
 */
declare function formatDuration(totalSeconds: number, style?: TimeFormatStyle): string;
/**
 * Format an ISO timestamp string to a consistent date-time format.
 *
 * @param timestamp - ISO 8601 timestamp string
 * @returns Formatted string in "yyyy-MM-dd'T'HH:mm:ss" format
 *
 * @example
 * ```ts
 * formatTimestamp("2024-01-15T10:30:00Z")
 * // Returns: "2024-01-15T10:30:00"
 * ```
 */
declare function formatTimestamp(timestamp: string): string;
/**
 * Format an ISO timestamp as a relative time string (e.g., "2 hours ago").
 *
 * @param timestamp - ISO 8601 timestamp string
 * @returns Human-readable relative time string
 *
 * @example
 * ```ts
 * formatTimeToNow("2024-01-15T10:30:00Z")
 * // Returns: "2 hours ago" (depending on current time)
 * ```
 */
declare function formatTimeToNow(timestamp: string): string;
//#endregion
//#region src/utils/formatters.d.ts
/**
 * "Formatters" -- these are your data formatting that returns a formatted value for UI presentation (e.g. number, string, falsey)
 */
/**
 *
 * @param num number type input
 * @param locales locale string
 * @param options
 * @returns a formatted string number, based on locale & options
 */
declare function formatNumber(num: number | string | undefined, locales?: string, options?: Intl.NumberFormatOptions): string | undefined;
/**
 * @param num fractional number type input
 * @returns a formatted percentage string, based on its percentage proximity to either ends (<0.1% and >99.9%)
 */
declare function formatIntervalMinMax(num: number): string | undefined;
/**
 * base < -2 => 2dp, scientific (small decimals)
 * base < 0 => 3dp (big decimals)
 * base < 3 => 2dp (ones, tens, hundreds)
 * base < 6 => 1dp, K (thousands)
 * base < 9 => 1dp, M (millions)
 * base < 12 => 1dp, T (trillions)
 * base < 15 => 1dp, B (billions)
 * base >= 15 => 0dp, B (billions)
 * @param input
 * @returns a formatted number by abbreviation, based on its order of magnitude
 */
declare function formatAsAbbreviatedNumber(input: number | string): string;
//#endregion
//#region src/utils/mergeKeys.d.ts
/**
 * @file mergeKeys.ts
 * @description Utilities for merging column arrays while detecting renames/additions/removals
 */
/**
 * Merge keys from base and current tables.
 * Unlike default union, it preserves the order for column rename, added, removed cases.
 */
declare function mergeKeys(_base: string[], _curr: string[]): string[];
type MergeStatus = "added" | "removed" | "reordered" | undefined;
/**
 * Merge keys from base and current tables, returning status for each key.
 * Status indicates whether the key was added, removed, reordered, or unchanged.
 */
declare function mergeKeysWithStatus(_base: string[], _curr: string[]): Record<string, MergeStatus>;
//#endregion
//#region src/utils/schemaDiff.d.ts
/**
 * Checks if a schema has changed between base and current environments.
 *
 * Detects the following types of changes:
 * - Column additions or removals (different key counts)
 * - Column reordering (same keys but different order)
 * - Type modifications (column exists in both but type differs)
 *
 * @param baseSchema - The base environment schema columns
 * @param currSchema - The current environment schema columns
 * @returns `true` if schema changed, `false` if unchanged, `undefined` if either schema is missing
 *
 * @example
 * ```typescript
 * import { isSchemaChanged } from '@datarecce/ui';
 *
 * const base = { id: { type: 'integer' }, name: { type: 'string' } };
 * const curr = { id: { type: 'integer' }, name: { type: 'varchar' } };
 *
 * isSchemaChanged(base, curr); // true (type modified)
 * ```
 */
declare function isSchemaChanged(baseSchema: NodeData["columns"], currSchema: NodeData["columns"]): boolean | undefined;
//#endregion
//#region src/utils/transforms.d.ts
/**
 * Converts a DataFrame to an array of row objects.
 *
 * Each row becomes an object with column keys as properties,
 * plus __status (undefined) and _index (1-based) fields.
 *
 * @param dataFrame - The DataFrame to convert
 * @returns Array of row objects with column values and metadata
 *
 * @example
 * ```ts
 * const df = {
 *   columns: [{ key: 'name' }, { key: 'age' }],
 *   data: [['Alice', 30], ['Bob', 25]]
 * };
 * const rows = dataFrameToRowObjects(df);
 * // [
 * //   { name: 'Alice', age: 30, __status: undefined, _index: 1 },
 * //   { name: 'Bob', age: 25, __status: undefined, _index: 2 }
 * // ]
 * ```
 */
declare function dataFrameToRowObjects(dataFrame: DataFrame): RowObjectType[];
/**
 * Converts a key string to a number.
 *
 * If the key is a valid number, it is parsed and returned.
 * Otherwise, the string is hashed to a stable numeric value.
 *
 * @param key - The key to convert
 * @returns A numeric representation of the key
 *
 * @example
 * ```ts
 * keyToNumber('123')    // 123
 * keyToNumber('abc')    // stable hash value
 * keyToNumber('-45.6')  // -45.6
 * ```
 */
declare function keyToNumber(key: string): number;
/**
 * Hashes a string to a stable numeric value.
 *
 * Uses a simple hash algorithm based on Java's String.hashCode().
 * Always returns a non-negative integer.
 *
 * @param str - The string to hash
 * @returns A non-negative integer hash value
 *
 * @example
 * ```ts
 * hashStringToNumber('hello')  // same value every time
 * hashStringToNumber('')       // 0
 * ```
 */
declare function hashStringToNumber(str: string): number;
/**
 * Gets a property value from an object using case-insensitive key matching.
 *
 * First tries lowercase match, then falls back to case-insensitive search.
 *
 * @param obj - The object to search
 * @param key - The property key (case-insensitive)
 * @returns The property value, or undefined if not found
 *
 * @example
 * ```ts
 * const obj = { Name: 'Alice', AGE: 30 };
 * getCaseInsensitive(obj, 'name')  // 'Alice'
 * getCaseInsensitive(obj, 'age')   // 30
 * getCaseInsensitive(obj, 'foo')   // undefined
 * ```
 */
declare function getCaseInsensitive<T extends RowObjectType>(obj: T, key: string): T[keyof T] | undefined;
/**
 * Gets a value from an object at a given path, with case-insensitive matching.
 *
 * Tries lowercase, then uppercase, then exact match.
 *
 * @param obj - The object to search
 * @param path - The property path (case-insensitive)
 * @returns The value at the path, or undefined if not found
 *
 * @example
 * ```ts
 * const obj = { Name: 'Alice', AGE: 30 };
 * getValueAtPath(obj, 'name')  // 'Alice'
 * getValueAtPath(obj, 'AGE')   // 30
 * getValueAtPath(obj, 'foo')   // undefined
 * ```
 */
declare function getValueAtPath<T = RowDataTypes>(obj: Record<string, T | undefined>, path: string): T | undefined;
//#endregion
//#region src/utils/urls.d.ts
/**
 * Generate the settings URL based on instance info.
 *
 * @param instanceInfo - Recce instance information containing web_url and organization_name
 * @param fallbackUrl - URL to use when not in cloud environment (e.g., calendar booking)
 * @returns Absolute URL to settings page or the fallback URL
 *
 * @example
 * ```typescript
 * // With cloud instance info
 * getSettingsUrl(instanceInfo, "https://cal.com/team/recce/chat");
 * // Returns: "https://cloud.recce.io/organizations/my-org/settings"
 *
 * // Without cloud instance info
 * getSettingsUrl(undefined, "https://cal.com/team/recce/chat");
 * // Returns: "https://cal.com/team/recce/chat"
 * ```
 */
declare function getSettingsUrl(instanceInfo: RecceInstanceInfo | undefined, fallbackUrl: string): string;
//#endregion
export { RowCountDiffDataGridResult as $, isExcludedColumn as $t, RowCountRowData as A, BuildDiffColumnDefinitionsResult as At, MergeColumnMapEntry as B, ColumnRenderComponents as Bt, validateColumns as C, SimpleColumnDefinition as Ct, validateToDataGridInputs as D, ToDataDiffGridConfig as Dt, validateToDataDiffGridInputs as E, QueryDataDiffGridOptions as Et, BuildDiffRowsConfig as F, RecceColumnContext as Ft, columnRenderedValue as G, ColumnPrecisionOption as Gt, buildColumnMap as H, DataFrameColumnHeaderProps as Ht, BuildDiffRowsResult as I, createCellClassBase as It, getCellClass as J, ColumnOrderConfig as Jt, determineRowStatus as K, columnPrecisionSelectOptions as Kt, DiffColumnMapEntry as L, createCellClassCurrent as Lt, getRowCountDiffStatus as M, buildDiffColumnDefinitions as Mt, rowCountDiffResultToDataFrame as N, DiffColumnConfig as Nt, validateToValueDiffGridInputs as O, toDataDiffGrid as Ot, rowCountResultToDataFrame as P, DiffColumnResult as Pt, validatePrimaryKeys as Q, getSimpleDisplayColumns as Qt, buildDiffRows as R, toDiffColumn as Rt, validateColumnDataAlignment as S, BuildSimpleColumnDefinitionsResult as St, validatePrimaryKeyConfig as T, DataDiffGridResult as Tt, buildJoinedColumnMap as U, DiffColumnRenderComponents as Ut, RowStats as V, DataFrameColumnGroupHeaderProps as Vt, buildMergedColumnMap as W, SimpleColumnRenderComponents as Wt, getPrimaryKeyValue as X, buildColumnOrder as Xt, getHeaderCellClass as Y, GridColumnsConfig as Yt, toRenderedValue as Z, getDisplayColumns as Zt, formatTimestamp as _, DataGridResult as _t, hashStringToNumber as a, toCSV as an, DiffColumnConfigConfigured as at, deltaPercentageString as b, toDataGrid as bt, MergeStatus as c, extractCSVData as cn, defaultRenderComponents as ct, formatAsAbbreviatedNumber as d, downloadCSV as dn, toDataGridConfigured as dt, isPinnedColumn as en, toRowCountDiffDataGrid as et, formatIntervalMinMax as f, toDiffColumnConfigured as ft, formatTimeToNow as g, toValueDiffGrid as gt, formatDuration as h, ValueDiffGridResult as ht, getValueAtPath as i, generateTimestamp as in, BuildSimpleColumnDefinitionsConfigConfigured as it, calculateDelta as j, DiffColumnDefinition as jt, RowCountDiffRowData as k, BuildDiffColumnDefinitionsConfig as kt, mergeKeys as l, supportsCSVExport as ln, defaultSimpleRenderComponents as lt, TimeFormatStyle as m, ToValueDiffGridConfig as mt, dataFrameToRowObjects as n, shouldIncludeColumn as nn, toRowCountDataGrid as nt, keyToNumber as o, CSVData as on, buildDiffColumnDefinitionsConfigured as ot, formatNumber as p, toValueDiffGridConfigured as pt, formatSmartDecimal as q, ColumnConfig as qt, getCaseInsensitive as r, generateCSVFilename as rn, BuildDiffColumnDefinitionsConfigConfigured as rt, isSchemaChanged as s, CSVExportOptions as sn, buildSimpleColumnDefinitionsConfigured as st, getSettingsUrl as t, isPrimaryKeyColumn as tn, RowCountDataGridResult as tt, mergeKeysWithStatus as u, copyCSVToClipboard as un, toDataDiffGridConfigured as ut, formatSelectColumns as v, QueryDataGridOptions as vt, validateDataFrame as w, buildSimpleColumnDefinitions as wt, DataGridValidationError as x, BuildSimpleColumnDefinitionsConfig as xt, extractSchemas as y, ToDataGridConfig as yt, ColumnMapEntry as z, CellRendererFunction as zt };
//# sourceMappingURL=index-h_fw6R9U.d.ts.map