devexpress-reporting-react 24.2.2-beta → 24.2.5

package/dx-report-viewer/components/reporting/AIPanel/AIPanel.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { IAIPanelViewModel } from 'devexpress-reporting/scopes/reporting-viewer-internal';
+import { ITabPanelItemViewModel } from '@devexpress/analytics-core/core/widgets/tabInfo';
 declare const AIPanel: React.FC<{
-    data: IAIPanelViewModel;
+    data: ITabPanelItemViewModel;
 }>;
 export default AIPanel;

package/dx-report-viewer/components/reporting/AIPanel/AIPanel.js

@@ -2,30 +2,23 @@ import React, { useMemo } from 'react';
 import { Button, CheckBox, LoadIndicator, SelectBox, TextArea, Popup } from 'devextreme-react';
 import Template from '../../core/Template';
 import { Position } from 'devextreme-react/cjs/popup';
-import useDxForceRerender from '../../../hooks/dxForceRerender';
+import { ViewModelChangedEvent } from '@devexpress/analytics-core/serializer/native/viewModels/viewModelGenerator';
 const AIPanel = ({ data }) => {
-    const GetVisible = () => {
-        return data.model?.tabInfo?.visible && data.model?.tabInfo?.active;
-    };
-    const getCopyTemplate = () => {
-        return data.model?.copyButtonTemplate;
-    };
-    const aiPanelHeaderLabel = data.model.getViewModel().aiPanelHeaderLabel;
-    const viewModel = data.model?.getViewModel();
+    const viewModel = data.model.getViewModel();
+    React.useEffect(() => {
+        const parentEventManagerHolder = data;
+        return viewModel._viewModelEvents?.on(ViewModelChangedEvent, (args) => parentEventManagerHolder._viewModelEvents.call(ViewModelChangedEvent, args));
+    }, [viewModel]);
     const popupAttributes = useMemo(() => {
         return {
             class: 'dxrd-preview-ai-panel-warning-popup'
         };
     }, []);
-    const forceRerender = useDxForceRerender();
-    React.useEffect(() => {
-        forceRerender();
-    }, [Object.values(data.model.getViewModel())]);
-    return (React.createElement("div", { id: "dxrd-preview-ai-panel-id", className: "dxrd-preview-ai-panel", hidden: !(GetVisible()) },
+    return (React.createElement("div", { id: "dxrd-preview-ai-panel-id", className: "dxrd-preview-ai-panel", hidden: !(data.visible && data.active) },
         React.createElement("div", { className: "dxrd-right-panel-header dxd-text-primary" },
             React.createElement("span", null,
                 " ",
-                aiPanelHeaderLabel,
+                viewModel?.aiPanelHeaderLabel,
                 " ")),
         !!viewModel && (React.createElement("div", null,
             React.createElement("div", { className: "dxrd-preview-ai-panel-wrapper dx-editors" },
@@ -34,18 +27,18 @@ const AIPanel = ({ data }) => {
                         React.createElement("label", { className: "dxrd-preview-ai-form-label", htmlFor: "dxrv-ai-target-select" },
                             " ",
                             viewModel.targetContentText),
-                        React.createElement(SelectBox, { id: "dxrv-ai-target-select", className: "dxrd-preview-ai-form-input", dataSource: viewModel.targetSelecBoxOptions.dataSource, onValueChanged: viewModel.targetSelecBoxOptions.onValueChanged, value: viewModel.targetSelecBoxOptions.value, displayExpr: viewModel.targetSelecBoxOptions.displayExpr, valueExpr: viewModel.targetSelecBoxOptions.valueExpr, inputAttr: viewModel.targetSelecBoxOptions.inputAttr })),
+                        React.createElement(SelectBox, { id: "dxrv-ai-target-select", className: "dxrd-preview-ai-form-input", dataSource: viewModel.targetSelectBoxOptions.dataSource, onValueChanged: viewModel.targetSelectBoxOptions.onValueChanged, value: viewModel.targetSelectBoxOptions.value, displayExpr: viewModel.targetSelectBoxOptions.displayExpr, valueExpr: viewModel.targetSelectBoxOptions.valueExpr, inputAttr: viewModel.targetSelectBoxOptions.inputAttr })),
                     React.createElement("div", { className: "dx-field dxrd-preview-ai-select-box" },
                         React.createElement("label", { className: "dxrd-preview-ai-form-label", htmlFor: "dxrv-ai-language-select" },
                             " ",
                             viewModel.targetLanguageText,
                             " "),
-                        React.createElement(SelectBox, { id: "dxrv-ai-language-select", className: "dxrd-preview-ai-form-input", dataSource: viewModel.languageSelecBoxOptions.dataSource, onValueChanged: viewModel.languageSelecBoxOptions.onValueChanged, value: viewModel.languageSelecBoxOptions.value, displayExpr: viewModel.languageSelecBoxOptions.displayExpr, valueExpr: viewModel.languageSelecBoxOptions.valueExpr, showClearButton: viewModel.languageSelecBoxOptions.showClearButton, inputAttr: viewModel.languageSelecBoxOptions.inputAttr })),
-                    viewModel.pageSelecBoxVisible && (React.createElement("div", { className: "dx-field dxrd-preview-ai-select-box" },
+                        React.createElement(SelectBox, { id: "dxrv-ai-language-select", className: "dxrd-preview-ai-form-input", dataSource: viewModel.languageSelectBoxOptions.dataSource, onValueChanged: viewModel.languageSelectBoxOptions.onValueChanged, value: viewModel.languageSelectBoxOptions.value, displayExpr: viewModel.languageSelectBoxOptions.displayExpr, valueExpr: viewModel.languageSelectBoxOptions.valueExpr, showClearButton: viewModel.languageSelectBoxOptions.showClearButton, inputAttr: viewModel.languageSelectBoxOptions.inputAttr })),
+                    viewModel.pageSelectBoxVisible && (React.createElement("div", { className: "dx-field dxrd-preview-ai-select-box" },
                         React.createElement("label", { className: "dxrd-preview-ai-form-label", htmlFor: "dxrv-ai-page-select" },
                             " ",
                             viewModel.pageSelectText),
-                        React.createElement(SelectBox, { className: "dxrd-preview-ai-form-input", id: "dxrv-ai-page-select", dataSource: viewModel.pageSelecBoxOptions.dataSource, onValueChanged: viewModel.pageSelecBoxOptions.onValueChanged, value: viewModel.pageSelecBoxOptions.value, displayExpr: viewModel.pageSelecBoxOptions.displayExpr, valueExpr: viewModel.pageSelecBoxOptions.valueExpr, searchExpr: viewModel.pageSelecBoxOptions.searchExpr, searchEnabled: viewModel.pageSelecBoxOptions.searchEnabled, visible: viewModel.pageSelecBoxOptions.visible, inputAttr: viewModel.pageSelecBoxOptions.inputAttr }))),
+                        React.createElement(SelectBox, { className: "dxrd-preview-ai-form-input", id: "dxrv-ai-page-select", dataSource: viewModel.pageSelectBoxOptions.dataSource, onValueChanged: viewModel.pageSelectBoxOptions.onValueChanged, value: viewModel.pageSelectBoxOptions.value, displayExpr: viewModel.pageSelectBoxOptions.displayExpr, valueExpr: viewModel.pageSelectBoxOptions.valueExpr, searchExpr: viewModel.pageSelectBoxOptions.searchExpr, searchEnabled: viewModel.pageSelectBoxOptions.searchEnabled, visible: viewModel.pageSelectBoxOptions.visible, inputAttr: viewModel.pageSelectBoxOptions.inputAttr }))),
                     React.createElement("div", { className: "dx-field" },
                         React.createElement("div", { className: "dxrd-preview-ai-buttons-wrapper" },
                             React.createElement(LoadIndicator, { className: "dxrd-preview-ai-buttons", visible: data.model.loading, height: 24, width: 24 }),
@@ -54,10 +47,10 @@ const AIPanel = ({ data }) => {
                 viewModel.resultVisible && (React.createElement("div", { className: "dxrd-right-panel-header dxd-text-primary dxd-border-primary dxrd-ai-result-text" },
                     React.createElement("span", { className: "dxrd-right-panel-result-text" },
                         " ",
-                        viewModel.textProcessingResultHeaderTest,
+                        viewModel.textProcessingResultHeaderText,
                         " "),
                     React.createElement("div", { role: "button", className: "dxrd-right-panel-copy-button dx-accessibility-focus-border-accented", tabIndex: 0, onKeyDown: (e) => viewModel.copyText(data, e) },
-                        React.createElement(Template, { template: getCopyTemplate(), className: "dxd-icon-highlighted", onClick: (e) => viewModel.buttons.copyResultButton.onClick(e) })))),
+                        React.createElement(Template, { template: data.model?.copyButtonTemplate, className: "dxd-icon-highlighted", onClick: (e) => viewModel.buttons.copyResultButton.onClick(e) })))),
                 React.createElement(TextArea, { id: "dxrd-ai-panel-text-area-id", tabIndex: 0, className: "dx-accessibility-focus-border-accented dxrd-preview-ai-panel-textarea dxd-back-primary2", value: viewModel.aiProcessingResultText, onInput: (e) => e.event.preventDefault(), onPaste: (e) => e.event.preventDefault(), onKeyDown: (e) => e.event.key !== 'Tab' && e.event.preventDefault(), hoverStateEnabled: false })),
             React.createElement(Popup, { width: 350, height: 200, shading: false, focusStateEnabled: false, visible: viewModel.warningTextLimitPopupVisible, container: '#dxrd-preview-ai-panel-id', showCloseButton: false, showTitle: false, wrapperAttr: popupAttributes },
                 React.createElement(Position, { at: "top", my: "top", of: "#dxrd-preview-ai-panel-id", collision: "fit" }),

package/dx-report-viewer/components/reporting/ReportPreview/Page/Page.js

@@ -38,7 +38,7 @@ const Page = ({ data }) => {
             React.createElement("div", { className: "dxrd-report-preview-content-loading-panel dxrd-text-align-center", style: { paddingTop: data.height / 2.3 + 'px' } },
                 React.createElement("div", { className: "dxrd-report-preview-content-loading-panel-text" }, data.loadingText))),
         React.createElement(Image, { data: data }),
-        data.activeBricks.length > 0 && (React.createElement("div", { style: { position: 'absolute', top: data.smartTagAIMenuPosition.topP, left: data.smartTagAIMenuPosition.leftP, right: data.smartTagAIMenuPosition.rightP, height: data.smartTagAIMenuPosition.heightP, width: data.smartTagAIMenuPosition.widthP } },
+        data.aiServicesEnabled && data.activeBricks.length > 0 && (React.createElement("div", { style: { position: 'absolute', top: data.smartTagAIMenuPosition.topP, left: data.smartTagAIMenuPosition.leftP, right: data.smartTagAIMenuPosition.rightP, height: data.smartTagAIMenuPosition.heightP, width: data.smartTagAIMenuPosition.widthP } },
             React.createElement(Menu, { dataSource: data.smartTagAIMenu.dataSource, hideSubmenuOnMouseLeave: data.smartTagAIMenu.hideSubmenuOnMouseLeave, elementAttr: menuAttributes, visible: data.smartTagAIMenu.visible, itemRender: renderMenuItemTemplate, showFirstSubmenuMode: 'onHover', onItemClick: (e) => typeof data.smartTagAIMenu.onItemClick === 'function' && data.smartTagAIMenu.onItemClick(e) })))));
 };
 export default Page;

package/dx-report-viewer/dx-parameters-panel/DxParametersPanel.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { JSReportParametersPanel } from 'devexpress-reporting/viewer/binding/jsReportParametersPanel';
+import { TemplateEngine } from '../core/template-engine';
+import '@devexpress/analytics-core/dx-analytics-core-svg-templates';
+import 'devexpress-reporting/dx-reporting-svg-templates';
+export type DxParametersPanelProps = {
+    height?: string;
+    width?: string;
+    cssClass?: string;
+    templateEngine?: TemplateEngine;
+    accessibilityCompliant?: boolean;
+    keepReportOnComponentDisposal?: boolean;
+    reportUrl?: string;
+    rtl?: boolean;
+    developmentMode?: boolean;
+    children?: React.ReactNode;
+};
+export type DxParametersPanelRef = {
+    instance: () => JSReportParametersPanel;
+};
+declare const DxParametersPanel: React.ForwardRefExoticComponent<DxParametersPanelProps & React.RefAttributes<DxParametersPanelRef>>;
+export default DxParametersPanel;

package/dx-report-viewer/dx-parameters-panel/DxParametersPanel.js

@@ -0,0 +1,87 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import Callbacks from './options/ParametersPanelCallbacks';
+import RequestOptions from './options/ParametersPanelRequestOptions';
+import OptionsManager from '../../core/options-manager';
+import { TemplateEngine } from '../core/template-engine';
+import { JSReportParametersPanelBinding } from 'devexpress-reporting/viewer/binding/jsReportParametersPanelBinding';
+import AccessibilitySettingsProvider from '../components/core/AccessibilitySettingsProvider';
+import TemplateEngineProvider from '../components/core/TemplateEngineProvider';
+import Template from '../components/core/Template';
+import { ViewModelChangedEvent, viewModelGeneratorSettings } from '@devexpress/analytics-core/serializer/native/viewModels/viewModelGenerator';
+import '@devexpress/analytics-core/dx-analytics-core-svg-templates';
+import 'devexpress-reporting/dx-reporting-svg-templates';
+const validChildComponents = {
+    'callbacks': { component: Callbacks },
+    'requestOptions': { component: RequestOptions },
+};
+const DxParametersPanel = React.forwardRef(({ reportUrl, ...props }, ref) => {
+    const parametersPanelRef = React.useRef(null);
+    const [viewModel, setViewModel] = React.useState(null);
+    const [parametersPanelBinding, setParametersPanelBinding] = React.useState(null);
+    React.useImperativeHandle(ref, () => ({
+        instance() {
+            return parametersPanelBinding?.sender;
+        }
+    }), [parametersPanelBinding]);
+    viewModelGeneratorSettings.ensureChangesImmutable = false;
+    React.useEffect(() => {
+        if (parametersPanelBinding && viewModel) {
+            parametersPanelBinding.sender.OpenReport(reportUrl);
+            setViewModel({ ...viewModel });
+        }
+    }, [reportUrl]);
+    React.useEffect(() => {
+        let disposeViewModelSubscription;
+        const updateViewModel = (model) => {
+            const viewModel = model.GetPreviewModel()?.getViewModel();
+            setViewModel({ ...viewModel });
+            disposeViewModelSubscription && disposeViewModelSubscription();
+            disposeViewModelSubscription = viewModel?._viewModelEvents?.on(ViewModelChangedEvent, () => setViewModel({ ...viewModel }));
+        };
+        const controlOptions = OptionsManager.getControlOptions({ ...props, reportUrl }, DxParametersPanel.propTypes, DxParametersPanelProps, validChildComponents);
+        let binding;
+        binding = new JSReportParametersPanelBinding({ ...controlOptions, callbacks: {} }, OptionsManager.getEventRaiser(controlOptions.callbacks, () => binding?.sender), false);
+        binding.applyBindings(parametersPanelRef.current);
+        setParametersPanelBinding(binding);
+        const model = binding.sender;
+        updateViewModel(model);
+        const disposeModelSubscription = model.events.on('propertyChanged', (args) => {
+            if (args.propertyName === 'previewModel') {
+                updateViewModel(model);
+            }
+        });
+        return () => {
+            disposeModelSubscription && disposeModelSubscription();
+            disposeViewModelSubscription && disposeViewModelSubscription();
+            setViewModel(null);
+            setParametersPanelBinding(null);
+            setTimeout(() => {
+                binding && binding.dispose();
+            });
+        };
+    }, []);
+    return (React.createElement(TemplateEngineProvider, { templateEngine: props.templateEngine ?? new TemplateEngine() },
+        React.createElement(AccessibilitySettingsProvider, { value: { accessibilityCompliant: !!viewModel?.accessibilityCompliant } },
+            React.createElement("div", { ref: parametersPanelRef, className: props.cssClass, style: { width: props.width || DxParametersPanelProps.width, height: props.height || DxParametersPanelProps.height } },
+                React.createElement("div", { className: "dx-designer" }, !!viewModel && React.createElement(Template, { template: "dx-designer", data: viewModel }))))));
+});
+DxParametersPanel.displayName = 'DxParametersPanel';
+DxParametersPanel.propTypes = {
+    height: PropTypes.string,
+    width: PropTypes.string,
+    cssClass: PropTypes.string,
+    templateEngine: PropTypes.instanceOf(TemplateEngine),
+    accessibilityCompliant: PropTypes.bool,
+    keepReportOnComponentDisposal: PropTypes.bool,
+    reportUrl: PropTypes.string,
+    rtl: PropTypes.bool,
+    developmentMode: PropTypes.bool,
+    children: PropTypes.node,
+};
+const DxParametersPanelProps = {
+    height: '100%',
+    width: '100%',
+    cssClass: '',
+};
+export default DxParametersPanel;

package/dx-report-viewer/dx-parameters-panel/index.d.ts

@@ -0,0 +1,6 @@
+import DxParametersPanel, { DxParametersPanelProps, DxParametersPanelRef } from './DxParametersPanel';
+import Callbacks from './options/ParametersPanelCallbacks';
+import RequestOptions from './options/ParametersPanelRequestOptions';
+export { Callbacks, RequestOptions, DxParametersPanel as DxReportViewer, };
+export type { DxParametersPanelProps as DxReportViewerProps, DxParametersPanelRef as DxReportViewerRef };
+export default DxParametersPanel;

package/dx-report-viewer/dx-parameters-panel/index.js

@@ -0,0 +1,5 @@
+import DxParametersPanel from './DxParametersPanel';
+import Callbacks from './options/ParametersPanelCallbacks';
+import RequestOptions from './options/ParametersPanelRequestOptions';
+export { Callbacks, RequestOptions, DxParametersPanel as DxReportViewer, };
+export default DxParametersPanel;

package/dx-report-viewer/dx-parameters-panel/options/ParametersPanelCallbacks.d.ts

@@ -0,0 +1,5 @@
+import { FunctionComponent } from 'react';
+import { BaseCallbacksPropsType } from '../../options/_baseCallbacks';
+type ParametersPanelCallbacksPropsType = BaseCallbacksPropsType & {};
+declare const ParametersPanelCallbacks: FunctionComponent<ParametersPanelCallbacksPropsType>;
+export default ParametersPanelCallbacks;

package/dx-report-viewer/dx-parameters-panel/options/ParametersPanelCallbacks.js

@@ -0,0 +1,7 @@
+import BaseCallbacks from '../../options/_baseCallbacks';
+const ParametersPanelCallbacks = () => null;
+ParametersPanelCallbacks.displayName = 'DxParametersPanelCallbacks';
+ParametersPanelCallbacks.propTypes = {
+    ...BaseCallbacks.propTypes
+};
+export default ParametersPanelCallbacks;

package/dx-report-viewer/dx-parameters-panel/options/ParametersPanelRequestOptions.d.ts

@@ -0,0 +1,5 @@
+import { FunctionComponent } from 'react';
+import { BaseRequestOptionsPropsType } from '../../options/_baseRequestOptions';
+type ParametersPanelRequestOptionsPropsType = BaseRequestOptionsPropsType & {};
+declare const ParametersPanelRequestOptions: FunctionComponent<ParametersPanelRequestOptionsPropsType>;
+export default ParametersPanelRequestOptions;

package/dx-report-viewer/dx-parameters-panel/options/ParametersPanelRequestOptions.js

@@ -0,0 +1,7 @@
+import BaseRequestOptions from '../../options/_baseRequestOptions';
+const ParametersPanelRequestOptions = () => null;
+ParametersPanelRequestOptions.displayName = 'DxParametersPanelRequestOptions';
+ParametersPanelRequestOptions.propTypes = {
+    ...BaseRequestOptions.propTypes
+};
+export default ParametersPanelRequestOptions;

package/dx-report-viewer/options/Callbacks.d.ts

@@ -1,21 +1,13 @@
 import { FunctionComponent } from 'react';
-type CallbacksPropsType = {
+import { BaseCallbacksPropsType } from './_baseCallbacks';
+export type ReportViewerCallbacksPropsType = BaseCallbacksPropsType & {
     CustomizeElements?: (args: any) => void;
     PreviewClick?: (args: any) => void;
     EditingFieldChanged?: (args: any) => void;
     DocumentReady?: (args: any) => void;
     CustomizeExportOptions?: (args: any) => void;
-    CustomizeParameterEditors?: (args: any) => void;
-    CustomizeParameterLookUpSource?: (args: any) => void;
-    ParametersReset?: (args: any) => void;
-    ParametersSubmitted?: (args: any) => void;
-    ParametersInitialized?: (args: any) => void;
     CustomizeMenuActions?: (args: any) => void;
-    CustomizeLocalization?: (args: any) => void;
-    OnInitializing?: (args: any) => void;
-    BeforeRender?: (args: any) => void;
-    OnServerError?: (args: any) => void;
     OnExport?: (args: any) => void;
 };
-declare const Callbacks: FunctionComponent<CallbacksPropsType>;
-export default Callbacks;
+declare const ReportViewerCallbacks: FunctionComponent<ReportViewerCallbacksPropsType>;
+export default ReportViewerCallbacks;

package/dx-report-viewer/options/Callbacks.js

@@ -1,22 +1,15 @@
 import PropTypes from 'prop-types';
-const Callbacks = () => null;
-Callbacks.displayName = 'DxReportViewerCallbacks';
-Callbacks.propTypes = {
+import BaseCallbacks from './_baseCallbacks';
+const ReportViewerCallbacks = () => null;
+ReportViewerCallbacks.displayName = 'DxReportViewerCallbacks';
+ReportViewerCallbacks.propTypes = {
+    ...BaseCallbacks.propTypes,
     CustomizeElements: PropTypes.func,
     PreviewClick: PropTypes.func,
     EditingFieldChanged: PropTypes.func,
     DocumentReady: PropTypes.func,
     CustomizeExportOptions: PropTypes.func,
-    CustomizeParameterEditors: PropTypes.func,
-    CustomizeParameterLookUpSource: PropTypes.func,
-    ParametersReset: PropTypes.func,
-    ParametersSubmitted: PropTypes.func,
-    ParametersInitialized: PropTypes.func,
     CustomizeMenuActions: PropTypes.func,
-    CustomizeLocalization: PropTypes.func,
-    OnInitializing: PropTypes.func,
-    BeforeRender: PropTypes.func,
-    OnServerError: PropTypes.func,
     OnExport: PropTypes.func,
 };
-export default Callbacks;
+export default ReportViewerCallbacks;

package/dx-report-viewer/options/RequestOptions.d.ts

@@ -1,8 +1,5 @@
 import { FunctionComponent } from 'react';
-type RequestOptionsPropsType = {
-    invokeAction: string;
-    getLocalizationAction?: string;
-    host: string;
-};
-declare const RequestOptions: FunctionComponent<RequestOptionsPropsType>;
-export default RequestOptions;
+import { BaseRequestOptionsPropsType } from './_baseRequestOptions';
+export type ReportViewerRequestOptionsPropsType = BaseRequestOptionsPropsType & {};
+declare const ReportViewerRequestOptions: FunctionComponent<ReportViewerRequestOptionsPropsType>;
+export default ReportViewerRequestOptions;

package/dx-report-viewer/options/RequestOptions.js

@@ -1,12 +1,7 @@
-import PropTypes from 'prop-types';
-const RequestOptions = () => null;
-RequestOptions.displayName = 'DxReportViewerRequestOptions';
-RequestOptions.propTypes = {
-    invokeAction: PropTypes.string.isRequired,
-    getLocalizationAction: PropTypes.string,
-    host: PropTypes.string.isRequired,
+import BaseRequestOptions from './_baseRequestOptions';
+const ReportViewerRequestOptions = () => null;
+ReportViewerRequestOptions.displayName = 'DxReportViewerRequestOptions';
+ReportViewerRequestOptions.propTypes = {
+    ...BaseRequestOptions.propTypes
 };
-RequestOptions.defaultProps = {
-    invokeAction: '/DXXRDV',
-};
-export default RequestOptions;
+export default ReportViewerRequestOptions;

package/dx-report-viewer/options/_baseCallbacks.d.ts

@@ -0,0 +1,14 @@
+import { FunctionComponent } from 'react';
+export type BaseCallbacksPropsType = {
+    CustomizeParameterEditors?: (args: any) => void;
+    CustomizeParameterLookUpSource?: (args: any) => void;
+    ParametersReset?: (args: any) => void;
+    ParametersSubmitted?: (args: any) => void;
+    ParametersInitialized?: (args: any) => void;
+    CustomizeLocalization?: (args: any) => void;
+    OnInitializing?: (args: any) => void;
+    BeforeRender?: (args: any) => void;
+    OnServerError?: (args: any) => void;
+};
+declare const Callbacks: FunctionComponent<BaseCallbacksPropsType>;
+export default Callbacks;

package/dx-report-viewer/options/_baseCallbacks.js

@@ -0,0 +1,15 @@
+import PropTypes from 'prop-types';
+const Callbacks = () => null;
+Callbacks.displayName = 'DxReportViewerBaseCallbacks';
+Callbacks.propTypes = {
+    CustomizeParameterEditors: PropTypes.func,
+    CustomizeParameterLookUpSource: PropTypes.func,
+    ParametersReset: PropTypes.func,
+    ParametersSubmitted: PropTypes.func,
+    ParametersInitialized: PropTypes.func,
+    CustomizeLocalization: PropTypes.func,
+    OnInitializing: PropTypes.func,
+    BeforeRender: PropTypes.func,
+    OnServerError: PropTypes.func,
+};
+export default Callbacks;

package/dx-report-viewer/options/_baseRequestOptions.d.ts

@@ -0,0 +1,8 @@
+import { FunctionComponent } from 'react';
+export type BaseRequestOptionsPropsType = {
+    invokeAction: string;
+    getLocalizationAction?: string;
+    host: string;
+};
+declare const BaseRequestOptions: FunctionComponent<BaseRequestOptionsPropsType>;
+export default BaseRequestOptions;

package/dx-report-viewer/options/_baseRequestOptions.js

@@ -0,0 +1,12 @@
+import PropTypes from 'prop-types';
+const BaseRequestOptions = () => null;
+BaseRequestOptions.displayName = 'DxReportViewerBaseRequestOptions';
+BaseRequestOptions.propTypes = {
+    invokeAction: PropTypes.string.isRequired,
+    getLocalizationAction: PropTypes.string,
+    host: PropTypes.string.isRequired,
+};
+BaseRequestOptions.defaultProps = {
+    invokeAction: '/DXXRDV',
+};
+export default BaseRequestOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devexpress-reporting-react",
-  "version": "24.2.2-beta",
+  "version": "24.2.5",
   "homepage": "https://www.devexpress.com/",
   "bugs": "https://www.devexpress.com/support/",
   "author": "Developer Express Inc.",
@@ -15,18 +15,19 @@
   "license": "SEE LICENSE IN README.md",
   "main": "./index.js",
   "dependencies": {
-    "devexpress-reporting": "24.2.2-beta",
+    "devexpress-reporting": "24.2.5",
     "prop-types": "^15.8.1"
   },
   "peerDependencies": {
+    "@types/prop-types": "15.7.13",
     "@types/react": "^18.0.28",
     "@types/react-dom": "^18.0.28",
-    "devextreme-react": "24.2.2-beta",
+    "devextreme-react": "24.2.5",
     "react": "^18.0.28",
     "react-dom": "^18.0.28"
   },
   "devDependencies": {
-    "@devexpress/analytics-core": "24.2.2-beta",
+    "@devexpress/analytics-core": "24.2.5",
     "shx": "^0.3.4",
     "typescript": "<5.3.0"
   },
@@ -34,5 +35,5 @@
     "prebuild": "npx shx rm -rf dist && npx shx mkdir dist && npx shx cp README.md dist/ && npx shx cp package.json dist/",
     "build": "npx tsc --project tsconfig.lib.json"
   },
-  "commitSHA": "cc41462435ed6449af1ecfedef0f3bc179dea83c"
+  "commitSHA": "eadbde5419c7c681a9b7959ed350211c84633c06"
 }