devexpress-reporting 23.2.0-build-000-1111 → 23.2.2-beta

package/viewer/parameters/previewParametersViewModel.js

@@ -1,17 +1,24 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\parameters\previewParametersViewModel.js)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
-import { AccordionKeyboardHelper, ajax } from '@devexpress/analytics-core/analytics-internal';
-import { getLocalization, TabInfoWithPropertyGrid } from '@devexpress/analytics-core/analytics-utils';
-import * as ko from 'knockout';
+/**
+* DevExpress HTML/JS Reporting (viewer\parameters\previewParametersViewModel.js)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { PropertyGridKeyboardHelper, ajax } from '@devexpress/analytics-core/analytics-internal-native';
+import { getLocalization, TabInfoWithPropertyGrid } from '@devexpress/analytics-core/analytics-utils-native';
 import { HandlerUri } from '../settings';
 import { ParameterPanelItemBase } from './parameterPanelItemBase';
 import { PreviewParameter } from './previewParameter';
 import * as $ from 'jquery';
+import { mutable, subscribableProperty, nativeMultiPlatformEngine, BaseEmptyModel } from '@devexpress/analytics-core/analytics-serializer-native';
+import { createPreviewParametersViewModel, updateViewModel } from './previewParametersViewModel.viewmodel';
 export class PreviewParametersViewModel extends ParameterPanelItemBase {
     constructor(reportPreview, parameterHelper, enableKeyboardSupport) {
         super(parameterHelper);
@@ -29,46 +36,43 @@ export class PreviewParametersViewModel extends ParameterPanelItemBase {
                         var matchedParameter = parametersViewModel._parameters.filter((p) => { return p.path === parametersInfoCollection.Key; })[0];
                         if (!parametersViewModel._shouldProcessParameter(matchedParameter))
                             return;
-                        matchedParameter.visible(parametersInfoCollection.Value.visible);
-                        matchedParameter.enabled(parametersInfoCollection.Value.enabled);
+                        matchedParameter.visible = parametersInfoCollection.Value.visible;
+                        matchedParameter.enabled = parametersInfoCollection.Value.enabled;
                         if (parametersViewModel._parameters.indexOf(changedParameter) < parametersViewModel._parameters.indexOf(matchedParameter) && parametersInfoCollection.Value.lookUpValues != null) {
                             parametersViewModel._setLookUpValues(matchedParameter, parametersInfoCollection.Value.lookUpValues);
                         }
                     });
                 }
                 finally {
-                    parametersViewModel.parametersLoading(false);
+                    parametersViewModel.parametersLoading = false;
                 }
             };
         };
         this._getFailGetParametersStateHandler = () => {
             var parametersViewModel = this;
             return (jqXHRError) => {
-                parametersViewModel.parametersLoading(false);
+                parametersViewModel.parametersLoading = false;
             };
         };
         this.restore = () => {
-            if (this.parametersLoading()) {
+            if (this.parametersLoading) {
                 return;
             }
             try {
-                this.parametersLoading(true);
+                this.parametersLoading = true;
                 this._parameters.forEach((parameter) => {
                     if (!this._shouldProcessParameter(parameter))
                         return;
-                    parameter.lookUpValues(parameter._originalLookUpValues);
+                    parameter.lookUpValues = parameter._originalLookUpValues;
                     parameter.initialize(parameter._originalValue, this.parameterHelper);
                 });
             }
             finally {
                 this.parameterHelper.callbacks && this.parameterHelper.callbacks.parametersReset && this.parameterHelper.callbacks.parametersReset(this, this._parameters);
-                this.parametersLoading(false);
+                this.parametersLoading = false;
             }
         };
-        this.getInfo = ko.observable(null);
-        this.needToUpdateParameter = ko.observable(false);
         this.processInvisibleParameters = false;
-        this.parametersLoading = ko.observable(false);
         this.prevParametersStateRequest = $.Deferred();
         this._reportPreview = reportPreview;
         this.validateAndSubmit = (params) => {
@@ -77,52 +81,59 @@ export class PreviewParametersViewModel extends ParameterPanelItemBase {
                 this.submit();
         };
         this.submit = () => {
-            if (this.parametersLoading())
+            if (this.parametersLoading)
                 return;
-            this.parametersLoading(true);
+            this.parametersLoading = true;
             var promise = reportPreview.startBuild();
-            promise && promise.done((val) => { this.parametersLoading(false); });
+            promise && promise.done((val) => { this.parametersLoading = false; });
         };
-        this._disposables.push(reportPreview.originalParametersInfo.subscribe((originalParametersInfo) => {
-            this.initialize(originalParametersInfo);
+        this.addDisposable(reportPreview.events.on('originalParametersInfoChanged', (args) => {
+            this.initialize(args.newValue);
         }));
-        this.initialize(reportPreview.originalParametersInfo());
-        var notEmpty = ko.pureComputed(() => !this.isEmpty());
+        this.initialize(reportPreview.originalParametersInfo);
+        this._popupVisible = !this.isEmpty && this._popupVisibleSwitch;
+        this.popupInfo = { visible: this._popupVisible, notEmpty: !this.isEmpty };
+        const keyboardHelperViewModelAccessor = () => this.tabInfo.getViewModel().propertyGrid.editors;
+        const keyboardHelper = enableKeyboardSupport ? new PropertyGridKeyboardHelper(keyboardHelperViewModelAccessor) : undefined;
         this.tabInfo = new TabInfoWithPropertyGrid({
             text: 'Parameters',
             template: 'dxrd-preview-parameters',
-            model: this,
-            keyboardHelper: enableKeyboardSupport ? new AccordionKeyboardHelper() : undefined,
+            model: this.getViewModel(),
+            propertyGridModel: this,
+            keyboardHelper,
             localizationId: 'PreviewStringId.RibbonPreview_Parameters_Caption',
             imageClassName: 'parameters',
             imageTemplateName: 'dxrd-svg-tabs-parameters',
-            visible: notEmpty
+            visible: !this.isEmpty,
+            engineType: 'native'
         });
-        var popupVisibleSwitch = ko.observable(false);
-        var popupVisible = ko.pureComputed({
-            read: () => {
-                return notEmpty() && popupVisibleSwitch();
-            },
-            write: (newVal) => {
-                return popupVisibleSwitch(newVal);
+        this._disposables.push({
+            dispose: () => {
+                var _a;
+                clearTimeout(this._updateParametersTimeOut);
+                (_a = this.prevParametersStateRequest) === null || _a === void 0 ? void 0 : _a.reject();
             }
         });
-        this.popupInfo = { visible: popupVisible, notEmpty: notEmpty };
-        this._disposables.push(this.popupInfo);
+    }
+    createViewModel() {
+        return createPreviewParametersViewModel.call(this, super.createViewModel());
+    }
+    updateViewModel(args) {
+        updateViewModel.call(this);
     }
     get _visibleParameters() {
-        return this._parameters.filter((p) => { return p.visible(); });
+        return this._parameters.filter((p) => { return p.visible; });
     }
     _shouldProcessParameter(param) {
-        return this.processInvisibleParameters || (param && (param.visible() || param.hasVisibleExpression || param.isFilteredLookUpSettings));
+        return this.processInvisibleParameters || (param && (param.visible || param.hasVisibleExpression || param.isFilteredLookUpSettings));
     }
     subscribeParameter(parameter) {
-        var needToUpdateParameter = this.needToUpdateParameter() || (this._shouldProcessParameter(parameter)) &&
+        var needToUpdateParameter = this._needToUpdateParameter || (this._shouldProcessParameter(parameter)) &&
             (parameter.isFilteredLookUpSettings || parameter.hasBindedExpressions);
-        this.needToUpdateParameter(needToUpdateParameter);
+        this._needToUpdateParameter = needToUpdateParameter;
         if (this._shouldProcessParameter(parameter)) {
-            this._disposables.push((parameter.isMultiValueWithLookUp ? parameter._value : parameter.value).subscribe((newValue) => {
-                if (this.needToUpdateParameter()) {
+            this.addDisposable(parameter.events.on(`${parameter.isMultiValueWithLookUp ? '_value' : 'value'}Changed`, (newValue) => {
+                if (this._needToUpdateParameter) {
                     this.updateParameters(parameter);
                 }
             }));
@@ -130,10 +141,10 @@ export class PreviewParametersViewModel extends ParameterPanelItemBase {
     }
     _setLookUpValues(parameter, lookUpValues) {
         if (!lookUpValues) {
-            parameter.lookUpValues([]);
+            parameter.lookUpValues = [];
             return;
         }
-        parameter.lookUpValues(this.parameterHelper.mapLookUpValues(parameter.type, lookUpValues));
+        parameter.lookUpValues = this.parameterHelper.mapLookUpValues(parameter.type, lookUpValues);
         var _parameterValuesContainedInLookUps = this._getParameterValuesContainedInLookups(lookUpValues, parameter);
         if (parameter.isMultiValue) {
             parameter.initialize(_parameterValuesContainedInLookUps.length > 0 ? _parameterValuesContainedInLookUps : [], this.parameterHelper);
@@ -145,11 +156,11 @@ export class PreviewParametersViewModel extends ParameterPanelItemBase {
     _getParameterValuesContainedInLookups(parameterLookUpValues, parameter) {
         if (parameterLookUpValues) {
             if (parameter.isMultiValue) {
-                var selectedItems = parameter.value().value();
+                var selectedItems = parameter.value.value;
                 return selectedItems.filter((item) => this._filterParameterValuesContainsInLookups(parameterLookUpValues, parameter.type, item).length > 0);
             }
             else {
-                return this._filterParameterValuesContainsInLookups(parameterLookUpValues, parameter.type, parameter.value());
+                return this._filterParameterValuesContainsInLookups(parameterLookUpValues, parameter.type, parameter.value);
             }
         }
         return [];
@@ -163,11 +174,11 @@ export class PreviewParametersViewModel extends ParameterPanelItemBase {
             if (value && !Array.isArray(value))
                 throw new Error(`The '${parameter.path}' parameter must be an array.`);
             if (descriptor.hasLookUpValues) {
-                parameter.value().value(value);
+                parameter.value.value = value;
             }
             else {
-                var parameterValues = this.parameterHelper.createMultiValueArray(value, parameter)();
-                parameter.value(parameterValues);
+                var parameterValues = this.parameterHelper.createMultiValueArray(value, parameter);
+                parameter.value = parameterValues;
             }
         }
         else {
@@ -180,6 +191,24 @@ export class PreviewParametersViewModel extends ParameterPanelItemBase {
             throw new Error(`The '${parameterName}' parameter is not found.`);
         this._setParameterValue(parameter, value);
     }
+    onPropertyChanged(args) {
+        if (args.propertyName === 'isEmpty') {
+            this.tabInfo.visible = !this.isEmpty;
+            if (this.popupInfo)
+                this.popupInfo.notEmpty = !this.isEmpty;
+        }
+        if (args.propertyName === '_popupVisible') {
+            this._popupVisibleSwitch = this._popupVisible;
+            if (this.popupInfo)
+                this.popupInfo.visible = this._popupVisible;
+        }
+        if (args.propertyName == '_popupVisibleSwitch' || args.propertyName === 'isEmpty') {
+            this._popupVisible = !this.isEmpty && this._popupVisibleSwitch;
+        }
+        if (args.propertyName == '_getInfo') {
+            this.tabInfo && this.tabInfo.propertyGrid.updateEditorsInfo(this, this.getInfo());
+        }
+    }
     initialize(originalParametersInfo) {
         originalParametersInfo && this.parameterHelper.initialize(originalParametersInfo.knownEnums);
         super.initialize(originalParametersInfo);
@@ -189,52 +218,61 @@ export class PreviewParametersViewModel extends ParameterPanelItemBase {
         if ((!layout || layout.layoutItems.length === 0) && originalParametersInfo.parameters) {
             this._parameters.forEach(x => this._add(x, {}));
         }
-        this.isEmpty(this._visibleParameters.length === 0);
+        this.isEmpty = this._visibleParameters.length === 0;
         var actualParametersInfo = [];
         this._parameters.forEach(x => {
             this.subscribeParameter(x);
-            var value = ko.computed({
+            const model = new BaseEmptyModel();
+            this.addDisposable(nativeMultiPlatformEngine.createComputedProperty(model, 'value', {
                 read: () => {
                     return x.serialize().Value;
                 },
                 write: (newVal) => {
                     this._setParameterValue(x, newVal);
                 }
-            });
-            var selectAll = ko.computed({
+            }, [
+                subscribableProperty(x, '*')
+            ]));
+            this.addDisposable(nativeMultiPlatformEngine.createComputedProperty(model, 'selectAll', {
                 read: () => {
-                    var _a;
-                    return ((_a = x.value()) === null || _a === void 0 ? void 0 : _a.isSelectedAll) && x.value().isSelectedAll();
+                    const value = x.value;
+                    return value === null || value === void 0 ? void 0 : value.isSelectedAll;
                 },
                 write: (newVal) => {
-                    var _a;
-                    ((_a = x.value()) === null || _a === void 0 ? void 0 : _a.isSelectedAll) && x.value().isSelectedAll(newVal);
+                    const value = x.value;
+                    if (value === null || value === void 0 ? void 0 : value.isSelectedAll) {
+                        value.isSelectedAll = newVal;
+                    }
                 }
-            });
-            this._disposables.push(selectAll);
-            this._disposables.push(value);
-            actualParametersInfo.push({
-                value,
-                selectAll,
-                parameterDescriptor: x.getParameterDescriptor(),
-                lookUpValues: x.lookUpValues
-            });
+            }, [
+                subscribableProperty(x, [{
+                        propertyName: 'value',
+                        subscribables: ['isSelectedAll']
+                    }
+                ])
+            ]));
+            model['parameterDescriptor'] = x.getParameterDescriptor(),
+                this.addDisposable(nativeMultiPlatformEngine.createComputedProperty(model, 'lookUpValues', {
+                    read: () => x.lookUpValues,
+                    write: (newVal) => x.lookUpValues = newVal
+                }, [subscribableProperty(x, ['lookUpValues'])]));
+            actualParametersInfo.push(model);
         });
         if (this.parameterHelper.callbacks && this.parameterHelper.callbacks.parametersInitialized) {
             this.parameterHelper.callbacks.parametersInitialized(this, actualParametersInfo, this.submit, originalParametersInfo.shouldRequestParameters);
         }
         if (this._reportPreview.documentId)
             return;
-        if (!originalParametersInfo.shouldRequestParameters || this.isEmpty()) {
+        if (!originalParametersInfo.shouldRequestParameters || this.isEmpty) {
             this.submit();
         }
         else {
             this._reportPreview.removeEmptyPages();
-            this.tabInfo.active(true);
-            if (this.tabInfo.visible() && ko.isWriteableObservable(this.tabInfo.collapsed))
-                this.tabInfo.collapsed(false);
-            this.popupInfo.visible(true);
-            this._reportPreview.pageLoading(false);
+            this.tabInfo.active = true;
+            if (this.tabInfo.visible && this.tabInfo.collapsed !== undefined)
+                this.tabInfo.collapsed = false;
+            this._popupVisible = true;
+            this._reportPreview.pageLoading = false;
         }
     }
     getPathsAfterPath(parameterPath) {
@@ -261,24 +299,47 @@ export class PreviewParametersViewModel extends ParameterPanelItemBase {
         if (!requiredParameterPaths || requiredParameterPaths.length === 0) {
             return;
         }
-        var argsObject = {
-            reportId: this._reportPreview.reportId,
-            reportUrl: this._reportPreview.reportUrl,
-            requiredParameterPaths: requiredParameterPaths,
-            parameters: this.serializeParameters(),
-            changedParameterPath: changedParameter.path,
-            timeZoneOffset: 0 - new Date().getTimezoneOffset()
+        var changedParameterIndex = this._parameters.indexOf(changedParameter);
+        var updateTopChangedParameter = (index, changedParameter, requiredParameterPaths) => {
+            this._topChangedParameter = { index: index, changedParameter: changedParameter, requiredParameterPaths: requiredParameterPaths };
         };
+        if (this._topChangedParameter && changedParameterIndex !== -1) {
+            if (this._topChangedParameter.index > changedParameterIndex)
+                updateTopChangedParameter(changedParameterIndex, changedParameter, requiredParameterPaths);
+            return;
+        }
+        updateTopChangedParameter(changedParameterIndex, changedParameter, requiredParameterPaths);
         this.prevParametersStateRequest.reject();
         var deferred = $.Deferred();
-        setTimeout(() => {
-            this.parametersLoading(true);
+        this._updateParametersTimeOut = setTimeout(() => {
+            this.parametersLoading = true;
+            var argsObject = {
+                reportId: this._reportPreview.reportId,
+                reportUrl: this._reportPreview.reportUrl,
+                requiredParameterPaths: this._topChangedParameter.requiredParameterPaths,
+                changedParameterPath: this._topChangedParameter.changedParameter.path,
+                parameters: this.serializeParameters(),
+                timeZoneOffset: 0 - new Date().getTimezoneOffset()
+            };
             this._getParametersStateRequest(argsObject)
                 .done((result) => deferred.resolve(result))
                 .fail(() => deferred.resolve());
-            deferred.done(this._getDoneGetParametersStateHandler(changedParameter));
+            deferred.done(this._getDoneGetParametersStateHandler(this._topChangedParameter.changedParameter));
             deferred.fail(this._getFailGetParametersStateHandler());
             this.prevParametersStateRequest = deferred;
-        }, 10);
+            this._topChangedParameter = null;
+        }, 20);
     }
 }
+__decorate([
+    mutable(false)
+], PreviewParametersViewModel.prototype, "_needToUpdateParameter", void 0);
+__decorate([
+    mutable(false)
+], PreviewParametersViewModel.prototype, "parametersLoading", void 0);
+__decorate([
+    mutable(true)
+], PreviewParametersViewModel.prototype, "_popupVisible", void 0);
+__decorate([
+    mutable(true)
+], PreviewParametersViewModel.prototype, "_popupVisibleSwitch", void 0);

package/viewer/parameters/previewParametersViewModel.viewmodel.d.ts

@@ -0,0 +1,20 @@
+/**
+* DevExpress HTML/JS Reporting (viewer\parameters\previewParametersViewModel.viewmodel.d.ts)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { IViewModel } from '@devexpress/analytics-core/analytics-serializer-native';
+import { PreviewParametersViewModel } from './previewParametersViewModel';
+import { Properties } from 'devextreme/ui/button';
+export interface IPreviewParametersViewModel extends IViewModel {
+    headerText: string;
+    emptyText: string;
+    isEmpty: boolean;
+    parametersLoading: boolean;
+    resetButton: Properties;
+    submitButton: Properties;
+}
+export declare function createPreviewParametersViewModel(this: PreviewParametersViewModel, baseModel: IPreviewParametersViewModel): IPreviewParametersViewModel;
+export declare function updateViewModel(this: PreviewParametersViewModel): void;

package/viewer/parameters/previewParametersViewModel.viewmodel.js

@@ -0,0 +1,30 @@
+/**
+* DevExpress HTML/JS Reporting (viewer\parameters\previewParametersViewModel.viewmodel.js)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { createViewModelGenerator } from '@devexpress/analytics-core/analytics-serializer-native';
+import { getLocalization } from '@devexpress/analytics-core/analytics-internal-native';
+export function createPreviewParametersViewModel(baseModel) {
+    return createViewModelGenerator(baseModel)
+        .generateProperty('headerText', getLocalization('Preview Parameters', 'ASPxReportsStringId.ReportDesigner_Preview_ParametersTitle'))
+        .generateProperty('emptyText', getLocalization('The report does not contain any parameters.', 'ASPxReportsStringId.WebDocumentViewer_NoParameters'))
+        .generateProperty('isEmpty', this.isEmpty)
+        .generateProperty('resetButton', {
+        text: getLocalization('Reset', 'ASPxReportsStringId.ParametersPanel_Reset'),
+        onClick: (e) => this.restore()
+    })
+        .generateProperty('submitButton', {
+        text: getLocalization('Submit', 'ASPxReportsStringId.ParametersPanel_Submit'),
+        onClick: (params) => this.validateAndSubmit(params)
+    })
+        .generateProperty('parametersLoading', this.parametersLoading)
+        .getViewModel();
+}
+export function updateViewModel() {
+    const viewModel = this.getViewModel();
+    viewModel.isEmpty = this.isEmpty;
+    viewModel.parametersLoading = this.parametersLoading;
+}

package/viewer/reportPreview.d.ts

@@ -1,37 +1,34 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\reportPreview.d.ts)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
+/**
+* DevExpress HTML/JS Reporting (viewer\reportPreview.d.ts)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
 /// <reference types="jquery" />
-import { Disposable } from '@devexpress/analytics-core/analytics-utils';
-import * as ko from 'knockout';
+import { ArrayPropertyChangedEventArgs, BaseRenderingModel, PropertyChangedEventArgs } from '@devexpress/analytics-core/analytics-serializer-native';
+import { TabPanel } from '@devexpress/analytics-core/analytics-utils-native';
 import { PreviewBricksKeyboardHelper } from './accessibility/_previewBricksKeyboardHelper';
+import { ZoomAutoBy } from './constants';
 import { IBookmarkNode } from './documentMap/_documentMapModel';
-import { EditingField, IEditingFieldModel } from './editing/editingField';
+import { EditingField, IEditingFieldSerializedModel } from './editing/editingField';
 import { ExportOptionsPreview } from './exportOptions/exportOptionsPreview';
 import { ExportHandler } from './internal/_exportHandler';
 import { PreviewPage } from './internal/_page';
+import { IPreviewPageViewModel } from './internal/_page.viewModel';
 import { PageLoader } from './internal/_pageLoader';
 import { IDocumentBuildStatus, PreviewHandlersHelper } from './internal/_previewHandlersHelper';
 import { ISignatureDisplayItem, PreviewRequestWrapper } from './internal/_previewRequestWrapper';
 import { IProgressHandler } from './internal/_progressViewModel';
-import { IReportParametersInfo } from './parameters/previewParametersViewModel';
+import { IReportParametersInfo, PreviewParametersViewModel } from './parameters/previewParametersViewModel';
+import { IReportPreviewViewModel } from './reportPreview.viewModel';
 import { IExportSettings, IPreviewCustomizationHandler, IPreviewExportOptionsCustomizationArgs, IPreviewInitialize } from './utils/initializer';
 import { IBrickNode, IBrickNodeNavigation, IDocumentOperationResult } from './utils/utils';
-export declare class ReportPreview extends Disposable {
+import { BreadcrumbModel } from './internal/_previewBreadcrumbs';
+export declare class ReportPreview extends BaseRenderingModel<IReportPreviewViewModel> {
     private enableKeyboardSupport?;
     private element?;
-    predefinedZoomLevels: ko.ObservableArray<number>;
-    _pageWidth: ko.Observable<number>;
-    _pageHeight: ko.Observable<number>;
-    _pageBackColor: ko.Observable<string>;
-    _currentReportId: ko.Observable<string>;
-    _currentReportUrl: ko.Observable<string>;
-    _currentDocumentId: ko.Observable<string>;
-    _unifier: ko.Observable<string>;
+    predefinedZoomLevels: number[];
     _stopBuildRequests: {
         [key: string]: boolean;
     };
@@ -44,10 +41,9 @@ export declare class ReportPreview extends Disposable {
     _cancelExportRequests: {
         [key: string]: boolean;
     };
-    _editingFields: ko.Observable<EditingField[]>;
+    _breadcrumb: BreadcrumbModel;
     private _openReportOperationDeferred;
     _startBuildOperationId: string;
-    private _editingValuesSubscriptions;
     private _drillDownState;
     private _sortingState;
     private _sortingProcessor;
@@ -60,20 +56,27 @@ export declare class ReportPreview extends Disposable {
     private _doDrillDown;
     private _doSorting;
     dispose(): void;
+    private _onDocumentBuildingChanged;
+    private _updateCurrentPage;
+    private _onOriginalZoomChanged;
+    private _onSignaturesChanged;
+    removePage(page: PreviewPage): void;
+    removeAllPages(): void;
     removeEmptyPages(all?: boolean): void;
     private _initialize;
-    createPage(pageIndex: number, processClick?: (target: IBrickNode) => void, loading?: ko.Observable<boolean>): PreviewPage;
+    createPage(pageIndex: number, processClick?: (target: IBrickNode) => void, subscribeToPageLoading?: boolean): PreviewPage;
     private _getIgnorePredicate;
     private _cleanTabInfo;
     private _clearReportInfo;
     createBrickClickProcessor(cyclePageIndex: number): (brick: IBrickNode, e?: JQueryEventObject) => void;
-    constructor(handlerUri?: string, previewRequestWrapper?: PreviewRequestWrapper, previewHandlersHelper?: PreviewHandlersHelper, callbacks?: IPreviewCustomizationHandler, rtl?: boolean, enableKeyboardSupport?: boolean, exportSettings?: IExportSettings, element?: Element);
+    constructor(handlerUri?: string, previewRequestWrapper?: PreviewRequestWrapper, previewHandlersHelper?: PreviewHandlersHelper, callbacks?: IPreviewCustomizationHandler, rtl?: boolean, enableKeyboardSupport?: boolean, exportSettings?: IExportSettings, element?: Element, breadcrumb?: BreadcrumbModel);
     delayedInit(): void;
     openReport(reportName: string): JQueryPromise<IPreviewInitialize>;
-    drillThrough(customData?: string, closeCurrentReport?: boolean): JQueryPromise<IPreviewInitialize>;
+    goToReport(customData?: string, closeCurrentReport?: boolean): JQueryPromise<IPreviewInitialize>;
+    drillThrough(drillThroughData: string): JQueryPromise<IPreviewInitialize>;
     _sortCustomParametersLookUpValues(reportParameterInfo?: IReportParametersInfo): void;
     _resolveFirstPage(status: IDocumentBuildStatus): void;
-    initialize(initializeDataPromise: JQueryPromise<IPreviewInitialize>): JQueryPromise<IPreviewInitialize>;
+    initialize(initializeDataPromise: JQueryPromise<IPreviewInitialize>, closeDocument?: boolean, submitParams?: boolean): JQueryPromise<IPreviewInitialize>;
     private _deserializeExportOptions;
     deactivate(): void;
     startBuild(): JQuery.Promise<boolean>;
@@ -93,54 +96,66 @@ export declare class ReportPreview extends Disposable {
     goToPage(pageIndex: number, forcePageChanging?: boolean, throttle?: number): void;
     private _goToPageTimer;
     getSelectedContent: (punctuationMark?: string) => string;
-    createEditingField(item: IEditingFieldModel, index: number): EditingField;
-    rtlReport: ko.Observable<boolean>;
+    createEditingField(item: IEditingFieldSerializedModel, index: number): EditingField;
     rtlViewer: boolean;
     exportHandler: ExportHandler;
     previewHandlersHelper: PreviewHandlersHelper;
-    currentPage: ko.Observable<PreviewPage>;
-    originalParametersInfo: ko.Observable<IReportParametersInfo>;
-    pageIndex: ko.Observable<number>;
-    showMultipagePreview: ko.Observable<boolean>;
-    documentMap: ko.Observable<IBookmarkNode>;
-    exportOptionsModel: ko.Observable<ExportOptionsPreview>;
-    pageLoading: ko.Observable<boolean>;
-    errorMessage: ko.Observable<string>;
-    documentBuilding: ko.Observable<boolean>;
-    reportOpening: ko.Observable<boolean>;
+    originalParametersInfo: IReportParametersInfo;
+    exportOptionsModel: ExportOptionsPreview;
+    errorMessage: string;
+    reportOpening: boolean;
     progressBar: IProgressHandler;
-    pages: ko.ObservableArray<PreviewPage>;
     customProcessBrickClick: (pageNamber: number, brick: IBrickNode, defaultHandler: () => void) => boolean;
+    documentReady: (documentId: string, reportId: string, pageCount: number) => void;
     brickClickDocumentMapHandler: (navigationBrick: IBrickNodeNavigation) => void;
     editingFieldChanged: (field: EditingField, oldVal: any, newVal: any) => void;
     customizeExportOptions: (options: IPreviewExportOptionsCustomizationArgs) => void;
-    isAutoFit: ko.Observable<boolean>;
-    autoFitBy: ko.Observable<number>;
-    exportDisabled: ko.PureComputed<boolean>;
-    _zoom: ko.Observable<number>;
-    zoom: ko.PureComputed<any>;
+    disposePagesChangedEvent: () => void;
+    exportDisabled: boolean;
+    private _updateExportDisabled;
+    tabPanel: TabPanel;
+    pages: PreviewPage[];
+    pageIndex: number;
+    currentPage: PreviewPage;
+    showMultipagePreview: boolean;
+    rtlReport: boolean;
+    editingFieldsHighlighted: boolean;
+    documentMap: IBookmarkNode;
+    pageLoading: boolean;
+    autoFitBy: ZoomAutoBy;
+    originalZoom: number;
+    zoom: number;
+    previewSize: number;
+    documentId: string;
+    reportId: string;
+    reportUrl: string;
+    documentBuilding: boolean;
+    _unifier: string;
+    _pageWidth: number;
+    _pageHeight: number;
+    _pageBackColor: string;
+    emptyDocumentCaption: string;
+    exportOptionsTabVisible: boolean;
+    previewVisible: boolean;
+    _editingFields: EditingField[];
+    onPropertyChanged(args: PropertyChangedEventArgs<ReportPreview>): void;
+    createViewModel(): IReportPreviewViewModel;
+    updateViewModel(args: PropertyChangedEventArgs<ReportPreview> | ArrayPropertyChangedEventArgs<ReportPreview>): void;
     editingFieldsProvider: () => EditingField[];
-    _currentPageText: ko.PureComputed<any>;
-    currentPageAriaLabelImgAlt(index: number): string;
     _getErrorMessage(jqXHR: JQuery.jqXHR): string;
     _processError(error: string, jqXHR?: JQuery.jqXHR, showForUser?: boolean, serverError?: string): void;
     _getToastMessageContainer(): Element;
     _raiseOnSizeChanged: () => void;
-    previewSize: ko.Observable<number>;
-    onSizeChanged: ko.Observable<any>;
-    previewVisible: ko.Observable<boolean>;
-    editingFieldsHighlighted: ko.Observable<boolean>;
+    _loadVisibleImages: (timeout?: number) => void;
+    _getPagesViewModels: () => IPreviewPageViewModel[];
     canSwitchToDesigner: boolean;
     allowURLsWithJSContent: boolean;
     requestWrapper: PreviewRequestWrapper;
-    zoomStep: ko.Observable<number>;
+    zoomStep: number;
     private _progressFirstTime;
-    emptyDocumentCaption: ko.PureComputed<string>;
-    get reportId(): string;
-    get reportUrl(): string;
-    get documentId(): string;
-    signatures: ko.ObservableArray<ISignatureDisplayItem>;
-    exportOptionsTabVisible: ko.Observable<boolean>;
+    private _updateEmptyDocumentCaption;
+    signatures: ISignatureDisplayItem[];
+    previewParametersViewModel: PreviewParametersViewModel;
     previewBrickKeyboardHelper: PreviewBricksKeyboardHelper;
     pageLoader: PageLoader;
 }