@startsimpli/funnels 0.1.2

package/dist/components/index.d.ts

@@ -0,0 +1,726 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { i as Funnel, k as FunnelRun, n as FunnelStatus, m as FunnelStage, o as StageStats, h as FilterRule, b as FieldDefinition, g as FilterLogic, O as Operator, M as MatchAction, N as NoMatchAction, l as FunnelRunStatus, T as TriggerType } from '../index-BGDEXbuz.js';
+import { NodeProps } from '@xyflow/react';
+import { F as FunnelApiClient } from '../client-3ESO2NHy.js';
+
+/**
+ * StageBreakdown Component
+ *
+ * Shows per-stage statistics in a funnel flow visualization.
+ *
+ * Design Rationale:
+ * - Sequential list shows funnel flow from top to bottom
+ * - Stage numbers (①②③) provide clear ordering
+ * - Exclusion count (-N) shows entities removed at each stage
+ * - Remaining count shows entities continuing to next stage
+ * - Color coding: gray for excluded, green for final matched
+ *
+ * Accessibility:
+ * - Semantic list structure
+ * - Clear text labels for all metrics
+ * - Color is supplementary to text
+ */
+interface StagePreviewStats {
+    stage_id: string;
+    stage_name: string;
+    input_count: number;
+    excluded_count: number;
+    remaining_count: number;
+}
+interface StageBreakdownProps {
+    stageStats: Record<string, StagePreviewStats>;
+    stages: Array<{
+        id: string;
+        name: string;
+        order: number;
+    }>;
+    className?: string;
+}
+declare function StageBreakdown({ stageStats, stages, className, }: StageBreakdownProps): react_jsx_runtime.JSX.Element;
+
+interface PreviewResult {
+    totalMatched: number;
+    totalExcluded: number;
+    matchPercentage: number;
+    previewEntities: any[];
+    stageStats: Record<string, StagePreviewStats>;
+}
+interface FunnelPreviewProps {
+    funnel: Funnel;
+    sampleEntities: any[];
+    onPreview?: (result: PreviewResult) => void;
+    renderEntity?: (entity: any) => ReactNode;
+    maxPreviewEntities?: number;
+    className?: string;
+}
+declare function FunnelPreview({ funnel, sampleEntities, onPreview, renderEntity, maxPreviewEntities, className, }: FunnelPreviewProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * PreviewStats Component
+ *
+ * Progress bar showing matched vs excluded entities with percentage.
+ *
+ * Design Rationale:
+ * - Horizontal progress bar shows match rate at a glance
+ * - Green (matched) and red (excluded) create clear visual distinction
+ * - Percentage provides quick understanding of funnel effectiveness
+ * - Counts below bar provide exact numbers
+ *
+ * Accessibility:
+ * - ARIA progressbar role for screen readers
+ * - Text labels provide non-visual indication
+ * - Sufficient color contrast
+ */
+interface PreviewStatsProps {
+    totalMatched: number;
+    totalExcluded: number;
+    matchPercentage: number;
+    className?: string;
+}
+declare function PreviewStats({ totalMatched, totalExcluded, matchPercentage, className, }: PreviewStatsProps): react_jsx_runtime.JSX.Element;
+
+interface EntityCardProps {
+    entity: any;
+    renderEntity?: (entity: any) => ReactNode;
+    className?: string;
+}
+declare function EntityCard({ entity, renderEntity, className, }: EntityCardProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * LoadingPreview Component
+ *
+ * Skeleton loading state for FunnelPreview.
+ *
+ * Design Rationale:
+ * - Skeleton shapes match actual content layout
+ * - Pulse animation indicates loading
+ * - Gray placeholders maintain visual hierarchy
+ * - Reduces perceived loading time
+ *
+ * Accessibility:
+ * - ARIA live region announces loading state
+ * - Screen readers informed of status change
+ */
+declare function LoadingPreview(): react_jsx_runtime.JSX.Element;
+
+interface FunnelCardProps {
+    /** Funnel definition (BRUTALLY GENERIC - works for any entity type) */
+    funnel: Funnel;
+    /** Latest run results (optional - shows "no runs yet" state if missing) */
+    latestRun?: FunnelRun;
+    /** Callback when "View Flow" is clicked */
+    onViewFlow?: (funnel: Funnel) => void;
+    /** Callback when edit action is triggered (future: click on card header) */
+    onEdit?: (funnel: Funnel) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function FunnelCard({ funnel, latestRun, onViewFlow, onEdit, className }: FunnelCardProps): react_jsx_runtime.JSX.Element;
+
+interface StatusBadgeProps {
+    status: FunnelStatus;
+    className?: string;
+}
+declare function StatusBadge({ status, className }: StatusBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * StageIndicator Component
+ *
+ * Displays a numbered circle badge for funnel stages with connecting vertical line.
+ *
+ * Design Rationale:
+ * - Numbered circles (①②③) provide clear sequential ordering
+ * - Vertical connecting line shows flow/progression
+ * - Compact layout conserves vertical space
+ * - Gray text for rule count de-emphasizes secondary info
+ *
+ * Accessibility:
+ * - Sufficient color contrast (4.5:1 minimum)
+ * - Semantic HTML structure
+ */
+interface StageIndicatorProps {
+    order: number;
+    name: string;
+    ruleCount: number;
+    isLast?: boolean;
+    className?: string;
+}
+declare function StageIndicator({ order, name, ruleCount, isLast, className }: StageIndicatorProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * MatchBar Component
+ *
+ * Progress bar showing match percentage with count label.
+ *
+ * Design Rationale:
+ * - Green gradient conveys success/completion
+ * - Rounded corners match card aesthetic
+ * - Label shows absolute count (more actionable than percentage alone)
+ * - Gray background shows full scale
+ *
+ * Accessibility:
+ * - Text label provides non-visual indication of value
+ * - Sufficient contrast between bar and background
+ */
+interface MatchBarProps {
+    matched: number;
+    total: number;
+    className?: string;
+}
+declare function MatchBar({ matched, total, className }: MatchBarProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * FunnelStats Component
+ *
+ * Three-column stats display showing INPUT / MATCHED / EXCLUDED counts.
+ *
+ * Design Rationale:
+ * - Three equal columns for balance
+ * - Color coding: Blue (input/neutral), Green (matched/success), Red (excluded/warning)
+ * - Large numbers draw attention to key metrics
+ * - Labels use uppercase for consistency with status badge
+ *
+ * Accessibility:
+ * - Semantic HTML (dl/dt/dd structure)
+ * - Color is supplementary (text labels provide meaning)
+ */
+interface FunnelStatsProps {
+    input: number;
+    matched: number;
+    excluded: number;
+    className?: string;
+}
+declare function FunnelStats({ input, matched, excluded, className }: FunnelStatsProps): react_jsx_runtime.JSX.Element;
+
+interface FunnelVisualFlowProps {
+    /** Funnel definition */
+    funnel: Funnel;
+    /** Optional run data for showing counts */
+    runData?: FunnelRun;
+    /** Callback when stage node is clicked */
+    onStageClick?: (stage: FunnelStage) => void;
+    /** Callback when edge is clicked (fromStageId, toStageId) */
+    onEdgeClick?: (fromStage: string, toStage: string) => void;
+    /** Additional CSS classes */
+    className?: string;
+    /** Height of the flow container (default: 600px) */
+    height?: number | string;
+}
+/**
+ * Generate circled numbers for stage indicators (①②③)
+ */
+declare function getCircledNumber(num: number): string;
+declare function FunnelVisualFlow({ funnel, runData, onStageClick, onEdgeClick, className, height, }: FunnelVisualFlowProps): react_jsx_runtime.JSX.Element;
+
+interface StageNodeData {
+    stage: FunnelStage;
+    stats?: StageStats;
+    onStageClick?: (stage: FunnelStage) => void;
+}
+declare function StageNode({ data }: NodeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * FlowLegend Component
+ *
+ * Legend explaining the color coding of funnel stages.
+ *
+ * Design:
+ * - Minimal, non-intrusive panel in bottom-right
+ * - Color swatches with labels
+ * - Collapsible to save space
+ *
+ * Colors:
+ * - Blue: Continue to next stage
+ * - Red: Exclude entities
+ * - Yellow: Tag entities
+ * - Green: Final output
+ */
+declare function FlowLegend(): react_jsx_runtime.JSX.Element;
+
+interface FilterRuleEditorProps {
+    /** Current filter rules */
+    rules: FilterRule[];
+    /** Callback when rules change */
+    onChange: (rules: FilterRule[]) => void;
+    /** Field registry for the entity type */
+    fieldRegistry: FieldDefinition[];
+    /** Filter logic (AND/OR) */
+    logic?: FilterLogic;
+    /** Callback when logic changes */
+    onLogicChange?: (logic: FilterLogic) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function FilterRuleEditor({ rules, onChange, fieldRegistry, logic, onLogicChange, className, }: FilterRuleEditorProps): react_jsx_runtime.JSX.Element;
+
+interface LogicToggleProps {
+    logic: FilterLogic;
+    onChange: (logic: FilterLogic) => void;
+    className?: string;
+}
+declare function LogicToggle({ logic, onChange, className }: LogicToggleProps): react_jsx_runtime.JSX.Element;
+
+interface FieldSelectorProps {
+    fields: FieldDefinition[];
+    value: string;
+    onChange: (fieldName: string) => void;
+    error?: string;
+    className?: string;
+}
+declare function FieldSelector({ fields, value, onChange, error, className, }: FieldSelectorProps): react_jsx_runtime.JSX.Element;
+
+interface OperatorSelectorProps {
+    operators: Operator[];
+    value: Operator | '';
+    onChange: (operator: Operator) => void;
+    disabled?: boolean;
+    error?: string;
+    className?: string;
+}
+declare function OperatorSelector({ operators, value, onChange, disabled, error, className, }: OperatorSelectorProps): react_jsx_runtime.JSX.Element;
+
+interface RuleRowProps {
+    rule: FilterRule;
+    onChange: (rule: FilterRule) => void;
+    onRemove: () => void;
+    fieldRegistry: FieldDefinition[];
+    className?: string;
+}
+declare function RuleRow({ rule, onChange, onRemove, fieldRegistry, className, }: RuleRowProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * TextValueInput Component
+ *
+ * Text input for string values.
+ *
+ * Design Goal:
+ * Simple text entry for string comparisons (contains, equals, etc.).
+ *
+ * Visual Hierarchy Rationale:
+ * - Standard text input styling
+ * - Placeholder text provides context
+ * - Error state clearly indicated with red border
+ */
+interface TextValueInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    error?: string;
+    className?: string;
+}
+declare function TextValueInput({ value, onChange, placeholder, error, className, }: TextValueInputProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * NumberValueInput Component
+ *
+ * Numeric input for number comparisons.
+ *
+ * Design Goal:
+ * Precise number entry with validation for numeric fields.
+ *
+ * Visual Hierarchy Rationale:
+ * - Standard number input with browser controls
+ * - Constraints (min/max) applied if provided
+ * - Error state clearly indicated
+ *
+ * Interaction Notes:
+ * - Arrow keys increment/decrement
+ * - Scroll wheel adjusts value (browser default)
+ * - Respects min/max constraints
+ */
+interface NumberValueInputProps {
+    value: number | null;
+    onChange: (value: number | null) => void;
+    min?: number;
+    max?: number;
+    placeholder?: string;
+    error?: string;
+    className?: string;
+}
+declare function NumberValueInput({ value, onChange, min, max, placeholder, error, className, }: NumberValueInputProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * DateValueInput Component
+ *
+ * Date input for date comparisons.
+ *
+ * Design Goal:
+ * Intuitive date selection with browser-native date picker.
+ *
+ * Visual Hierarchy Rationale:
+ * - Native date input for familiar UX
+ * - Calendar picker on click (browser default)
+ * - ISO date format for consistency
+ *
+ * Interaction Notes:
+ * - Click to open calendar picker
+ * - Keyboard entry also supported (YYYY-MM-DD)
+ * - Respects min/max constraints
+ *
+ * Accessibility Considerations:
+ * - Native date input is screen reader friendly
+ * - Keyboard navigation supported
+ */
+interface DateValueInputProps {
+    value: string | null;
+    onChange: (value: string | null) => void;
+    min?: string;
+    max?: string;
+    placeholder?: string;
+    error?: string;
+    className?: string;
+}
+declare function DateValueInput({ value, onChange, min, max, placeholder, error, className, }: DateValueInputProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * BooleanValueInput Component
+ *
+ * Checkbox input for boolean values.
+ *
+ * Design Goal:
+ * Simple true/false toggle for boolean fields.
+ *
+ * Visual Hierarchy Rationale:
+ * - Checkbox with clear label
+ * - Aligned with other value inputs
+ * - Checked state visually distinct
+ *
+ * Interaction Notes:
+ * - Click checkbox or label to toggle
+ * - Space bar toggles when focused
+ *
+ * Accessibility Considerations:
+ * - Proper label association
+ * - Keyboard accessible
+ * - Focus visible
+ */
+interface BooleanValueInputProps {
+    value: boolean;
+    onChange: (value: boolean) => void;
+    label?: string;
+    error?: string;
+    className?: string;
+}
+declare function BooleanValueInput({ value, onChange, label, error, className, }: BooleanValueInputProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ChoiceValueInput Component
+ *
+ * Single-select dropdown for choice fields.
+ *
+ * Design Goal:
+ * Select a single value from predefined choices (e.g., firm stage, recipe cuisine).
+ *
+ * Visual Hierarchy Rationale:
+ * - Standard select dropdown
+ * - Choices provided by field definition
+ * - Clear placeholder when nothing selected
+ *
+ * Interaction Notes:
+ * - Click to open dropdown
+ * - Keyboard navigation supported
+ * - Selected value shown in dropdown
+ *
+ * Accessibility Considerations:
+ * - Proper label association
+ * - Keyboard navigation (arrow keys)
+ * - Focus visible
+ */
+interface ChoiceValueInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    choices: any[];
+    placeholder?: string;
+    error?: string;
+    className?: string;
+}
+declare function ChoiceValueInput({ value, onChange, choices, placeholder, error, className, }: ChoiceValueInputProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * MultiChoiceValueInput Component
+ *
+ * Multi-select for choosing multiple values from choices.
+ *
+ * Design Goal:
+ * Select multiple values for 'in', 'has_any', 'has_all' operators.
+ * For example: "Firm stage is one of [Series A, Series B, Series C]".
+ *
+ * Visual Hierarchy Rationale:
+ * - Tag-based interface shows selected values as pills
+ * - Each tag has an X button to remove
+ * - Dropdown allows adding more selections
+ * - Compact layout for multiple values
+ *
+ * Interaction Notes:
+ * - Select from dropdown to add value
+ * - Click X on tag to remove value
+ * - Can select multiple values
+ * - Already-selected values hidden from dropdown
+ *
+ * Accessibility Considerations:
+ * - Keyboard navigation for dropdown
+ * - Focus management for tag removal
+ * - Screen reader announces selected items
+ */
+interface MultiChoiceValueInputProps {
+    value: string[];
+    onChange: (value: string[]) => void;
+    choices: any[];
+    placeholder?: string;
+    error?: string;
+    className?: string;
+}
+declare function MultiChoiceValueInput({ value, onChange, choices, placeholder, error, className, }: MultiChoiceValueInputProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * FilterRuleEditor Constants
+ *
+ * Operator labels and field type mappings
+ */
+
+declare const OPERATOR_LABELS: Record<Operator, string>;
+/**
+ * Operators that don't require a value input
+ */
+declare const NULL_VALUE_OPERATORS: Operator[];
+/**
+ * Operators that require array/multi-value input
+ */
+declare const MULTI_VALUE_OPERATORS: Operator[];
+
+interface FunnelStageBuilderProps {
+    /** The funnel being edited */
+    funnel: Funnel;
+    /** Callback when funnel is updated */
+    onUpdate: (funnel: Funnel) => void;
+    /** Available fields for filter rules */
+    fieldRegistry: FieldDefinition[];
+    /** Optional CSS class */
+    className?: string;
+}
+/**
+ * Main FunnelStageBuilder component
+ */
+declare function FunnelStageBuilder({ funnel, onUpdate, fieldRegistry, className, }: FunnelStageBuilderProps): react_jsx_runtime.JSX.Element;
+
+interface StageCardProps {
+    /** The stage to display */
+    stage: FunnelStage;
+    /** Whether stage is expanded */
+    expanded: boolean;
+    /** Toggle expanded state */
+    onToggleExpanded: () => void;
+    /** Update stage */
+    onUpdate: (stage: FunnelStage) => void;
+    /** Remove stage */
+    onRemove: () => void;
+    /** Available fields */
+    fieldRegistry: FieldDefinition[];
+    /** Validation error */
+    error?: string;
+    /** Show warnings */
+    showWarnings?: boolean;
+}
+/**
+ * StageCard component
+ */
+declare function StageCard({ stage, expanded, onToggleExpanded, onUpdate, onRemove, fieldRegistry, error, showWarnings, }: StageCardProps): react_jsx_runtime.JSX.Element;
+
+interface StageFormProps {
+    /** The stage being edited */
+    stage: FunnelStage;
+    /** Update stage */
+    onUpdate: (stage: FunnelStage) => void;
+    /** Available fields */
+    fieldRegistry: FieldDefinition[];
+}
+/**
+ * StageForm component
+ */
+declare function StageForm({ stage, onUpdate, fieldRegistry, }: StageFormProps): react_jsx_runtime.JSX.Element;
+
+interface StageActionsProps {
+    /** The stage being configured */
+    stage: FunnelStage;
+    /** Match action change handler */
+    onMatchActionChange: (action: MatchAction) => void;
+    /** No match action change handler */
+    onNoMatchActionChange: (action: NoMatchAction) => void;
+}
+/**
+ * StageActions component
+ */
+declare function StageActions({ stage, onMatchActionChange, onNoMatchActionChange, }: StageActionsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * TagInput - Multi-tag input component
+ *
+ * Features:
+ * - Add tags with Enter or comma
+ * - Remove tags with click
+ * - Visual tag chips
+ * - Duplicate prevention
+ */
+interface TagInputProps {
+    /** Current tags */
+    tags: string[];
+    /** Change handler */
+    onChange: (tags: string[]) => void;
+    /** Input placeholder */
+    placeholder?: string;
+    /** Optional CSS class */
+    className?: string;
+}
+/**
+ * TagInput component
+ */
+declare function TagInput({ tags, onChange, placeholder, className, }: TagInputProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * AddStageButton - Button to add new stages
+ *
+ * Features:
+ * - Different styles for top/bottom/inline positions
+ * - Clear visual affordance
+ */
+interface AddStageButtonProps {
+    /** Click handler */
+    onClick: () => void;
+    /** Position context */
+    position: 'top' | 'bottom' | 'inline';
+    /** Optional CSS class */
+    className?: string;
+}
+/**
+ * AddStageButton component
+ */
+declare function AddStageButton({ onClick, position, className, }: AddStageButtonProps): react_jsx_runtime.JSX.Element;
+
+interface FunnelRunHistoryProps {
+    funnelId: string;
+    apiClient: FunnelApiClient;
+    onViewResults?: (run: FunnelRun) => void;
+    className?: string;
+}
+declare function FunnelRunHistory({ funnelId, apiClient, onViewResults, className, }: FunnelRunHistoryProps): react_jsx_runtime.JSX.Element;
+
+interface RunStatusBadgeProps {
+    status: FunnelRunStatus;
+    className?: string;
+}
+declare function RunStatusBadge({ status, className }: RunStatusBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * FunnelRunHistory Types
+ *
+ * Shared types for the run history component suite
+ */
+
+/**
+ * Filter state for run history
+ */
+interface RunFilters$1 {
+    status?: FunnelRunStatus | 'all';
+    trigger_type?: TriggerType | 'all';
+    date_range?: 'all' | 'today' | 'week' | 'month' | 'custom';
+    start_date?: Date;
+    end_date?: Date;
+}
+/**
+ * Sort configuration for run history
+ */
+interface RunSort {
+    field: 'started_at' | 'status' | 'match_rate' | 'duration_ms';
+    direction: 'asc' | 'desc';
+}
+/**
+ * Pagination state
+ */
+interface Pagination {
+    page: number;
+    page_size: number;
+    total: number;
+}
+/**
+ * Run action types
+ */
+type RunAction = 'view_details' | 'view_results' | 're_run' | 'cancel';
+
+interface RunFiltersProps {
+    filters: RunFilters$1;
+    onFiltersChange: (filters: RunFilters$1) => void;
+    className?: string;
+}
+declare function RunFilters({ filters, onFiltersChange, className, }: RunFiltersProps): react_jsx_runtime.JSX.Element;
+
+interface RunRowProps {
+    run: FunnelRun;
+    onViewDetails: (run: FunnelRun) => void;
+    onViewResults: (run: FunnelRun) => void;
+    onReRun: (run: FunnelRun) => void;
+    onCancel?: (run: FunnelRun) => void;
+}
+declare function RunRow({ run, onViewDetails, onViewResults, onReRun, onCancel, }: RunRowProps): react_jsx_runtime.JSX.Element;
+
+interface RunActionsProps {
+    run: FunnelRun;
+    onViewDetails: (run: FunnelRun) => void;
+    onViewResults: (run: FunnelRun) => void;
+    onReRun: (run: FunnelRun) => void;
+    onCancel?: (run: FunnelRun) => void;
+    className?: string;
+}
+declare function RunActions({ run, onViewDetails, onViewResults, onReRun, onCancel, className, }: RunActionsProps): react_jsx_runtime.JSX.Element;
+
+interface RunDetailsModalProps {
+    run: FunnelRun | null;
+    onClose: () => void;
+    onViewResults?: (run: FunnelRun) => void;
+    onReRun?: (run: FunnelRun) => void;
+}
+declare function RunDetailsModal({ run, onClose, onViewResults, onReRun, }: RunDetailsModalProps): react_jsx_runtime.JSX.Element | null;
+
+interface StageBreakdownListProps {
+    stages: StageStats[];
+    className?: string;
+}
+declare function StageBreakdownList({ stages, className, }: StageBreakdownListProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * FunnelRunHistory Utilities
+ *
+ * Helper functions for formatting and calculations
+ */
+/**
+ * Format duration in milliseconds to human-readable string
+ *
+ * Examples:
+ * - 1234 → "1.2s"
+ * - 65000 → "1m 5s"
+ * - 3661000 → "1h 1m"
+ */
+declare function formatDuration(ms?: number): string;
+/**
+ * Format relative time
+ *
+ * Examples:
+ * - 5 minutes ago → "5m ago"
+ * - 2 hours ago → "2h ago"
+ * - Yesterday → "1d ago"
+ */
+declare function formatRelativeTime(date: Date | string): string;
+/**
+ * Calculate match rate percentage
+ */
+declare function calculateMatchRate(matched: number, total: number): number;
+/**
+ * Format number with commas
+ */
+declare function formatNumber(num: number): string;
+/**
+ * Format full timestamp for tooltips
+ */
+declare function formatFullTimestamp(date: Date | string): string;
+
+export { AddStageButton, type AddStageButtonProps, BooleanValueInput, ChoiceValueInput, DateValueInput, EntityCard, FieldSelector, FilterRuleEditor, type FilterRuleEditorProps, FlowLegend, FunnelCard, type FunnelCardProps, FunnelPreview, type FunnelPreviewProps, FunnelRunHistory, FunnelStageBuilder, type FunnelStageBuilderProps, FunnelStats, FunnelVisualFlow, type FunnelVisualFlowProps, LoadingPreview, LogicToggle, MULTI_VALUE_OPERATORS, MatchBar, MultiChoiceValueInput, NULL_VALUE_OPERATORS, NumberValueInput, OPERATOR_LABELS, OperatorSelector, type Pagination, type PreviewResult, PreviewStats, RuleRow, type RunAction, RunActions, RunDetailsModal, RunFilters, type RunFilters$1 as RunFiltersType, RunRow, type RunSort, RunStatusBadge, StageActions, type StageActionsProps, StageBreakdown, StageBreakdownList, StageCard, type StageCardProps, StageForm, type StageFormProps, StageIndicator, StageNode, type StageNodeData, type StagePreviewStats, StatusBadge, TagInput, type TagInputProps, TextValueInput, calculateMatchRate, formatDuration, formatFullTimestamp, formatNumber, formatRelativeTime, getCircledNumber };