react-semaphor 0.1.503 → 0.1.505

package/dist/types/components/surfboard/filter/filter-configuration-panel.d.ts

@@ -0,0 +1,102 @@
+import { ReactNode } from 'react';
+import { TFilter } from './types.js';
+import { TInlineFilter } from '../../../lib/types/common-types.js';
+import { GlobalDateComparisonSelection } from '../../../shared/analytics-protocol/index.js';
+import { FilterOptionBrowseState } from '../../../lib/hooks/use-filter-option-browse.js';
+type FilterType = TFilter | TInlineFilter;
+type StagedUpdates = Partial<TFilter> | Partial<TInlineFilter>;
+type SectionProps = {
+    filter: FilterType;
+    onUpdate: (updates: StagedUpdates) => void;
+    variableName?: string;
+    reservedVariableNames?: string[];
+    onUpdateInputMetadata?: (metadata: {
+        variableName?: string;
+    }) => void;
+    /** Legacy static option records (first page only). Prefer
+     * `defaultValueOptions`, which adds search and load-on-scroll. */
+    filterOptionsData?: {
+        records: any[];
+    };
+    /** Paged browse + search state from `useFilterOptionBrowse`. */
+    defaultValueOptions?: FilterOptionBrowseState;
+    optionLabelFieldName?: string;
+    timezone?: string;
+    showFilterId?: boolean;
+};
+type BasicSettingsSectionProps = Pick<SectionProps, 'filter' | 'onUpdate' | 'showFilterId' | 'filterOptionsData' | 'defaultValueOptions' | 'optionLabelFieldName' | 'timezone'> & {
+    /** Variant controls layering needs for nested overlays. */
+    variant?: 'dashboard' | 'inline' | 'document';
+    forceSelection?: boolean;
+    onForceSelectionChange?: (enabled: boolean) => void;
+    defaultComparisonSelection?: GlobalDateComparisonSelection;
+    onDefaultComparisonChange?: (selection: GlobalDateComparisonSelection) => void;
+    onDefaultDatePickerOpenChange?: (open: boolean) => void;
+    /** Rendered directly under the Display Label field. Used for the Option
+     * Label / Option Value pickers, which read as one naming group with the
+     * label before the plumbing (variable name, defaults). */
+    afterLabelSlot?: ReactNode;
+};
+/**
+ * Basic Settings section: Label, Default Values
+ */
+export declare function BasicSettingsSection({ filter, onUpdate, showFilterId, filterOptionsData, defaultValueOptions, optionLabelFieldName, timezone, variant, defaultComparisonSelection, onDefaultComparisonChange, onDefaultDatePickerOpenChange, afterLabelSlot, forceSelection, onForceSelectionChange, }: BasicSettingsSectionProps): import("react/jsx-runtime").JSX.Element;
+type VariableNameSectionProps = Pick<SectionProps, 'variableName' | 'reservedVariableNames' | 'onUpdateInputMetadata'>;
+/**
+ * Variable Name: the identifier other surfaces reference this input by
+ * (e.g. {{region}} in documents). Plumbing rather than everyday
+ * configuration, so it lives on the Advanced tab.
+ */
+export declare function VariableNameSection({ variableName, reservedVariableNames, onUpdateInputMetadata, }: VariableNameSectionProps): import("react/jsx-runtime").JSX.Element | null;
+type UICustomizationSectionProps = Pick<SectionProps, 'filter' | 'onUpdate'> & {
+    /** Variant controls which settings are shown. 'inline' adds Width/ShowLabel. */
+    variant?: 'dashboard' | 'inline' | 'document';
+};
+/**
+ * UI Customization section: Selection Type, UI Component, Custom Filter Component
+ * For inline variant, also includes Width and Show Label settings.
+ */
+export declare function UICustomizationSection({ filter, onUpdate, variant, }: UICustomizationSectionProps): import("react/jsx-runtime").JSX.Element;
+type AdvancedSectionProps = Pick<SectionProps, 'filter' | 'onUpdate'> & {
+    /** Variant controls which settings are shown. */
+    variant?: 'dashboard' | 'inline' | 'document';
+};
+export declare function BehaviorAndDataSection({ filter, onUpdate, variant, }: AdvancedSectionProps): import("react/jsx-runtime").JSX.Element;
+type AdvancedQuerySectionProps = Pick<SectionProps, 'filter' | 'onUpdate'> & {
+    /** Variant controls layering needs for nested overlays. */
+    variant?: 'dashboard' | 'inline' | 'document';
+};
+/**
+ * Advanced Query section: Search Mode, SQL
+ */
+export declare function AdvancedQuerySection({ filter, onUpdate, variant, }: AdvancedQuerySectionProps): import("react/jsx-runtime").JSX.Element;
+type FilterConfigurationPanelProps = {
+    /** The filter being configured (dashboard filter or inline filter) */
+    filter: FilterType;
+    /** Callback when user changes a setting. Parent handles staged updates. */
+    onUpdate: (updates: StagedUpdates) => void;
+    /** Filter options data for default values selection */
+    filterOptionsData?: {
+        records: any[];
+    };
+    /** Dashboard timezone for date pickers */
+    timezone?: string;
+    /** Whether to show the filter ID in the title tooltip (dashboard filters only) */
+    showFilterId?: boolean;
+};
+/**
+ * Shared configuration panel for both dashboard filters and inline filters.
+ *
+ * This component is **stateless** - it receives the current filter state and
+ * an onUpdate callback. The parent component is responsible for:
+ * 1. Managing staged updates (local state before Accept)
+ * 2. Persisting changes to the appropriate store on Accept
+ *
+ * For dashboard filters: Parent uses `updateFilter` from dashboard store
+ * For inline filters: Parent uses `setCard` from editor store
+ *
+ * @deprecated Use the individual section components (BasicSettingsSection,
+ * UICustomizationSection, AdvancedQuerySection) for the new sidebar layout.
+ */
+export declare function FilterConfigurationPanel({ filter, onUpdate, filterOptionsData, timezone, showFilterId, }: FilterConfigurationPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/filter-default-values-picker.d.ts

@@ -0,0 +1,29 @@
+import { FilterOptionListBrowseState } from './filter-option-list.js';
+import { FilterOptionDependencyState } from '../../../lib/hooks/use-filter-option-browse.js';
+import { FilterOptionValue } from './types.js';
+export type FilterDefaultValueOption = {
+    key: string;
+    value: FilterOptionValue;
+    label: string;
+};
+type FilterDefaultValuesPickerProps = {
+    options: FilterDefaultValueOption[];
+    selectedKeys: ReadonlySet<string>;
+    onToggle: (option: FilterDefaultValueOption) => void;
+    state: FilterOptionListBrowseState;
+    /** Authoring diagnostics for dependencies applied to or skipped by this list. */
+    dependency?: FilterOptionDependencyState;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    /** Extra classes for the floating panel (layering for nested surfaces). */
+    contentClassName?: string;
+};
+/**
+ * Compact multi-select picker for authoring default filter values.
+ *
+ * A thin host of `FilterOptionList` at settings-panel density. Toggling an
+ * option reports immediately; the caller stages the change and renders the
+ * selected chips, so there is no draft/apply step here.
+ */
+export declare function FilterDefaultValuesPicker({ options, selectedKeys, onToggle, state, dependency, placeholder, searchPlaceholder, contentClassName, }: FilterDefaultValuesPickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/filter-error-state.d.ts

@@ -0,0 +1,7 @@
+type FilterErrorStateProps = {
+    isCardStorage?: boolean;
+    message?: string;
+    className?: string;
+};
+export declare function FilterErrorState({ isCardStorage, message, className, }: FilterErrorStateProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/filter-header.d.ts

@@ -0,0 +1,4 @@
+import { TFilter } from './types.js';
+export default function FilterHeader({ filter }: {
+    filter: TFilter;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/surfboard/filter/filter-info.d.ts

@@ -0,0 +1,17 @@
+import { FilterGroup } from '../../../lib/types/explorer-types.js';
+import { TInlineFilter } from '../../../lib/types/common-types.js';
+import { TFilterValue } from './types.js';
+import { ResolvedPrimaryDateField } from '../../../lib/types/semantic-runtime-types.js';
+interface FilterInfoProps {
+    cardId?: string;
+    cardFilters?: FilterGroup;
+    cardFilterCount?: number;
+    onFiltersClick?: () => void;
+    inlineFilters?: TInlineFilter[];
+    inlineFilterValues?: TFilterValue[];
+    sheetId?: string;
+    removeInlineFilterValue?: (filterId: string) => void;
+    resolvedPrimaryDateField?: ResolvedPrimaryDateField;
+}
+export default function FilterInfo({ cardId, cardFilters, cardFilterCount, onFiltersClick, inlineFilters, inlineFilterValues, sheetId: _sheetId, removeInlineFilterValue, resolvedPrimaryDateField, }: FilterInfoProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/surfboard/filter/filter-option-dependencies-settings.d.ts

@@ -0,0 +1,33 @@
+import { NormalizedFilterDashboardInput } from '../../../lib/types/common-types.js';
+import { DashboardInputTargetExclusion } from '../../../lib/dashboard-inputs/dashboard-input-target-context.js';
+import { DashboardFilterOptionDependencies, DashboardFilterOptionPopulation, DashboardFilterOptionSource } from '../../../shared/dashboard-authoring/index.js';
+/** Datasets an author may name as the population for fact-bridged cascades. */
+export type OptionPopulationChoice = {
+    label: string;
+    source: Extract<DashboardFilterOptionSource['source'], {
+        kind: 'semantic';
+    }>;
+};
+/**
+ * "Narrow available options by" for one dashboard filter. The three modes and
+ * the peer checklist are the authored policy; applicability and relationship
+ * proof stay server-owned, so this control never claims a peer will apply.
+ */
+export declare function FilterOptionDependenciesSettings({ value, population, peerInputs, excludedInputs, populationChoices, selectContentClassName, onChange, onPopulationChange, }: {
+    /** Authored policy; undefined means the dashboard default (All applicable). */
+    value: DashboardFilterOptionDependencies | undefined;
+    population: DashboardFilterOptionPopulation | undefined;
+    peerInputs: NormalizedFilterDashboardInput[];
+    /** Inputs in scope the runtime context excluded, with the reason. */
+    excludedInputs?: DashboardInputTargetExclusion[];
+    /** Empty when the option source is not semantic. */
+    populationChoices: OptionPopulationChoice[];
+    /**
+     * Stacking class for the portaled list when the host popover raises its
+     * own z-index (inline and document variants), same as the other Selects
+     * in the settings panel.
+     */
+    selectContentClassName?: string;
+    onChange: (next: DashboardFilterOptionDependencies | undefined) => void;
+    onPopulationChange: (next: DashboardFilterOptionPopulation | undefined) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/surfboard/filter/filter-option-list.d.ts

@@ -0,0 +1,39 @@
+import { ReactNode } from 'react';
+import { FilterOptionBrowseState, FilterOptionDependencyState } from '../../../lib/hooks/use-filter-option-browse.js';
+import { TSelectedRecord } from './types.js';
+/** The slice of browse state the list renders. Hosts pass it straight
+ * through from `useFilterOptionBrowse` or `useTextFilter`. */
+export type FilterOptionListBrowseState = Pick<FilterOptionBrowseState, 'query' | 'setQuery' | 'isLoadingOptions' | 'isError' | 'retry' | 'isSearching' | 'searchError' | 'hasNextPage' | 'hasLoadedMoreOptions' | 'isFetchingNextPage' | 'isNextPageError' | 'loadNextPage'>;
+export type FilterOptionListProps = {
+    records: TSelectedRecord[];
+    /** Identities (see `getFilterOptionValueIdentity`) of selected records. */
+    selectedIdentities: ReadonlySet<string>;
+    onToggle: (record: TSelectedRecord) => void;
+    /** Radio indicator for single, checkbox for multiple. Default: multiple. */
+    selectionMode?: 'single' | 'multiple';
+    browse: FilterOptionListBrowseState;
+    searchPlaceholder: string;
+    /** Accessible name for the listbox. */
+    listLabel?: string;
+    /** `compact` is the settings-panel density (12px rows, 240px list). */
+    density?: 'default' | 'compact';
+    /** Rendered between the search row and the list: mode toggles, the All
+     * checkbox, anything the host needs above the options. */
+    toolbar?: ReactNode;
+    /** Dependency feedback from the browse hook: what narrowed the list, the
+     * active browse override, and the one classified failure a viewer may
+     * browse around. Absent for lists without a dependency context. */
+    dependency?: FilterOptionDependencyState;
+};
+/**
+ * The one option list for every filter-value surface.
+ *
+ * Renders the search row, the (virtualized) option rows, loading skeleton,
+ * empty and error states, and the load-more status row, and owns keyboard
+ * navigation and listbox semantics. It renders as a fragment so the host
+ * owns the frame and can place a footer or its own toolbar around it.
+ *
+ * Hosts own everything about selection: which identities are selected,
+ * what a toggle means (draft vs commit), and where the selection lives.
+ */
+export declare function FilterOptionList({ records, selectedIdentities, onToggle, selectionMode, browse, searchPlaceholder, listLabel, density, toolbar, dependency, }: FilterOptionListProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/surfboard/filter/filter-option-source-settings.d.ts

@@ -0,0 +1,14 @@
+import { DashboardFilterMappingFieldLabels, DashboardFilterOptionFieldChoice } from '../../../lib/dashboard-inputs/dashboard-filter-mapping-candidate-metadata.js';
+import { DashboardFilterOptionSource } from '../../../shared/dashboard-authoring/index.js';
+export declare function FilterOptionSourceSettings({ value, fieldChoices, fieldLabels, isLoading, error, onRetry, onChange, }: {
+    value: DashboardFilterOptionSource;
+    fieldChoices: DashboardFilterOptionFieldChoice[];
+    /** Live catalog labels for the option source; missing entries fall back to names. */
+    fieldLabels?: DashboardFilterMappingFieldLabels;
+    isLoading?: boolean;
+    error?: unknown;
+    onRetry?: () => void;
+    onChange: (value: DashboardFilterOptionSource, meta?: {
+        changedValueField?: DashboardFilterOptionFieldChoice;
+    }) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/surfboard/filter/filter-picker-popover-content.d.ts

@@ -0,0 +1 @@
+export declare function FilterPickerPopoverContent(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/surfboard/filter/filter-popover-parts.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Section wrapper inside the active-filters popover. Section labels use the
+ * canonical `text-[10px] uppercase tracking-[0.08em]` token (matches FIELDS /
+ * CHART SETTINGS / Semantic Domains headings), and the section owns the
+ * popover's horizontal padding so every source lines up on one left edge.
+ */
+export declare function FilterSection({ label, children, }: {
+    label: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * A single filter value inside a section.
+ *
+ * One recipe for all four filter sources (dashboard, card, inline, click).
+ * They previously hand-rolled near-identical chips, which is how the click
+ * section drifted into a blue variant while the rest stayed monochrome.
+ *
+ * `onRemove` is the only thing that changes the shape: with it, the chip is a
+ * button carrying an X; without it, a static span. Removability is signalled
+ * by the affordance rather than by colour — per design/TOKENS.md, colour marks
+ * state that needs attention, not "this one is interactive".
+ */
+export declare function FilterChip({ label, onRemove, title, className, }: {
+    label: string;
+    onRemove?: () => void;
+    title?: string;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Field name + optional qualifier above a row of chips. Shared so the four
+ * sections can't drift on type scale.
+ */
+export declare function FilterFieldHeader({ label, qualifier, action, }: {
+    label: string;
+    qualifier?: string;
+    action?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/surfboard/filter/filter-scope-config.d.ts

@@ -0,0 +1,8 @@
+import { TFilter } from './types.js';
+interface FilterScopeConfigProps {
+    filter: TFilter;
+    onUpdate: (updates: Partial<TFilter>) => void;
+    cardScopeMode?: 'editable' | 'mapping';
+}
+export declare function FilterScopeConfig({ filter, onUpdate, cardScopeMode, }: FilterScopeConfigProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/filter-settings-popover.d.ts

@@ -0,0 +1,5 @@
+/**
+ * FilterSettingsPopover - Dashboard-level filter layout settings.
+ * Allows users to configure how filters are displayed (canvas cards vs toolbar).
+ */
+export declare function FilterSettingsPopover(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/surfboard/filter/filter-toolbar-item.d.ts

@@ -0,0 +1,21 @@
+import { FilterStorageOptions, TFilter } from './types.js';
+import { FilterAuthoringAcceptance, FilterAuthoringInputMetadata, FilterSettingsVariant } from './custom-filter-popover.js';
+import { DraggableAttributes } from '@dnd-kit/core';
+import { SyntheticListenerMap } from '@dnd-kit/core/dist/hooks/utilities';
+type FilterToolbarItemProps = {
+    filter: TFilter;
+    isEditing?: boolean;
+    /** Drag listeners from useSortable - applied to the grip handle */
+    dragListeners?: SyntheticListenerMap;
+    /** Sortable aria attributes from useSortable - applied to the grip handle */
+    dragAttributes?: DraggableAttributes;
+    storageOptions?: FilterStorageOptions;
+    settingsVariant?: FilterSettingsVariant;
+    inputVariableName?: string;
+    reservedInputVariableNames?: string[];
+    isDashboardFilterReference?: boolean;
+    onUpdateFilter?: (filter: TFilter, inputMetadata?: FilterAuthoringInputMetadata) => FilterAuthoringAcceptance;
+    onRemoveFilter?: (filterId: string) => void;
+};
+export default function FilterToolbarItem({ filter, isEditing, dragListeners, dragAttributes, storageOptions: providedStorageOptions, settingsVariant, inputVariableName, reservedInputVariableNames, isDashboardFilterReference, onUpdateFilter, onRemoveFilter, }: FilterToolbarItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/filter-toolbar-order-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function mergeSubsetOrderIntoFullOrder<T extends {
+    id: string;
+}>(fullItems: T[], currentSubsetIds: string[], nextSubsetIds: string[]): string[];

package/dist/types/components/surfboard/filter/filter-toolbar.d.ts

@@ -0,0 +1,7 @@
+/**
+ * FilterToolbar - A horizontal toolbar for displaying filters in a compact format.
+ * Renders filters that have displayMode='toolbar' or 'inherit' (when dashboard default is 'toolbar').
+ *
+ * In edit mode, filters can be dragged to reorder them.
+ */
+export default function FilterToolbar(): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/surfboard/filter/global-date-comparison-footer.d.ts

@@ -0,0 +1,14 @@
+import { GlobalDateComparisonSelection } from '../../../shared/analytics-protocol/index.js';
+import { TFilterValue } from './types.js';
+type DateComparisonFooterProps = {
+    selection: GlobalDateComparisonSelection;
+    controlLabel: string;
+    scopeMessage: string;
+    authorControlledCardCount: number;
+    activeDateFilterValue?: TFilterValue;
+    hasRuntimeOverride: boolean;
+    onChange: (selection: GlobalDateComparisonSelection) => void;
+    onReset: () => void;
+};
+export declare function DateComparisonFooter({ selection, controlLabel, scopeMessage, authorControlledCardCount, activeDateFilterValue, hasRuntimeOverride, onChange, onReset, }: DateComparisonFooterProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/global-date-filter.d.ts

@@ -0,0 +1,9 @@
+import { FilterStorageOptions, TFilter } from './types.js';
+type GlobalDateFilterComponentProps = {
+    filter: TFilter;
+    storageOptions?: FilterStorageOptions;
+    inline?: boolean;
+    onApplied?: () => void;
+};
+export declare function GlobalDateFilterComponent({ filter, storageOptions: providedStorageOptions, inline, onApplied, }: GlobalDateFilterComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/hidden-filters.d.ts

@@ -0,0 +1 @@
+export default function HiddenFilters(): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/surfboard/filter/month-picker.d.ts

@@ -0,0 +1,18 @@
+export type MonthPickerValue = {
+    year: number;
+    month: number;
+};
+type MonthPickerProps = {
+    value?: MonthPickerValue;
+    onChange?: (year: number, month: number) => void;
+    onClear?: () => void;
+    placeholder?: string;
+    className?: string;
+    buttonClassName?: string;
+    /** Render the grid directly inside an enclosing filter popover. */
+    inline?: boolean;
+    /** Inline callers close their popover after selection or clearing. */
+    onApplied?: () => void;
+};
+export default function MonthPicker({ value, onChange, onClear, placeholder, className, buttonClassName, inline, onApplied, }: MonthPickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/multi-select-filter.d.ts

@@ -0,0 +1,16 @@
+import { TFilter, FilterStorageOptions } from './types.js';
+type MultiSelectFilterProps = {
+    filter: TFilter;
+    /** Storage options for inline filters (card-scoped) vs dashboard filters */
+    storageOptions?: FilterStorageOptions;
+};
+export default function MultiSelectFilter({ filter, storageOptions, }: MultiSelectFilterProps): import("react/jsx-runtime").JSX.Element;
+export declare function FilterModeButton({ filter, storageOptions, compact, }: {
+    filter: TFilter;
+    storageOptions?: FilterStorageOptions;
+    /** 24px segmented (h-5 buttons, 11px labels) for the dense chip
+     * popover — Aligned density reference. The legacy canvas panel keeps
+     * the default 28px size. */
+    compact?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/multi-select-inline-content.d.ts

@@ -0,0 +1,39 @@
+import { TFilter, FilterStorageOptions } from './types.js';
+/**
+ * MultiSelectInlineContent — canonical chip-popover content for
+ * multi-select / dropdown filters.
+ *
+ * Replaces the ComboBox2-based `MultiSelectFilter` rendering when the
+ * filter sits inside a `FilterChip` popover. Same data layer
+ * (`useTextFilter`), same actions, same operations — but the UI is
+ * rendered inline (no nested popover) so opening the chip's popover
+ * shows the full filter UI immediately.
+ *
+ * Layout (top to bottom):
+ *   - `FilterOptionList`: search input, Include / Exclude + All toolbar,
+ *     scrollable option rows with load-more (DRAFT — toggling does NOT
+ *     commit; user picks freely without firing a query per click)
+ *   - Footer: count · Clear (resets draft) · Apply (commits)
+ *
+ * Draft + Apply rationale:
+ *   - Each filter change fires an expensive query. Picking 5 values
+ *     should fire one query, not five. Standard pattern in BI tools
+ *     (Looker, Metabase, Sigma).
+ *   - Apply button is the single commit point. Clear resets the local
+ *     draft (does NOT commit empty — user must Apply to commit). The
+ *     chip's external `×` button still does a one-click commit-empty
+ *     for users who just want to clear the filter without opening the
+ *     popover.
+ *   - Include / Exclude toggle stays live-commit (one-click semantic
+ *     change; users typically pick mode before picking values, so the
+ *     query at that moment runs against an empty value set).
+ */
+type MultiSelectInlineContentProps = {
+    filter: TFilter;
+    storageOptions?: FilterStorageOptions;
+    /** Fired after Apply commits — caller closes the popover. Skipping
+     * this leaves the popover open after Apply (legacy behavior). */
+    onApplied?: () => void;
+};
+export default function MultiSelectInlineContent({ filter, storageOptions, onApplied, }: MultiSelectInlineContentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/numeric-filter-input.d.ts

@@ -0,0 +1,8 @@
+import { TFilter, FilterStorageOptions } from './types.js';
+type NumericFilterInputProps = {
+    filter: TFilter;
+    /** Storage options for inline filters (card-scoped) vs dashboard filters */
+    storageOptions?: FilterStorageOptions;
+};
+export default function NumericFilterInput({ filter, storageOptions, }: NumericFilterInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/radio-button-filter.d.ts

@@ -0,0 +1,8 @@
+import { TFilter, FilterStorageOptions } from './types.js';
+type RadioButtonFilterProps = {
+    filter: TFilter;
+    /** Storage options for inline filters (card-scoped) vs dashboard filters */
+    storageOptions?: FilterStorageOptions;
+};
+export default function RadioButtonFilter({ filter, storageOptions, }: RadioButtonFilterProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/sortable-filter-toolbar-item.d.ts

@@ -0,0 +1,24 @@
+import { TFilter, FilterStorageOptions } from './types.js';
+import { FilterAuthoringAcceptance, FilterAuthoringInputMetadata, FilterSettingsVariant } from './custom-filter-popover.js';
+type SortableFilterToolbarItemProps = {
+    filter: TFilter;
+    isEditing?: boolean;
+    disabled?: boolean;
+    storageOptions?: FilterStorageOptions;
+    settingsVariant?: FilterSettingsVariant;
+    inputVariableName?: string;
+    reservedInputVariableNames?: string[];
+    isDashboardFilterReference?: boolean;
+    onUpdateFilter?: (filter: TFilter, inputMetadata?: FilterAuthoringInputMetadata) => FilterAuthoringAcceptance;
+    onRemoveFilter?: (filterId: string) => void;
+};
+/**
+ * SortableFilterToolbarItem - Wrapper that adds drag-to-reorder functionality
+ * to FilterToolbarItem using @dnd-kit.
+ *
+ * In edit mode, the header area becomes draggable (not the whole item,
+ * to avoid conflicts with the resize handle).
+ * In view mode, dragging is disabled.
+ */
+export default function SortableFilterToolbarItem({ filter, isEditing, disabled, storageOptions, settingsVariant, inputVariableName, reservedInputVariableNames, isDashboardFilterReference, onUpdateFilter, onRemoveFilter, }: SortableFilterToolbarItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/surfboard/filter/tabs-filter.d.ts

@@ -0,0 +1,8 @@
+import { TFilter, FilterStorageOptions } from './types.js';
+type TabsFilterProps = {
+    filter: TFilter;
+    /** Storage options for inline filters (card-scoped) vs dashboard filters */
+    storageOptions?: FilterStorageOptions;
+};
+export default function TabsFilter({ filter, storageOptions, }: TabsFilterProps): import("react/jsx-runtime").JSX.Element;
+export {};