react-semaphor 0.1.533 → 0.1.535

package/dist/types/lib/utils/card-calculated-field-utils.d.ts

@@ -1,12 +0,0 @@
-import { Field, GroupByField, MetricField } from '../types/explorer-types.js';
-export declare function resolveCardCalculatedFieldForEdit(field: Field, options: {
-    storedCalculatedFields: Field[];
-    metricFields: MetricField[];
-    groupByFields: GroupByField[];
-}): MetricField | GroupByField | undefined;
-export declare function resolveDomainCalculatedFieldForEdit(field: Field, availableFields: Field[]): MetricField | GroupByField | undefined;
-export declare function mergeConfiguredCalculatedFieldSelection<TField extends Field>(existingField: TField, nextField: TField): TField;
-export declare function upsertCardCalculatedFieldInConfig<TField extends Field>(fields: TField[], field: TField, matchField?: Field, options?: {
-    allowComparableFallback?: boolean;
-    mergeMatchedField?: (existing: TField, next: TField) => TField;
-}): TField[] | null;

package/dist/types/lib/utils/card-config-utils.d.ts

@@ -1,24 +0,0 @@
-import { CardConfig, DataSource, FilterGroup, JoinPlan } from '../types/explorer-types.js';
-import { TCard } from '../types/common-types.js';
-/** Matrix acquisition requires its structured definition, never an authored SQL query. */
-export declare function supportsSqlEditor(cardType: TCard['type']): boolean;
-/** Crossing this representation boundary starts a fresh query, not an implicit migration. */
-export declare function resetMatrixRepresentation(card: TCard, nextType: TCard['type']): Partial<TCard>;
-/** Replacing the base dataset starts a new definition; metadata refresh does not. */
-export declare function withAuthoredCardDataSource(card: TCard, dataSource: DataSource): Partial<TCard>;
-export declare function getAuthoredCardJoinPlan(card: Pick<TCard, 'type' | 'config'>): JoinPlan | undefined;
-/** The normal join editor writes the canonical definition, including empty drafts. */
-export declare function withAuthoredCardJoinPlan(card: Pick<TCard, 'type' | 'config' | 'dataSource'>, joinPlan: JoinPlan | undefined): CardConfig;
-/** Authored predicates from the card's canonical representation. */
-export declare function getAuthoredCardFilters(card: Pick<TCard, 'type' | 'config'> | undefined): FilterGroup | undefined;
-export declare function withAuthoredCardFilters(card: Pick<TCard, 'type' | 'config' | 'dataSource'>, filters: FilterGroup | undefined): CardConfig;
-/**
- * Checks if a card config object has actual configuration data
- * An empty config object {} should be treated as no config
- */
-export declare function hasValidCardConfig(config: CardConfig | undefined, cardType?: TCard['type']): boolean;
-type CardSetupCheckOptions = {
-    skipSetupCheck?: boolean;
-};
-export declare function isCardUnconfigured(card: Pick<TCard, 'type' | 'sql' | 'config' | 'connectionId' | 'dataSource' | 'customCardPreferences'>, options?: CardSetupCheckOptions): boolean;
-export {};

package/dist/types/lib/utils/card-loading-state.d.ts

@@ -1,18 +0,0 @@
-import { TCard } from '../types/common-types.js';
-type CardLoadingPresentationInput = {
-    card: Pick<TCard, 'type'> | undefined;
-    fetchStatus?: 'fetching' | 'paused' | 'idle';
-    isLoading?: boolean;
-    isFetching?: boolean;
-    isPending?: boolean;
-    hasRecords?: boolean;
-};
-export declare function shouldUseCardSkeletonDuringRefetch(card: Pick<TCard, 'type'> | undefined): boolean;
-export declare function showsOwnRefetchCue(card: Pick<TCard, 'type'> | undefined): boolean;
-export declare function getCardLoadingPresentation({ card, fetchStatus, isLoading, isFetching, isPending, hasRecords, }: CardLoadingPresentationInput): {
-    isBusy: boolean;
-    showCardSkeleton: boolean;
-    showGenericLoadingFallback: boolean;
-    showStaleDataOverlay: boolean;
-};
-export {};

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

@@ -1,70 +0,0 @@
-import { TDashboard, TCard, TSheet } from '../types/common-types.js';
-export type DashboardCardEntry = {
-    card: TCard;
-    sheet: TSheet;
-    /** Set when the card sits in a frame. */
-    frameId?: string;
-    /** Set when the card belongs to a document section (a section may own several cards). */
-    sectionId?: string;
-};
-/** Dashboard cards: sheet cards and frame cards. Document section cards are not included. */
-export declare function getDashboardCardEntries(dashboard: Pick<TDashboard, 'sheets'>): DashboardCardEntry[];
-/**
- * Every card a dashboard hosts, with where it sits: sheet cards, frame cards,
- * and every card of a document section. Use this, not
- * `getDashboardCardEntries`, when a card may be reached by a scope that names
- * document sections.
- */
-export declare function getDashboardCardLocations(dashboard: Pick<TDashboard, 'sheets'>): DashboardCardEntry[];
-export declare function getDashboardCards(dashboard: Pick<TDashboard, 'sheets'>): TCard[];
-/**
- * Check if a card ID is unique across the entire dashboard
- * @param dashboard - The dashboard to check against
- * @param cardId - The proposed card ID
- * @param currentCardId - The current card ID (to exclude from check when editing)
- * @returns true if the ID is unique, false otherwise
- */
-export declare function isCardIdUnique(dashboard: TDashboard, cardId: string, currentCardId?: string): boolean;
-/**
- * Validate card ID format
- * @param cardId - The card ID to validate
- * @returns An object with isValid flag and error message if invalid
- */
-export declare function validateCardId(cardId: string): {
-    isValid: boolean;
-    error?: string;
-};
-/**
- * Sanitize user input for card ID
- * Converts to lowercase and replaces spaces with hyphens
- * @param input - The user input to sanitize
- * @returns Sanitized card ID
- */
-export declare function sanitizeCardId(input: string): string;
-/**
- * Get all card IDs in the dashboard
- * @param dashboard - The dashboard to extract IDs from
- * @returns Array of all card IDs
- */
-export declare function getAllCardIds(dashboard: TDashboard): string[];
-/**
- * Find a card by ID in the dashboard
- * @param dashboard - The dashboard to search in
- * @param cardId - The card ID to find
- * @returns The card if found, undefined otherwise
- */
-export declare function findCardById(dashboard: TDashboard, cardId: string): TCard | undefined;
-/**
- * A dashboard card (sheet or frame) by id. Document section cards are not
- * included: they need their section for input resolution, so they are found
- * through section-aware lookups (for example the dashboard input snapshot's
- * section targets). Phase 1.2 routes KPI card execution through those.
- */
-export declare function findCardLocationById(dashboard: TDashboard, cardId: string): {
-    card: TCard;
-    sheet: TSheet;
-} | undefined;
-export declare function findFrameCardLocationById(dashboard: TDashboard, cardId: string): {
-    card: TCard;
-    sheet: TSheet;
-} | undefined;

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

@@ -1,26 +0,0 @@
-import { default as React } from 'react';
-import { BulletChartIcon } from '../../components/icons/bullet-chart-icon.js';
-export declare const chartTypes: ({
-    id: string;
-    icon: React.ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
-    label: string;
-} | {
-    id: string;
-    icon: import('react-icons/lib').IconType;
-    label: string;
-} | {
-    id: string;
-    icon: typeof BulletChartIcon;
-    label: string;
-})[];
-/**
- * Auto-detect chart type from component name
- * Checks if the lowercase name contains any standard chart type IDs
- * Special handling for doughnut/donut spelling variations
- */
-export declare const getAutoDetectedChartIcon: (componentName: string) => React.ReactElement<any> | null;
-/**
- * Get chart icon component by chart type ID
- * Returns the icon component for a specific chart type
- */
-export declare const getChartIconByType: (chartType: string, className?: string) => React.ReactElement<any>;

package/dist/types/lib/utils/chart-type-field-validation.d.ts

@@ -1,25 +0,0 @@
-import { Field, ContainerId } from '../types/explorer-types.js';
-import { TChartType } from '../charts/types.js';
-export interface FieldValidationResult {
-    isValid: boolean;
-    reason?: string;
-}
-/**
- * Validates if a field can be dropped/added to a container for a specific chart type.
- * This centralizes all chart-type-specific field validation logic.
- *
- * @param field - The field to validate
- * @param containerId - The target container (groupBy, metrics, pivotBy, sortBy)
- * @param chartType - The current chart type
- * @returns Validation result with optional reason for rejection
- */
-export declare function validateFieldForChartType(field: Field, containerId: ContainerId, chartType: TChartType): FieldValidationResult;
-/**
- * Checks if a field is compatible with the current chart type
- * This is used for visual feedback (e.g., disabling fields in the field list)
- *
- * @param field - The field to check
- * @param chartType - The current chart type
- * @returns true if the field can be used with this chart type
- */
-export declare function isFieldCompatibleWithChartType(field: Field, chartType: TChartType): boolean;

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

@@ -1,31 +0,0 @@
-import { TCard } from '../types/common-types.js';
-import { QueryColumnKeyMap } from '../types/explorer-types.js';
-import { ComparisonMetadataMap } from '../types/query-types.js';
-import { ComparisonPresentationSpec } from '../../shared/analytics-protocol/index.js';
-export type ComparisonExportProjection = {
-    excludedKeys: Set<string>;
-    selectedDerivedKeys: Set<string>;
-    columnLabels: Map<string, string>;
-    columnPresentationOwners: Map<string, {
-        metricId: string;
-        metricAlias: string;
-        kind: 'comparison' | 'delta' | 'percent_change' | 'ratio';
-    }>;
-};
-export declare function getComparisonExportProjection(params: {
-    comparisonMetadata?: ComparisonMetadataMap;
-    presentation?: ComparisonPresentationSpec;
-    resolveMetricName?: (identity: {
-        metricId: string;
-        metricAlias: string;
-    }) => string | undefined;
-}): ComparisonExportProjection;
-export declare function getCardComparisonExportProjection(params: {
-    card?: TCard;
-    comparisonMetadata?: ComparisonMetadataMap;
-    columnKeyMap?: QueryColumnKeyMap;
-}): ComparisonExportProjection;
-export declare function hasComparisonExportMetadataGap(params: {
-    card: TCard;
-    comparisonMetadata?: ComparisonMetadataMap;
-}): boolean;

package/dist/types/lib/utils/comparison-output-keys.d.ts

@@ -1,37 +0,0 @@
-import { ComparisonMetadataMap } from '../types/query-types.js';
-import { MetricField } from '../types/explorer-types.js';
-import { ComparisonPresentationSpec, MetricComparisonOutput } from '../../shared/analytics-protocol/index.js';
-import { MetricComparisonKind } from './metric-comparison-config.js';
-type MetricOutputIdentity = {
-    id?: string;
-    name?: string;
-    alias?: string;
-};
-export declare function getComparisonMetadataForMetric(comparisonMetadata: ComparisonMetadataMap | undefined, metric: MetricOutputIdentity): import('../../shared/analytics-protocol/index.js').MetricComparisonMetadataEntry | undefined;
-/**
- * Resolves the comparison identity a result renderer should present.
- * Canonical execution metadata wins because inherited comparisons intentionally
- * have no metric-level authoring config. The authored kind is only a fallback
- * for callers rendering before canonical metadata is available.
- */
-export declare function resolveMetricComparisonRenderContext(comparisonMetadata: ComparisonMetadataMap | undefined, metric: MetricField): {
-    comparisonKind: MetricComparisonKind;
-    metadata: ReturnType<typeof getComparisonMetadataForMetric>;
-};
-export declare function showsComparisonPresentation(presentation?: ComparisonPresentationSpec): boolean;
-export declare function getPresentedComparisonOutputKeys(output: MetricComparisonOutput, presentation?: ComparisonPresentationSpec): Set<string>;
-export type ComparisonOutputKeySets = {
-    internalKeys: Set<string>;
-    bookkeepingKeys: Set<string>;
-    comparisonColumnKeys: Set<string>;
-    deltaColumnKeys: Set<string>;
-    percentChangeColumnKeys: Set<string>;
-    ratioColumnKeys: Set<string>;
-    comparisonSeriesLabels: Map<string, {
-        metricName: string;
-        comparisonLabel: string;
-    }>;
-};
-export declare function getComparisonOutputKeySets(comparisonMetadata?: ComparisonMetadataMap): ComparisonOutputKeySets;
-export declare function isInternalComparisonOutputKey(key: string, comparisonMetadata?: ComparisonMetadataMap): boolean;
-export {};

package/dist/types/lib/utils/comparison-period-utils.d.ts

@@ -1,6 +0,0 @@
-export type ComparisonPeriod = {
-    start: string;
-    end: string;
-};
-export declare function formatComparisonDate(dateString: string | null | undefined, _displayTimezone?: string): string | null;
-export declare function formatComparisonPeriodRange(period: ComparisonPeriod | undefined, displayTimezone?: string): string | null;

package/dist/types/lib/utils/comparison-validation-utils.d.ts

@@ -1,16 +0,0 @@
-import { CardConfig } from '../types/explorer-types.js';
-import { TChartType } from '../charts/types.js';
-/**
- * Validates that a card configuration has a valid comparison setup.
- *
- * This function performs two checks:
- * 1. Chart type check: Ensures the chart type supports comparison mode
- * 2. Date field check: If period comparison is enabled, ensures at least one date field exists in groupBy
- *
- * If validation fails, returns a corrected config with comparison type reset to 'none'.
- *
- * @param cardConfig - The card configuration to validate
- * @param chartType - The type of chart
- * @returns The validated card configuration with ineligible metric specs cleared.
- */
-export declare function validateComparisonConfig(cardConfig: CardConfig, chartType: TChartType): CardConfig;

package/dist/types/lib/utils/comparison-window-caption.d.ts

@@ -1,12 +0,0 @@
-import { MetricComparisonWindowGrain } from '../../shared/analytics-protocol/index.js';
-export declare function formatCanonicalComparisonRange(period: {
-    start: string;
-    end: string;
-}, timezone: string, windowGrain: MetricComparisonWindowGrain | undefined, short?: boolean): string;
-export declare function formatCanonicalComparisonBoundaries(period: {
-    start: string;
-    end: string;
-}, timezone: string, windowGrain: MetricComparisonWindowGrain | undefined, short?: boolean): {
-    start: string;
-    end: string;
-};

package/dist/types/lib/utils/connection-capabilities.d.ts

@@ -1,26 +0,0 @@
-import { TDbCapabilities } from '../types/common-types.js';
-/**
- * Build qualified table name using prefixLevels from capabilities.
- * Backend always provides prefixLevels, so no fallback lookup needed.
- *
- * @example
- * // PostgreSQL with prefixLevels: ['schema', 'table']
- * buildQualifiedTableName({ capabilities, database: 'mydb', schema: 'public', table: 'orders' })
- * // => 'public.orders'
- *
- * @example
- * // Snowflake with prefixLevels: ['database', 'schema', 'table']
- * buildQualifiedTableName({ capabilities, database: 'analytics', schema: 'reporting', table: 'orders' })
- * // => 'analytics.reporting.orders'
- *
- * @example
- * // S3/API with prefixLevels: ['table']
- * buildQualifiedTableName({ capabilities, table: 'data.csv' })
- * // => 'data.csv'
- */
-export declare function buildQualifiedTableName({ capabilities, database, schema, table, }: {
-    capabilities: TDbCapabilities;
-    database?: string;
-    schema?: string;
-    table: string;
-}): string;

package/dist/types/lib/utils/control-default-value-utils.d.ts

@@ -1,46 +0,0 @@
-import { ControlDefinition, TDashboard } from '../types/common-types.js';
-export declare function shouldUseSavedDefault(control: ControlDefinition): boolean;
-export type RuntimeControlHydration = {
-    dashboardControlValues: Record<string, unknown>;
-    cardControlValuesMap: Record<string, Record<string, unknown>>;
-};
-export declare function flattenRuntimeControlValues(params: {
-    dashboardValues?: Record<string, unknown>;
-    cardValuesMap?: Record<string, Record<string, unknown>>;
-}): Record<string, unknown>;
-export declare function computeDashboardControlDefaults(dashboard: TDashboard): Record<string, unknown>;
-export declare function computePersistedDashboardDefaultValues(params: {
-    controls: ControlDefinition[] | undefined;
-    dashboardDefaultValues?: Record<string, unknown>;
-}): Record<string, unknown>;
-export declare function syncDashboardDefaultValuesIntoControls(params: {
-    controls: ControlDefinition[] | undefined;
-    dashboardDefaultValues?: Record<string, unknown>;
-}): ControlDefinition[];
-export declare function resolveSavedDefaultValue(control: ControlDefinition, dashboardDefaultValues?: Record<string, unknown>): unknown;
-export declare function computeCardControlDefaults(dashboard: TDashboard): Record<string, Record<string, unknown>>;
-export declare function computeRuntimeControlHydration(dashboard: TDashboard, runtimeOverrides?: Record<string, unknown>, options?: {
-    hasExplicitRuntimeOverrides?: boolean;
-}): RuntimeControlHydration;
-export declare function mergeRelevantControlValues(params: {
-    relevantControlIds: Iterable<string>;
-    dashboardValues?: Record<string, unknown>;
-    cardValues?: Record<string, unknown>;
-}): Record<string, unknown>;
-export declare function reconcileDashboardControlRuntimeValues(params: {
-    previousValues: Record<string, unknown>;
-    nextControls: ControlDefinition[];
-    nextDefaultValues?: Record<string, unknown>;
-    renamed?: {
-        oldId: string;
-        newId: string;
-    };
-}): Record<string, unknown>;
-export declare function reconcileCardControlRuntimeValues(params: {
-    previousValues: Record<string, unknown> | undefined;
-    nextControls: ControlDefinition[];
-    renamed?: {
-        oldId: string;
-        newId: string;
-    };
-}): Record<string, unknown>;

package/dist/types/lib/utils/control-placeholder-utils.d.ts

@@ -1,14 +0,0 @@
-import { ControlBinding } from '../types/common-types.js';
-export type SqlParamReference = {
-    paramId: string;
-    controlId: string;
-};
-export declare function extractParamControlIdsFromSql(sql?: string): string[];
-export declare function extractReferencedControlIds(params: {
-    sql?: string;
-    controlBindings?: ControlBinding[];
-}): string[];
-export declare function extractSqlParamReferences(params: {
-    sql?: string;
-    controlBindings?: ControlBinding[];
-}): SqlParamReference[];

package/dist/types/lib/utils/control-reference-utils.d.ts

@@ -1,18 +0,0 @@
-import { ControlBinding, TCard, TDashboard } from '../types/common-types.js';
-type ControlMutation = {
-    type: 'rename';
-    oldId: string;
-    newId: string;
-} | {
-    type: 'remove';
-    controlId: string;
-};
-export declare function renameControlBindings(bindings: ControlBinding[] | undefined, oldId: string, newId: string): ControlBinding[] | undefined;
-export declare function removeControlBindings(bindings: ControlBinding[] | undefined, controlId: string): ControlBinding[] | undefined;
-export declare function renameDirectSqlControlReferences(sql: string | undefined, oldId: string, newId: string): string | undefined;
-export declare function applyControlMutationToCard(card: TCard, mutation: ControlMutation): TCard;
-export declare function applyControlMutationToDashboard(dashboard: TDashboard, mutation: ControlMutation): TDashboard;
-export declare function applyControlBindingsToDashboardCards(dashboard: TDashboard, cardBindingsById: Record<string, ControlBinding[] | undefined>, options?: {
-    affectedControlIds?: string[];
-}): TDashboard;
-export {};

package/dist/types/lib/utils/copy-control-bindings.d.ts

@@ -1,3 +0,0 @@
-import { ControlBinding, TCard } from '../types/common-types.js';
-/** Preserve the query's parameter names when its backing controls are copied. */
-export declare function copyControlBindings(card: Pick<TCard, 'sql' | 'controlBindings'>, copiedControlIds: ReadonlyMap<string, string>): ControlBinding[] | undefined;

package/dist/types/lib/utils/custom-visual-inputs.d.ts

@@ -1,43 +0,0 @@
-import { TCard, TFrame } from '../types/common-types.js';
-import { CustomVisualInputResult, SlotDefinition } from '../../components/visual/custom-visual/custom-visual-types.js';
-import { TChartType } from '../charts/types.js';
-type ManifestVisualMeta = {
-    visualType?: 'single' | 'multiple';
-    slots?: unknown[];
-    minInputs?: number;
-    maxInputs?: number;
-    dataInputs?: string[];
-};
-type GetInputCardsOptions = {
-    frame: TFrame;
-    configCard?: TCard | null;
-    isMultiInputVisual?: boolean;
-};
-type MultiInputVisualConfig = {
-    url: string;
-    name: string;
-    icon?: string;
-    chartType?: string;
-    minInputs?: number;
-    maxInputs?: number;
-    dataInputs?: string[];
-    visualType?: 'single' | 'multiple';
-    slots?: SlotDefinition[];
-};
-export declare function getSlotExpectedChartType(slot?: SlotDefinition): TChartType;
-export declare function getConfigSlotDefinition(slots?: SlotDefinition[]): SlotDefinition | undefined;
-export declare function getSlotDefinitionForIndex(slots: SlotDefinition[] | undefined, index: number): SlotDefinition | undefined;
-export declare function getSlotExpectedTypeForIndex(slots: SlotDefinition[] | undefined, index: number): TChartType | undefined;
-export declare function getSlotIndexForCard(card: TCard | null | undefined, fallbackIndex: number): number;
-export declare function isCustomVisualConfigCard(card: TCard | null | undefined, frameCards?: TCard[]): boolean;
-export declare function buildSlotOrderedCards(cards: Array<TCard | null>): Array<TCard | null>;
-export declare function reindexSlotCards(cards: TCard[]): TCard[];
-export declare function getConfigSlotExpectedType(slots?: SlotDefinition[]): TChartType | undefined;
-export declare function getEffectiveCardTypeForSlot(inputCard: TCard | null | undefined, slotIndex: number, slots: SlotDefinition[] | undefined): TChartType | undefined;
-export declare function createCardsFromSlots(slots: SlotDefinition[], visual: MultiInputVisualConfig, baseCard: TCard): TCard[];
-export declare function getCustomVisualInputCards({ frame, configCard, isMultiInputVisual, }: GetInputCardsOptions): Array<TCard | null>;
-export declare function findCustomVisualConfigCard(frame: TFrame, activeCard?: TCard | null): TCard | null;
-export declare function resolveMultiInputType(configCard: TCard | null, manifestComponent?: ManifestVisualMeta): 'single' | 'multiple' | null;
-export declare function resolveMultiInputTypeFromVisual(visual: MultiInputVisualConfig): 'single' | 'multiple';
-export declare function normalizeMultiInputPayload(data: CustomVisualInputResult | Record<string, unknown>[]): CustomVisualInputResult;
-export {};

package/dist/types/lib/utils/dashboard-controls-visibility.d.ts

@@ -1,23 +0,0 @@
-import { UIConfig } from '../types/token-types.js';
-type DashboardControlsVisibilityConfig = Pick<UIConfig, 'showDashboardHub' | 'showDashboardSharing' | 'showGroupManagement'>;
-export type DashboardControlsVisibility = {
-    showDashboardHub: boolean;
-    showDashboardSharing: boolean;
-    showGroupManagement: boolean;
-};
-export declare function isDashboardSharingVisible(config?: Pick<UIConfig, 'showDashboardSharing'>): boolean;
-export declare function resolveDashboardTitleEditability({ isDashboardEditing, canEditDashboard, }: {
-    isDashboardEditing: boolean;
-    canEditDashboard: boolean;
-}): boolean;
-/**
- * Resolves token-scoped dashboard chrome without weakening authorization.
- * Token flags can hide a permitted capability, but can never grant one.
- */
-export declare function resolveDashboardControlsVisibility({ config, canNavigateDashboardHub, canShareDashboard, canManageGroups, }: {
-    config?: DashboardControlsVisibilityConfig;
-    canNavigateDashboardHub: boolean;
-    canShareDashboard: boolean;
-    canManageGroups: boolean;
-}): DashboardControlsVisibility;
-export {};

package/dist/types/lib/utils/dashboard-date-filter-utils.d.ts

@@ -1,16 +0,0 @@
-import { Field } from '../types/explorer-types.js';
-import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
-import { getSelectedDateFilterColumn } from './date-filter-column-utils.js';
-import { DashboardInputValues, TCard, TDashboard } from '../types/common-types.js';
-import { DashboardCardFilterCompilationResult } from '../query-context/compile-dashboard-card-filters.js';
-export { getSelectedDateFilterColumn };
-export declare function hasMatchingCompiledDashboardDateFilter(card: TCard, compilation: DashboardCardFilterCompilationResult): boolean;
-export declare function hasMatchingDashboardDateFilter(dashboardFilters: TFilter[], dateGroupByField: Pick<Field, 'name' | 'qualifiedFieldName' | 'qualifiedEntityName'> | null | undefined, filterValues: TFilterValue[] | undefined): boolean;
-export declare function hasMatchingDashboardInputDateFilter({ dashboard, dateGroupByField, dashboardInputValues, sheetId, card, timezone, }: {
-    dashboard: TDashboard | undefined;
-    dateGroupByField: Field | undefined;
-    dashboardInputValues: DashboardInputValues | undefined;
-    sheetId?: string | null;
-    card?: TCard | null;
-    timezone?: string;
-}): boolean;

package/dist/types/lib/utils/dashboard-interaction-mode.d.ts

@@ -1,12 +0,0 @@
-export type DashboardInteractionMode = {
-    canEditDashboard: boolean | undefined;
-    hasInspectionUser: boolean;
-    isInspectionMode: boolean;
-    isInspectionSurface: boolean;
-    inspectionMessage: string | null;
-};
-export declare function resolveDashboardInteractionMode({ canEditDashboard, endUserId, inspection, }: {
-    canEditDashboard: boolean | undefined;
-    endUserId: string | undefined;
-    inspection: boolean | undefined;
-}): DashboardInteractionMode;

package/dist/types/lib/utils/data-source-semantic-domain.d.ts

@@ -1,12 +0,0 @@
-import { DataSource } from '../types/explorer-types.js';
-/**
- * The semantic domain a card's data source belongs to.
- *
- * `DataSource.semanticDomainId` is authoritative when set. Cards whose
- * datasets were picked from a domain may carry the domain only on the
- * selected entities, so fall back to the first dataset entity's `domainId`.
- * Every surface that decides "is this card semantic" (field list, click
- * and drop gates, column loader) must use this, so none of them can judge
- * the same card differently.
- */
-export declare function getDataSourceSemanticDomainId(dataSource: Pick<DataSource, 'semanticDomainId' | 'selectedEntities'> | null | undefined): string | undefined;

package/dist/types/lib/utils/data-source-utils.d.ts

@@ -1,22 +0,0 @@
-import { DataSource } from '../types/explorer-types.js';
-/**
- * Extract table metadata from the new data source structure
- * Provides compatibility with legacy SQL generation that expects table/schema/database names
- */
-export declare function extractTableMetadata(dataSource: DataSource | undefined): {
-    tableName: undefined;
-    schemaName: undefined;
-    databaseName: undefined;
-    connectionId: string | undefined;
-    connectionType: string | undefined;
-} | {
-    tableName: string;
-    schemaName: string | undefined;
-    databaseName: string | undefined;
-    connectionId: string;
-    connectionType: string;
-};
-/**
- * Check if we have sufficient table metadata for SQL generation
- */
-export declare function hasTableMetadata(dataSource: DataSource | undefined): boolean;

package/dist/types/lib/utils/date-filter-column-utils.d.ts

@@ -1,2 +0,0 @@
-import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
-export declare function getSelectedDateFilterColumn(filter: TFilter, filterValues: TFilterValue[] | undefined): string;

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

@@ -1,8 +0,0 @@
-import { DateFormatOption, TimeGranularity } from '../types/explorer-types.js';
-/**
- * Get available date format options for a specific granularity level
- *
- * @param granularity - Time granularity (day, week, month, quarter, year, hour, minute, second)
- * @returns Array of format options with value and label
- */
-export declare function getDateFormatOptionsForGranularity(granularity: TimeGranularity): DateFormatOption[];

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

@@ -1,5 +0,0 @@
-import { TimeGranularity } from '../types/explorer-types.js';
-export declare const DATE_GRANULARITY_OPTIONS: TimeGranularity[];
-export declare const DATE_TIME_GRANULARITY_OPTIONS: TimeGranularity[];
-export declare const supportsSubDayGranularity: (dataType?: string) => boolean;
-export declare const getGranularityOptionsForFieldType: (dataType?: string) => TimeGranularity[];

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

@@ -1,75 +0,0 @@
-import { Field, TimeGranularity } from '../types/explorer-types.js';
-import { DrillHierarchy, DrillHierarchyStep } from '../types/interaction-types.js';
-import { TCard } from '../types/common-types.js';
-/**
- * Generate a complete date drill hierarchy for a given date field
- *
- * Creates a dynamic hierarchy with all granularity levels.
- * DATE columns stop at day. TIMESTAMP/DATETIME columns continue to hour/minute/second.
- * The hierarchy uses type 'date' to enable runtime determination of next drill step.
- *
- * Each step is configured with:
- * - Proper granularity
- * - Human-readable labels
- * - Appropriate date formats
- * - Drill-down mode
- *
- * The steps serve as a "reference pool" - the actual next step is determined dynamically
- * at drill time based on the current chart's granularity.
- *
- * @param dateField - The date field to create hierarchy for
- * @returns Complete drill hierarchy with all granularity steps
- */
-export declare function generateDateHierarchy(dateField: Field): DrillHierarchy;
-/**
- * Check if a field should have an auto-generated date hierarchy
- *
- * Criteria:
- * - Field must be a date type
- * - No existing hierarchy for this field
- *
- * @param field - Field to check
- * @param existingHierarchies - Already configured hierarchies
- * @returns true if hierarchy should be auto-generated
- */
-export declare function shouldAutoGenerateDateHierarchy(field: Field, existingHierarchies?: DrillHierarchy[]): boolean;
-/**
- * Find existing date hierarchy for a given field
- *
- * Checks both:
- * - Auto-generated hierarchies (ID pattern: auto_date_{fieldId})
- * - Manual hierarchies that use this field
- *
- * @param fieldId - ID of the field to search for
- * @param hierarchies - Hierarchies to search
- * @returns Matching hierarchy or undefined
- */
-export declare function findDateHierarchyForField(fieldId: string, hierarchies: DrillHierarchy[]): DrillHierarchy | undefined;
-/**
- * Dynamically determine the next date drill step based on current granularity
- *
- * This function enables runtime determination of drill steps, allowing hierarchies
- * to adapt to the current chart state. For example:
- * - Chart showing Month → next step is Week
- * - Chart showing Year → next step is Quarter
- *
- * @param hierarchy - The date hierarchy configuration
- * @param currentGranularity - Current chart granularity level
- * @returns Next drill step based on current state, or undefined if at most granular level
- */
-export declare function getNextDateHierarchyStep(hierarchy: DrillHierarchy, currentGranularity: TimeGranularity | undefined): DrillHierarchyStep | undefined;
-/**
- * Get current date granularity from card config or breadcrumbs
- *
- * This utility consolidates the logic for determining the current granularity level
- * when working with date hierarchies. It checks breadcrumbs first (for drilled state),
- * then falls back to finding the matching field in the card's groupByColumns.
- *
- * @param hierarchy - The date hierarchy configuration
- * @param card - Card containing field configuration
- * @param breadcrumbs - Optional breadcrumb trail from drill interactions
- * @returns Current granularity level or undefined if not found
- */
-export declare function getCurrentDateGranularity(hierarchy: DrillHierarchy, card: TCard, breadcrumbs?: readonly {
-    granularity?: TimeGranularity;
-}[]): TimeGranularity | undefined;