@epam/statgpt-conversation-view 0.7.0-dev.8 → 0.7.0-dev.9

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/components/Attachments/useViewModeScrollAnchor.d.ts

@@ -0,0 +1,27 @@
+import { RefObject } from 'react';
+/**
+ * Keeps the conversation content and the attachment's tabs/buttons row fixed on
+ * screen while the user switches the visualization (e.g. grid ↔ chart) and the
+ * new content has a different height.
+ *
+ * Call {@link captureAnchor} synchronously right before triggering the switch.
+ * It simply locks `scrollTop` for a short settle window:
+ *
+ * - **Taller / same-size new view** → `scrollTop` is valid throughout, so the
+ *   view stays exactly put (no jump), even while the chart builds.
+ * - **Shorter new view** → holding the old `scrollTop` is only clamped by the
+ *   browser when it now exceeds the maximum, which happens exactly when the user
+ *   was at the very bottom of the taller view. In that case the content settles
+ *   down by the height difference (the one allowed movement); otherwise it still
+ *   stays put.
+ *
+ * Native scroll anchoring is suspended during the window (its heuristic is
+ * unreliable for the last message / at the bottom), and re-enabled afterwards.
+ * A manual scroll (wheel / touch) hands control back to the user immediately.
+ *
+ * No-op when `enabled` is false (e.g. advanced view has no such scroll
+ * container).
+ */
+export declare function useViewModeScrollAnchor<T extends HTMLElement>(anchorRef: RefObject<T | null>, enabled: boolean): {
+    captureAnchor: () => void;
+};

package/components/ConversationView/hooks/use-conversation-lifecycle.d.ts

@@ -0,0 +1,20 @@
+import { Conversation, ConversationInfo } from '@epam/ai-dial-shared';
+import { ConversationViewActions } from '../../../models/actions';
+export interface UseConversationLifecycleArgs {
+    actions: ConversationViewActions;
+    conversation: Conversation | null;
+    locale: string;
+    conversationsRoute?: string;
+    openUrl: (url: string) => void;
+    setConversations: (conversations: ConversationInfo[]) => void;
+}
+/**
+ * Conversation-level actions: duplicating the current (read-only) conversation
+ * — copying its attachments when the file actions are available, then creating
+ * the copy, refreshing the conversation list and navigating to it — and opening
+ * a fresh conversation from the onboarding footer.
+ */
+export declare const useConversationLifecycle: ({ actions, conversation, locale, conversationsRoute, openUrl, setConversations, }: UseConversationLifecycleArgs) => {
+    handleOpeningOfNewConversation: () => void;
+    duplicateConversation: () => Promise<void>;
+};

package/components/ConversationView/hooks/use-conversation-loader.d.ts

@@ -0,0 +1,24 @@
+import { Conversation } from '@epam/ai-dial-shared';
+import { Dispatch, SetStateAction } from 'react';
+import { ConversationViewActions } from '../../../models/actions';
+export interface UseConversationLoaderArgs {
+    conversationKey: string;
+    actions: ConversationViewActions;
+    setConversation: Dispatch<SetStateAction<Conversation | null>>;
+    setCrossDatasetAttachmentsState: () => void;
+    sendMessageToConversation: (content: string, data: Conversation | null, customChoiceId?: string) => void;
+    onConversationNotFound?: () => void;
+}
+/**
+ * Loads the conversation for the current `conversationKey`, derives its
+ * read-only flag, and sends the stored `prompt` to start the first turn when
+ * there are no user messages yet (an empty conversation, or one holding only a
+ * seed assistant message). Owns the `isLoading` / `isReadonlyConversation` UI
+ * state and clears the request cache around each load. On failure it marks the
+ * conversation read-only and calls `onConversationNotFound`. Re-fetches only
+ * when `conversationKey` changes.
+ */
+export declare const useConversationLoader: ({ conversationKey, actions, setConversation, setCrossDatasetAttachmentsState, sendMessageToConversation, onConversationNotFound, }: UseConversationLoaderArgs) => {
+    isLoading: boolean;
+    isReadonlyConversation: boolean;
+};

package/components/ConversationView/hooks/use-conversation-saver.d.ts

@@ -0,0 +1,13 @@
+import { Conversation } from '@epam/ai-dial-shared';
+import { ConversationViewActions } from '../../../models/actions';
+export interface UseConversationSaverArgs {
+    actions: ConversationViewActions;
+    conversationKey: string;
+}
+/**
+ * Persists the conversation back to the DIAL API via `actions.updateConversation`
+ * — only `name`, `messages` and `customViewState` are sent. Failures are logged
+ * and swallowed (the local state is left untouched). Shared by the streaming and
+ * message-feedback flows, which both flush local edits to the server.
+ */
+export declare const useConversationSaver: ({ actions, conversationKey, }: UseConversationSaverArgs) => (updatedConversation: Conversation) => Promise<void>;

package/components/ConversationView/hooks/use-conversation-streaming.d.ts

@@ -0,0 +1,35 @@
+import { Conversation } from '@epam/ai-dial-shared';
+import { Message } from '../../../../../dial-toolkit/src/index';
+import { HttpError } from '../../../../../shared-toolkit/src/index';
+import { Dispatch, SetStateAction } from 'react';
+import { StatusMessages } from '../../../types/texts';
+export interface UseConversationStreamingArgs {
+    conversation: Conversation | null;
+    setConversation: Dispatch<SetStateAction<Conversation | null>>;
+    saveConversation: (conversation: Conversation) => Promise<void>;
+    updateAssistantMessage: (assistantMessage: Message, partialMessage: Partial<Message>) => Message | undefined;
+    addUserMessageToConversation: (userMessage: Message) => void;
+    initializeAssistantMessage: () => Message;
+    isStreaming: boolean;
+    setIsStreaming: (isStreaming: boolean) => void;
+    statusMessages: StatusMessages;
+    isCrossDatasetModeOn: boolean;
+    token?: string | null;
+    handleInvalidStreaming?: (error: HttpError) => void;
+}
+/**
+ * The SSE streaming engine: starting/aborting a stream, merging partials,
+ * mapping transport errors to user-facing messages, persisting the finalized
+ * conversation, and the send / regenerate / edit entry points. Decoupled from
+ * the `conversation` prop for its core flow — every entry point receives the
+ * conversation as an explicit `data` argument; the prop is only read to derive
+ * the "retry last failed message" affordance.
+ */
+export declare const useConversationStreaming: ({ conversation, setConversation, saveConversation, updateAssistantMessage, addUserMessageToConversation, initializeAssistantMessage, isStreaming, setIsStreaming, statusMessages, isCrossDatasetModeOn, token, handleInvalidStreaming, }: UseConversationStreamingArgs) => {
+    sendMessageToConversation: (content: string, data: Conversation | null, customChoiceId?: string) => Promise<void>;
+    regenerateMessage: (message: Message, data: Conversation | null) => Promise<void>;
+    editMessage: (message: Message, data: Conversation | null) => Promise<void>;
+    onStopStreaming: () => void;
+    isLastMessageFailed: boolean;
+    regenerateLastMessage: (() => Promise<void>) | undefined;
+};

package/components/ConversationView/hooks/use-conversation-view.d.ts

@@ -0,0 +1,43 @@
+import { CustomViewState } from '../../../../../dial-toolkit/src/index';
+import { ConversationViewProps } from '../types';
+/**
+ * Orchestrates the ConversationView feature: reads the shared contexts once and
+ * composes the focused sub-hooks — saver → message mutations → streaming →
+ * feedback → lifecycle → loader, plus the standalone `useOnboardingSync`
+ * effects — then returns a flat view-model object consumed by the presentational
+ * layout. Mirrors the `useFilters` orchestration pattern. The only hard ordering
+ * constraint is that streaming is wired before the loader, since the loader
+ * auto-sends the first message via `sendMessageToConversation`.
+ */
+export declare const useConversationView: (props: ConversationViewProps) => {
+    isLoading: boolean;
+    isReadonlyConversation: boolean;
+    isStreaming: boolean;
+    isOpenedAdvancedView: boolean;
+    isShowOnboarding: boolean | undefined;
+    isAgentAvailable: boolean;
+    statusMessages: import('../../../types/texts').StatusMessages;
+    conversationViewState: CustomViewState | undefined;
+    messageServerActions: {
+        getFile: import('../../../types/actions').GetAttachmentContent;
+        putOnboardingFile: import('../../../types/actions').PutOnboardingFile;
+        getDataSet: import('../../../types/actions').GetDatasetDetails;
+        getDataSetData: import('../../../types/actions').GetDatasetData;
+        getConstraints: import('../../../types/actions').getConstraints;
+        updateCurrentDataQuery: (dataQuery?: import('../../../../../shared-toolkit/src/index').DataQuery) => void;
+        updateDataQueries: (dataQueries?: import('../../../../../shared-toolkit/src/index').DataQuery[]) => void;
+        updateDatasets: (datasets?: import('../../../../../sdmx-toolkit/src/index').Dataflow[]) => void;
+        downloadDataSet: import('../../../../../download-panel/src/types/actions').DownloadDatasetAction;
+    };
+    sendMessageToConversation: (content: string, data: import('@epam/ai-dial-shared').Conversation | null, customChoiceId?: string) => Promise<void>;
+    regenerateMessage: (message: import('../../../../../dial-toolkit/src/index').Message, data: import('@epam/ai-dial-shared').Conversation | null) => Promise<void>;
+    editMessage: (message: import('../../../../../dial-toolkit/src/index').Message, data: import('@epam/ai-dial-shared').Conversation | null) => Promise<void>;
+    onStopStreaming: () => void;
+    isLastMessageFailed: boolean;
+    regenerateLastMessage: (() => Promise<void>) | undefined;
+    rateResponse: (id: string, rate: import('@epam/ai-dial-shared').LikeState) => void;
+    handleCodeAttachmentUpdated: (messageId: string, newRawAttachment: import('@epam/ai-dial-shared').Attachment) => void;
+    duplicateConversation: () => Promise<void>;
+    handleOpeningOfNewConversation: () => void;
+};
+export type ConversationViewModel = ReturnType<typeof useConversationView>;

package/components/ConversationView/hooks/use-message-feedback.d.ts

@@ -0,0 +1,19 @@
+import { Attachment, Conversation, LikeState } from '@epam/ai-dial-shared';
+import { Dispatch, SetStateAction } from 'react';
+import { ConversationViewActions } from '../../../models/actions';
+export interface UseMessageFeedbackArgs {
+    actions: ConversationViewActions;
+    conversation: Conversation | null;
+    setConversation: Dispatch<SetStateAction<Conversation | null>>;
+    saveConversation: (conversation: Conversation) => Promise<void>;
+}
+/**
+ * Per-message feedback actions: rating a response (thumbs up/down) and
+ * replacing a Python code attachment after an in-place edit. Both persist the
+ * resulting conversation. `rateResponse` mutates `conversation.messages` in
+ * place — preserved as-is from the original component.
+ */
+export declare const useMessageFeedback: ({ actions, conversation, setConversation, saveConversation, }: UseMessageFeedbackArgs) => {
+    handleCodeAttachmentUpdated: (messageId: string, newRawAttachment: Attachment) => void;
+    rateResponse: (id: string, rate: LikeState) => void;
+};

package/components/ConversationView/hooks/use-message-mutations.d.ts

@@ -0,0 +1,17 @@
+import { Conversation } from '@epam/ai-dial-shared';
+import { Message } from '../../../../../dial-toolkit/src/index';
+import { Dispatch, SetStateAction } from 'react';
+export interface UseMessageMutationsArgs {
+    setConversation: Dispatch<SetStateAction<Conversation | null>>;
+}
+/**
+ * Local message-state mutations on the in-memory conversation: appending the
+ * user message, seeding an empty assistant message, and merging updates
+ * (streamed partials, or an error message) into that assistant message by id.
+ * Touches React state only — no persistence or network.
+ */
+export declare const useMessageMutations: ({ setConversation, }: UseMessageMutationsArgs) => {
+    addUserMessageToConversation: (userMessage: Message) => void;
+    initializeAssistantMessage: () => Message;
+    updateAssistantMessage: (assistantMessage: Message, partialMessage: Partial<Message>) => Message | undefined;
+};