react-semaphor 0.1.533 → 0.1.535

package/dist/types/lib/utils/date-timezone-utils.d.ts

@@ -1,79 +0,0 @@
-import { CalendarContext } from '../types/token-types.js';
-/**
- * Gets the start of day (00:00:00.000) for a date in the specified timezone.
- * This ensures that when the Date is serialized to UTC, it represents the correct day boundary.
- *
- * @param date - The date to get start of day for
- * @param timezone - The timezone to use (e.g., 'America/Los_Angeles')
- * @returns A Date object representing midnight in the specified timezone
- *
- * @example
- * // Nov 18, 2025 14:30 PST
- * startOfDayInTimezone(new Date('2025-11-18T22:30:00Z'), 'America/Los_Angeles')
- * // Returns a Date that serializes to: 2025-11-18T08:00:00.000Z (Nov 18 00:00 PST)
- *
- * Do not pass `new Date('YYYY-MM-DD')`: that is UTC midnight, which is the
- * previous day in zones west of UTC. Use `parseFilterDateValue` for
- * date-only strings.
- */
-export declare const startOfDayInTimezone: (date: Date, timezone: string) => Date;
-/**
- * Gets the last millisecond of the day for a date in the specified timezone:
- * 23:59:59.999, or the instant before the next day starts on a day that
- * ends inside a daylight-saving change.
- * This ensures that when the Date is serialized to UTC, it represents the correct day boundary.
- *
- * @param date - The date to get end of day for
- * @param timezone - The timezone to use (e.g., 'America/Los_Angeles')
- * @returns A Date object representing 23:59:59.999 in the specified timezone
- *
- * @example
- * // Nov 20, 2025 14:30 PST
- * endOfDayInTimezone(new Date('2025-11-20T22:30:00Z'), 'America/Los_Angeles')
- * // Returns a Date that serializes to: 2025-11-21T07:59:59.999Z (Nov 20 23:59:59 PST)
- */
-export declare const endOfDayInTimezone: (date: Date, timezone: string) => Date;
-/**
- * Parses a stored date filter value into the instant the date pickers would
- * have written for it.
- *
- * Filter values are usually instants, but date-only strings (`YYYY-MM-DD`)
- * also arrive from SDK/embed defaults, generated dashboards and inputs. A
- * date-only string names a calendar day, not an instant: it maps to the start
- * (or, for an upper bound, the end) of that day in `timezone`, exactly as
- * `startOfDayInTimezone` / `endOfDayInTimezone` produce for a picked day.
- * `new Date('YYYY-MM-DD')` would instead give UTC midnight, which displays as
- * the previous day in zones west of UTC.
- *
- * Everything else parses as an instant. Returns undefined for empty or
- * unparseable values, including `YYYY-MM-DD` strings that name no calendar
- * day (which `new Date` would silently roll into the next month). A missing timezone falls back to the browser zone, as
- * `getEffectiveTimezone` does.
- */
-export declare const parseFilterDateValue: (value: unknown, timezone: string | null | undefined, bound?: "start" | "end") => Date | undefined;
-/**
- * Resolves the effective timezone.
- *
- * Since backend always includes calendarContext in JWT tokens, prefer using
- * useCalendarContext() hook instead. This function is kept for backward compatibility
- * and for contexts where hooks are not available.
- *
- * Resolution order:
- * 1. CalendarContext.tz (if CalendarContext provided)
- * 2. Explicit timezone string
- * 3. Browser's timezone (fallback)
- *
- * @param timezoneOrContext - Optional timezone string or CalendarContext
- * @returns The effective IANA timezone string
- *
- * @example
- * // With CalendarContext (preferred)
- * getEffectiveTimezone(calendarContext) // Returns calendarContext.tz
- *
- * // With token timezone
- * getEffectiveTimezone('America/New_York') // Returns 'America/New_York'
- *
- * // Without timezone (falls back to browser)
- * getEffectiveTimezone() // Returns browser's timezone (e.g., 'America/Los_Angeles')
- */
-export declare const getEffectiveTimezone: (timezoneOrContext?: string | CalendarContext | null) => string;

package/dist/types/lib/utils/drag-and-drop-utils.d.ts

@@ -1,8 +0,0 @@
-import { ContainerId, GroupByField, MetricField, SortByField, PivotByField, DetailField, Field, AggregateFunction } from '../types/explorer-types.js';
-import { TCard } from '../types/index.js';
-import { ShelfDefinitionCard } from './card-definition.js';
-export declare function getFieldId(containerId: ContainerId, field: Field): string;
-export declare function getAggregationLabel(columnName: string, aggregation: AggregateFunction): string;
-export declare function getSmartContainerForField(field: Field, existingFields: Field[], chartType?: TCard['type']): ContainerId | null;
-export declare function getNewField(activeField: Field, overContainer: ContainerId, existingFields?: Field[]): GroupByField | MetricField | PivotByField | DetailField | SortByField | null;
-export declare function isCardConfigPresent(card: ShelfDefinitionCard): boolean;

package/dist/types/lib/utils/drill-context-utils.d.ts

@@ -1,32 +0,0 @@
-import { ClickFilterCondition } from '../types/interaction-types.js';
-import { TFilterValue } from '../../components/surfboard/filter/types.js';
-/**
- * Convert ClickFilterCondition to TFilterValue format
- *
- * Note: This is a temporary solution for drill context. In the long term,
- * we need a more robust system for cross-dashboard filter passing.
- */
-export declare function convertClickFilterToFilterValue(condition: ClickFilterCondition): TFilterValue;
-/**
- * Build combined filters based on contextMode
- *
- * @param drillFilters - Filters from the clicked element (drill context)
- * @param dashboardFilters - Current dashboard filters (optional)
- * @param contextMode - How to combine filters
- * @returns Combined filters as TFilterValue[]
- */
-export declare function buildDrillFilters(drillFilters: ClickFilterCondition[], dashboardFilters?: TFilterValue[], contextMode?: 'interactionFilters' | 'full' | 'none'): TFilterValue[];
-/**
- * Get display text for drill context breadcrumb
- *
- * @param conditions - Filter conditions to display
- * @returns Human-readable text like "Country = USA, State = CA"
- */
-export declare function getDrillBreadcrumbText(conditions: ClickFilterCondition[]): string;
-/**
- * Get source dashboard title for back button
- *
- * @param sourceDashboardTitle - Optional dashboard title from drill history
- * @returns Display text like "Back to Sales Dashboard" or just "Back"
- */
-export declare function getBackButtonText(sourceDashboardTitle?: string): string;

package/dist/types/lib/utils/entity-consistency-utils.d.ts

@@ -1,48 +0,0 @@
-import { Field, JoinPlan, MetricField, AggregateFunction, ContainerId, FilterGroup } from '../types/explorer-types.js';
-import { FieldStateResult } from './field-state-calculator.js';
-import { FieldAvailabilityContext } from './field-availability-context.js';
-/**
- * Check if two entities are joined based on the join plan
- */
-export declare function areEntitiesJoined(entity1: string, entity2: string, joinPlan: JoinPlan | undefined): boolean;
-/**
- * Validate whether a field can be added to the query alongside the fields
- * already on the shelves.
- *
- * This is the ONE gate. Drag-drop, row click, keyboard insertion, and the
- * matrix editor all call it, and it defers entirely to
- * `calculateFieldState`, so the list, the preview card, and the drop
- * behaviour can never disagree. Calculated fields are evaluated through
- * the datasets they read from; they are not exempt.
- *
- * Returns the field state so callers can explain a refusal precisely.
- */
-export declare function validateEntityConsistency(newField: Field, existingFields: Field[], context: FieldAvailabilityContext): {
-    isValid: boolean;
-    showError?: boolean;
-    fieldState?: FieldStateResult;
-};
-/**
- * Show the "cannot add this field" notification. Uses the precise reason
- * and action from the field state when available; falls back to the
- * generic join guidance.
- */
-export declare function showJoinRequiredNotification(fieldState?: FieldStateResult): void;
-/**
- * Check if a field already exists in a container
- * For metric fields, always allow duplicates since users will configure different filters after dropping
- */
-export declare function fieldAlreadyExists(field: Field, containerFields: Field[]): boolean;
-/**
- * Generate a descriptive label for a metric field that includes filter information
- */
-export declare function getMetricDisplayLabel(field: Field): string;
-/**
- * Generate a unique label for duplicate metric fields
- * This helps users distinguish between multiple instances of the same field
- */
-export declare function getUniqueMetricLabel(field: Field, existingFields: Field[], containerId: ContainerId): string;
-/**
- * Create a metric field with filter parameters
- */
-export declare function createMetricWithFilter(baseField: Field, aggregate: AggregateFunction, filters?: FilterGroup, customLabel?: string): MetricField;

package/dist/types/lib/utils/entity-icon-utils.d.ts

@@ -1,17 +0,0 @@
-import { EntityType } from '../types/explorer-types.js';
-interface GetEntityIconOptions {
-    /**
-     * Size class for the icon (e.g., "h-4 w-4", "h-3 w-3")
-     * @default "h-4 w-4"
-     */
-    size?: string;
-}
-/**
- * Get entity icon component based on entity type
- *
- * @param type - The entity type (table, view, model, dataset, file, etc.)
- * @param options - Optional configuration for icon appearance
- * @returns React icon component
- */
-export declare function getEntityIcon(type: EntityType | string, options?: GetEntityIconOptions): import("react").JSX.Element;
-export {};

package/dist/types/lib/utils/explorer-derived-field.d.ts

@@ -1,4 +0,0 @@
-import { Field } from '../types/explorer-types.js';
-import { SemaphorDerivedFieldDefinition, SemaphorFieldRef } from '../../shared/analytics-protocol/index.js';
-/** Adapt the existing formula editor without parsing SQL or guessing aggregate semantics. */
-export declare function explorerDerivedField(field: Field, resolveField: (field: Field) => SemaphorFieldRef | undefined): SemaphorDerivedFieldDefinition | undefined;

package/dist/types/lib/utils/explorer-field-identity.d.ts

@@ -1,15 +0,0 @@
-import { ContainerId, Field } from '../types/explorer-types.js';
-type ShelfFieldIdentity = Pick<Field, 'name'> & Partial<Pick<Field, 'id' | 'entityName' | 'qualifiedEntityName'>>;
-/**
- * Resolves the identity a shelf uses for a field.
- *
- * Saved cards can contain fields with no persisted `id`, so the shelf
- * synthesizes one to keep drag, selection, and field editing working.
- */
-export declare function resolveShelfFieldId(field: ShelfFieldIdentity, containerId: ContainerId): string;
-/**
- * Finds a field by shelf identity. Persisted IDs are authoritative; synthesized
- * identities are considered only when no stored ID matches.
- */
-export declare function findShelfFieldIndex(fields: readonly ShelfFieldIdentity[] | undefined, columnId: string, containerId: ContainerId): number;
-export {};

package/dist/types/lib/utils/export-result-source.d.ts

@@ -1,20 +0,0 @@
-import { FlatTableTotalsByColumnId } from '../table-formatting/table-totals-settings.js';
-import { QueryColumnKeyMap } from '../types/explorer-types.js';
-import { SemaphorResultColumn } from '../../shared/analytics-protocol/index.js';
-type ResolveExportResultSourceParams<T> = {
-    cardType: string;
-    queriedResult: T | null | undefined;
-    suppliedResult: T | null | undefined;
-};
-/**
- * Select one result snapshot for an export and keep its presentation metadata
- * attached. Matrix expansion is supplied by the renderer; other cards prefer
- * the query owned by the export dialog.
- */
-export declare function resolveExportResultSource<T>({ cardType, queriedResult, suppliedResult, }: ResolveExportResultSourceParams<T>): {
-    resultColumns?: readonly SemaphorResultColumn[];
-    columnKeyMap?: QueryColumnKeyMap;
-    exportData: T | null | undefined;
-    tableTotalsByColumnId: FlatTableTotalsByColumnId | undefined;
-};
-export {};

package/dist/types/lib/utils/export-utils.d.ts

@@ -1,26 +0,0 @@
-/**
- * Utility functions for determining supported export formats based on card type
- */
-export type ExportFormat = 'pdf' | 'csv' | 'png';
-/**
- * Get supported export formats for a given card type
- * @param cardType - The type of card/visual
- * @returns Array of supported export formats
- */
-export declare function getSupportedExportFormats(cardType: string, options?: {
-    allowDownload?: boolean;
-}): ExportFormat[];
-/**
- * Get the default export format for a given card type
- * @param cardType - The type of card/visual
- * @returns Default export format
- */
-export declare function getDefaultExportFormat(cardType: string, options?: {
-    allowDownload?: boolean;
-}): ExportFormat;
-/**
- * Check if a card type is a table type
- * @param cardType - The type of card/visual
- * @returns True if the card is a table type
- */
-export declare function isTableType(cardType: string): boolean;

package/dist/types/lib/utils/expression-field-classification.d.ts

@@ -1,12 +0,0 @@
-import { Field } from '../types/explorer-types.js';
-export type ExpressionFieldKind = 'none' | 'inline_expression' | 'domain_calculated' | 'user_calculated';
-export type CalculatedFieldPickerContext = 'editor' | 'filter' | 'inline-filter';
-export declare function isRootCalculatedFieldReference(field: Field): boolean;
-export declare function getExpressionFieldKind(field: Field): ExpressionFieldKind;
-export declare function isCalculatedExpressionField(field: Field): boolean;
-export declare function isManagedCalculatedExpressionField(field: Field): boolean;
-export declare function isSharedManagedCalculatedExpressionField(field: Field): boolean;
-export declare function isInlineExpressionField(field: Field): boolean;
-export declare function isCalculatedFieldVisibleInPicker(field: Field, context: CalculatedFieldPickerContext, options?: {
-    isValuePickSafe?: boolean;
-}): boolean;

package/dist/types/lib/utils/fetch-export-data.d.ts

@@ -1,14 +0,0 @@
-import { DashboardCardQueryRequestPayloadBase } from '../query-context/build-dashboard-card-query-contract.js';
-import { TableTotalsRequest } from '../types/explorer-types.js';
-export type FetchExportDataParams = {
-    apiServiceUrl: string;
-    authToken: string;
-    connectionId: string;
-    requestPayloadBase: DashboardCardQueryRequestPayloadBase;
-    tableTotalsRequest?: TableTotalsRequest;
-};
-/**
- * Fetch all data for export (up to 10K rows)
- * Uses the existing /v1/query endpoint with exportMode flag
- */
-export declare function fetchAllDataForExport({ apiServiceUrl, authToken, connectionId, requestPayloadBase, tableTotalsRequest, }: FetchExportDataParams): Promise<any>;

package/dist/types/lib/utils/field-availability-context.d.ts

@@ -1,25 +0,0 @@
-import { TCard } from '../types/common-types.js';
-import { AutoJoinMetadata } from '../types/query-types.js';
-import { JoinabilityMapResponse } from '../types/semantic-types.js';
-import { FieldStateContext } from './field-state-calculator.js';
-/**
- * Everything `calculateFieldState` needs about a visual, except the
- * selected fields (which differ per call). Built by ONE function so the
- * field list, the click gate, the drop gate, and the matrix editor judge
- * the same card from the same facts: the same join plan (the authored
- * one, which is also right for matrix cards), the same auto-resolved
- * base, the same relationship map, aliases, labels, mode, and data-source
- * anchor. A caller that assembles these by hand will eventually disagree
- * with the others; do not.
- */
-export type FieldAvailabilityContext = Omit<FieldStateContext, 'selectedFields'> & {
-    /** The semantic domain the card reads, when any. */
-    semanticDomainId?: string;
-};
-export declare function buildFieldAvailabilityContext(input: {
-    card: Pick<TCard, 'type' | 'config' | 'dataSource'> | null | undefined;
-    joinabilityData?: JoinabilityMapResponse | null;
-    autoJoinMetadata?: AutoJoinMetadata;
-    /** Labels the caller knows from elsewhere (entity groups); catalog labels win. */
-    extraDatasetLabels?: Record<string, string>;
-}): FieldAvailabilityContext;

package/dist/types/lib/utils/field-icon-utils.d.ts

@@ -1,10 +0,0 @@
-/**
- * Field Icon Utilities
- *
- * Centralized utility for displaying field icons with consistent styling.
- * Used across the application for field visualization (fields list,
- * trigger selector, drag overlays, etc.). Delegates to the canonical
- * monochrome `TypeGlyph` primitive so a single change here propagates
- * everywhere a field icon is rendered.
- */
-export declare function getFieldIconComponent(dataType: string | undefined): import("react").JSX.Element;

package/dist/types/lib/utils/field-state-calculator.d.ts

@@ -1,159 +0,0 @@
-import { Field, JoinPlan } from '../types/explorer-types.js';
-import { JoinabilityMap } from '../types/semantic-types.js';
-import { AutoJoinMetadata } from '../types/query-types.js';
-import { resolveFieldDatasetDependencies, FieldDatasetDependency } from './field-dependencies.js';
-import { getQualifiedEntityName } from './qualified-entity-name.js';
-export interface DatasetIdentityAlias {
-    name: string;
-    table?: string | null;
-    catalog?: string | null;
-    schema?: string | null;
-}
-/**
- * Field draggability states for the query builder
- *
- * - **base**: Field is from the base dataset (first dataset selected)
- * - **draggable**: Field has a direct relationship to base dataset (1-hop)
- * - **indirect**: Field requires a multi-hop join (2-hop via intermediate dataset)
- * - **setup**: A relationship exists but the engine will not use it on its
- *   own (not set to auto-join). The user can fix this; until then the field
- *   is blocked exactly like `unreachable`.
- * - **unreachable**: No relationship path exists to this field's dataset
- *
- * Calculated fields take the worst state among the datasets they read from.
- */
-export type FieldDraggableState = 'base' | 'draggable' | 'indirect' | 'setup' | 'unreachable'
-/**
- * Nothing is on the shelves and the dataset is not one of the chart's
- * data-source datasets. Not a fault to fix: the customer chose their
- * datasets and this field reads another one. Blocked, with the path to
- * using it (add the dataset) offered as information.
- */
- | 'absent';
-/** Per-dataset availability, attached to calculated-field results. */
-export interface FieldDependencyState {
-    /** Catalog dataset name. */
-    entityName: string;
-    /** Customer-facing dataset label. */
-    label: string;
-    state: FieldDraggableState;
-    /** Customer-facing sentence when the dataset is not simply available. */
-    reason?: string;
-}
-/**
- * Result of field state calculation
- */
-export interface FieldStateResult {
-    /** The calculated draggability state */
-    state: FieldDraggableState;
-    /** For indirect joins: the path through intermediate datasets */
-    joinPath?: string[];
-    /** Short tooltip text explaining the state (row `title`). */
-    tooltip?: string;
-    /**
-     * Customer-facing explanation when the field cannot be added as-is.
-     * Precise: names the dataset and the actual problem.
-     */
-    reason?: string;
-    /** The one thing the user can do about `reason`, when there is one. */
-    action?: string;
-    /**
-     * Dataset labels that `reason` mentions, so the UI can set them off from
-     * the surrounding sentence (a chip) without parsing the text.
-     */
-    mentions?: string[];
-    /**
-     * Non-blocking caution from governed catalog metadata, for example a
-     * one-to-many join that can repeat an aggregate. Shown in the preview.
-     */
-    warning?: string;
-    /**
-     * Datasets a calculated field reads from, each with its own state.
-     * Undefined for base fields (their dataset is their group).
-     */
-    dependencies?: FieldDependencyState[];
-    /**
-     * False when availability could not be checked (relationship map still
-     * loading, or a dependency could not be traced). UI must not present
-     * such a field as verified-ready.
-     */
-    verified?: boolean;
-    /** Indicates if this field is already selected/in the query */
-    isSelected?: boolean;
-}
-/** States that block adding the field to the query. */
-export declare function isBlockedFieldState(state: FieldDraggableState | undefined): boolean;
-export interface FieldStateContext {
-    joinabilityMap: JoinabilityMap | null;
-    selectedFields: Field[];
-    joinPlan?: JoinPlan;
-    autoJoinMetadata?: AutoJoinMetadata;
-    baseEntityName?: string;
-    datasetAliases?: DatasetIdentityAlias[];
-    /**
-     * Whether the card reads from a semantic domain. Drives the fallback when
-     * `joinabilityMap` is null:
-     *   - true  -> the map is still loading: report `verified: false`.
-     *   - false -> physical datasets: reachability comes from the join plan.
-     *   - undefined (legacy callers) -> everything draggable, as before.
-     */
-    hasSemanticDomain?: boolean;
-    /** Customer-facing dataset labels keyed by dataset name. */
-    datasetLabels?: Record<string, string>;
-    /**
-     * The datasets the chart's data source lists (`DataSource.selectedEntities`),
-     * in order. When nothing is on the shelves yet, these ARE the chart's
-     * datasets: a calculated field's dependencies are judged against them,
-     * so the card talks about the dataset the customer actually picked
-     * instead of the calculation's own first input.
-     */
-    dataSourceEntities?: DatasetAnchorRef[];
-}
-/** Minimal entity reference the calculator needs to identify a dataset. */
-export type DatasetAnchorRef = Parameters<typeof getQualifiedEntityName>[0];
-/**
- * Customer-facing words for a state, in one place. The row tag under a
- * dependency and the title of the refusal toast both read from here.
- */
-export declare function getFieldStateCopy(state: FieldDraggableState | undefined): {
-    /** Short tag beside a blocking dependency; null when nothing blocks. */
-    tag: string | null;
-    /** Title of the refusal toast. */
-    toastTitle: string;
-};
-/**
- * Calculate the draggability state for a field in the query builder
- *
- * This determines whether a field can be dragged based on:
- * - Current selected fields (what's already in the query)
- * - Joinability map (what relationships exist between datasets)
- * - For calculated fields: the datasets their inputs read from
- *
- * **Fallback behavior**:
- * - No joinability map and no `hasSemanticDomain` flag: all fields draggable
- *   (legacy callers, no restrictions)
- * - No fields selected yet: base fields are draggable (first selection
- *   establishes the base dataset); calculated fields are judged against the
- *   data source's datasets when there are any, else against their own first
- *   dataset
- */
-export declare function calculateFieldState(field: Field, context: FieldStateContext): FieldStateResult;
-/** One data-source dataset's connection to the visual's base, for the Datasets panel. */
-export interface DataSourceConnection {
-    /** Dataset identity (name in semantic mode, qualified table in physical). */
-    entityName: string;
-    label: string;
-    state: FieldDraggableState;
-    reason?: string;
-    action?: string;
-    mentions?: string[];
-}
-/**
- * How each selected dataset connects to the visual's base dataset, using
- * the same identity, base cascade, and per-dataset evaluation as the field
- * list. The Datasets panel shows this at selection time so the customer
- * learns about an unconnected dataset before the first drag. Order and
- * verdicts match `calculateFieldState` for a field of that dataset.
- */
-export declare function describeDataSourceConnections(context: FieldStateContext): DataSourceConnection[];
-export { resolveFieldDatasetDependencies, type FieldDatasetDependency };

package/dist/types/lib/utils/filter-formatter.d.ts

@@ -1,24 +0,0 @@
-import { TFilterValue } from '../../components/surfboard/filter/types.js';
-type FormatFilterLineOptions = {
-    timezone?: string;
-};
-/**
- * The filter line heads a PDF and travels in export requests, so a long
- * multi-select is summarized rather than listed in full.
- */
-export declare const FILTER_LINE_MAX_LISTED_VALUES = 10;
-/**
- * Converts an array of filter values into a human-readable filter line
- * @param filterValues Array of TFilterValue objects
- * @returns Human-readable filter description string
- */
-export declare function formatFilterLine(filterValues: TFilterValue[], options?: FormatFilterLineOptions): string;
-/**
- * Formats a date range filter into a readable string
- * @param startDate Start date
- * @param endDate End date
- * @param fieldName Name of the date field
- * @returns Formatted date range string
- */
-export declare function formatDateRange(startDate: Date | string, endDate: Date | string, fieldName?: string): string;
-export {};

package/dist/types/lib/utils/filter-metadata-utils.d.ts

@@ -1,28 +0,0 @@
-import { DataSource, Field, FilterGroup } from '../types/explorer-types.js';
-import { FilterFieldMeta, FilterSemanticContext, TFilter } from '../../components/surfboard/filter/types.js';
-import { TInlineFilter } from '../types/common-types.js';
-import { NativeDataTypeDefinition } from '../../shared/filter-native-data-type.js';
-export { materializeFilterDefinitionNativeDataType, materializeFilterValueNativeDataType, materializeFilterValuesNativeDataType, resolveFilterFieldNativeDataType, } from '../../shared/filter-native-data-type.js';
-/**
- * Builds the metadata update for moving a filter definition to another field.
- * Target columns do not carry exact catalog metadata, so the previous field's
- * native type must be cleared until the server proves the new field's type.
- */
-export declare function buildFilterFieldRetarget(definition: NativeDataTypeDefinition, fieldName: string): Pick<TFilter, 'column' | 'nativeDataType'> & {
-    fieldMeta?: FilterFieldMeta;
-};
-export declare function buildFilterFieldMeta(field: Field): FilterFieldMeta;
-export declare function buildFilterSemanticContext(dataSource?: DataSource | null, fallback?: {
-    connectionId?: string;
-    connectionType?: string;
-}, field?: Field): FilterSemanticContext | undefined;
-export declare function getFilterSourceDatabase(dataSource: DataSource | null | undefined, context: FilterSemanticContext | undefined, field: Field): string | undefined;
-type StoredFilterFieldDefinition = {
-    column: string;
-    fieldMeta?: FilterFieldMeta;
-};
-export declare function doesStoredFilterMatchField(storedFilter: StoredFilterFieldDefinition, field: Field): boolean;
-export declare function rewriteStoredFilterForPromotedField<TStoredFilter extends StoredFilterFieldDefinition>(storedFilter: TStoredFilter, promotedField: Field, editingField?: Field): TStoredFilter;
-export declare function rewriteStoredFiltersForPromotedField(filters: TFilter[] | undefined, promotedField: Field, editingField?: Field): TFilter[] | undefined;
-export declare function rewriteInlineFiltersForPromotedField(filters: TInlineFilter[] | undefined, promotedField: Field, editingField?: Field): TInlineFilter[] | undefined;
-export declare function rewriteFilterGroupForPromotedField(group: FilterGroup | null | undefined, promotedField: Field, editingField?: Field): FilterGroup | null | undefined;

package/dist/types/lib/utils/filter-name-utils.d.ts

@@ -1,27 +0,0 @@
-import { Field } from '../types/explorer-types.js';
-export type QualifiedFilterNamesResult = {
-    qualifiedColumnName: string;
-    qualifiedTableName: string;
-    formattedColumnName: string;
-};
-/**
- * Builds qualified column and table names for filter assignment.
- * Uses Field's qualifiedFieldName and qualifiedEntityName directly.
- *
- * @param field - Field object with qualifiedFieldName, qualifiedEntityName, and name
- *
- * @example
- * buildQualifiedFilterNames(field)
- * // field = { name: 'event_type', qualifiedFieldName: 'semaphor.telemetry.token_events.event_type', ... }
- * // => {
- * //   qualifiedColumnName: 'semaphor.telemetry.token_events.event_type',
- * //   qualifiedTableName: 'semaphor.telemetry.token_events',
- * //   formattedColumnName: '"event_type"'
- * // }
- *
- * @example
- * // Mixed-case identifiers are quoted for PostgreSQL compatibility
- * // field = { qualifiedEntityName: 'SalesDB.Public.Events', ... }
- * // => { qualifiedTableName: '"SalesDB"."Public"."Events"' }
- */
-export declare function buildQualifiedFilterNames(field: Field): QualifiedFilterNamesResult;

package/dist/types/lib/utils/filter-scoping-utils.d.ts

@@ -1,64 +0,0 @@
-import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
-/**
- * Normalize column name for comparison by stripping quotes.
- * This ensures backward compatibility if any old filters stored quoted column names.
- *
- * @param name - Column name that may contain quotes
- * @returns Column name with quotes stripped
- */
-export declare function normalizeColumnName(name: string): string;
-/**
- * Normalize qualified table name for comparison by stripping quotes.
- * This keeps legacy filters with quoted table names compatible with new ones.
- *
- * @param name - Qualified table name that may contain quotes
- * @returns Qualified table name with quotes stripped
- */
-export declare function normalizeQualifiedTableName(name: string): string;
-/**
- * Apply sheet-level scoping to filters.
- * Returns filters that apply to the given sheet based on the new scoping system.
- *
- * Scoping logic:
- * 1. Backward compatibility: Checks legacy `sheetId` property first
- * 2. Checks new `applyToSheetIds` (only specific sheets)
- * 3. Checks new `excludeSheetIds` (all except specific sheets)
- * 4. Default: Applies to all sheets if no scope properties are set
- *
- * @param filters - Array of filters to scope
- * @param selectedSheetId - ID of the sheet to scope to
- * @returns Array of filters that apply to the given sheet
- */
-export declare function getSheetScopedFilters(filters: TFilter[] | undefined, selectedSheetId: string | null | undefined): TFilter[];
-type GetSheetScopedFilterValuesOptions = {
-    includeCardScoped?: boolean;
-};
-export declare function isSheetScopedAdHocFilter(filterId: string, selectedSheetId: string | null | undefined): boolean;
-export declare function getSheetScopedFilterValues(filters: TFilter[] | undefined, filterValues: TFilterValue[] | undefined, selectedSheetId: string | null | undefined, options?: GetSheetScopedFilterValuesOptions): TFilterValue[];
-/**
- * Checks if a filter with the given qualified column name exists within a specific sheet's scope.
- * Used for duplicate detection when creating sheet-local filters.
- *
- * This enables the feature where the same column can have multiple filters
- * across different sheets, while preventing duplicates within the same sheet.
- *
- * @param filters - All dashboard filters
- * @param qualifiedColumnName - Fully qualified column name (e.g., "database.schema.table.column")
- * @param qualifiedTableName - Fully qualified table name for defensive check (e.g., "database.schema.table")
- * @param sheetId - Target sheet ID to check within
- * @returns The conflicting filter, or undefined if no conflict
- *
- * @example
- * // Check if filter for "semaphor.telemetry.token_events.event_type" exists on sheet-1
- * const conflict = filterExistsInSheet(
- *   filters,
- *   "semaphor.telemetry.token_events.event_type",
- *   "semaphor.telemetry.token_events",
- *   "sheet-1"
- * );
- * if (conflict) {
- *   console.log("Filter already exists on this sheet");
- * }
- */
-export declare function filterExistsInSheet(filters: TFilter[], qualifiedColumnName: string, qualifiedTableName: string, sheetId: string): TFilter | undefined;
-export {};

package/dist/types/lib/utils/filter-search-sql.d.ts

@@ -1,17 +0,0 @@
-import { Dialect } from '../types/explorer-types.js';
-/**
- * Generates a case-insensitive text search condition for a column
- * @param column - The column name to search
- * @param searchTerm - The search term (already SQL-escaped)
- * @param dialect - The database dialect
- * @returns SQL condition string for text search
- */
-export declare function buildTextSearchCondition(column: string, searchTerm: string, dialect?: Dialect): string;
-/**
- * Parses a numeric operator query and generates SQL condition
- * @param column - The column name
- * @param query - The user query (e.g., ">100", "<=50", "=100")
- * @param dialect - The database dialect (optional, affects casting)
- * @returns SQL condition string or null if invalid
- */
-export declare function buildNumericCondition(column: string, query: string, dialect?: Dialect): string | null;