@cubejs-client/ngx 0.28.51 → 0.29.0

package/dist/bundles/cubejs-client-ngx.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs'), require('@cubejs-client/core'), require('rxjs/operators'), require('fast-deep-equal')) :
     typeof define === 'function' && define.amd ? define('@cubejs-client/ngx', ['exports', '@angular/core', 'rxjs', '@cubejs-client/core', 'rxjs/operators', 'fast-deep-equal'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global['cubejs-client'] = global['cubejs-client'] || {}, global['cubejs-client'].ngx = {}), global.ng.core, global.rxjs, global.cubejs, global.rxjs.operators, global.equal));
-}(this, (function (exports, core, rxjs, cubejs, operators, equal) { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global["cubejs-client"] = global["cubejs-client"] || {}, global["cubejs-client"].ngx = {}), global.ng.core, global.rxjs, global.cubejs, global.rxjs.operators, global.equal));
+})(this, (function (exports, core, rxjs, cubejs, operators, equal) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -328,95 +328,53 @@
     }
 
     var CubejsClient = /** @class */ (function () {
-        /**
-         * @param {?} config
-         */
         function CubejsClient(config) {
             var _this = this;
             this.config = config;
             this.ready$ = new rxjs.BehaviorSubject(false);
             if (this.config instanceof rxjs.Observable) {
-                this.config.subscribe(( /**
-                 * @return {?}
-                 */function () {
+                this.config.subscribe(function () {
                     _this.ready$.next(true);
-                }));
+                });
             }
             else {
                 this.ready$.next(true);
             }
         }
-        /**
-         * @private
-         * @return {?}
-         */
         CubejsClient.prototype.apiInstace = function () {
             var _this = this;
             if (!this.cubeJsApi) {
                 if (this.config instanceof rxjs.Observable) {
-                    this.config.subscribe(( /**
-                     * @param {?} config
-                     * @return {?}
-                     */function (config) {
-                        _this.cubeJsApi = cubejs__default['default'](config.token, config.options);
+                    this.config.subscribe(function (config) {
+                        _this.cubeJsApi = cubejs__default["default"](config.token, config.options);
                         if (!_this.cubeJsApi) {
                             throw new Error('Cannot create CubejsApi instance. Please check that the config is passed correctly and contains all required options.');
                         }
-                    }));
+                    });
                 }
                 else {
-                    this.cubeJsApi = cubejs__default['default'](this.config.token, this.config.options);
+                    this.cubeJsApi = cubejs__default["default"](this.config.token, this.config.options);
                 }
             }
             return this.cubeJsApi;
         };
-        /**
-         * @param {?} query
-         * @param {?=} options
-         * @return {?}
-         */
         CubejsClient.prototype.load = function (query, options) {
-            return rxjs.from(( /** @type {?} */(this.apiInstace().load(query, options))));
+            return rxjs.from(this.apiInstace().load(query, options));
         };
-        /**
-         * @param {?} query
-         * @param {?=} options
-         * @return {?}
-         */
         CubejsClient.prototype.sql = function (query, options) {
             return rxjs.from(this.apiInstace().sql(query, options));
         };
-        /**
-         * @param {?} query
-         * @param {?=} options
-         * @return {?}
-         */
         CubejsClient.prototype.dryRun = function (query, options) {
             return rxjs.from(this.apiInstace().dryRun(query, options));
         };
-        /**
-         * @param {?=} options
-         * @return {?}
-         */
         CubejsClient.prototype.meta = function (options) {
             return rxjs.from(this.apiInstace().meta(options));
         };
-        /**
-         * @param {?} query
-         * @param {?=} params
-         * @return {?}
-         */
         CubejsClient.prototype.watch = function (query, params) {
             var _this = this;
             if (params === void 0) { params = {}; }
-            return new rxjs.Observable(( /**
-             * @param {?} observer
-             * @return {?}
-             */function (observer) { return query.subscribe({
-                next: ( /**
-                 * @param {?} query
-                 * @return {?}
-                 */function (query) { return __awaiter(_this, void 0, void 0, function () {
+            return new rxjs.Observable(function (observer) { return query.subscribe({
+                next: function (query) { return __awaiter(_this, void 0, void 0, function () {
                     var resultSet;
                     return __generator(this, function (_a) {
                         switch (_a.label) {
@@ -427,45 +385,29 @@
                                 return [2 /*return*/];
                         }
                     });
-                }); }),
-            }); }));
+                }); },
+            }); });
         };
         return CubejsClient;
     }());
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
     CubejsClient.decorators = [
         { type: core.Injectable }
     ];
-    /** @nocollapse */
+    /**
+     * @type {function(): !Array<(null|{
+     *   type: ?,
+     *   decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>),
+     * })>}
+     * @nocollapse
+     */
     CubejsClient.ctorParameters = function () { return [
         { type: undefined, decorators: [{ type: core.Inject, args: ['config',] }] }
     ]; };
-    if (false) {
-        /** @type {?} */
-        CubejsClient.prototype.ready$;
-        /**
-         * @type {?}
-         * @private
-         */
-        CubejsClient.prototype.cubeJsApi;
-        /**
-         * @type {?}
-         * @private
-         */
-        CubejsClient.prototype.config;
-    }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: src/module.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     var CubejsClientModule = /** @class */ (function () {
         function CubejsClientModule() {
         }
-        /**
-         * @param {?} config
-         * @return {?}
-         */
         CubejsClientModule.forRoot = function (config) {
             return {
                 ngModule: CubejsClientModule,
@@ -480,157 +422,79 @@
         };
         return CubejsClientModule;
     }());
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
     CubejsClientModule.decorators = [
         { type: core.NgModule, args: [{
                     providers: [CubejsClient],
                 },] }
     ];
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: src/query-builder/common.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     */
     var StateSubject = /** @class */ (function () {
-        /**
-         * @param {?} value
-         */
         function StateSubject(value) {
             this.subject = new rxjs.BehaviorSubject(value);
         }
-        /**
-         * @return {?}
-         */
         StateSubject.prototype.get = function () {
             return this.subject.getValue();
         };
-        /**
-         * @param {?} value
-         * @return {?}
-         */
         StateSubject.prototype.set = function (value) {
             this.subject.next(value);
         };
         return StateSubject;
     }());
-    if (false) {
-        /** @type {?} */
-        StateSubject.prototype.subject;
-    }
 
     var BaseMember = /** @class */ (function () {
-        /**
-         * @param {?} query
-         * @param {?} field
-         */
         function BaseMember(query, field) {
             this.query = query;
             this.field = field;
         }
         Object.defineProperty(BaseMember.prototype, "members", {
-            /**
-             * @private
-             * @return {?}
-             */
             get: function () {
                 return this.query.asCubeQuery()[this.field] || [];
             },
             enumerable: false,
             configurable: true
         });
-        /**
-         * @param {?} name
-         * @return {?}
-         */
         BaseMember.prototype.add = function (name) {
             var _b;
             this.query.setPartialQuery((_b = {},
-                _b[this.field] = __spread(this.members, [name]),
+                _b[this.field] = __spreadArray(__spreadArray([], __read(this.members)), [name]),
                 _b));
         };
-        /**
-         * @param {?} name
-         * @param {?} replaceWithName
-         * @return {?}
-         */
         BaseMember.prototype.replace = function (name, replaceWithName) {
             var _b;
             this.query.setPartialQuery((_b = {},
-                _b[this.field] = this.members.map(( /**
-                 * @param {?} currentName
-                 * @return {?}
-                 */function (currentName) { return currentName === name ? replaceWithName : currentName; })),
+                _b[this.field] = this.members.map(function (currentName) { return currentName === name ? replaceWithName : currentName; }),
                 _b));
         };
-        /**
-         * @param {?} by
-         * @return {?}
-         */
         BaseMember.prototype.remove = function (by) {
             var _b;
             this.query.setPartialQuery((_b = {},
                 _b[this.field] = this.query
-                    .asCubeQuery()[this.field].filter(( /**
-             * @param {?} currentName
-             * @param {?} index
-             * @return {?}
-             */function (currentName, index) {
+                    .asCubeQuery()[this.field].filter(function (currentName, index) {
                     if (typeof by === 'string') {
                         return currentName !== by;
                     }
                     return index !== by;
-                })),
+                }),
                 _b));
         };
-        /**
-         * @param {?} members
-         * @return {?}
-         */
         BaseMember.prototype.set = function (members) {
             var _b;
             this.query.setPartialQuery((_b = {},
                 _b[this.field] = members,
                 _b));
         };
-        /**
-         * @return {?}
-         */
         BaseMember.prototype.asArray = function () {
             var _this = this;
-            return (this.query.asCubeQuery()[this.field] || []).map(( /**
-             * @param {?} name
-             * @return {?}
-             */function (name) { return _this.query.meta.resolveMember(name, _this.field); }));
+            return (this.query.asCubeQuery()[this.field] || []).map(function (name) { return _this.query.meta.resolveMember(name, _this.field); });
         };
         return BaseMember;
     }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        BaseMember.prototype.query;
-        /**
-         * @type {?}
-         * @private
-         */
-        BaseMember.prototype.field;
-    }
     var TimeDimensionMember = /** @class */ (function () {
-        /**
-         * @param {?} query
-         */
         function TimeDimensionMember(query) {
             this.query = query;
         }
         Object.defineProperty(TimeDimensionMember.prototype, "members", {
-            /**
-             * @private
-             * @return {?}
-             */
             get: function () {
                 return this.query.asCubeQuery().timeDimensions || [];
             },
@@ -638,9 +502,6 @@
             configurable: true
         });
         Object.defineProperty(TimeDimensionMember.prototype, "granularity", {
-            /**
-             * @return {?}
-             */
             get: function () {
                 var _a;
                 return (_a = this.members[0]) === null || _a === void 0 ? void 0 : _a.granularity;
@@ -648,31 +509,17 @@
             enumerable: false,
             configurable: true
         });
-        /**
-         * @param {?} by
-         * @param {?} updateWith
-         * @return {?}
-         */
         TimeDimensionMember.prototype.updateTimeDimension = function (by, updateWith) {
-            /** @type {?} */
-            var timeDimensions = this.members.map(( /**
-             * @param {?} td
-             * @param {?} index
-             * @return {?}
-             */function (td, index) {
+            var timeDimensions = this.members.map(function (td, index) {
                 if (td.dimension === by || index === by) {
                     return Object.assign(Object.assign({}, td), updateWith);
                 }
                 return td;
-            }));
+            });
             this.query.setPartialQuery({
                 timeDimensions: timeDimensions,
             });
         };
-        /**
-         * @param {?} name
-         * @return {?}
-         */
         TimeDimensionMember.prototype.add = function (name) {
             this.query.setPartialQuery({
                 timeDimensions: [
@@ -682,496 +529,244 @@
                 ],
             });
         };
-        /**
-         * @param {?} name
-         * @return {?}
-         */
         TimeDimensionMember.prototype.remove = function (name) {
             this.query.setPartialQuery({
-                timeDimensions: this.members.filter(( /**
-                 * @param {?} __0
-                 * @return {?}
-                 */function (_b) {
+                timeDimensions: this.members.filter(function (_b) {
                     var dimension = _b.dimension;
                     return dimension !== name;
-                })),
+                }),
             });
         };
-        /**
-         * @param {?} timeDimensions
-         * @return {?}
-         */
         TimeDimensionMember.prototype.set = function (timeDimensions) {
             this.query.setPartialQuery({
                 timeDimensions: timeDimensions,
             });
         };
-        /**
-         * @param {?} by
-         * @param {?} dateRange
-         * @return {?}
-         */
         TimeDimensionMember.prototype.setDateRange = function (by, dateRange) {
             this.updateTimeDimension(by, { dateRange: dateRange });
         };
-        /**
-         * @param {?} by
-         * @param {?} granularity
-         * @return {?}
-         */
         TimeDimensionMember.prototype.setGranularity = function (by, granularity) {
             this.updateTimeDimension(by, { granularity: granularity });
         };
-        /**
-         * @return {?}
-         */
         TimeDimensionMember.prototype.asArray = function () {
             var _this = this;
-            return (this.query.asCubeQuery().timeDimensions || []).map(( /**
-             * @param {?} td
-             * @return {?}
-             */function (td) {
+            return (this.query.asCubeQuery().timeDimensions || []).map(function (td) {
                 return Object.assign(Object.assign({}, _this.query.meta.resolveMember(td.dimension, 'dimensions')), td);
-            }));
+            });
         };
         return TimeDimensionMember;
     }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        TimeDimensionMember.prototype.query;
-    }
     var Order = /** @class */ (function () {
-        /**
-         * @param {?} query
-         */
         function Order(query) {
             this.query = query;
             this.orderMembers = new rxjs.BehaviorSubject([]);
             this.query.subject.subscribe(this.handleQueryChange.bind(this));
             this.orderMembers.subscribe(this.handleOrderMembersChange.bind(this));
         }
-        /**
-         * @private
-         * @param {?} orderMembers
-         * @return {?}
-         */
         Order.prototype.handleOrderMembersChange = function (orderMembers) {
-            /** @type {?} */
-            var order = ( /** @type {?} */(orderMembers
-                .filter(( /**
-         * @param {?} __0
-         * @return {?}
-         */function (_b) {
+            var order = orderMembers
+                .filter(function (_b) {
                 var order = _b.order;
                 return order !== 'none';
-            }))
-                .reduce(( /**
-         * @param {?} memo
-         * @param {?} __1
-         * @return {?}
-         */function (memo, _b) {
+            })
+                .reduce(function (memo, _b) {
                 var _c;
                 var id = _b.id, order = _b.order;
                 return (Object.assign(Object.assign({}, memo), (_c = {}, _c[id] = order, _c)));
-            }), {})));
-            if (!equal__default['default'](order, this.asObject())) {
+            }, {});
+            if (!equal__default["default"](order, this.asObject())) {
                 this.query.setPartialQuery({ order: order });
             }
         };
-        /**
-         * @private
-         * @return {?}
-         */
         Order.prototype.handleQueryChange = function () {
             var _this = this;
-            this.orderMembers.next(__spread(this.query.measures.asArray(), this.query.dimensions.asArray(), this.query.timeDimensions.asArray()).map(( /**
-             * @param {?} __0
-             * @return {?}
-             */function (_b) {
+            this.orderMembers.next(__spreadArray(__spreadArray(__spreadArray([], __read(this.query.measures.asArray())), __read(this.query.dimensions.asArray())), __read(this.query.timeDimensions.asArray())).map(function (_b) {
                 var name = _b.name, title = _b.title;
                 return {
                     id: name,
                     order: _this.of(name),
                     title: title,
                 };
-            })));
+            }));
         };
-        /**
-         * @param {?} id
-         * @param {?} order
-         * @return {?}
-         */
         Order.prototype.setMemberOrder = function (id, order) {
-            this.orderMembers.next(this.orderMembers.getValue().map(( /**
-             * @param {?} orderMember
-             * @return {?}
-             */function (orderMember) {
+            this.orderMembers.next(this.orderMembers.getValue().map(function (orderMember) {
                 if (orderMember.id === id) {
                     return Object.assign(Object.assign({}, orderMember), { order: order });
                 }
                 return orderMember;
-            })));
+            }));
         };
-        /**
-         * @param {?} sourceIndex
-         * @param {?} destinationIndex
-         * @return {?}
-         */
         Order.prototype.reorder = function (sourceIndex, destinationIndex) {
             this.orderMembers.next(cubejs.moveItemInArray(this.orderMembers.getValue(), sourceIndex, destinationIndex));
         };
-        /**
-         * @param {?} member
-         * @return {?}
-         */
         Order.prototype.of = function (member) {
             return (this.query.asCubeQuery().order || {})[member] || 'none';
         };
-        /**
-         * @param {?} order
-         * @return {?}
-         */
         Order.prototype.set = function (order) {
             this.query.setPartialQuery({ order: order });
         };
-        /**
-         * @return {?}
-         */
         Order.prototype.asArray = function () {
             if (Array.isArray(this.query.asCubeQuery().order)) {
-                return ( /** @type {?} */(this.query.asCubeQuery().order));
+                return this.query.asCubeQuery().order;
             }
             return Object.entries(this.query.asCubeQuery().order || {});
         };
-        /**
-         * @return {?}
-         */
         Order.prototype.asObject = function () {
-            return this.asArray().reduce(( /**
-             * @param {?} memo
-             * @param {?} __1
-             * @return {?}
-             */function (memo, _b) {
+            return this.asArray().reduce(function (memo, _b) {
                 var _c;
                 var _d = __read(_b, 2), key = _d[0], value = _d[1];
                 return (Object.assign(Object.assign({}, memo), (_c = {}, _c[key] = value, _c)));
-            }), {});
+            }, {});
         };
         return Order;
     }());
-    if (false) {
-        /** @type {?} */
-        Order.prototype.orderMembers;
-        /**
-         * @type {?}
-         * @private
-         */
-        Order.prototype.query;
-    }
     var FilterMember = /** @class */ (function () {
-        /**
-         * @param {?} query
-         */
         function FilterMember(query) {
             this.query = query;
         }
         Object.defineProperty(FilterMember.prototype, "filters", {
-            /**
-             * @private
-             * @return {?}
-             */
             get: function () {
                 // TODO: update this type assertion once the QueryBuilder supports logical and/or
-                return ( /** @type {?} */((this.query.asCubeQuery().filters || [])));
+                return (this.query.asCubeQuery().filters || []);
             },
             enumerable: false,
             configurable: true
         });
-        /**
-         * @param {?} by
-         * @param {?} updateWith
-         * @return {?}
-         */
         FilterMember.prototype.update = function (by, updateWith) {
-            /** @type {?} */
-            var filters = this.filters.map(( /**
-             * @param {?} filter
-             * @param {?} index
-             * @return {?}
-             */function (filter, index) {
+            var filters = this.filters.map(function (filter, index) {
                 if (index === by || filter.member === by || filter.dimension === by) {
                     return Object.assign(Object.assign({}, filter), updateWith);
                 }
                 return filter;
-            }));
+            });
             this.query.setPartialQuery({
-                filters: ( /** @type {?} */(filters)),
+                filters: filters,
             });
         };
-        /**
-         * @param {?} filter
-         * @return {?}
-         */
         FilterMember.prototype.add = function (filter) {
             this.query.setPartialQuery({
-                filters: __spread(this.filters, [filter]),
+                filters: __spreadArray(__spreadArray([], __read(this.filters)), [filter]),
             });
         };
-        /**
-         * @param {?} by
-         * @return {?}
-         */
         FilterMember.prototype.remove = function (by) {
             this.query.setPartialQuery({
-                filters: this.filters.filter(( /**
-                 * @param {?} filter
-                 * @param {?} index
-                 * @return {?}
-                 */function (filter, index) {
+                filters: this.filters.filter(function (filter, index) {
                     if (filter.member === by || filter.dimension === by || index === by) {
                         return false;
                     }
                     return true;
-                })),
+                }),
             });
         };
-        /**
-         * @param {?} filters
-         * @return {?}
-         */
         FilterMember.prototype.set = function (filters) {
             this.query.setPartialQuery({
                 filters: filters,
             });
         };
-        /**
-         * @param {?} name
-         * @param {?} replaceWithName
-         * @return {?}
-         */
         FilterMember.prototype.replace = function (name, replaceWithName) {
             this.query.setPartialQuery({
-                filters: this.filters.map(( /**
-                 * @param {?} filter
-                 * @return {?}
-                 */function (filter) {
+                filters: this.filters.map(function (filter) {
                     var _b;
-                    /** @type {?} */
                     var field = filter.member ? 'member' : 'dimension';
                     return filter.member === name || filter.dimension === name
                         ? Object.assign(Object.assign({}, filter), (_b = {}, _b[field] = replaceWithName, _b)) : filter;
-                })),
+                }),
             });
         };
-        /**
-         * @return {?}
-         */
         FilterMember.prototype.asArray = function () {
             var _this = this;
-            return this.filters.map(( /**
-             * @param {?} filter
-             * @return {?}
-             */function (filter) {
+            return this.filters.map(function (filter) {
                 return Object.assign(Object.assign(Object.assign({}, _this.query.meta.resolveMember(filter.member || filter.dimension, [
                     'dimensions',
                     'measures',
                 ])), { operators: _this.query.meta.filterOperatorsForMember(filter.member || filter.dimension, ['dimensions', 'measures']) }), filter);
-            }));
+            });
         };
         return FilterMember;
     }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        FilterMember.prototype.query;
-    }
 
-    /** @enum {string} */
-    var MemberType = {
-        Measures: "measures",
-        Dimensions: "dimensions",
-        Segments: "segments",
-        TimeDimensions: "timeDimensions",
-        Filters: "filters",
-        Order: "order",
-    };
+    exports.MemberType = void 0;
+    (function (MemberType) {
+        MemberType["Measures"] = "measures";
+        MemberType["Dimensions"] = "dimensions";
+        MemberType["Segments"] = "segments";
+        MemberType["TimeDimensions"] = "timeDimensions";
+        MemberType["Filters"] = "filters";
+        MemberType["Order"] = "order";
+    })(exports.MemberType || (exports.MemberType = {}));
     var Query = /** @class */ (function (_super) {
         __extends(Query, _super);
-        /**
-         * @param {?} meta
-         * @param {?=} _onBeforeChange
-         */
         function Query(meta, _onBeforeChange) {
-            if (_onBeforeChange === void 0) { _onBeforeChange = ( /**
-             * @param {?} newQuery
-             * @return {?}
-             */function (newQuery) { return newQuery; }); }
+            if (_onBeforeChange === void 0) { _onBeforeChange = function (newQuery) { return newQuery; }; }
             var _this = _super.call(this, {}) || this;
             _this.meta = meta;
             _this._onBeforeChange = _onBeforeChange;
             _this.init();
             return _this;
         }
-        /**
-         * @private
-         * @return {?}
-         */
         Query.prototype.init = function () {
-            this.measures = new BaseMember(this, MemberType.Measures);
-            this.dimensions = new BaseMember(this, MemberType.Dimensions);
-            this.segments = new BaseMember(this, MemberType.Segments);
+            this.measures = new BaseMember(this, exports.MemberType.Measures);
+            this.dimensions = new BaseMember(this, exports.MemberType.Dimensions);
+            this.segments = new BaseMember(this, exports.MemberType.Segments);
             this.timeDimensions = new TimeDimensionMember(this);
             this.filters = new FilterMember(this);
             this.order = new Order(this);
         };
-        /**
-         * @return {?}
-         */
         Query.prototype.asCubeQuery = function () {
             return this.subject.getValue() || {};
         };
-        /**
-         * @param {?} query
-         * @return {?}
-         */
         Query.prototype.setQuery = function (query) {
             this.subject.next(this._onBeforeChange(query, this.subject.getValue(), this));
         };
-        /**
-         * @param {?} partialQuery
-         * @return {?}
-         */
         Query.prototype.setPartialQuery = function (partialQuery) {
             this.subject.next(this._onBeforeChange(Object.assign(Object.assign({}, this.subject.getValue()), partialQuery), this.subject.getValue(), this));
         };
-        /**
-         * @param {?} limit
-         * @return {?}
-         */
         Query.prototype.setLimit = function (limit) {
             this.setPartialQuery({ limit: limit });
         };
-        /**
-         * @return {?}
-         */
         Query.prototype.isPresent = function () {
             return cubejs.isQueryPresent(this.asCubeQuery());
         };
         return Query;
     }(StateSubject));
-    if (false) {
-        /** @type {?} */
-        Query.prototype.measures;
-        /** @type {?} */
-        Query.prototype.dimensions;
-        /** @type {?} */
-        Query.prototype.segments;
-        /** @type {?} */
-        Query.prototype.timeDimensions;
-        /** @type {?} */
-        Query.prototype.filters;
-        /** @type {?} */
-        Query.prototype.order;
-        /** @type {?} */
-        Query.prototype.meta;
-        /**
-         * @type {?}
-         * @private
-         */
-        Query.prototype._onBeforeChange;
-    }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: src/query-builder/builder-meta.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
     var BuilderMeta = /** @class */ (function () {
-        /**
-         * @param {?} meta
-         */
         function BuilderMeta(meta) {
             this.meta = meta;
             this.mapMeta();
         }
-        /**
-         * @private
-         * @return {?}
-         */
         BuilderMeta.prototype.mapMeta = function () {
             var _this = this;
-            /** @type {?} */
-            var allDimensions = ( /** @type {?} */((this.meta.membersForQuery(null, 'dimensions'))));
-            this.measures = ( /** @type {?} */(this.meta.membersForQuery(null, 'measures')));
+            var allDimensions = (this.meta.membersForQuery(null, 'dimensions'));
+            this.measures = this.meta.membersForQuery(null, 'measures');
             this.segments = this.meta.membersForQuery(null, 'segments');
-            this.dimensions = allDimensions.filter(( /**
-             * @param {?} __0
-             * @return {?}
-             */function (_a) {
+            this.dimensions = allDimensions.filter(function (_a) {
                 var type = _a.type;
                 return type !== 'time';
-            }));
-            this.timeDimensions = allDimensions.filter(( /**
-             * @param {?} __0
-             * @return {?}
-             */function (_a) {
+            });
+            this.timeDimensions = allDimensions.filter(function (_a) {
                 var type = _a.type;
                 return type === 'time';
-            }));
-            this.filters = __spread(allDimensions, this.measures).map(( /**
-             * @param {?} member
-             * @return {?}
-             */function (member) {
+            });
+            this.filters = __spreadArray(__spreadArray([], __read(allDimensions)), __read(this.measures)).map(function (member) {
                 return Object.assign(Object.assign({}, member), { operators: _this.meta.filterOperatorsForMember(member.name, [
                         'dimensions',
                         'measures',
                     ]) });
-            }));
+            });
         };
         return BuilderMeta;
     }());
-    if (false) {
-        /** @type {?} */
-        BuilderMeta.prototype.measures;
-        /** @type {?} */
-        BuilderMeta.prototype.dimensions;
-        /** @type {?} */
-        BuilderMeta.prototype.segments;
-        /** @type {?} */
-        BuilderMeta.prototype.timeDimensions;
-        /** @type {?} */
-        BuilderMeta.prototype.filters;
-        /** @type {?} */
-        BuilderMeta.prototype.meta;
-    }
 
     var PivotConfig = /** @class */ (function (_super) {
         __extends(PivotConfig, _super);
-        /**
-         * @param {?} pivotConfig
-         */
         function PivotConfig(pivotConfig) {
             return _super.call(this, pivotConfig) || this;
         }
-        /**
-         * @param {?} sourceIndex
-         * @param {?} destinationIndex
-         * @param {?} sourceAxis
-         * @param {?} destinationAxis
-         * @return {?}
-         */
         PivotConfig.prototype.moveItem = function (sourceIndex, destinationIndex, sourceAxis, destinationAxis) {
             this.subject.next(cubejs.movePivotItem(this.get(), sourceIndex, destinationIndex, sourceAxis, destinationAxis));
         };
-        /**
-         * @param {?} fillMissingDates
-         * @return {?}
-         */
         PivotConfig.prototype.setFillMissingDates = function (fillMissingDates) {
             this.subject.next(Object.assign(Object.assign({}, this.get()), { fillMissingDates: fillMissingDates }));
         };
@@ -1180,9 +775,6 @@
 
     var ChartType = /** @class */ (function (_super) {
         __extends(ChartType, _super);
-        /**
-         * @param {?} value
-         */
         function ChartType(value) {
             return _super.call(this, value) || this;
         }
@@ -1194,57 +786,35 @@
             var _this = this;
             this._disableHeuristics = false;
             this._heuristicChange$ = new rxjs.Subject();
-            this.builderMeta = new Promise(( /**
-             * @param {?} resolve
-             * @return {?}
-             */function (resolve) { return (_this._resolveBuilderMeta = resolve); }));
-            this.query = new Promise(( /**
-             * @param {?} resolve
-             * @return {?}
-             */function (resolve) { return (_this._resolveQuery = resolve); }));
+            this.builderMeta = new Promise(function (resolve) { return (_this._resolveBuilderMeta = resolve); });
+            this.query = new Promise(function (resolve) { return (_this._resolveQuery = resolve); });
             this.state = new rxjs.BehaviorSubject({});
         }
-        /**
-         * @private
-         * @return {?}
-         */
         QueryBuilderService.prototype.init = function () {
             return __awaiter(this, void 0, void 0, function () {
                 var _this = this;
                 return __generator(this, function (_c) {
                     this.pivotConfig = new PivotConfig(null);
                     this.chartType = new ChartType('line');
-                    this._cubejs.meta().subscribe(( /**
-                     * @param {?} meta
-                     * @return {?}
-                     */function (meta) {
+                    this._cubejs.meta().subscribe(function (meta) {
                         _this._meta = meta;
                         _this._query = new Query(_this._meta, _this._handleQueryChange.bind(_this));
                         _this._resolveQuery(_this._query);
                         _this._resolveBuilderMeta(new BuilderMeta(_this._meta));
-                    }));
+                    });
                     this.subscribe();
                     if (!this._disableHeuristics) {
                         this._heuristicChange$
-                            .pipe(operators.switchMap(( /**
-                     * @param {?} data
-                     * @return {?}
-                     */function (data) {
+                            .pipe(operators.switchMap(function (data) {
                             return rxjs.combineLatest([
-                                _this._cubejs.dryRun(data.query).pipe(operators.catchError(( /**
-                                 * @param {?} error
-                                 * @return {?}
-                                 */function (error) {
+                                _this._cubejs.dryRun(data.query).pipe(operators.catchError(function (error) {
                                     console.error(error);
                                     return rxjs.of(null);
-                                }))),
+                                })),
                                 rxjs.of(data.shouldApplyHeuristicOrder),
                             ]);
-                        })))
-                            .subscribe(( /**
-                     * @param {?} __0
-                     * @return {?}
-                     */function (_c) {
+                        }))
+                            .subscribe(function (_c) {
                             var _d = __read(_c, 2), dryRunResponse = _d[0], shouldApplyHeuristicOrder = _d[1];
                             if (!dryRunResponse) {
                                 return;
@@ -1252,31 +822,20 @@
                             var pivotQuery = dryRunResponse.pivotQuery, queryOrder = dryRunResponse.queryOrder;
                             _this.pivotConfig.set(cubejs.ResultSet.getNormalizedPivotConfig(pivotQuery, _this.pivotConfig.get()));
                             if (shouldApplyHeuristicOrder) {
-                                _this._query.order.set(queryOrder.reduce(( /**
-                                 * @param {?} a
-                                 * @param {?} b
-                                 * @return {?}
-                                 */function (a, b) { return (Object.assign(Object.assign({}, a), b)); }), {}));
+                                _this._query.order.set(queryOrder.reduce(function (a, b) { return (Object.assign(Object.assign({}, a), b)); }, {}));
                             }
-                        }));
+                        });
                     }
                     return [2 /*return*/];
                 });
             });
         };
-        /**
-         * @private
-         * @param {?} newQuery
-         * @param {?} oldQuery
-         * @return {?}
-         */
         QueryBuilderService.prototype._handleQueryChange = function (newQuery, oldQuery) {
             var _a, _b;
             var _c = cubejs.defaultHeuristics(newQuery, oldQuery, {
                 meta: this._meta,
                 sessionGranularity: (_b = (_a = newQuery === null || newQuery === void 0 ? void 0 : newQuery.timeDimensions) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.granularity,
             }), chartType = _c.chartType, shouldApplyHeuristicOrder = _c.shouldApplyHeuristicOrder, heuristicQuery = _c.query;
-            /** @type {?} */
             var query = this._disableHeuristics
                 ? newQuery
                 : heuristicQuery || newQuery;
@@ -1291,54 +850,30 @@
             }
             return query;
         };
-        /**
-         * @param {?} cubejsClient
-         * @return {?}
-         */
         QueryBuilderService.prototype.setCubejsClient = function (cubejsClient) {
             this._cubejs = cubejsClient;
             this.init();
         };
-        /**
-         * @private
-         * @return {?}
-         */
         QueryBuilderService.prototype.subscribe = function () {
             var _this = this;
-            Object.getOwnPropertyNames(this).forEach(( /**
-             * @param {?} key
-             * @return {?}
-             */function (key) {
+            Object.getOwnPropertyNames(this).forEach(function (key) {
                 if (_this[key] instanceof StateSubject) {
-                    _this[key].subject.subscribe(( /**
-                     * @param {?} value
-                     * @return {?}
-                     */function (value) {
+                    _this[key].subject.subscribe(function (value) {
                         var _c;
                         return _this.setPartialState((_c = {},
                             _c[key] = value,
                             _c));
-                    }));
+                    });
                 }
-            }));
-            this.query.then(( /**
-             * @param {?} query
-             * @return {?}
-             */function (query) {
-                query.subject.subscribe(( /**
-                 * @param {?} cubeQuery
-                 * @return {?}
-                 */function (cubeQuery) {
+            });
+            this.query.then(function (query) {
+                query.subject.subscribe(function (cubeQuery) {
                     _this.setPartialState({
                         query: cubeQuery,
                     });
-                }));
-            }));
+                });
+            });
         };
-        /**
-         * @param {?} state
-         * @return {?}
-         */
         QueryBuilderService.prototype.deserialize = function (state) {
             return __awaiter(this, void 0, void 0, function () {
                 var _this = this;
@@ -1351,109 +886,42 @@
                             (_c.sent()).setQuery(state.query);
                             _c.label = 2;
                         case 2:
-                            Object.entries(state).forEach(( /**
-                             * @param {?} __0
-                             * @return {?}
-                             */function (_c) {
+                            Object.entries(state).forEach(function (_c) {
                                 var _d = __read(_c, 2), key = _d[0], value = _d[1];
                                 if (_this[key] instanceof StateSubject) {
                                     _this[key].set(value);
                                 }
-                            }));
+                            });
                             this.subscribe();
                             return [2 /*return*/];
                     }
                 });
             });
         };
-        /**
-         * @param {?} partialState
-         * @return {?}
-         */
         QueryBuilderService.prototype.setPartialState = function (partialState) {
             this.state.next(Object.assign(Object.assign({}, this.state.getValue()), partialState));
         };
-        /**
-         * @return {?}
-         */
         QueryBuilderService.prototype.disableHeuristics = function () {
             this._disableHeuristics = false;
         };
-        /**
-         * @return {?}
-         */
         QueryBuilderService.prototype.enableHeuristics = function () {
             this._disableHeuristics = true;
         };
         return QueryBuilderService;
     }());
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
     QueryBuilderService.decorators = [
         { type: core.Injectable }
     ];
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        QueryBuilderService.prototype._cubejs;
-        /**
-         * @type {?}
-         * @private
-         */
-        QueryBuilderService.prototype._meta;
-        /**
-         * @type {?}
-         * @private
-         */
-        QueryBuilderService.prototype._query;
-        /**
-         * @type {?}
-         * @private
-         */
-        QueryBuilderService.prototype._disableHeuristics;
-        /**
-         * @type {?}
-         * @private
-         */
-        QueryBuilderService.prototype._resolveQuery;
-        /**
-         * @type {?}
-         * @private
-         */
-        QueryBuilderService.prototype._resolveBuilderMeta;
-        /**
-         * @type {?}
-         * @private
-         */
-        QueryBuilderService.prototype._heuristicChange$;
-        /** @type {?} */
-        QueryBuilderService.prototype.builderMeta;
-        /** @type {?} */
-        QueryBuilderService.prototype.query;
-        /** @type {?} */
-        QueryBuilderService.prototype.state;
-        /** @type {?} */
-        QueryBuilderService.prototype.pivotConfig;
-        /** @type {?} */
-        QueryBuilderService.prototype.chartType;
-    }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: src/public_api.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+    /*
+     * Public API Surface of cubejs-client-ngx
      */
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: index.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
+    // This file is not used to build this module. It is only used during editing
 
     /**
-     * @fileoverview added by tsickle
-     * Generated from: cubejs-client-ngx.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     * Generated bundle index. Do not edit.
      */
 
     exports.BaseMember = BaseMember;
@@ -1462,15 +930,14 @@
     exports.CubejsClient = CubejsClient;
     exports.CubejsClientModule = CubejsClientModule;
     exports.FilterMember = FilterMember;
-    exports.MemberType = MemberType;
     exports.Order = Order;
     exports.PivotConfig = PivotConfig;
     exports.Query = Query;
     exports.QueryBuilderService = QueryBuilderService;
     exports.TimeDimensionMember = TimeDimensionMember;
-    exports.ɵa = StateSubject;
+    exports["ɵa"] = StateSubject;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=cubejs-client-ngx.umd.js.map