@epam/statgpt-conversation-view 0.7.0-dev.3 → 0.7.0-dev.31

package/components/AdvancedView/Filters/FiltersModal/filter-settings-controller.d.ts

@@ -0,0 +1,47 @@
+import { DataConstraints, Hierarchy, StructuralData } from '../../../../../../sdmx-toolkit/src/index';
+import { DataQuery, TimeRangeOptions } from '../../../../../../shared-toolkit/src/index';
+import { Dispatch, ReactNode, SetStateAction } from 'react';
+import { Filter, FiltersModalProps, HierarchyState } from '../../../../models/filters';
+export interface FilterSettingsState {
+    filtersList: Filter[];
+    selectedFilter?: Filter;
+    isDisableValues?: boolean;
+    isValuesLoading?: boolean;
+    selectedTimeOption?: string | number;
+    disabledDatasetUrns: Set<string>;
+    timeSeriesCount?: string;
+}
+export interface FilterSettingsOptions {
+    locale?: string;
+    timeRangeOptions?: TimeRangeOptions[];
+    modalProps?: FiltersModalProps;
+    initialConstraints?: DataConstraints[];
+    initialConstraintsMap?: Map<string, DataConstraints[] | undefined>;
+    datasetIcon?: ReactNode;
+    structuresMap?: Map<string, StructuralData | undefined>;
+    dataQueries?: DataQuery[];
+}
+export interface FilterSettingsHandlers {
+    setSelectedFilter: Dispatch<SetStateAction<Filter | undefined>>;
+    onSelectDisplayMode: (filter?: Filter, displayMode?: string) => void;
+    onDeleteFilter?: (filter?: Filter) => void;
+    onClearAllFilters?: () => void;
+    updateSelectedFilterValues?: (filter?: Filter) => void;
+    onTimePeriodChange?: (value: string | number) => void;
+    onToggleDataset: (urn: string, enabled: boolean) => void;
+    onClearAllDatasets: () => void;
+}
+export interface FilterSettingsHierarchy {
+    hierarchyStateMap?: Map<string, HierarchyState>;
+    onSelectHierarchy?: (filter?: Filter, hierarchy?: Hierarchy | null) => void;
+    onExpandHierarchyNode?: (filterKey: string, nodeId: string) => void;
+}
+/**
+ * The single structured prop the orchestration passes to `FilterSettings`.
+ */
+export interface FilterSettingsController {
+    state: FilterSettingsState;
+    options: FilterSettingsOptions;
+    handlers: FilterSettingsHandlers;
+    hierarchy: FilterSettingsHierarchy;
+}

package/components/AdvancedView/Filters/hooks/use-filter-apply.d.ts

@@ -0,0 +1,36 @@
+import { Filter } from '../../../../models/filters';
+/** Filters passed to the system message: flat (single) or per-dataset (multi). */
+export type SystemMessageFilters = Filter[] | Map<string, Filter[]>;
+/**
+ * Mode-specific apply behavior injected into the shared {@link useFilterApply}
+ * skeleton. `runApply` performs the mode's `onFiltersChange` side effect and
+ * returns the next applied filters plus the filters to persist on the system
+ * message; `getIsFiltersUnchanged` powers the Apply-disabled state.
+ */
+export interface FilterApplyStrategy {
+    getIsFiltersUnchanged: (modalFilters: Filter[], appliedFilters: Filter[], disabledDatasetUrns: Set<string>, appliedDisabledUrns: Set<string>) => boolean;
+    runApply: (modalFilters: Filter[], disabledDatasetUrns: Set<string>) => {
+        appliedFilters: Filter[];
+        systemMessageFilters: SystemMessageFilters;
+    };
+}
+interface UseFilterApplyParams {
+    apply: FilterApplyStrategy;
+    modalFilters: Filter[];
+    appliedFilters: Filter[];
+    disabledDatasetUrns: Set<string>;
+    appliedDisabledUrns: Set<string>;
+    setAppliedFilters: (filters: Filter[]) => void;
+    closeModal: () => void;
+    addSystemMessage: (filters: SystemMessageFilters, disabledDatasetUrns: Set<string>) => Promise<void>;
+}
+/**
+ * Shared apply control flow for both filter modes: compute the unchanged state,
+ * and on apply run the mode-specific change, persist applied filters, close the
+ * modal and write the system message off the render path.
+ */
+export declare const useFilterApply: ({ apply, modalFilters, appliedFilters, disabledDatasetUrns, appliedDisabledUrns, setAppliedFilters, closeModal, addSystemMessage, }: UseFilterApplyParams) => {
+    isFiltersUnchanged: boolean;
+    onApply: () => void;
+};
+export {};

package/components/AdvancedView/Filters/hooks/use-filter-constraints.d.ts

@@ -0,0 +1,59 @@
+import { DataConstraints } from '../../../../../../sdmx-toolkit/src/index';
+import { DataQuery } from '../../../../../../shared-toolkit/src/index';
+import { Dispatch, SetStateAction } from 'react';
+import { Filter } from '../../../../models/filters';
+type SetFilters = (filters: Filter[]) => void;
+type SetBooleanLoading = (isLoading: boolean) => void;
+/**
+ * Mode-specific constraint operations injected into the shared
+ * {@link useFilterConstraints} skeleton. The single-dataset flow works on a
+ * flat `DataConstraints[]`; the multi-dataset flow works on a per-dataset map.
+ * `TResult` is the opaque per-call constraints payload each mode produces.
+ */
+export interface FilterConstraintsStrategy<TResult> {
+    /**
+     * Fire the constraint request(s) for `filters`. `shouldTrackLoading` drives
+     * the shared loading counter. `targetDataQueries` narrows the request set on
+     * the delete path (multi-dataset only; ignored by single-dataset).
+     */
+    startFetch: (filters: Filter[], targetDataQueries?: DataQuery[]) => {
+        promise: Promise<TResult>;
+        shouldTrackLoading: boolean;
+    };
+    /** Constraints payload to use when a request fails. */
+    fallbackResult: (filters: Filter[]) => TResult;
+    /** Drop values no longer supported by the fetched constraints. */
+    cleanIncompatible: (filters: Filter[], result: TResult, changedFilter: Filter) => {
+        filters: Filter[];
+        changed: boolean;
+    };
+    /** Fill `filters` with the fetched constraints. */
+    fill: (filters: Filter[], result: TResult) => Filter[];
+    /** Persist the fetched constraints into the mode-specific ref. */
+    commit: (result: TResult) => void;
+    /** Constraints to rebuild the hierarchy tree with after a change. */
+    getRebuildConstraints: (changedFilter: Filter, result: TResult) => DataConstraints[] | undefined;
+}
+interface UseFilterConstraintsParams<TResult> {
+    strategy: FilterConstraintsStrategy<TResult>;
+    modalFilters: Filter[];
+    setModalFilters: SetFilters;
+    setSelectedFilter: Dispatch<SetStateAction<Filter | undefined>>;
+    rebuildHierarchyTree: (filter: Filter, constraints?: DataConstraints[]) => void;
+}
+/**
+ * Shared constraint-fetching control flow for both filter modes. The async
+ * skeleton (request → optionally clean-and-recurse → fill/commit → catch/finally)
+ * is identical across single- and multi-dataset; the mode-specific primitives
+ * arrive through `strategy`.
+ */
+export declare const useFilterConstraints: <TResult>({ strategy, modalFilters, setModalFilters, setSelectedFilter, rebuildHierarchyTree, }: UseFilterConstraintsParams<TResult>) => {
+    isConstraintsLoading: boolean | undefined;
+    isDisableFilterValues: boolean | undefined;
+    isFilterValuesLoading: boolean;
+    setIsConstraintsLoading: Dispatch<SetStateAction<boolean | undefined>>;
+    handleFiltersWithConstraints: (filters: Filter[], setFilters: SetFilters, setLoading?: SetBooleanLoading, changedFilter?: Filter) => void;
+    handleFiltersDelete: (filtersToUpdate: Filter[], targetDataQueries?: DataQuery[]) => void;
+    updateSelectedFilterValues: (filter?: Filter) => void;
+};
+export {};

package/components/AdvancedView/Filters/hooks/use-filter-initialization.d.ts

@@ -0,0 +1,40 @@
+import { Filter } from '../../../../models/filters';
+type SetFilters = (filters: Filter[]) => void;
+type SetBooleanLoading = (isLoading: boolean) => void;
+/**
+ * Outcome of a mode's initialization check:
+ * - `ready`   — preselect now with `filters`;
+ * - `pending` — structure data not ready yet, show loading and wait;
+ * - `skip`    — nothing to do (e.g. already initialized, or no structure).
+ */
+export type FilterInitResult = {
+    status: 'ready';
+    filters: Filter[];
+} | {
+    status: 'pending';
+} | {
+    status: 'skip';
+};
+/**
+ * Mode-specific initialization behavior injected into the shared
+ * {@link useFilterInitialization} skeleton. `prepareInit` computes the preselected
+ * filters (or signals pending/skip); `markInitialized` lets a one-shot mode
+ * (single-dataset) record that it has run.
+ */
+export interface FilterInitStrategy {
+    prepareInit: () => FilterInitResult;
+    markInitialized?: () => void;
+}
+interface UseFilterInitializationParams {
+    init: FilterInitStrategy;
+    setAppliedFilters: SetFilters;
+    setIsConstraintsLoading: SetBooleanLoading;
+    handleFiltersWithConstraints: (filters: Filter[], setFilters: SetFilters, setLoading?: SetBooleanLoading) => void;
+}
+/**
+ * Shared initial preselect for both filter modes. Re-runs whenever the mode's
+ * `prepareInit` identity changes (i.e., its inputs change); the mode decides via
+ * the returned status whether to preselect, wait, or skip.
+ */
+export declare const useFilterInitialization: ({ init, setAppliedFilters, setIsConstraintsLoading, handleFiltersWithConstraints, }: UseFilterInitializationParams) => void;
+export {};

package/components/AdvancedView/Filters/hooks/use-filter-modal-state.d.ts

@@ -0,0 +1,49 @@
+import { PopUpState } from '../../../../../../ui-components/src/index';
+import { Dispatch, SetStateAction } from 'react';
+import { Filter, FilterMode, FiltersProps, HierarchyState } from '../../../../models/filters';
+interface UseFilterModalStateParams {
+    mode: FilterMode;
+    modalState: PopUpState;
+    dataQueries?: FiltersProps['dataQueries'];
+    hierarchyStateMap: Map<string, HierarchyState>;
+    loadAvailableHierarchies: (filter: Filter) => void | Promise<void>;
+}
+export interface UseFilterModalStateResult {
+    modalFilters: Filter[];
+    setModalFilters: Dispatch<SetStateAction<Filter[]>>;
+    appliedFilters: Filter[];
+    setAppliedFilters: Dispatch<SetStateAction<Filter[]>>;
+    selectedFilter: Filter | undefined;
+    setSelectedFilter: Dispatch<SetStateAction<Filter | undefined>>;
+    selectedFilterValues: Filter[];
+    selectedTimeOption: string | number | undefined;
+    disabledDatasetUrns: Set<string>;
+    appliedDisabledUrns: Set<string>;
+    onSelectDisplayMode: (filter?: Filter, displayMode?: string) => void;
+    onClearAllDatasets: () => void;
+    onToggleDataset: (urn: string, enabled: boolean) => void;
+    onTimePeriodChange: (value: string | number) => void;
+}
+/**
+ * Modal state shared by both filter modes (modal/applied filters, selected
+ * filter, time option). The two modes are identical except for two `multi`-only
+ * concerns: the dataset-disable sets, and resetting `selectedTimeOption` when
+ * the modal opens — single-dataset keeps the last time option across reopens.
+ */
+export declare const useFilterModalState: ({ mode, modalState, dataQueries, hierarchyStateMap, loadAvailableHierarchies, }: UseFilterModalStateParams) => {
+    modalFilters: Filter[];
+    setModalFilters: Dispatch<SetStateAction<Filter[]>>;
+    appliedFilters: Filter[];
+    setAppliedFilters: Dispatch<SetStateAction<Filter[]>>;
+    selectedFilter: Filter | undefined;
+    setSelectedFilter: Dispatch<SetStateAction<Filter | undefined>>;
+    selectedFilterValues: Filter[];
+    selectedTimeOption: string | number | undefined;
+    disabledDatasetUrns: Set<string>;
+    appliedDisabledUrns: Set<string>;
+    onSelectDisplayMode: (filter?: Filter, displayMode?: string) => void;
+    onClearAllDatasets: () => void;
+    onToggleDataset: (urn: string, enabled: boolean) => void;
+    onTimePeriodChange: (value: string | number) => void;
+};
+export {};

package/components/AdvancedView/Filters/hooks/use-filter-system-message.d.ts

@@ -0,0 +1,35 @@
+import { Conversation } from '@epam/ai-dial-shared';
+import { DataQuery } from '../../../../../../shared-toolkit/src/index';
+import { FiltersProps } from '../../../../models/filters';
+import { SystemMessageFilters } from './use-filter-apply';
+/**
+ * Mode-specific system-message builder injected into the shared
+ * {@link useFilterSystemMessage} skeleton. Given the current conversation and the
+ * applied filters, it returns the conversation updated with the new system message
+ * (or `null` when there is no conversation) plus the data queries to persist. The
+ * single-dataset flow works on a flat `Filter[]`; the multi-dataset flow works on
+ * a per-dataset map and additionally folds in `disabledDatasetUrns`.
+ */
+export interface FilterSystemMessageStrategy {
+    buildSystemMessage: (conversation: Conversation | null, systemMessageFilters: SystemMessageFilters, disabledDatasetUrns: Set<string>) => {
+        conversation: Conversation | null;
+        nextDataQueries: DataQuery[];
+    };
+}
+interface UseFilterSystemMessageParams {
+    buildSystemMessage: FilterSystemMessageStrategy['buildSystemMessage'];
+    conversation?: FiltersProps['conversation'];
+    conversationKey: string;
+    setConversation?: FiltersProps['setConversation'];
+    updateConversation: FiltersProps['updateConversation'];
+    updateDataQueries?: FiltersProps['updateDataQueries'];
+}
+/**
+ * Shared system-message persistence for both filter modes: snapshot the current
+ * conversation off a ref, delegate message + data-query construction to the
+ * mode-specific `buildSystemMessage`, then persist the result (local conversation
+ * state, data queries, and the remote conversation). No per-mode branching lives
+ * here — all of it is encapsulated in `buildSystemMessage`.
+ */
+export declare const useFilterSystemMessage: ({ buildSystemMessage, conversation, conversationKey, setConversation, updateConversation, updateDataQueries, }: UseFilterSystemMessageParams) => (systemMessageFilters: SystemMessageFilters, disabledDatasetUrns?: Set<string>) => Promise<void>;
+export {};

package/components/AdvancedView/Filters/hooks/use-filter-values-loading.d.ts

@@ -0,0 +1,5 @@
+export declare const useFilterValuesLoading: () => {
+    isLoading: boolean;
+    startLoading: () => void;
+    finishLoading: () => void;
+};

package/components/AdvancedView/Filters/hooks/use-filters.d.ts

@@ -0,0 +1,49 @@
+import { DataConstraints } from '../../../../../../sdmx-toolkit/src/index';
+import { DataQuery } from '../../../../../../shared-toolkit/src/index';
+import { Filter, FilterMode, FiltersProps } from '../../../../models/filters';
+import { FilterSettingsOptions } from '../FiltersModal/filter-settings-controller';
+import { FiltersModalShellProps } from '../FiltersModal/FiltersModalShell';
+import { FilterApplyStrategy } from './use-filter-apply';
+import { FilterConstraintsStrategy } from './use-filter-constraints';
+import { FilterInitStrategy } from './use-filter-initialization';
+import { FilterSystemMessageStrategy } from './use-filter-system-message';
+/**
+ * Everything mode-specific about a filter flow, bundled behind one object so the
+ * shared {@link useFilters} orchestration stays mode-agnostic. Built per mode by
+ * `useSingleFilterStrategy` / `useMultiFilterStrategy`.
+ */
+export interface FilterStrategy<TResult> {
+    mode: FilterMode;
+    /** Constraint operations consumed by the shared constraints skeleton. */
+    constraints: FilterConstraintsStrategy<TResult>;
+    /** Apply operations consumed by the shared apply skeleton. */
+    apply: FilterApplyStrategy;
+    /**
+     * Builds the mode-specific system message + persisted data queries, consumed
+     * by the shared system-message skeleton on apply.
+     */
+    buildSystemMessage: FilterSystemMessageStrategy['buildSystemMessage'];
+    /** Initialization behavior consumed by the shared init skeleton. */
+    init: FilterInitStrategy;
+    getConstraintsForFilter: (filter: Filter) => DataConstraints[] | undefined;
+    getCodelistUrnForFilter: (filter: Filter) => string | undefined;
+    getSourceArtefactUrn: (filter: Filter) => string | undefined;
+    remember: () => void;
+    restore: () => void;
+    /** Data queries whose constraints to refresh when a single filter is deleted. */
+    getDeleteTargets: (filter: Filter | undefined, dataQueries?: DataQuery[]) => DataQuery[] | undefined;
+    /** Data queries whose constraints to refresh when all filters are cleared. */
+    getClearTargets: (dataQueries?: DataQuery[]) => DataQuery[] | undefined;
+    /** Mode-specific `FilterSettings` options (merged with the common ones). */
+    controllerOptions: Partial<FilterSettingsOptions>;
+    /** Total timeseries count (single-dataset only). */
+    timeSeriesCount?: number;
+}
+/**
+ * Shared orchestration for both filter modes: wires hierarchy, modal state,
+ * constraint fetching, initialization, system-message persistence and apply,
+ * then assembles the `FiltersModalShell` props. All mode-specific behavior is
+ * provided by `strategy`, so this hook contains no per-mode branching beyond a
+ * couple of tiny gates keyed on `strategy.mode`.
+ */
+export declare const useFilters: <TResult>({ actions, buttonProps, modalProps, dataQueries, locale, timeRangeOptions, conversationKey, conversation, setConversation, updateConversation, updateDataQueries, limitMessages, filterIconClassName, }: FiltersProps, strategy: FilterStrategy<TResult>) => FiltersModalShellProps;

package/components/AdvancedView/Filters/hooks/use-single-dataset-filters.d.ts

@@ -0,0 +1,7 @@
+import { FiltersProps } from '../../../../models/filters';
+import { FiltersModalShellProps } from '../FiltersModal/FiltersModalShell';
+/**
+ * Single-dataset (attachment-scoped) filter flow. Builds the single-dataset
+ * strategy and delegates orchestration to the shared {@link useFilters} hook.
+ */
+export declare const useSingleDatasetFilters: (props: FiltersProps) => FiltersModalShellProps;

package/components/AdvancedView/Filters/hooks/use-single-filter-strategy.d.ts

@@ -0,0 +1,22 @@
+import { DataConstraints } from '../../../../../../sdmx-toolkit/src/index';
+import { FiltersProps } from '../../../../models/filters';
+import { FilterStrategy } from './use-filters';
+interface UseSingleFilterStrategyParams {
+    actions?: FiltersProps['actions'];
+    attachmentsDataQuery?: FiltersProps['attachmentsDataQuery'];
+    dataQueries?: FiltersProps['dataQueries'];
+    dimensions?: FiltersProps['dimensions'];
+    structureDimensions?: FiltersProps['structureDimensions'];
+    structures?: FiltersProps['structures'];
+    initialConstraints?: DataConstraints[];
+    locale?: string;
+    onFiltersChange?: FiltersProps['onFiltersChange'];
+}
+/**
+ * Single-dataset filter strategy. Owns the flat `DataConstraints[]` ref and
+ * provides the array-shaped constraint, apply and init primitives the shared
+ * {@link useFilters} orchestration injects, plus the hierarchy getters and
+ * the modal remember/restore snapshot.
+ */
+export declare const useSingleFilterStrategy: ({ actions, attachmentsDataQuery, dataQueries, dimensions, structureDimensions, structures, initialConstraints, locale, onFiltersChange, }: UseSingleFilterStrategyParams) => FilterStrategy<DataConstraints[]>;
+export {};

package/components/AdvancedView/MultiDatasetFilters/hooks/use-multi-dataset-display-data-queries.d.ts

@@ -0,0 +1,3 @@
+import { FiltersProps } from '../../../../models/filters';
+import { StructureDataMaps } from '../../../../models/structure-data';
+export declare const useMultiDatasetDisplayDataQueries: (dataQueries?: FiltersProps["dataQueries"], structuresMap?: StructureDataMaps["structuresMap"], locale?: string) => import('../../../../../../shared-toolkit/src/index').DataQuery[] | undefined;

package/components/AdvancedView/MultiDatasetFilters/hooks/use-multi-dataset-filters.d.ts

@@ -0,0 +1,7 @@
+import { FiltersProps } from '../../../../models/filters';
+import { FiltersModalShellProps } from '../../Filters/FiltersModal/FiltersModalShell';
+/**
+ * Multi-dataset (cross-dataset) filter flow. Builds the multi-dataset strategy
+ * and delegates orchestration to the shared {@link useFilters} hook.
+ */
+export declare const useMultiDatasetFilters: (props: FiltersProps) => FiltersModalShellProps;

package/components/AdvancedView/MultiDatasetFilters/hooks/use-multi-filter-strategy.d.ts

@@ -0,0 +1,27 @@
+import { DataConstraints, DatasetDimensionsMetadataMap } from '../../../../../../sdmx-toolkit/src/index';
+import { Filter, FiltersProps } from '../../../../models/filters';
+import { StructureDataMaps } from '../../../../models/structure-data';
+import { FilterStrategy } from '../../Filters/hooks/use-filters';
+type ConstraintsMap = Map<string, DataConstraints[] | undefined>;
+export interface MultiConstraintsResult {
+    filtersMap: Map<string, Filter[]>;
+    constraints: ConstraintsMap;
+    structureDataMaps: StructureDataMaps;
+}
+interface UseMultiFilterStrategyParams {
+    actions?: FiltersProps['actions'];
+    dataQueries?: FiltersProps['dataQueries'];
+    datasetDimensionsMetadataMap?: DatasetDimensionsMetadataMap;
+    structureDataMaps?: StructureDataMaps;
+    datasetIcon?: FiltersProps['datasetIcon'];
+    locale?: string;
+    onMultipleDataFiltersChange?: FiltersProps['onMultipleDataFiltersChange'];
+}
+/**
+ * Multi-dataset (cross-dataset) filter strategy. Owns the per-dataset
+ * constraints map ref and provides the map-shaped constraint, apply and init
+ * primitives the shared {@link useFilters} orchestration injects, plus the
+ * hierarchy getters and the modal remember/restore snapshot.
+ */
+export declare const useMultiFilterStrategy: ({ actions, dataQueries, datasetDimensionsMetadataMap, structureDataMaps, datasetIcon, locale, onMultipleDataFiltersChange, }: UseMultiFilterStrategyParams) => FilterStrategy<MultiConstraintsResult>;
+export {};

package/components/Attachments/GridCellRenderers/helpers/get-observation-metadata-content.d.ts

@@ -1,6 +1,6 @@
 import { getObsAttributesFromParams } from '../../../../utils/attachments/metadata';
 import { ICellRendererParams } from 'ag-grid-community';
-import { StructuralData } from '../../../../../../sdmx-toolkit/src/index';
+import { Dataflow, StructuralData } from '../../../../../../sdmx-toolkit/src/index';
 import { MetadataSettings } from '../../../../models/metadata';
 import { ConversationViewTitles } from '../../../../index';
 export interface ObservationValueCellRendererParams extends ICellRendererParams {
@@ -11,7 +11,7 @@ export interface ObservationValueCellRendererParams extends ICellRendererParams
     titles?: ConversationViewTitles;
 }
 export type ObservationMetadataContent = ReturnType<typeof getObservationMetadataContent>;
-export declare const getObservationMetadataContent: (params: ObservationValueCellRendererParams, obsAttributes: NonNullable<ReturnType<typeof getObsAttributesFromParams>>) => {
+export declare const getObservationMetadataContent: (params: ObservationValueCellRendererParams, obsAttributes: NonNullable<ReturnType<typeof getObsAttributesFromParams>>, getDatasetLastUpdated?: (dataset: Dataflow | null | undefined) => string | undefined) => {
     metadata: (import('../../../../index').StructureComponentValue | {
         title: string;
         value: string | undefined;

package/constants/grid.d.ts

@@ -13,6 +13,8 @@ export declare const GRID_COLUMN_FLEX: {
     minWidth: number;
 };
 export declare const CHART_COLUMN_WIDTH = 32;
+export declare const MOBILE_GRID_COLUMN_WIDTH = 100;
+export declare const FIXED_GRID_COLUMN_MAX_WIDTH = 64;
 export declare const OBSERVATION_VALUE_CELL_RENDER = "observationValueCell";
 export declare const METADATA_CELL_RENDER = "metadataCell";
 export declare const CHART_CELL_RENDER = "chartCell";
@@ -21,4 +23,5 @@ export declare const DATASET_DETAIL_CELL_RENDER = "datasetDetailCell";
 export declare const CHART_COLUMN_ID = "Chart_column";
 export declare const getMetaDataColumn: (dataSetData?: StructuralData, data?: Data, locale?: string, metadataSettings?: MetadataSettings, titles?: ConversationViewTitles, action?: PutOnboardingFile) => ColDef;
 export declare function getChartColumn(dataSetData?: StructuralData, data?: Data, locale?: string, width?: number, titles?: ConversationViewTitles, action?: PutOnboardingFile): ColDef;
+export declare function applyMobileColumnWidth(col: ColDef, isMobile: boolean): ColDef;
 export declare function getCrossDatasetMetadataColumn(structuresMap: Map<string, StructuralData | undefined>, attributesDataMap: Map<string, Data | undefined>, locale: string, titles?: ConversationViewTitles): ColDef;

package/index.d.ts

@@ -26,3 +26,9 @@ export type { ConversationViewSidePanelConfig, ConversationViewSidePanelScope, }
 export { ConversationViewFeatureTogglesProvider, useConversationViewFeatureToggles, } from './context/ConversationViewFeatureTogglesContext';
 export type { ConversationViewFeatureToggles } from './context/ConversationViewFeatureTogglesContext';
 export { CrossDatasetAttachmentsProvider, useCrossDatasetAttachments, } from './context/CrossDatasetAttachmentsContext';
+export { AttachmentRenderer } from './components/Attachments/AttachmentRenderer';
+export { CustomChartAttachment } from './components/Attachments/CustomAttachments/CustomChartAttachment';
+export { CustomDataGridAttachment } from './components/Attachments/CustomAttachments/CustomGridAttachment';
+export { CrossDatasetGridAttachment } from './components/Attachments/CustomAttachments/CrossDatasetGridAttachment';
+export type { ChartingData, ChartUnit, ChartUnitGroup, } from './models/charting';
+export type { GridData } from './types/data-grid/grid-data';