angular-br-test/bundles/angular-br-test.umd.js

The Bold Reports by Syncfuion components for Angular contains ReportViewer and ReportDesigner reporting components for enterprise web development

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common')) :
	typeof define === 'function' && define.amd ? define(['exports', '@angular/core', '@angular/common'], factory) :
	(factory((global['angular-br-test'] = {}),global.ng.core,global.ng.common));
}(this, (function (exports,core,common) { 'use strict';

var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var firstVal = {};
/**
 * Internal Helpers
 */
var Utils = /** @class */ (function () {
    function Utils() {
    }
    /**
     * @param {?} obj
     * @return {?}
     */
    Utils.IterateAndGetChanges = function (obj) {
        if (ej.isNullOrUndefined(obj.tags) || obj.tags.length === 0) {
            return null;
        }
        var /** @type {?} */ res = {};
        for (var /** @type {?} */ i = 0, /** @type {?} */ tags = obj.tags; i < tags.length; i++) {
            var /** @type {?} */ tag = tags[i], /** @type {?} */ tagElement = ( /** @type {?} */(obj))['tag_' + tag.replace(/\./g, '_')];
            if (!ej.isNullOrUndefined(tagElement) && tagElement.hasChanges) {
                res[tag] = tagElement.getChangesAndReset();
            }
        }
        return res;
    };
    return Utils;
}());
var BoldReportComponents = /** @class */ (function () {
    /**
     * @param {?} controlName
     * @param {?} el
     * @param {?} cdRef
     * @param {?} tags
     * @param {?} ejIterableDiffers
     * @param {?} _ejKeyValueDiffers
     */
    function BoldReportComponents(controlName, el, cdRef, tags, ejIterableDiffers, _ejKeyValueDiffers) {
        this.controlName = controlName;
        this.el = el;
        this.cdRef = cdRef;
        this.tags = tags;
        this.ejIterableDiffers = ejIterableDiffers;
        this._ejKeyValueDiffers = _ejKeyValueDiffers;
        this.model = ({});
        this.outputs = [];
        this.inputs = [];
        this.twoways = [];
        //        this.__shadow = this.dom.getShadowRoot(this.el.nativeElement);
        this.firstCheck = true;
        this.ejIterable = this.ejIterableDiffers.find([]).create(null);
        this.ejKeyValueDif = _ejKeyValueDiffers.find([]).create();
    }
    /**
     * @param {?} instance
     * @param {?} model
     * @param {?} event
     * @return {?}
     */
    BoldReportComponents.bindAndRaiseEvent = function (instance, model, event) {
        if (!event.startsWith('model.')) { // && instance[event]['observers'].length > 1) {
            var /** @type {?} */ originalEvt = event.startsWith('bold') ? event.substr(4) : event;
            model[originalEvt] = function (params) {
                instance[event + '_output']['emit'](params);
            };
        }
    };
    /**
     * @param {?} twoways
     * @return {?}
     */
    BoldReportComponents.prototype.createTwoways = function (twoways) {
        if (!twoways) {
            return;
        }
        var /** @type {?} */ model = this.model;
        for (var /** @type {?} */ i = 0; i < twoways.length; i++) {
            var /** @type {?} */ element = twoways[i].replace(/\_/g, '.');
            ej.createObject(element + 'Change', ( /** @type {?} */(this))[twoways[i] + '_twoChange'], model);
            ej.createObject(element, this.addTwoways(element), model);
        }
    };
    /**
     * @param {?} prop
     * @return {?}
     */
    BoldReportComponents.prototype.addTwoways = function (prop) {
        var /** @type {?} */ model = this.model, /** @type {?} */ value = firstVal; // , originalProp = prop.replace(/-/g, '.');
        return function (newVal, isApp) {
            if (value === firstVal) {
                value = ej.getObject(prop + '_two', model);
                if (value === undefined) {
                    value = ej.getObject(prop, this === undefined || this.defaults === undefined ? {} : this.defaults);
                }
            }
            if (newVal === undefined) {
                return value;
            }
            if (value === newVal) {
                return;
            }
            value = newVal;
            if (!isApp) {
                ej.createObject(prop + '_two', newVal, model);
                ej.getObject(prop + 'Change', model).emit(newVal);
            }
        };
    };
    /**
     * @return {?}
     */
    BoldReportComponents.prototype.ngOnInit = function () {
        for (var /** @type {?} */ key in this) {
            if (key.indexOf('_input') != -1)
                this.inputs.push(key);
            if (key.indexOf('_output') != -1)
                this.outputs.push(key);
            if (key.indexOf('_two') != -1 && key.indexOf('_twoChange') == -1)
                this.twoways.push(key.replace('_two', ''));
        }
        if (ej.isNullOrUndefined(( /** @type {?} */(this))['options'])) {
            this.createTwoways(this.twoways);
        }
    };
    /**
     * @return {?}
     */
    BoldReportComponents.prototype.ngAfterContentInit = function () {
        this.firstCheck = false;
        var /** @type {?} */ model = this.model, /** @type {?} */ events = this.outputs;
        if (events) {
            for (var /** @type {?} */ i = 0; i < events.length; i++) {
                var /** @type {?} */ event = events[i].replace('_output', '');
                BoldReportComponents.bindAndRaiseEvent(this, model, event);
            }
        }
        if (ej.isNullOrUndefined(( /** @type {?} */(this))['options'])) {
            for (var /** @type {?} */ i = 0; i < this.tags.length; i++) {
                var /** @type {?} */ element = this.tags[i], /** @type {?} */ item = ( /** @type {?} */(this))['tag_' + element.replace(/\./g, '_')];
                if (!ej.isNullOrUndefined(item)) {
                    ej.createObject(element, item.getList(), this.model);
                }
            }
            for (var /** @type {?} */ i = 0; i < this.inputs.length; i++) {
                var /** @type {?} */ property = this.inputs[i];
                var /** @type {?} */ modelProperty = this.inputs[i].replace('_input', '');
                if (( /** @type {?} */(this))[property] != null) {
                    if (modelProperty.indexOf('_') == -1) {
                        if (( /** @type {?} */(this.model))[modelProperty]) {
                            $.extend(true, ( /** @type {?} */(this.model))[modelProperty], ( /** @type {?} */(this))[property]);
                        }
                        else {
                            ( /** @type {?} */(this.model))[modelProperty] = ( /** @type {?} */(this))[property];
                        }
                    }
                    else if (modelProperty.indexOf('_two') == -1) {
                        var /** @type {?} */ tempObj = {};
                        var /** @type {?} */ key = modelProperty.replace(/\_/g, '.');
                        ej.createObject(key, ( /** @type {?} */(this))[property], tempObj);
                        var /** @type {?} */ rootProp = key.split('.')[0];
                        if (( /** @type {?} */(this.model))[rootProp] == undefined)
                            ( /** @type {?} */(this.model))[rootProp] = {};
                        $.extend(true, ( /** @type {?} */(this.model))[rootProp], tempObj[rootProp]);
                    }
                }
            }
            for (var /** @type {?} */ i = 0; i < this.twoways.length; i++) {
                var /** @type {?} */ twoway = this.twoways[i];
                var /** @type {?} */ twowayProperty = twoway + '_two';
                if (( /** @type {?} */(this))[twowayProperty] != null) {
                    if (twoway.indexOf('_') == -1) {
                        ( /** @type {?} */(this.model))[twowayProperty] = ( /** @type {?} */(this))[twowayProperty];
                    }
                    else {
                        var /** @type {?} */ tempObj = {};
                        var /** @type {?} */ key = twoway.replace(/\_/g, '.') + '_two';
                        ej.createObject(key, ( /** @type {?} */(this))[twowayProperty], tempObj);
                        var /** @type {?} */ rootProp = twowayProperty.split('_')[0];
                        $.extend(true, ( /** @type {?} */(this.model))[rootProp], tempObj[rootProp]);
                    }
                }
            }
        }
        else
            this.model = jQuery.extend(this.model, ( /** @type {?} */(this))['options']);
    };
    /**
     * @return {?}
     */
    BoldReportComponents.prototype.ngDoCheck = function () {
        var _this = this;
        if (ej.isNullOrUndefined(( /** @type {?} */(this))['options'])) {
            this.twoways.forEach(function (element) {
                if (( /** @type {?} */(_this))[element + '_two'] instanceof Array) {
                    var /** @type {?} */ changes = _this.ejIterable.diff(( /** @type {?} */(_this))[element + '_two']);
                    if (changes) {
                        var /** @type {?} */ ngChanges = {};
                        if (_this.widget != undefined) {
                            ngChanges = _this.getTwowayChanges(changes.collection, ngChanges, element.replace(/\_/g, '.'));
                            ej.createObject(element.replace(/\_/g, '.') + '.two', changes.collection, ngChanges);
                            ( /** @type {?} */(_this.widget))['setModel'](ngChanges, $.isPlainObject(ngChanges));
                        }
                    }
                }
            });
        }
        else {
            var /** @type {?} */ changes = this.ejKeyValueDif.diff(( /** @type {?} */(this))['options']);
            if (changes) {
                if (this.widget != undefined) {
                    var /** @type {?} */ ngchanges = {};
                    changes.forEachChangedItem(function (changedprop) {
                        ej.createObject(changedprop.key, changedprop.currentValue, ngchanges);
                    });
                    ( /** @type {?} */(this.widget))['setModel'](ngchanges, $.isPlainObject(ngchanges));
                }
            }
        }
    };
    /**
     * @return {?}
     */
    BoldReportComponents.prototype.ngAfterViewInit = function () {
        var /** @type {?} */ nativeElement = this.isEditor ? $(this.el.nativeElement.children) : $(this.el.nativeElement);
        var /** @type {?} */ controlName = this.lowerCaseFirstLetter(this.controlName);
        this.widget = ( /** @type {?} */($(nativeElement)))[controlName](this.model)[controlName]('instance');
    };
    /**
     * @param {?} string
     * @return {?}
     */
    BoldReportComponents.prototype.lowerCaseFirstLetter = function (string) {
        return string[0].toLowerCase() + string.slice(1);
    };
    /**
     * @param {?} changes
     * @return {?}
     */
    BoldReportComponents.prototype.ngOnChanges = function (changes) {
        if (this.firstCheck) {
            return;
        }
        var /** @type {?} */ ngChanges = {};
        if (ej.isNullOrUndefined(( /** @type {?} */(this))['options'])) {
            for (var /** @type {?} */ key in changes) {
                var /** @type {?} */ element = changes[key];
                if (element.previousValue === element.currentValue) {
                    break;
                }
                key = key.replace('_input', '').replace(/\_/g, '.');
                if (key.endsWith('.two')) {
                    var /** @type {?} */ oKey = key.replace('.two', '');
                    ngChanges = this.getTwowayChanges(element.currentValue, ngChanges, oKey);
                }
                ej.createObject(key, element.currentValue, ngChanges);
            }
            ( /** @type {?} */(this.widget))['setModel'](ngChanges, $.isPlainObject(ngChanges));
        }
    };
    /**
     * @param {?} value
     * @param {?} ngChanges
     * @param {?} prop
     * @return {?}
     */
    BoldReportComponents.prototype.getTwowayChanges = function (value, ngChanges, prop) {
        var /** @type {?} */ valFn = ej.getObject(prop, ( /** @type {?} */(this.widget))['model']);
        valFn(value, true);
        ej.createObject(prop, valFn, ngChanges);
        return ngChanges;
    };
    /**
     * @return {?}
     */
    BoldReportComponents.prototype.ngAfterContentChecked = function () {
        // TODO: ChangeDetection Third/Multi level
        var /** @type {?} */ changes = Utils.IterateAndGetChanges(this);
        for (var /** @type {?} */ key in changes) {
            if (changes.hasOwnProperty(key)) {
                var /** @type {?} */ element = changes[key];
                ( /** @type {?} */(this.widget))['_' + key](element);
            }
        }
    };
    /**
     * @return {?}
     */
    BoldReportComponents.prototype.ngOnDestroy = function () {
        ( /** @type {?} */(this.widget))['destroy']();
    };
    return BoldReportComponents;
}());
// tslint:disable-next-line:max-line-length
var BoldReportViewerComponent = /** @class */ (function (_super) {
    __extends(BoldReportViewerComponent, _super);
    /**
     * @param {?} el
     * @param {?} cdRef
     * @param {?} _ejIterableDiffers
     * @param {?} _ejkeyvaluediffers
     */
    function BoldReportViewerComponent(el, cdRef, _ejIterableDiffers, _ejkeyvaluediffers) {
        var _this = _super.call(this, 'BoldReportViewer', el, cdRef, [], _ejIterableDiffers, _ejkeyvaluediffers) || this;
        _this.el = el;
        _this.cdRef = cdRef;
        _this._ejIterableDiffers = _ejIterableDiffers;
        _this._ejkeyvaluediffers = _ejkeyvaluediffers;
        _this.drillThrough_output = new core.EventEmitter();
        _this.renderingBegin_output = new core.EventEmitter();
        _this.renderingComplete_output = new core.EventEmitter();
        _this.reportError_output = new core.EventEmitter();
        _this.reportExport_output = new core.EventEmitter();
        _this.reportLoaded_output = new core.EventEmitter();
        _this.showError_output = new core.EventEmitter();
        _this.viewReportClick_output = new core.EventEmitter();
        _this.ajaxBeforeLoad_output = new core.EventEmitter();
        _this.ajaxSuccess_output = new core.EventEmitter();
        _this.ajaxError_output = new core.EventEmitter();
        _this.toolbarRendering_output = new core.EventEmitter();
        _this.exportProgressChanged_output = new core.EventEmitter();
        _this.printProgressChanged_output = new core.EventEmitter();
        _this.exportItemClick_output = new core.EventEmitter();
        _this.toolBarItemClick_output = new core.EventEmitter();
        _this.hyperlink_output = new core.EventEmitter();
        _this.reportPrint_output = new core.EventEmitter();
        return _this;
    }
    return BoldReportViewerComponent;
}(BoldReportComponents));
BoldReportViewerComponent.decorators = [
    { type: core.Component, args: [{
                selector: 'bold-reportviewer',
                template: ''
            },] },
];
/**
 * @nocollapse
 */
BoldReportViewerComponent.ctorParameters = function () { return [
    { type: core.ElementRef, },
    { type: core.ChangeDetectorRef, },
    { type: core.IterableDiffers, },
    { type: core.KeyValueDiffers, },
]; };
BoldReportViewerComponent.propDecorators = {
    'dataSources_input': [{ type: core.Input, args: ['dataSources',] },],
    'enablePageCache_input': [{ type: core.Input, args: ['enablePageCache',] },],
    'exportSettings_input': [{ type: core.Input, args: ['exportSettings',] },],
    'isResponsive_input': [{ type: core.Input, args: ['isResponsive',] },],
    'locale_input': [{ type: core.Input, args: ['locale',] },],
    'pageSettings_input': [{ type: core.Input, args: ['pageSettings',] },],
    'parameters_input': [{ type: core.Input, args: ['parameters',] },],
    'toolbarSettings_input': [{ type: core.Input, args: ['toolbarSettings',] },],
    'parameterSettings_input': [{ type: core.Input, args: ['parameterSettings',] },],
    'printMode_input': [{ type: core.Input, args: ['printMode',] },],
    'printOption_input': [{ type: core.Input, args: ['printOption',] },],
    'processingMode_input': [{ type: core.Input, args: ['processingMode',] },],
    'renderMode_input': [{ type: core.Input, args: ['renderMode',] },],
    'reportPath_input': [{ type: core.Input, args: ['reportPath',] },],
    'reportServerUrl_input': [{ type: core.Input, args: ['reportServerUrl',] },],
    'reportServiceUrl_input': [{ type: core.Input, args: ['reportServiceUrl',] },],
    'zoomFactor_input': [{ type: core.Input, args: ['zoomFactor',] },],
    'serviceAuthorizationToken_input': [{ type: core.Input, args: ['serviceAuthorizationToken',] },],
    'enableParameterBlockScroller_input': [{ type: core.Input, args: ['enableParameterBlockScroller',] },],
    'enableDatasourceBlockScroller_input': [{ type: core.Input, args: ['enableDatasourceBlockScroller',] },],
    'sizeToReportContent_input': [{ type: core.Input, args: ['sizeToReportContent',] },],
    'autoRender_input': [{ type: core.Input, args: ['autoRender',] },],
    'enableNotificationBar_input': [{ type: core.Input, args: ['enableNotificationBar',] },],
    'enableDropDownSearch_input': [{ type: core.Input, args: ['enableDropDownSearch',] },],
    'enablePageVirtualization_input': [{ type: core.Input, args: ['enablePageVirtualization',] },],
    'waitingPopupTemplate_input': [{ type: core.Input, args: ['waitingPopupTemplate',] },],
    'dataSources_name_input': [{ type: core.Input, args: ['dataSources.name',] },],
    'dataSources_value_input': [{ type: core.Input, args: ['dataSources.value',] },],
    'exportSettings_exportOptions_input': [{ type: core.Input, args: ['exportSettings.exportOptions',] },],
    'exportSettings_excelFormat_input': [{ type: core.Input, args: ['exportSettings.excelFormat',] },],
    'exportSettings_wordFormat_input': [{ type: core.Input, args: ['exportSettings.wordFormat',] },],
    'exportSettings_customItems_input': [{ type: core.Input, args: ['exportSettings.customItems',] },],
    'pageSettings_orientation_input': [{ type: core.Input, args: ['pageSettings.orientation',] },],
    'pageSettings_paperSize_input': [{ type: core.Input, args: ['pageSettings.paperSize',] },],
    'pageSettings_height_input': [{ type: core.Input, args: ['pageSettings.height',] },],
    'pageSettings_width_input': [{ type: core.Input, args: ['pageSettings.width',] },],
    'pageSettings_margins_input': [{ type: core.Input, args: ['pageSettings.margins',] },],
    'parameters_labels_input': [{ type: core.Input, args: ['parameters.labels',] },],
    'parameters_name_input': [{ type: core.Input, args: ['parameters.name',] },],
    'parameters_nullable_input': [{ type: core.Input, args: ['parameters.nullable',] },],
    'parameters_prompt_input': [{ type: core.Input, args: ['parameters.prompt',] },],
    'parameters_values_input': [{ type: core.Input, args: ['parameters.values',] },],
    'parameterSettings_delimiterChar_input': [{ type: core.Input, args: ['parameterSettings.delimiterChar',] },],
    'parameterSettings_popupHeight_input': [{ type: core.Input, args: ['parameterSettings.popupHeight',] },],
    'parameterSettings_popupWidth_input': [{ type: core.Input, args: ['parameterSettings.popupWidth',] },],
    'parameterSettings_itemWidth_input': [{ type: core.Input, args: ['parameterSettings.itemWidth',] },],
    'parameterSettings_labelWidth_input': [{ type: core.Input, args: ['parameterSettings.labelWidth',] },],
    'parameterSettings_hideParameterBlock_input': [{ type: core.Input, args: ['parameterSettings.hideParameterBlock',] },],
    'toolbarSettings_click_input': [{ type: core.Input, args: ['toolbarSettings.click',] },],
    'toolbarSettings_items_input': [{ type: core.Input, args: ['toolbarSettings.items',] },],
    'toolbarSettings_showToolbar_input': [{ type: core.Input, args: ['toolbarSettings.showToolbar',] },],
    'toolbarSettings_showTooltip_input': [{ type: core.Input, args: ['toolbarSettings.showTooltip',] },],
    'toolbarSettings_templateId_input': [{ type: core.Input, args: ['toolbarSettings.templateId',] },],
    'toolbarSettings_customItems_input': [{ type: core.Input, args: ['toolbarSettings.customItems',] },],
    'toolbarSettings_customGroups_input': [{ type: core.Input, args: ['toolbarSettings.customGroups',] },],
    'drillThrough_output': [{ type: core.Output, args: ['drillThrough',] },],
    'renderingBegin_output': [{ type: core.Output, args: ['renderingBegin',] },],
    'renderingComplete_output': [{ type: core.Output, args: ['renderingComplete',] },],
    'reportError_output': [{ type: core.Output, args: ['reportError',] },],
    'reportExport_output': [{ type: core.Output, args: ['reportExport',] },],
    'reportLoaded_output': [{ type: core.Output, args: ['reportLoaded',] },],
    'showError_output': [{ type: core.Output, args: ['showError',] },],
    'viewReportClick_output': [{ type: core.Output, args: ['viewReportClick',] },],
    'ajaxBeforeLoad_output': [{ type: core.Output, args: ['ajaxBeforeLoad',] },],
    'ajaxSuccess_output': [{ type: core.Output, args: ['ajaxSuccess',] },],
    'ajaxError_output': [{ type: core.Output, args: ['ajaxError',] },],
    'toolbarRendering_output': [{ type: core.Output, args: ['toolbarRendering',] },],
    'exportProgressChanged_output': [{ type: core.Output, args: ['exportProgressChanged',] },],
    'printProgressChanged_output': [{ type: core.Output, args: ['printProgressChanged',] },],
    'exportItemClick_output': [{ type: core.Output, args: ['exportItemClick',] },],
    'toolBarItemClick_output': [{ type: core.Output, args: ['toolBarItemClick',] },],
    'hyperlink_output': [{ type: core.Output, args: ['hyperlink',] },],
    'reportPrint_output': [{ type: core.Output, args: ['reportPrint',] },],
};
var BoldReportViewerModule = /** @class */ (function () {
    function BoldReportViewerModule() {
    }
    return BoldReportViewerModule;
}());
BoldReportViewerModule.decorators = [
    { type: core.NgModule, args: [{
                imports: [
                    common.CommonModule
                ],
                declarations: [
                    BoldReportViewerComponent
                ],
                exports: [
                    BoldReportViewerComponent
                ]
            },] },
];
/**
 * @nocollapse
 */
BoldReportViewerModule.ctorParameters = function () { return []; };
// tslint:disable-next-line:max-line-length
var BoldReportDesignerComponent = /** @class */ (function (_super) {
    __extends(BoldReportDesignerComponent, _super);
    /**
     * @param {?} el
     * @param {?} cdRef
     * @param {?} _ejIterableDiffers
     * @param {?} _ejkeyvaluediffers
     */
    function BoldReportDesignerComponent(el, cdRef, _ejIterableDiffers, _ejkeyvaluediffers) {
        var _this = _super.call(this, 'BoldReportDesigner', el, cdRef, [], _ejIterableDiffers, _ejkeyvaluediffers) || this;
        _this.el = el;
        _this.cdRef = cdRef;
        _this._ejIterableDiffers = _ejIterableDiffers;
        _this._ejkeyvaluediffers = _ejkeyvaluediffers;
        _this.ajaxBeforeLoad_output = new core.EventEmitter();
        _this.ajaxError_output = new core.EventEmitter();
        _this.ajaxSuccess_output = new core.EventEmitter();
        _this.create_output = new core.EventEmitter();
        _this.destroy_output = new core.EventEmitter();
        _this.newDataClick_output = new core.EventEmitter();
        _this.openReportClick_output = new core.EventEmitter();
        _this.previewReport_output = new core.EventEmitter();
        _this.reportModified_output = new core.EventEmitter();
        _this.reportOpened_output = new core.EventEmitter();
        _this.reportSaved_output = new core.EventEmitter();
        _this.saveReportClick_output = new core.EventEmitter();
        _this.toolbarClick_output = new core.EventEmitter();
        _this.toolbarRendering_output = new core.EventEmitter();
        return _this;
    }
    return BoldReportDesignerComponent;
}(BoldReportComponents));
BoldReportDesignerComponent.decorators = [
    { type: core.Component, args: [{
                selector: 'bold-reportdesigner',
                template: ''
            },] },
];
/**
 * @nocollapse
 */
BoldReportDesignerComponent.ctorParameters = function () { return [
    { type: core.ElementRef, },
    { type: core.ChangeDetectorRef, },
    { type: core.IterableDiffers, },
    { type: core.KeyValueDiffers, },
]; };
BoldReportDesignerComponent.propDecorators = {
    'configurePaneSettings_input': [{ type: core.Input, args: ['configurePaneSettings',] },],
    'locale_input': [{ type: core.Input, args: ['locale',] },],
    'permissionSettings_input': [{ type: core.Input, args: ['permissionSettings',] },],
    'previewOptions_input': [{ type: core.Input, args: ['previewOptions',] },],
    'reportDataExtensions_input': [{ type: core.Input, args: ['reportDataExtensions',] },],
    'reportItemExtensions_input': [{ type: core.Input, args: ['reportItemExtensions',] },],
    'reportPath_input': [{ type: core.Input, args: ['reportPath',] },],
    'reportType_input': [{ type: core.Input, args: ['reportType',] },],
    'reportServerUrl_input': [{ type: core.Input, args: ['reportServerUrl',] },],
    'serviceAuthorizationToken_input': [{ type: core.Input, args: ['serviceAuthorizationToken',] },],
    'serviceUrl_input': [{ type: core.Input, args: ['serviceUrl',] },],
    'tenantName_input': [{ type: core.Input, args: ['tenantName',] },],
    'toolbarSettings_input': [{ type: core.Input, args: ['toolbarSettings',] },],
    'waitingPopupTemplate_input': [{ type: core.Input, args: ['waitingPopupTemplate',] },],
    'configurePaneSettings_items_input': [{ type: core.Input, args: ['configurePaneSettings.items',] },],
    'configurePaneSettings_showPane_input': [{ type: core.Input, args: ['configurePaneSettings.showPane',] },],
    'dataSources_name_input': [{ type: core.Input, args: ['dataSources.name',] },],
    'dataSources_value_input': [{ type: core.Input, args: ['dataSources.value',] },],
    'exportSettings_exportOptions_input': [{ type: core.Input, args: ['exportSettings.exportOptions',] },],
    'exportSettings_excelFormat_input': [{ type: core.Input, args: ['exportSettings.excelFormat',] },],
    'exportSettings_wordFormat_input': [{ type: core.Input, args: ['exportSettings.wordFormat',] },],
    'exportSettings_customItems_input': [{ type: core.Input, args: ['exportSettings.customItems',] },],
    'pageSettings_orientation_input': [{ type: core.Input, args: ['pageSettings.orientation',] },],
    'pageSettings_paperSize_input': [{ type: core.Input, args: ['pageSettings.paperSize',] },],
    'pageSettings_height_input': [{ type: core.Input, args: ['pageSettings.height',] },],
    'pageSettings_width_input': [{ type: core.Input, args: ['pageSettings.width',] },],
    'pageSettings_margins_input': [{ type: core.Input, args: ['pageSettings.margins',] },],
    'parameters_labels_input': [{ type: core.Input, args: ['parameters.labels',] },],
    'parameters_name_input': [{ type: core.Input, args: ['parameters.name',] },],
    'parameters_nullable_input': [{ type: core.Input, args: ['parameters.nullable',] },],
    'parameters_prompt_input': [{ type: core.Input, args: ['parameters.prompt',] },],
    'parameters_values_input': [{ type: core.Input, args: ['parameters.values',] },],
    'parameterSettings_delimiterChar_input': [{ type: core.Input, args: ['parameterSettings.delimiterChar',] },],
    'parameterSettings_popupHeight_input': [{ type: core.Input, args: ['parameterSettings.popupHeight',] },],
    'parameterSettings_popupWidth_input': [{ type: core.Input, args: ['parameterSettings.popupWidth',] },],
    'parameterSettings_itemWidth_input': [{ type: core.Input, args: ['parameterSettings.itemWidth',] },],
    'parameterSettings_labelWidth_input': [{ type: core.Input, args: ['parameterSettings.labelWidth',] },],
    'permissionSettings_dataSet_input': [{ type: core.Input, args: ['permissionSettings.dataSet',] },],
    'permissionSettings_dataSource_input': [{ type: core.Input, args: ['permissionSettings.dataSource',] },],
    'previewOptions_dataSources_input': [{ type: core.Input, args: ['previewOptions.dataSources',] },],
    'previewOptions_enableParameterBlockScroller_input': [{ type: core.Input, args: ['previewOptions.enableParameterBlockScroller',] },],
    'previewOptions_enableDatasourceBlockScroller_input': [{ type: core.Input, args: ['previewOptions.enableDatasourceBlockScroller',] },],
    'previewOptions_enableDropDownSearch_input': [{ type: core.Input, args: ['previewOptions.enableDropDownSearch',] },],
    'previewOptions_exportSettings_input': [{ type: core.Input, args: ['previewOptions.exportSettings',] },],
    'previewOptions_pageSettings_input': [{ type: core.Input, args: ['previewOptions.pageSettings',] },],
    'previewOptions_parameters_input': [{ type: core.Input, args: ['previewOptions.parameters',] },],
    'previewOptions_parameterSettings_input': [{ type: core.Input, args: ['previewOptions.parameterSettings',] },],
    'previewOptions_printMode_input': [{ type: core.Input, args: ['previewOptions.printMode',] },],
    'previewOptions_printOption_input': [{ type: core.Input, args: ['previewOptions.printOption',] },],
    'previewOptions_toolbarSettings_input': [{ type: core.Input, args: ['previewOptions.toolbarSettings',] },],
    'previewOptions_zoomFactor_input': [{ type: core.Input, args: ['previewOptions.zoomFactor',] },],
    'reportDataExtensions_name_input': [{ type: core.Input, args: ['reportDataExtensions.name',] },],
    'reportDataExtensions_className_input': [{ type: core.Input, args: ['reportDataExtensions.className',] },],
    'reportDataExtensions_imageClass_input': [{ type: core.Input, args: ['reportDataExtensions.imageClass',] },],
    'reportDataExtensions_displayName_input': [{ type: core.Input, args: ['reportDataExtensions.displayName',] },],
    'reportItemExtensions_name_input': [{ type: core.Input, args: ['reportItemExtensions.name',] },],
    'reportItemExtensions_className_input': [{ type: core.Input, args: ['reportItemExtensions.className',] },],
    'reportItemExtensions_imageClass_input': [{ type: core.Input, args: ['reportItemExtensions.imageClass',] },],
    'reportItemExtensions_displayName_input': [{ type: core.Input, args: ['reportItemExtensions.displayName',] },],
    'reportItemExtensions_category_input': [{ type: core.Input, args: ['reportItemExtensions.category',] },],
    'reportItemExtensions_toolTip_input': [{ type: core.Input, args: ['reportItemExtensions.toolTip',] },],
    'toolbarSettings_items_input': [{ type: core.Input, args: ['toolbarSettings.items',] },],
    'toolbarSettings_showToolbar_input': [{ type: core.Input, args: ['toolbarSettings.showToolbar',] },],
    'toolbarSettings_templateId_input': [{ type: core.Input, args: ['toolbarSettings.templateId',] },],
    'ajaxBeforeLoad_output': [{ type: core.Output, args: ['ajaxBeforeLoad',] },],
    'ajaxError_output': [{ type: core.Output, args: ['ajaxError',] },],
    'ajaxSuccess_output': [{ type: core.Output, args: ['ajaxSuccess',] },],
    'create_output': [{ type: core.Output, args: ['create',] },],
    'destroy_output': [{ type: core.Output, args: ['destroy',] },],
    'newDataClick_output': [{ type: core.Output, args: ['newDataClick',] },],
    'openReportClick_output': [{ type: core.Output, args: ['openReportClick',] },],
    'previewReport_output': [{ type: core.Output, args: ['previewReport',] },],
    'reportModified_output': [{ type: core.Output, args: ['reportModified',] },],
    'reportOpened_output': [{ type: core.Output, args: ['reportOpened',] },],
    'reportSaved_output': [{ type: core.Output, args: ['reportSaved',] },],
    'saveReportClick_output': [{ type: core.Output, args: ['saveReportClick',] },],
    'toolbarClick_output': [{ type: core.Output, args: ['toolbarClick',] },],
    'toolbarRendering_output': [{ type: core.Output, args: ['toolbarRendering',] },],
};
var BoldReportDesignerModule = /** @class */ (function () {
    function BoldReportDesignerModule() {
    }
    return BoldReportDesignerModule;
}());
BoldReportDesignerModule.decorators = [
    { type: core.NgModule, args: [{
                imports: [
                    common.CommonModule
                ],
                declarations: [
                    BoldReportDesignerComponent
                ],
                exports: [
                    BoldReportDesignerComponent
                ]
            },] },
];
/**
 * @nocollapse
 */
BoldReportDesignerModule.ctorParameters = function () { return []; };
var BoldReportsModule = /** @class */ (function () {
    function BoldReportsModule() {
    }
    return BoldReportsModule;
}());
BoldReportsModule.decorators = [
    { type: core.NgModule, args: [{
                imports: [
                    common.CommonModule,
                    BoldReportViewerModule,
                    BoldReportDesignerModule
                ],
                declarations: [],
                exports: [
                    BoldReportViewerModule,
                    BoldReportDesignerModule
                ]
            },] },
];
/**
 * @nocollapse
 */
BoldReportsModule.ctorParameters = function () { return []; };

exports.BoldReportViewerModule = BoldReportViewerModule;
exports.BoldReportDesignerModule = BoldReportDesignerModule;
exports.BoldReportsModule = BoldReportsModule;
exports.ɵb = BoldReportComponents;
exports.ɵc = BoldReportDesignerComponent;
exports.ɵa = BoldReportViewerComponent;

Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=angular-br-test.umd.js.map