devexpress-reporting 23.1.5 → 23.2.1-alpha-23254-1700

package/viewer/mobile/internal/gallery/_galleryComponent.js

@@ -1,175 +1,252 @@
 /**
 * DevExpress HTML/JS Reporting (viewer\mobile\internal\gallery\_galleryComponent.js)
-* Version:  23.1.5
-* Build date: Aug 29, 2023
+* Version:  23.2.1-alpha-23254-1700
+* Build date: Sep 11, 2023
 * Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
 * License: https://www.devexpress.com/Support/EULAs/universal.xml
 */
-import { addDisposeCallback } from '@devexpress/analytics-core/analytics-internal';
+import { addDisposeCallback } from '@devexpress/analytics-core/analytics-internal-native';
 import registerComponent from 'devextreme/core/component_registrator';
 import 'devextreme/ui/gallery';
 import dxGallery from 'devextreme/ui/gallery';
 import * as $ from 'jquery';
-export class dxGalleryReportPreview extends dxGallery {
-    constructor(element, options) {
-        super(element, options);
-        this._animationClassName = 'dxrdp-gallery-item-animation';
-        this.currentBlockItem = null;
-        this.nextBlockItem = null;
-        this.initializeBlockItems = () => {
-            this.blockItems = [];
-            var $items = this['_getAvailableItems']();
+export class dxGalleryExtender {
+    constructor(_gallery) {
+        this._gallery = _gallery;
+    }
+    extend(element) {
+        this
+            ._extendCtor(element)
+            ._extendRepaint()
+            ._extend_blockItemsHaveExpired()
+            ._extend_getNextIndex()
+            ._extend_swipeStartHandler()
+            ._extend_setSwipeAnimation()
+            ._extend_addAnimation()
+            ._extend_restoreDefault()
+            ._extend_getItem()
+            ._extend_swipeUpdateHandler()
+            ._extend_swipeEndHandler()
+            ._extend_endSwipe();
+        this._gallery.repaint();
+    }
+    _extendCtor(element) {
+        this._gallery._animationClassName = 'dxrdp-gallery-item-animation';
+        this._gallery.currentBlockItem = null;
+        this._gallery.nextBlockItem = null;
+        this._gallery.swipeEnabled = true;
+        this._gallery.initializeBlockItems = () => {
+            this._gallery.blockItems = [];
+            var $items = this._gallery['_getAvailableItems']();
             for (var i = 0; i < $items.length; i++) {
                 var left = parseFloat($items[i]['style'].left);
                 left = isNaN(left) ? 0 : left;
-                this.blockItems.push({
+                this._gallery.blockItems.push({
                     element: $.fn.constructor($items[i]),
                     left: left
                 });
             }
         };
-        this.initializeBlockItems();
-        this.gallery = this['option']('gallery');
-        var subscription = this.gallery.repaint.subscribe((newVal) => {
-            if (!this.gallery.preview._hasActiveEditingFields()) {
-                this.repaint();
+        this._gallery.initializeBlockItems();
+        this._gallery.gallery = this._gallery['option']('gallery').getModel();
+        this._gallery.slideOptions = this._gallery['option']('slideOptions');
+        var subscriptionDispose = this._gallery.gallery.events.on('repaintChanged', (args) => {
+            if (!this._gallery.gallery.preview._hasActiveEditingFields()) {
+                this._gallery.repaint();
             }
         });
         addDisposeCallback(element, () => {
-            subscription.dispose();
+            subscriptionDispose();
         });
+        return this;
     }
-    repaint() {
-        super.repaint.apply(this);
-        this.initializeBlockItems();
+    _extendRepaint() {
+        const oldRepaint = this._gallery.repaint;
+        this._gallery.repaint = () => {
+            oldRepaint.apply(this._gallery);
+            this._gallery.initializeBlockItems();
+        };
+        return this;
     }
-    _swipeStartHandler(e) {
-        super['_swipeStartHandler'].apply(this, [e]);
-        var swipeRightEnable = this.gallery.swipeRightEnable();
-        var swipeLeftEnable = this.gallery.swipeLeftEnable();
-        if (!swipeRightEnable || !swipeLeftEnable) {
-            var selectedIndex = swipeRightEnable ? 0 : 2;
-            var startOffset = 3 - selectedIndex - 1, endOffset = selectedIndex;
-            if (!swipeRightEnable && !swipeLeftEnable) {
-                startOffset = 0;
-                endOffset = 0;
-            }
-            e.event.maxLeftOffset = startOffset;
-            e.event.maxRightOffset = endOffset;
-        }
-        this.gallery.isAnimated(true);
-        if (this.gallery.animationEnabled()) {
-            this.currentBlockItem && this.currentBlockItem.element.removeClass(this._animationClassName);
-            this.nextBlockItem && this.nextBlockItem.element.removeClass(this._animationClassName);
-        }
+    _extend_blockItemsHaveExpired() {
+        this._gallery._blockItemsHaveExpired = () => this._gallery.blockItems.length && !document.body.contains(this._gallery.blockItems[0].element[0]);
+        return this;
     }
-    _getNextIndex(offset) {
-        var index = this.gallery.selectedIndex();
-        if (offset < 0) {
-            if (index === 2) {
-                index = 0;
+    _extend_swipeStartHandler() {
+        const old_swipeStartHandler = this._gallery['_swipeStartHandler'];
+        this._gallery['_swipeStartHandler'] = (e) => {
+            this._gallery.swipeEnabled = this._gallery.slideOptions.getSwipeEnabled();
+            if (!this._gallery.swipeEnabled)
+                return;
+            old_swipeStartHandler.apply(this._gallery, [e]);
+            if (this._gallery._blockItemsHaveExpired()) {
+                this._gallery.initializeBlockItems();
             }
-            else {
-                index++;
+            var swipeRightEnable = this._gallery.gallery.getSwipeRightEnabled();
+            var swipeLeftEnable = this._gallery.gallery.getSwipeLeftEnabled();
+            if (!swipeRightEnable || !swipeLeftEnable) {
+                var selectedIndex = swipeRightEnable ? 0 : 2;
+                var startOffset = 3 - selectedIndex - 1, endOffset = selectedIndex;
+                if (!swipeRightEnable && !swipeLeftEnable) {
+                    startOffset = 0;
+                    endOffset = 0;
+                }
+                e.event.maxLeftOffset = startOffset;
+                e.event.maxRightOffset = endOffset;
             }
-        }
-        else {
-            if (index === 0) {
-                index = 2;
+            this._gallery.gallery.isAnimated = true;
+            if (this._gallery.gallery.animationEnabled) {
+                this._gallery.currentBlockItem && this._gallery.currentBlockItem.element.removeClass(this._gallery._animationClassName);
+                this._gallery.nextBlockItem && this._gallery.nextBlockItem.element.removeClass(this._gallery._animationClassName);
+            }
+        };
+        return this;
+    }
+    _extend_getNextIndex() {
+        this._gallery._getNextIndex = (offset) => {
+            var index = this._gallery.gallery.selectedIndex;
+            if (offset < 0) {
+                if (index === 2) {
+                    index = 0;
+                }
+                else {
+                    index++;
+                }
             }
             else {
-                index--;
+                if (index === 0) {
+                    index = 2;
+                }
+                else {
+                    index--;
+                }
             }
-        }
-        return index;
+            return index;
+        };
+        return this;
     }
-    _setSwipeAnimation(element, difference, offset, right) {
-        var diffperc = 100 * offset / 4;
-        var newLeft = '0%';
-        if (right) {
-            newLeft = (element.left + diffperc) + '%';
-        }
-        else {
-            newLeft = (element.left - diffperc) + '%';
-        }
-        element.element.css({
-            'opacity': difference,
-            'transform': 'scale(' + difference + ')',
-            'left': newLeft
-        });
+    _extend_setSwipeAnimation() {
+        this._gallery._setSwipeAnimation = (element, difference, offset, right) => {
+            var diffperc = 100 * offset / 4;
+            var newLeft = '0%';
+            if (right) {
+                newLeft = (element.left + diffperc) + '%';
+            }
+            else {
+                newLeft = (element.left - diffperc) + '%';
+            }
+            element.element.css({
+                'opacity': difference,
+                'transform': 'scale(' + difference + ')',
+                'left': newLeft
+            });
+        };
+        return this;
     }
-    _addAnimation(item) {
-        if (item) {
-            if (this.gallery.animationEnabled()) {
-                item.element.addClass(this._animationClassName);
+    _extend_addAnimation() {
+        this._gallery._addAnimation = (item) => {
+            if (item) {
+                if (this._gallery.gallery.animationEnabled) {
+                    item.element.addClass(this._gallery._animationClassName);
+                }
             }
-        }
+        };
+        return this;
     }
-    _restoreDefault(item) {
-        if (item) {
-            item.element.css({
-                'opacity': 1,
-                'transform': 'scale(' + 1 + ')',
-                'left': item.left + '%'
-            });
-        }
+    _extend_restoreDefault() {
+        this._gallery._restoreDefault = (item) => {
+            if (item) {
+                item.element.css({
+                    'opacity': 1,
+                    'transform': 'scale(' + 1 + ')',
+                    'left': item.left + '%'
+                });
+            }
+        };
+        return this;
     }
-    _getItem(index, loopTest) {
-        var realIndex = index;
-        var currentBlockIndex = this.blockItems.indexOf(this.currentBlockItem);
-        if (loopTest) {
-            if (currentBlockIndex === 2 && index === 0) {
-                realIndex = 3;
-            }
-            else if (currentBlockIndex === 0 && index === 2) {
-                realIndex = 4;
-            }
-        }
-        var item = this.blockItems[realIndex];
-        if (this.gallery.animationEnabled()) {
-            item.element.removeClass(this._animationClassName);
-        }
-        return item;
+    _extend_getItem() {
+        this._gallery._getItem = (index, loopTest) => {
+            var realIndex = index;
+            var currentBlockIndex = this._gallery.blockItems.indexOf(this._gallery.currentBlockItem);
+            if (loopTest) {
+                if (currentBlockIndex === 2 && index === 0) {
+                    realIndex = 3;
+                }
+                else if (currentBlockIndex === 0 && index === 2) {
+                    realIndex = 4;
+                }
+            }
+            var item = this._gallery.blockItems[realIndex];
+            if (this._gallery.gallery.animationEnabled) {
+                item.element.removeClass(this._gallery._animationClassName);
+            }
+            return item;
+        };
+        return this;
     }
-    _swipeUpdateHandler(e) {
-        super['_swipeUpdateHandler'].apply(this, [e]);
-        var offset = e.event.offset;
-        var nextIndex = this._getNextIndex(offset);
-        var currentIndex = this.gallery.selectedIndex();
-        var currentBlockIndex = this.blockItems.indexOf(this.currentBlockItem);
-        var nextBlockIndex = this.blockItems.indexOf(this.nextBlockItem);
-        if (!this.currentBlockItem || currentBlockIndex !== currentIndex) {
-            this.currentBlockItem = this._getItem(currentIndex, false);
-        }
-        if (!this.nextBlockItem || nextBlockIndex !== nextIndex) {
-            this.nextBlockItem = this._getItem(nextIndex, true);
-        }
-        if (this.gallery.animationEnabled()) {
-            offset = Math.abs(offset);
-            var right = (nextIndex - currentIndex === 1) || (currentIndex === 2 && nextIndex === 0);
-            this._setSwipeAnimation(this.currentBlockItem, Math.min(1, (1 - offset)), offset, right);
-            this._setSwipeAnimation(this.nextBlockItem, Math.min(1, offset * 1.5), offset, !right);
-        }
+    _extend_swipeUpdateHandler() {
+        const oldswipeUpdateHandler = this._gallery['_swipeUpdateHandler'];
+        this._gallery['_swipeUpdateHandler'] = (e) => {
+            if (!this._gallery.swipeEnabled)
+                return;
+            oldswipeUpdateHandler.apply(this._gallery, [e]);
+            var offset = e.event.offset;
+            var nextIndex = this._gallery._getNextIndex(offset);
+            var currentIndex = this._gallery.gallery.selectedIndex;
+            var currentBlockIndex = this._gallery.blockItems.indexOf(this._gallery.currentBlockItem);
+            var nextBlockIndex = this._gallery.blockItems.indexOf(this._gallery.nextBlockItem);
+            if (!this._gallery.currentBlockItem || currentBlockIndex !== currentIndex) {
+                this._gallery.currentBlockItem = this._gallery._getItem(currentIndex, false);
+            }
+            if (!this._gallery.nextBlockItem || nextBlockIndex !== nextIndex) {
+                this._gallery.nextBlockItem = this._gallery._getItem(nextIndex, true);
+            }
+            if (this._gallery.gallery.animationEnabled) {
+                offset = Math.abs(offset);
+                var right = (nextIndex - currentIndex === 1) || (currentIndex === 2 && nextIndex === 0);
+                this._gallery._setSwipeAnimation(this._gallery.currentBlockItem, Math.min(1, (1 - offset)), offset, right);
+                this._gallery._setSwipeAnimation(this._gallery.nextBlockItem, Math.min(1, offset * 1.5), offset, !right);
+            }
+        };
+        return this;
     }
-    _swipeEndHandler(e) {
-        super['_swipeEndHandler'].apply(this, [e]);
-        if (this.gallery.animationEnabled()) {
-            for (var i = 0; i < this.blockItems.length; i++) {
-                if (this.blockItems[i] === this.currentBlockItem || this.blockItems[i] === this.nextBlockItem) {
-                    this._addAnimation(this.blockItems[i]);
+    _extend_swipeEndHandler() {
+        const oldSwipeEnd = this._gallery['_swipeEndHandler'];
+        this._gallery['_swipeEndHandler'] = (e) => {
+            if (!this._gallery.swipeEnabled)
+                return;
+            oldSwipeEnd.apply(this._gallery, [e]);
+            if (this._gallery.gallery.animationEnabled) {
+                for (var i = 0; i < this._gallery.blockItems.length; i++) {
+                    if (this._gallery.blockItems[i] === this._gallery.currentBlockItem || this._gallery.blockItems[i] === this._gallery.nextBlockItem) {
+                        this._gallery._addAnimation(this._gallery.blockItems[i]);
+                    }
+                    this._gallery._restoreDefault(this._gallery.blockItems[i]);
                 }
-                this._restoreDefault(this.blockItems[i]);
             }
-        }
-        else {
-            this.gallery.isAnimated(false);
-            this.gallery.updatePagesVisible(this.gallery.preview);
-        }
+            else {
+                this._gallery.gallery.isAnimated = false;
+                this._gallery.gallery.updatePagesVisible(this._gallery.gallery.preview);
+            }
+        };
+        return this;
     }
-    _endSwipe() {
-        super['_endSwipe'].apply(this, arguments);
-        this.gallery.isAnimated(false);
-        this.gallery.updatePagesVisible(this.gallery.preview);
+    _extend_endSwipe() {
+        var oldEndSwipe = this._gallery['_endSwipe'];
+        var self = this;
+        this._gallery['_endSwipe'] = function () {
+            oldEndSwipe.apply(self._gallery, arguments);
+            self._gallery.gallery.isAnimated = false;
+            self._gallery.gallery.updatePagesVisible(self._gallery.gallery.preview);
+        };
+        return this;
+    }
+}
+export class dxGalleryReportPreview extends dxGallery {
+    constructor(element, options) {
+        super(element, options);
+        new dxGalleryExtender(this).extend(element);
     }
 }
 registerComponent('dxGalleryReportPreview', dxGalleryReportPreview);

package/viewer/mobile/internal/gallery/_galleryItem.d.ts

@@ -0,0 +1,56 @@
+/**
+* DevExpress HTML/JS Reporting (viewer\mobile\internal\gallery\_galleryItem.d.ts)
+* Version:  23.2.1-alpha-23254-1700
+* Build date: Sep 11, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { ArrayPropertyChangedEventArgs, BaseRenderingModel, IViewModel, PropertyChangedEventArgs } from '@devexpress/analytics-core/analytics-serializer-native';
+import { PreviewPage } from '../../../internal/_page';
+import { IPreviewPageViewModel } from '../../../internal/_page.viewModel';
+import { MobileReportPreview } from '../../mobilePreview';
+import { IMobileReportPreviewViewModel } from '../../mobilePreview.viewModel';
+import { GalleryModel, IAbsolutePosition, IGalleryViewModel as IGalleryViewModel } from './_galleryModel';
+export interface IGalleryItemBlock {
+    repaint?: boolean;
+    page: PreviewPage | IPreviewPageViewModel;
+    classSet?: any;
+    visible?: boolean;
+    position: IAbsolutePosition;
+    reportPreview: IMobileReportPreviewViewModel;
+}
+export interface IGalleryItemBlockViewModel extends IViewModel, IGalleryItemBlock {
+    page: IPreviewPageViewModel;
+    active: boolean;
+}
+export interface IGalleryItemViewModel extends IViewModel {
+    blocks: IGalleryItemBlockViewModel[];
+    reportPreview: IMobileReportPreviewViewModel;
+    gallery: IGalleryViewModel;
+}
+export declare class GalleryItemBlock extends BaseRenderingModel<IGalleryItemBlockViewModel> {
+    deferredUpdateViewModel(): boolean;
+    onPropertyChanged(args: PropertyChangedEventArgs<GalleryItemBlock>): void;
+    createViewModel(): IGalleryItemBlockViewModel;
+    updateViewModel(args: PropertyChangedEventArgs<GalleryItemBlock> | ArrayPropertyChangedEventArgs<GalleryItemBlock>): void;
+    constructor(options: IGalleryItemBlock);
+    repaint?: boolean;
+    page: PreviewPage;
+    classSet?: any;
+    visible?: boolean;
+    position: IAbsolutePosition;
+    active: boolean;
+    preview: IMobileReportPreviewViewModel;
+}
+export declare class GalleryItem extends BaseRenderingModel<IGalleryItemViewModel> {
+    deferredUpdateViewModel(): boolean;
+    createViewModel(): IGalleryItemViewModel;
+    updateViewModel(args: PropertyChangedEventArgs<GalleryItem> | ArrayPropertyChangedEventArgs<GalleryItem>): void;
+    onPropertyChanged(args: PropertyChangedEventArgs<GalleryItem>): void;
+    constructor(preview: MobileReportPreview, gallery: GalleryModel);
+    blocks: GalleryItemBlock[];
+    realIndex?: number;
+    preview: IMobileReportPreviewViewModel;
+    gallery: IGalleryViewModel;
+    enabled: boolean;
+}

package/viewer/mobile/internal/gallery/_galleryItem.js

@@ -0,0 +1,95 @@
+/**
+* DevExpress HTML/JS Reporting (viewer\mobile\internal\gallery\_galleryItem.js)
+* Version:  23.2.1-alpha-23254-1700
+* Build date: Sep 11, 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 { BaseRenderingModel, createViewModelGenerator, mutable, mutableArray } from '@devexpress/analytics-core/analytics-serializer-native';
+export class GalleryItemBlock extends BaseRenderingModel {
+    constructor(options) {
+        super();
+        this.repaint = options.repaint;
+        this.page = options.page;
+        this.classSet = options.classSet;
+        this.visible = options.visible;
+        this.position = options.position;
+        this.preview = options.reportPreview;
+    }
+    deferredUpdateViewModel() { return false; }
+    onPropertyChanged(args) { }
+    createViewModel() {
+        var _a;
+        return createViewModelGenerator(super.createViewModel())
+            .generateProperty('repaint', this.repaint)
+            .generateProperty('classSet', this.classSet)
+            .generateProperty('visible', this.visible)
+            .generateProperty('position', this.position)
+            .generateProperty('active', this.active)
+            .generateProperty('page', (_a = this.page) === null || _a === void 0 ? void 0 : _a.getViewModel())
+            .generateProperty('reportPreview', this.preview)
+            .getViewModel();
+    }
+    updateViewModel(args) {
+        const viewModel = this.getViewModel();
+        if (args.propertyName === 'position') {
+            viewModel.position = this.position;
+        }
+        viewModel.active = this.active;
+    }
+}
+__decorate([
+    mutable(null)
+], GalleryItemBlock.prototype, "position", void 0);
+__decorate([
+    mutable(false)
+], GalleryItemBlock.prototype, "active", void 0);
+export class GalleryItem extends BaseRenderingModel {
+    constructor(preview, gallery) {
+        super();
+        this.preview = preview.getViewModel();
+        this.gallery = gallery.getViewModel();
+    }
+    deferredUpdateViewModel() { return false; }
+    createViewModel() {
+        return createViewModelGenerator(super.createViewModel())
+            .generateProperty('blocks', this.blocks.map(x => x.getViewModel()))
+            .generateProperty('gallery', this.gallery)
+            .generateProperty('reportPreview', this.preview)
+            .getViewModel();
+    }
+    updateViewModel(args) {
+        var _a, _b;
+        const viewModel = this.getViewModel();
+        if (args.propertyName === 'blocks') {
+            const arrayArgs = args;
+            if (arrayArgs.added || arrayArgs.removed) {
+                (_a = arrayArgs.added) === null || _a === void 0 ? void 0 : _a.forEach(change => viewModel.blocks.splice(change.index, 0, change.item.getViewModel()));
+                (_b = arrayArgs.removed) === null || _b === void 0 ? void 0 : _b.sort((a, b) => b.index - a.index).forEach(change => viewModel.blocks.splice(change.index, 1));
+            }
+            else {
+                viewModel.blocks = arrayArgs.newValue.map(x => x.getViewModel());
+            }
+        }
+    }
+    onPropertyChanged(args) {
+        if (args.propertyName === 'blocks') {
+            this.enabled = this.blocks.length > 1;
+        }
+        else if (args.propertyName === 'enabled') {
+            this.blocks.forEach(x => x.active === args.newValue);
+        }
+    }
+}
+__decorate([
+    mutableArray(() => [])
+], GalleryItem.prototype, "blocks", void 0);
+__decorate([
+    mutable(false)
+], GalleryItem.prototype, "enabled", void 0);

package/viewer/mobile/internal/gallery/_galleryModel.d.ts

@@ -1,69 +1,64 @@
 /**
 * DevExpress HTML/JS Reporting (viewer\mobile\internal\gallery\_galleryModel.d.ts)
-* Version:  23.1.5
-* Build date: Aug 29, 2023
+* Version:  23.2.1-alpha-23254-1700
+* Build date: Sep 11, 2023
 * Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
 * License: https://www.devexpress.com/Support/EULAs/universal.xml
 */
 import { PreviewPage } from '../../../internal/_page';
 import { MobileReportPreview } from '../../mobilePreview';
-import * as ko from 'knockout';
-import { Disposable } from '@devexpress/analytics-core/analytics-utils';
-export interface IGalleryItemBlock {
-    repaint?: boolean;
-    page: PreviewPage;
-    classSet?: any;
-    visible?: boolean;
-    position: ko.Observable<IAbsolutePosition> | ko.Computed<IAbsolutePosition>;
-}
+import { ArrayPropertyChangedEventArgs, BaseRenderingModel, IViewModel, PropertyChangedEventArgs } from '@devexpress/analytics-core/analytics-serializer-native';
+import { GalleryItem, GalleryItemBlock, IGalleryItemViewModel } from './_galleryItem';
+import { OptionChangedEvent } from 'devextreme/ui/gallery';
 export interface IAbsolutePosition {
     left: number;
     top: number;
     height: number;
     width: number;
 }
-export interface IGalleryItem {
-    blocks: ko.ObservableArray<IGalleryItemBlock>;
-    realIndex?: number;
+export interface IGalleryViewModel extends IViewModel {
+    items: IGalleryItemViewModel[];
+    animationEnabled: boolean;
+    selectedIndex: number;
+    onOptionChanged: (event: OptionChangedEvent) => void;
 }
-export declare class GalleryModel extends Disposable {
+export declare class GalleryModel extends BaseRenderingModel<IGalleryViewModel> {
     preview: MobileReportPreview;
-    private previewWrapperSize;
+    deferredUpdateViewModel(): boolean;
     private _spacing;
     private _animationTimeout;
+    private _currentItemSubscriptionDispose;
     private _createBlock;
-    constructor(preview: MobileReportPreview, previewWrapperSize: ko.Observable<{
-        width: number;
-        height: number;
-    }>);
+    createViewModel(): IGalleryViewModel;
+    updateViewModel(args: PropertyChangedEventArgs<GalleryModel> | ArrayPropertyChangedEventArgs<GalleryModel>): void;
+    onPropertyChanged(args: PropertyChangedEventArgs<GalleryModel> | ArrayPropertyChangedEventArgs<GalleryModel>): void;
+    updateContentSize(): void;
+    constructor(preview: MobileReportPreview);
     dispose(): void;
     updatePagesVisible(preview: MobileReportPreview): void;
     updateCurrentBlock(): void;
     updateContent(preview: MobileReportPreview, pagesCount: number): void;
-    updateBlockPositions(blocks: IGalleryItemBlock[], visible: any): void;
-    updateStartBlocks(galleryItem: IGalleryItem, pages: PreviewPage[]): number;
-    updateLastBlocks(galleryItem: IGalleryItem, pages: PreviewPage[]): number;
-    updateBlocks(galleryItem: IGalleryItem, pagesCount: number, preview: MobileReportPreview, index: any, useAnimation?: boolean): void;
+    updateBlockPositions(blocks: GalleryItemBlock[], visible: boolean): void;
+    updateStartBlocks(galleryItem: GalleryItem, pages: PreviewPage[]): number;
+    updateLastBlocks(galleryItem: GalleryItem, pages: PreviewPage[]): number;
+    updateBlocks(galleryItem: GalleryItem, pagesCount: number, preview: MobileReportPreview, index: number, useAnimation?: boolean): void;
     changePage(preview: MobileReportPreview): void;
-    repaint: ko.Observable<{}>;
-    repaintTimeout: ko.Observable<number>;
-    contentSize: ko.Observable<{
-        width: string;
-        height: string;
-    }> | ko.Computed<{
+    repaint: object;
+    _repaint: () => void;
+    repaintTimeout: ReturnType<typeof setTimeout>;
+    contentSize: {
         width: string;
         height: string;
-    }>;
-    horizontal: ko.Observable<number> | ko.Computed<number>;
-    vertical: ko.Observable<number> | ko.Computed<number>;
+    };
+    horizontal: number;
+    vertical: number;
     pageCount: number;
-    isAnimated: ko.Observable<boolean> | ko.Computed<boolean>;
-    items: ko.ObservableArray<IGalleryItem>;
-    currentBlockText: ko.Observable<string> | ko.Computed<string>;
-    selectedIndexReal: ko.Observable<number>;
-    loopEnabled: ko.Computed<boolean>;
-    selectedIndex: ko.Observable<number>;
-    animationEnabled: ko.Observable<boolean> | ko.Computed<boolean>;
-    swipeRightEnable: ko.Computed<boolean>;
-    swipeLeftEnable: ko.Computed<boolean>;
+    isAnimated: boolean;
+    items: GalleryItem[];
+    currentBlockText: string;
+    selectedIndexReal: number;
+    selectedIndex: number;
+    animationEnabled: boolean;
+    getSwipeRightEnabled: () => boolean;
+    getSwipeLeftEnabled: () => boolean;
 }